@ai-matrx/rich-editor 0.0.0 → 0.1.1

package/dist/core/source-format.js

@@ -0,0 +1,104 @@
+function toggleWrap(text, from, to, marker) {
+  const size = marker.length;
+  const before = text.slice(Math.max(0, from - size), from);
+  const after = text.slice(to, to + size);
+  if (before === marker && after === marker) {
+    return {
+      changes: [
+        { from: from - size, to: from, insert: "" },
+        { from: to, to: to + size, insert: "" }
+      ],
+      anchor: from - size,
+      head: to - size
+    };
+  }
+  const selected = text.slice(from, to);
+  if (selected.length >= size * 2 && selected.startsWith(marker) && selected.endsWith(marker)) {
+    return {
+      changes: [{ from, to, insert: selected.slice(size, selected.length - size) }],
+      anchor: from,
+      head: to - size * 2
+    };
+  }
+  return {
+    changes: [{ from, to, insert: `${marker}${selected}${marker}` }],
+    anchor: from + size,
+    head: to + size
+  };
+}
+const LINE_PREFIX = /^( {0,3})(#{1,6}[ \t]+|[-*+][ \t]+\[[ xX]\][ \t]+|[-*+][ \t]+|\d{1,9}[.)][ \t]+|>[ \t]?)?/;
+function setLinePrefix(text, from, to, prefix) {
+  const start = text.lastIndexOf("\n", from - 1) + 1;
+  const endBreak = text.indexOf("\n", to);
+  const end = endBreak === -1 ? text.length : endBreak;
+  const lines = text.slice(start, end).split("\n");
+  let number = 1;
+  let delta = 0;
+  const changes = [];
+  let offset = start;
+  let firstDelta = 0;
+  lines.forEach((line, index) => {
+    const match = LINE_PREFIX.exec(line);
+    const existing = match?.[0] ?? "";
+    const indent = match?.[1] ?? "";
+    const next = prefix === null ? indent : `${indent}${prefix === "1. " ? `${number++}. ` : prefix}`;
+    if (existing !== next) {
+      changes.push({ from: offset, to: offset + existing.length, insert: next });
+      delta += next.length - existing.length;
+      if (index === 0) firstDelta = next.length - existing.length;
+    }
+    offset += line.length + 1;
+  });
+  return { changes, anchor: Math.max(start, from + firstDelta), head: to + delta };
+}
+function makeLink(text, from, to, url = "") {
+  const label = text.slice(from, to) || "link";
+  const insert = `[${label}](${url})`;
+  const urlStart = from + label.length + 3;
+  return { changes: [{ from, to, insert }], anchor: urlStart, head: urlStart + url.length };
+}
+function applySourceEdit(text, result) {
+  let out = text;
+  for (const change of [...result.changes].sort((a, b) => b.from - a.from)) {
+    out = out.slice(0, change.from) + change.insert + out.slice(change.to);
+  }
+  return out;
+}
+const CONTINUABLE = /^([ \t]*)(?:([-*+])|(\d{1,9})([.)]))([ \t]+)(\[[ xX]\][ \t]+)?(.*)$/;
+const QUOTE = /^([ \t]*(?:>[ \t]?)+)(.*)$/;
+function continueMarkupOnEnter(text, pos) {
+  const lineStart = text.lastIndexOf("\n", pos - 1) + 1;
+  const lineEndBreak = text.indexOf("\n", pos);
+  const lineEnd = lineEndBreak === -1 ? text.length : lineEndBreak;
+  if (text.slice(pos, lineEnd).trim() !== "") return null;
+  const line = text.slice(lineStart, lineEnd);
+  const item = CONTINUABLE.exec(line);
+  if (item) {
+    const [, indent = "", bullet, number, delimiter, gap = " ", task, rest = ""] = item;
+    if (!rest.trim()) {
+      return { changes: [{ from: lineStart, to: lineEnd, insert: "" }], anchor: lineStart, head: lineStart };
+    }
+    const marker = bullet ?? `${Number(number) + 1}${delimiter}`;
+    const insert = `
+${indent}${marker}${gap}${task ? "[ ] " : ""}`;
+    return { changes: [{ from: pos, to: pos, insert }], anchor: pos + insert.length, head: pos + insert.length };
+  }
+  const quote = QUOTE.exec(line);
+  if (quote && line.trimStart().startsWith(">")) {
+    const [, prefix = "> ", rest = ""] = quote;
+    if (!rest.trim()) {
+      return { changes: [{ from: lineStart, to: lineEnd, insert: "" }], anchor: lineStart, head: lineStart };
+    }
+    const insert = `
+${prefix}`;
+    return { changes: [{ from: pos, to: pos, insert }], anchor: pos + insert.length, head: pos + insert.length };
+  }
+  return null;
+}
+export {
+  applySourceEdit,
+  continueMarkupOnEnter,
+  makeLink,
+  setLinePrefix,
+  toggleWrap
+};

package/dist/core/text-metrics.d.ts

@@ -0,0 +1,11 @@
+export interface TextMetrics {
+    words: number;
+    /** Characters of prose, spaces included (what "characters" means in Docs). */
+    characters: number;
+    /** Whole minutes at 238 words per minute (the adult silent-reading average), minimum 1 when there is any prose. */
+    readingMinutes: number;
+    /** Protected blocks and inline islands the counts leave out. */
+    islands: number;
+}
+export declare const READING_WORDS_PER_MINUTE = 238;
+export declare function measureText(text: string): TextMetrics;

package/dist/core/text-metrics.js

@@ -0,0 +1,35 @@
+import { tokenizeSource } from "@ai-matrx/content-ir/source";
+import { isGfmDelimiterRow } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/gfm-table-lines";
+const READING_WORDS_PER_MINUTE = 238;
+function proseOf(raw) {
+  return raw.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/<https?:[^>]+>/g, " ").replace(/^ {0,3}(#{1,6}|>|[-*+]|\d{1,9}[.)])[ \t]+/gm, "").replace(/^ {0,3}[-*_](?:[ \t]*[-*_]){2,}[ \t]*$/gm, "").split("\n").map((line) => isGfmDelimiterRow(line) ? "" : line).join("\n").replace(/\[[ xX]\][ \t]/g, "").replace(/[*_~`|]+/g, "");
+}
+function measureText(text) {
+  let prose = "";
+  let islands = 0;
+  for (const block of tokenizeSource(text)) {
+    if (block.kind === "island") {
+      islands += 1;
+      continue;
+    }
+    if (block.kind !== "prose") continue;
+    let cursor = block.start;
+    let raw = "";
+    for (const island of block.inlines) {
+      raw += `${text.slice(cursor, island.start)} `;
+      cursor = island.end;
+      islands += 1;
+    }
+    raw += text.slice(cursor, block.end);
+    prose += `${proseOf(raw)}
+`;
+  }
+  const words = prose.match(/[\p{L}\p{N}][\p{L}\p{N}'’.-]*/gu)?.length ?? 0;
+  const characters = prose.replace(/\s+/g, " ").trim().length;
+  const readingMinutes = words === 0 ? 0 : Math.max(1, Math.round(words / READING_WORDS_PER_MINUTE));
+  return { words, characters, readingMinutes, islands };
+}
+export {
+  READING_WORDS_PER_MINUTE,
+  measureText
+};

package/dist/core/variable-name.d.ts

@@ -0,0 +1,13 @@
+/**
+ * THE variable-name rule for `{{name}}` in the editor: what a declarable variable name looks like.
+ * (Ported from @ai-matrx/chat agents/utils/variable-utils; chat imports it from here at rich-content
+ * phase 3 so there is one rule.)
+ *
+ *   - Lowercase, spaces/hyphens → underscores
+ *   - Remove non-alphanumeric/underscore characters
+ *   - Collapse consecutive underscores to one
+ *   - Strip leading/trailing underscores
+ */
+export declare const sanitizeVariableName: (input: string) => string;
+/** A name that survives `sanitizeVariableName` unchanged can be declared as a variable. */
+export declare const isDeclarableVariableName: (name: string) => boolean;

package/dist/core/variable-name.js

@@ -0,0 +1,13 @@
+const sanitizeVariableName = (input) => {
+  const trimmed = input.trim();
+  const lowercased = trimmed.toLowerCase();
+  const underscored = lowercased.replace(/[\s-]+/g, "_");
+  const cleaned = underscored.replace(/[^a-z0-9_]/g, "");
+  const single = cleaned.replace(/_+/g, "_");
+  return single.replace(/^_+|_+$/g, "");
+};
+const isDeclarableVariableName = (name) => name.length > 0 && sanitizeVariableName(name) === name;
+export {
+  isDeclarableVariableName,
+  sanitizeVariableName
+};

package/dist/core/variables.d.ts

@@ -0,0 +1,37 @@
+export type VariableState = "declared" | "undeclared" | "literal" | "unbound";
+/** A variable the surface declares, with its type when the surface knows it. */
+export interface DeclaredVariable {
+    name: string;
+    type?: string;
+    description?: string;
+}
+export interface VariableInfo {
+    name: string;
+    state: VariableState;
+    declared: DeclaredVariable | null;
+    /** Hover text in plain English. */
+    title: string;
+}
+/** The name inside `{{name}}`, or null when the raw text is not a variable. */
+export declare function variableName(raw: string): string | null;
+export declare function classifyVariable(raw: string, declared: readonly DeclaredVariable[] | null | undefined): VariableInfo;
+/** Tailwind classes per state (the HighlightedText palette). */
+export declare const VARIABLE_STATE_CLASS: Record<VariableState, string>;
+/** A typed name for a new variable: letters, digits and underscores. */
+export declare function toVariableName(input: string): string;
+/** Every distinct `{{name}}` in a text, in order of first appearance. */
+export declare function variableNamesInText(text: string): string[];
+export interface VariableSuggestion {
+    name: string;
+    type?: string;
+    description?: string;
+    /** Declared by the surface, already used in this document, or a new name from what was typed. */
+    source: "declared" | "document" | "new";
+}
+/**
+ * THE `{{` menu's rows, for both views: the surface's declared variables, then
+ * the variables this document already uses (so a prompt's own `{{site_name}}`
+ * is one keystroke away even where the host declares nothing), then the typed
+ * name as a new variable.
+ */
+export declare function variableSuggestions(declared: readonly DeclaredVariable[], documentNames: readonly string[], query: string): VariableSuggestion[];

package/dist/core/variables.js

@@ -0,0 +1,77 @@
+import { isDeclarableVariableName } from "./variable-name.js";
+const VARIABLE_RE = /^\{\{([^}]+)\}\}$/;
+function variableName(raw) {
+  return VARIABLE_RE.exec(raw)?.[1] ?? null;
+}
+function classifyVariable(raw, declared) {
+  const name = variableName(raw) ?? raw;
+  const trimmed = name.trim();
+  if (!declared) {
+    return {
+      name,
+      state: isDeclarableVariableName(trimmed) ? "unbound" : "literal",
+      declared: null,
+      title: isDeclarableVariableName(trimmed) ? `Variable: ${name}` : `Literal text \u2014 "${name}" is not a valid variable name, so it is sent as written`
+    };
+  }
+  const match = declared.find((variable) => variable.name === name) ?? null;
+  if (match) {
+    return {
+      name,
+      state: "declared",
+      declared: match,
+      title: `Variable: ${name}${match.type ? ` (${match.type})` : ""}${match.description ? ` \u2014 ${match.description}` : ""}`
+    };
+  }
+  if (!isDeclarableVariableName(trimmed)) {
+    return {
+      name,
+      state: "literal",
+      declared: null,
+      title: `Literal text \u2014 "${name}" is not a valid variable name, so it is sent as written`
+    };
+  }
+  return {
+    name,
+    state: "undeclared",
+    declared: null,
+    title: `Undefined variable: ${name} \u2014 it resolves to nothing until it is declared`
+  };
+}
+const VARIABLE_STATE_CLASS = {
+  declared: "bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300 border-green-200 dark:border-green-800",
+  undeclared: "bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300 border-red-200 dark:border-red-800",
+  literal: "bg-muted text-muted-foreground border-border",
+  unbound: "bg-primary/10 text-primary-ink border-primary/30"
+};
+function toVariableName(input) {
+  return input.trim().replace(/[^\p{L}\p{N}_]+/gu, "_").replace(/^_+|_+$/g, "");
+}
+const VARIABLE_IN_TEXT_RE = /\{\{\s*([\p{L}\p{N}_][\p{L}\p{N}_.-]*)\s*\}\}/gu;
+function variableNamesInText(text) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(VARIABLE_IN_TEXT_RE)) seen.add(match[1]);
+  return [...seen];
+}
+function variableSuggestions(declared, documentNames, query) {
+  const q = query.replace(/\}+$/, "").trim().toLowerCase();
+  const matches = (name) => !q || name.toLowerCase().includes(q);
+  const out = declared.filter((variable) => matches(variable.name)).map((variable) => ({ ...variable, source: "declared" }));
+  const known = new Set(declared.map((variable) => variable.name));
+  for (const name of documentNames) {
+    if (known.has(name) || !matches(name)) continue;
+    known.add(name);
+    out.push({ name, source: "document" });
+  }
+  const fresh = toVariableName(query.replace(/\}+$/, ""));
+  if (fresh && !known.has(fresh)) out.push({ name: fresh, source: "new" });
+  return out;
+}
+export {
+  VARIABLE_STATE_CLASS,
+  classifyVariable,
+  toVariableName,
+  variableName,
+  variableNamesInText,
+  variableSuggestions
+};

package/dist/core/visual-document.d.ts

@@ -0,0 +1,52 @@
+import type { JSONContent } from "@tiptap/core";
+import type { Node as PMNode, Schema } from "@tiptap/pm/model";
+import { type SourceBlock } from "@ai-matrx/content-ir/source";
+import { type Adjacency } from "./markdown-serialize.js";
+export interface VisualLoadStats {
+    /** Stored prose blocks. */
+    proseBlocks: number;
+    /** Prose blocks held whole as source (see markdown-parse.ts). */
+    lockedBlocks: number;
+    /** Constructs inside editable prose blocks held as source. */
+    lockedChildren: number;
+    /** Constructs editable as rich text. */
+    editableChildren: number;
+    /** Stored islands (kinds, XML, fences, math, HTML, anchors…). */
+    islandBlocks: number;
+    /** Inline islands ({{variables}}, citations, inline math, tags…). */
+    inlineIslands: number;
+}
+export interface VisualPlan {
+    /** The text this document was built from. */
+    readonly text: string;
+    readonly blocks: readonly SourceBlock[];
+    /** For each non-gap block index, the next non-gap block index. */
+    readonly nextNonGap: ReadonlyMap<number, number>;
+    /** Text before the first block / after the last (document-edge spacing). */
+    readonly leading: string;
+    readonly trailing: string;
+    readonly adjacency: ReadonlyMap<string, Adjacency>;
+    /** Exact stored bytes of every direct child of a prose block, by id. */
+    readonly childRaw: ReadonlyMap<string, string>;
+    readonly stats: VisualLoadStats;
+}
+export interface VisualLoad {
+    json: JSONContent;
+    plan: VisualPlan;
+}
+export declare function buildVisualDocument(text: string, schema: Schema): VisualLoad;
+export interface VisualBaseline {
+    readonly plan: VisualPlan;
+    /** The editor's own top-level node for each stored block, by block index. */
+    readonly topNodes: ReadonlyMap<number, PMNode>;
+    /** The editor's own node for each direct child of a prose block, by id. */
+    readonly children: ReadonlyMap<string, PMNode>;
+}
+/**
+ * Record the loaded document as the "unchanged" reference. Call it with the
+ * document AS THE EDITOR HOLDS IT after load, never with the JSON — whatever
+ * the editor did on load is then part of the baseline, not an edit.
+ */
+export declare function captureBaseline(doc: PMNode, plan: VisualPlan): VisualBaseline;
+/** The current document → source text. Unchanged blocks are their stored bytes. */
+export declare function serializeVisualDocument(doc: PMNode, baseline: VisualBaseline): string;

package/dist/core/visual-document.js

@@ -0,0 +1,142 @@
+import { collectLinkDefinitions, tokenizeSource } from "@ai-matrx/content-ir/source";
+import { parseProseBlock } from "./markdown-parse.js";
+import {
+  createSerializeContext,
+  serializeBlock,
+  serializeChildren
+} from "./markdown-serialize.js";
+function buildVisualDocument(text, schema) {
+  const blocks = tokenizeSource(text);
+  const linkDefinitions = collectLinkDefinitions(text);
+  const adjacency = /* @__PURE__ */ new Map();
+  const childRaw = /* @__PURE__ */ new Map();
+  const nextNonGap = /* @__PURE__ */ new Map();
+  const stats = {
+    proseBlocks: 0,
+    lockedBlocks: 0,
+    lockedChildren: 0,
+    editableChildren: 0,
+    islandBlocks: 0,
+    inlineIslands: 0
+  };
+  let counter = 0;
+  const nextId = () => `m${counter += 1}`;
+  const content = [];
+  let prevIndex = null;
+  let firstStart = null;
+  let lastEnd = null;
+  blocks.forEach((block, index) => {
+    if (block.kind === "gap") return;
+    if (prevIndex !== null) nextNonGap.set(prevIndex, index);
+    prevIndex = index;
+    if (firstStart === null) firstStart = block.start;
+    lastEnd = block.end;
+    if (block.kind === "island") {
+      stats.islandBlocks += 1;
+      content.push({
+        type: "islandBlock",
+        attrs: {
+          raw: block.raw,
+          islandType: block.islandType ?? "fence",
+          complete: block.complete,
+          b: index
+        }
+      });
+      return;
+    }
+    stats.proseBlocks += 1;
+    stats.inlineIslands += block.inlines.length;
+    const parsed = parseProseBlock(block, schema, adjacency, nextId, linkDefinitions);
+    if (parsed.lockedReason !== null) {
+      stats.lockedBlocks += 1;
+      content.push({
+        type: "sourceLocked",
+        attrs: { raw: block.raw, reason: parsed.lockedReason, b: index }
+      });
+      return;
+    }
+    for (const child of parsed.children) {
+      childRaw.set(child.id, child.raw);
+      if (child.lockedReason) stats.lockedChildren += 1;
+      else stats.editableChildren += 1;
+    }
+    content.push({
+      type: "sourceBlock",
+      attrs: { b: index },
+      content: parsed.children.map((child) => child.json)
+    });
+  });
+  if (content.length === 0) content.push({ type: "paragraph" });
+  const leading = firstStart === null ? text : text.slice(0, firstStart);
+  const trailing = lastEnd === null ? "" : text.slice(lastEnd);
+  return {
+    json: { type: "doc", content },
+    plan: { text, blocks, nextNonGap, leading, trailing, adjacency, childRaw, stats }
+  };
+}
+function captureBaseline(doc, plan) {
+  const topNodes = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  doc.forEach((node) => {
+    const b = node.attrs.b;
+    if (typeof b === "number" && !topNodes.has(b)) topNodes.set(b, node);
+    if (node.type.name === "sourceBlock") {
+      node.forEach((child) => {
+        const id = child.attrs.mdId;
+        if (typeof id === "string" && !children.has(id)) children.set(id, child);
+      });
+    }
+  });
+  return { plan, topNodes, children };
+}
+function claimDescendantIds(node, claimed) {
+  node.descendants((child) => {
+    const id = child.attrs.mdId;
+    if (typeof id === "string") claimed.add(id);
+    return true;
+  });
+}
+function serializeVisualDocument(doc, baseline) {
+  const { plan } = baseline;
+  const ctx = createSerializeContext(plan.adjacency, (id, node) => {
+    const stored = plan.childRaw.get(id);
+    if (stored === void 0) return null;
+    return baseline.children.get(id)?.eq(node) ? stored : null;
+  });
+  const claimedBlocks = /* @__PURE__ */ new Set();
+  let out = plan.leading;
+  let prevB = null;
+  let first = true;
+  doc.forEach((node) => {
+    let b = typeof node.attrs.b === "number" ? node.attrs.b : null;
+    if (b !== null) {
+      if (claimedBlocks.has(b)) b = null;
+      else claimedBlocks.add(b);
+    }
+    let body;
+    const block = b !== null ? plan.blocks[b] : void 0;
+    if (b !== null && block && baseline.topNodes.get(b)?.eq(node)) {
+      body = block.raw;
+      claimDescendantIds(node, ctx.claimed);
+    } else if (node.type.name === "sourceBlock") {
+      body = serializeChildren(node, "wrapper", ctx);
+    } else {
+      body = serializeBlock(node, ctx);
+    }
+    if (body === "") return;
+    if (!first) {
+      const prevBlock = prevB !== null ? plan.blocks[prevB] : void 0;
+      const originallyAdjacent = prevB !== null && b !== null && plan.nextNonGap.get(prevB) === b;
+      out += originallyAdjacent && prevBlock && block ? plan.text.slice(prevBlock.end, block.start) : "\n\n";
+    }
+    out += body;
+    first = false;
+    prevB = b;
+  });
+  return out + plan.trailing;
+}
+export {
+  buildVisualDocument,
+  captureBaseline,
+  serializeVisualDocument
+};

package/dist/core/visual-find.d.ts

@@ -0,0 +1,27 @@
+import type { Node as PMNode } from "@tiptap/pm/model";
+import type { Transaction } from "@tiptap/pm/state";
+import { type FindOptions } from "./find-replace.js";
+export interface VisualMatch {
+    /** Document range for text matches; the island's own position for island matches. */
+    from: number;
+    to: number;
+    island: null | {
+        pos: number;
+        start: number;
+        end: number;
+        raw: string;
+    };
+}
+export interface VisualFindResult {
+    matches: VisualMatch[];
+    skippedProtected: number;
+    error: string | null;
+}
+export declare function findInDoc(doc: PMNode, query: string, options?: FindOptions): VisualFindResult;
+/**
+ * Replace the given matches in one transaction, back to front so earlier
+ * positions stay valid. Island matches rewrite the island's bytes; the caller
+ * records them as approved island edits. Returns the stored bytes of every
+ * island it changed.
+ */
+export declare function replaceInDoc(tr: Transaction, matches: readonly VisualMatch[], query: string, replacement: string, options?: FindOptions): string[];

package/dist/core/visual-find.js

@@ -0,0 +1,93 @@
+import { buildFindRegex, replacementFor } from "./find-replace.js";
+const ATOM = "\uFFFC";
+function findInDoc(doc, query, options = {}) {
+  const { regex, error } = buildFindRegex(query, options);
+  if (!regex) return { matches: [], skippedProtected: 0, error };
+  const matches = [];
+  let skippedProtected = 0;
+  const searchIsland = (node, pos) => {
+    const raw = String(node.attrs.raw ?? "");
+    for (const match of raw.matchAll(regex)) {
+      if (!match[0]) continue;
+      if (!options.includeProtected) {
+        skippedProtected += 1;
+        continue;
+      }
+      const start = match.index ?? 0;
+      matches.push({ from: pos, to: pos + node.nodeSize, island: { pos, start, end: start + match[0].length, raw } });
+    }
+  };
+  doc.descendants((node, pos) => {
+    if (node.type.name === "islandBlock" || node.type.name === "sourceLocked") {
+      searchIsland(node, pos);
+      return false;
+    }
+    if (!node.isTextblock) return true;
+    let text = "";
+    const map = [];
+    node.forEach((child, offset) => {
+      const childPos = pos + 1 + offset;
+      if (child.isText) {
+        for (let i = 0; i < (child.text ?? "").length; i += 1) map.push(childPos + i);
+        text += child.text ?? "";
+      } else {
+        if (child.type.name === "inlineIsland") searchIsland(child, childPos);
+        map.push(childPos);
+        text += ATOM;
+      }
+    });
+    for (const match of text.matchAll(regex)) {
+      if (!match[0] || match[0].includes(ATOM)) continue;
+      const start = match.index ?? 0;
+      const from = map[start];
+      const last = map[start + match[0].length - 1];
+      if (from === void 0 || last === void 0) continue;
+      matches.push({ from, to: last + 1, island: null });
+    }
+    return false;
+  });
+  matches.sort((a, b) => a.from - b.from || (a.island?.start ?? 0) - (b.island?.start ?? 0));
+  return { matches, skippedProtected, error: null };
+}
+function replaceInDoc(tr, matches, query, replacement, options = {}) {
+  const changedIslands = [];
+  const islandEdits = /* @__PURE__ */ new Map();
+  const textMatches = [];
+  for (const match of matches) {
+    if (match.island) {
+      const entry = islandEdits.get(match.island.pos) ?? { raw: match.island.raw, edits: [] };
+      entry.edits.push({ start: match.island.start, end: match.island.end });
+      islandEdits.set(match.island.pos, entry);
+    } else {
+      textMatches.push(match);
+    }
+  }
+  const ordered = [
+    ...textMatches.map((match) => ({ pos: match.from, apply: () => {
+      const found = tr.doc.textBetween(match.from, match.to);
+      tr.insertText(replacementFor(found, query, replacement, options), match.from, match.to);
+    } })),
+    ...[...islandEdits.entries()].map(([pos, entry]) => ({ pos, apply: () => {
+      const node = tr.doc.nodeAt(pos);
+      if (!node) return;
+      let next = "";
+      let cursor = 0;
+      for (const edit of entry.edits.sort((a, b) => a.start - b.start)) {
+        next += entry.raw.slice(cursor, edit.start);
+        next += replacementFor(entry.raw.slice(edit.start, edit.end), query, replacement, options);
+        cursor = edit.end;
+      }
+      next += entry.raw.slice(cursor);
+      if (next !== entry.raw) {
+        changedIslands.push(entry.raw);
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, raw: next });
+      }
+    } }))
+  ].sort((a, b) => b.pos - a.pos);
+  for (const step of ordered) step.apply();
+  return changedIslands;
+}
+export {
+  findInDoc,
+  replaceInDoc
+};

package/dist/format/format-target.d.ts

@@ -0,0 +1,39 @@
+import { type FormatCommandId } from "../core/markdown-format.js";
+import { type SourceEditResult } from "../core/source-format.js";
+export type FormatEngine = "visual" | "source" | "textarea";
+export interface FormatTarget {
+    engine: FormatEngine;
+    /** Run a command. False when the editor refused (read-only, destroyed). */
+    run(command: FormatCommandId): boolean;
+    /** Is the command already on for the selection (the toolbar's pressed state)? */
+    isActive(command: FormatCommandId): boolean;
+    /** Is there something to format (an editable, non-blank selection)? */
+    canFormat(): boolean;
+    /** Call `onChange` when the selection or text moves (pressed state follows). */
+    subscribe?(onChange: () => void): () => void;
+}
+/** The selection-zone host half every non-visual engine contributes. */
+export declare const MARKDOWN_FORMAT_HOST_KEY = "markdownFormat";
+export interface MarkdownFormatHost {
+    kind: "markdown-format";
+    target: FormatTarget;
+}
+export declare function markdownFormatHost(target: FormatTarget): Record<string, unknown>;
+export interface TextSelectionState {
+    text: string;
+    from: number;
+    to: number;
+    editable: boolean;
+}
+/** Any engine whose document is markdown text. `apply` writes the minimal change. */
+export declare function textFormatTarget(engine: "source" | "textarea", read: () => TextSelectionState | null, apply: (result: SourceEditResult, text: string) => void, subscribe?: (onChange: () => void) => () => void): FormatTarget;
+/**
+ * Write a text edit into a <textarea> so the browser's own undo takes it back
+ * and React's onChange sees it: the changes collapse to ONE replaced span (the
+ * bytes between them are re-inserted unchanged), inserted with
+ * `execCommand("insertText")` — the editing path that records undo — with
+ * `setRangeText` + an input event where that path is unavailable.
+ */
+export declare function applyEditToTextarea(el: HTMLTextAreaElement, result: SourceEditResult): void;
+/** The textarea engine. */
+export declare function textareaFormatTarget(el: HTMLTextAreaElement): FormatTarget;