@dojo-ng/rich-text-criticmarkup 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @dojo-ng/rich-text-criticmarkup
+
+CriticMarkup tracked-changes plugin for @dojo-ng/rich-text
+
+Part of [Dojo NG](../../README.md), a framework-agnostic web component library. BSD-3-Clause.
+
+> An opt-in plugin for `@dojo-ng/rich-text` (not a custom element). Tracks changes in CriticMarkup, the five-mark plain-text convention: `{++inserted++}`, `{--deleted--}`, `{~~old~>new~~}` (a substitution — imported as a deletion immediately followed by an insertion, and resolved as that pair, never as a lone half), `{>>comment<<}` (bare, or anchored right after a highlight), and `{==highlighted==}` (an annotation, kept on both accept and decline). Turn suggestion mode on with `setSuggestionMode(editor, true)` (or `createCriticMarkupPlugin({ suggesting: true })`): typed/deleted text is wrapped as marks instead of applied directly. Resolve one mark with `markAtSelection`/`acceptMark`/`declineMark`, or the whole document with `acceptAllMarks`/`declineAllMarks` — a bare comment is left standing either way, and a highlight's own anchored comment goes with it, since it is state on the node, not a separate mark. A paragraph split or merge proposed in suggestion mode is carried as a token (`¶`) inside a ONE-LINE mark rather than a real newline, because `@lexical/markdown` splits the document on `\n` before any transformer runs and a mark spanning that split could never be seen on import; `structuralEdits` (plugin option, default `"mark"`) controls this — `"annotate"` lets the edit happen untracked and drops a bare comment at the boundary instead, `"block"` refuses it outright, `"apply"` allows it silently. THE PARAGRAPH TOKEN IS A DIALECT, NOT CRITICMARKUP: no other CriticMarkup tool knows it, so a document written this way shows a literal `¶` to anything else — call `toPortableCriticMarkup(value)` to convert back to plain CriticMarkup before handing it to another tool (splitting a multi-paragraph mark into one mark per block, at the cost of a blank line left behind on decline — the price of interop), or set `structuralEdits: "annotate"` so this plugin never emits the token at all. A LITERAL PILCROW AN AUTHOR TYPES IS WRITTEN DOUBLED (`¶¶`) so it round-trips as itself rather than a break. A mark nested inside another (same kind or different) is detected and refused as its own node — masked to a private-use sentinel on import, unmasked back to literal delimiter text on export, rather than mangled the way a naive regex import would mangle it — firing `dj-criticmarkup-refused`. The grammar (`parseMarks`, `accept`/`decline`/`acceptAll`/`declineAll`, `stripComments`, the token functions) is a standalone string API with no Lexical import anywhere in it, for a consumer with markdown in hand and no editor — a build step, a server, a CLI; `fixtures/conformance.json` ships in the package so a second-language port of the same grammar (this plugin's own origin: a clean-room port of NovelMaker's Python `critic.py`) can run the identical cases. Comments are authored in the editor: `insertComment(editor, text)` inserts bare at a collapsed caret or anchors `{==selection==}{>>note<<}` over a range, `editComment` changes an existing note, and the two deletes are separately labeled because they are genuinely different — `removeComment` drops just the note and leaves the highlight, `removeHighlight` drops both. A NOTE BODY CANNOT CONTAIN `<<}` OR `{>>` (either would break its own mark on the next round trip); `isValidCommentText` checks this against the same grammar the string API uses, and an invalid save is refused inline, naming the offending sequence. To recognize CriticMarkup inside `@dojo-ng/rich-text-markdown`'s own general markdown format, compose `criticMarkupTransformers` into its transformer set; this plugin also registers its own `criticmarkup` format (`format="criticmarkup"`) so tracked changes work with no markdown plugin loaded at all. Setting `plugins` REPLACES the default set, so spread `...defaultPlugins` to keep bold/italic/underline + undo/redo.
+
+## Install
+
+```bash
+npm install @dojo-ng/rich-text-criticmarkup
+```
+
+## Usage
+
+Compose the plugin with the default set, starting in suggestion mode: typed/deleted text is wrapped as marks instead of applied directly.
+
+```html
+<dj-rich-text id="editor" label="Draft"></dj-rich-text>
+<script type="module">
+  import "@dojo-ng/rich-text";
+  import { defaultPlugins } from "@dojo-ng/rich-text";
+  import { createCriticMarkupPlugin } from "@dojo-ng/rich-text-criticmarkup";
+  const el = document.getElementById("editor");
+  el.plugins = [...defaultPlugins, createCriticMarkupPlugin({ suggesting: true })];
+  el.value = "The quick brown fox.";
+</script>
+```
+
+## Examples
+
+### Resolve CriticMarkup with no editor
+
+The grammar is a plain string API — parse and resolve marks from a server, a build step, or a CLI, with no Lexical/DOM dependency at all.
+
+```html
+import { parseMarks, acceptAll, declineAll } from "@dojo-ng/rich-text-criticmarkup";
+
+const draft = "The {--old--}{++new++} plan is set.";
+acceptAll(draft);                        // "The new plan is set."
+declineAll(draft);                       // "The old plan is set."
+parseMarks(draft).map((m) => m.kind);    // ["deletion", "insertion"]
+```

package/dist/comment-authoring.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Comment authoring (Track T4, decision 15): insert (bare or anchored), edit, and the two deletes.
+ * The UI shell (the popup with its text area and buttons) is Track T3/T4's `nodes.ts`/toolbar
+ * concern; these are the plain editor-level operations it calls.
+ */
+import { type LexicalEditor, type LexicalNode } from "lexical";
+/** Whether `text` is safe as a note body: `"{>>" + text + "<<}"` must parse as EXACTLY one comment
+ * mark spanning the whole string. A note containing `<<}` would terminate its own mark early on the
+ * next round trip; one containing `{>>` nests. This is the grammar module earning its place a second
+ * time (decision 2): the editor and the string API agree because they call the same parser. */
+export declare function isValidCommentText(text: string): boolean;
+/** Insert a comment at the current selection: bare at a collapsed caret, anchored (a `HighlightNode`
+ * carrying the note) over a range. */
+export declare function insertComment(editor: LexicalEditor, text: string): void;
+/** Change an existing note's text — a bare `CommentNode`'s own text, or a `HighlightNode`'s anchored
+ * comment. */
+export declare function editComment(editor: LexicalEditor, node: LexicalNode, text: string): void;
+/** "Remove note": drop an anchored comment's note, leaving the highlight and its text standing. */
+export declare function removeComment(editor: LexicalEditor, node: LexicalNode): void;
+/** "Remove highlight": drop both the note and the highlight, leaving the text unmarked. */
+export declare function removeHighlight(editor: LexicalEditor, node: LexicalNode): void;

package/dist/comment-authoring.js

@@ -0,0 +1,79 @@
+/**
+ * Comment authoring (Track T4, decision 15): insert (bare or anchored), edit, and the two deletes.
+ * The UI shell (the popup with its text area and buttons) is Track T3/T4's `nodes.ts`/toolbar
+ * concern; these are the plain editor-level operations it calls.
+ */
+import { $getNodeByKey, $getSelection, $isRangeSelection } from "lexical";
+import { parseMarks } from "./grammar.js";
+import { $createCommentNode, $createHighlightNode, $isCommentNode, $isHighlightNode } from "./nodes.js";
+/** Whether `text` is safe as a note body: `"{>>" + text + "<<}"` must parse as EXACTLY one comment
+ * mark spanning the whole string. A note containing `<<}` would terminate its own mark early on the
+ * next round trip; one containing `{>>` nests. This is the grammar module earning its place a second
+ * time (decision 2): the editor and the string API agree because they call the same parser. */
+export function isValidCommentText(text) {
+    const candidate = `{>>${text}<<}`;
+    const marks = parseMarks(candidate);
+    return marks.length === 1 && marks[0].kind === "comment" && marks[0].start === 0 && marks[0].end === candidate.length;
+}
+function assertValidCommentText(text) {
+    if (isValidCommentText(text))
+        return;
+    const offending = text.includes("<<}") ? "<<}" : text.includes("{>>") ? "{>>" : "a sequence that breaks the mark";
+    throw new Error(`Comment text is not valid: it contains "${offending}", which would not round-trip through value.`);
+}
+/** Insert a comment at the current selection: bare at a collapsed caret, anchored (a `HighlightNode`
+ * carrying the note) over a range. */
+export function insertComment(editor, text) {
+    assertValidCommentText(text);
+    editor.update(() => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection))
+            return;
+        if (selection.isCollapsed()) {
+            selection.insertNodes([$createCommentNode(text)]);
+            return;
+        }
+        const nodes = selection.extract();
+        if (nodes.length === 0)
+            return;
+        const highlightNode = $createHighlightNode();
+        highlightNode.setComment(text);
+        nodes[0].insertBefore(highlightNode);
+        for (const node of nodes)
+            highlightNode.append(node);
+    }, { discrete: true });
+}
+/** Change an existing note's text — a bare `CommentNode`'s own text, or a `HighlightNode`'s anchored
+ * comment. */
+export function editComment(editor, node, text) {
+    assertValidCommentText(text);
+    editor.update(() => {
+        const fresh = $getNodeByKey(node.getKey());
+        if ($isCommentNode(fresh))
+            fresh.setText(text);
+        else if ($isHighlightNode(fresh))
+            fresh.setComment(text);
+    }, { discrete: true });
+}
+/** "Remove note": drop an anchored comment's note, leaving the highlight and its text standing. */
+export function removeComment(editor, node) {
+    editor.update(() => {
+        const fresh = $getNodeByKey(node.getKey());
+        if ($isHighlightNode(fresh))
+            fresh.setComment(null);
+    }, { discrete: true });
+}
+/** "Remove highlight": drop both the note and the highlight, leaving the text unmarked. */
+export function removeHighlight(editor, node) {
+    editor.update(() => {
+        const fresh = $getNodeByKey(node.getKey());
+        if ($isHighlightNode(fresh))
+            unwrap(fresh);
+    }, { discrete: true });
+}
+/** Replace `node` with its own children, in place (the standard Lexical "unlink" shape). */
+function unwrap(node) {
+    for (const child of node.getChildren())
+        node.insertBefore(child);
+    node.remove();
+}

package/dist/comment-popup.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The comment popup shell (Track T3, filled in by T4): ONE shared `dj-popup` holding a
+ * `dj-text-area` and Save/Cancel/"Remove note"/"Remove highlight" controls, opened against
+ * whichever control triggered it — the toolbar's add-comment button, a bare `CommentNode`'s own
+ * button, or a `HighlightNode` with a comment. Built once by the plugin's `setup()` (decision 15's
+ * "the popup and its focus handling exist in one place"), not per node instance.
+ *
+ * Focus management (decision 15): opening moves focus to the text area; Escape closes without
+ * saving; Save and Cancel both return focus to the control that opened the popup.
+ */
+import "@dojo-ng/popup";
+import "@dojo-ng/text-area";
+import "@dojo-ng/button";
+import type { LexicalEditor, LexicalNode } from "lexical";
+export type CommentPopupMode = "insert-bare" | "insert-anchored" | "edit-comment" | "edit-highlight";
+export interface CommentPopupOpenOptions {
+    anchor: HTMLElement;
+    mode: CommentPopupMode;
+    /** The current text to seed the field with — "" for an insert. */
+    text: string;
+    /** Required for "edit-comment"/"edit-highlight"; ignored for the insert modes. */
+    node?: LexicalNode;
+}
+export interface CommentPopupController {
+    /** The `dj-popup` element — append it once, anywhere reachable in the DOM. */
+    element: HTMLElement;
+    open(options: CommentPopupOpenOptions): void;
+}
+export declare function createCommentPopupController(editor: LexicalEditor, msg: (key: string) => string): CommentPopupController;

package/dist/comment-popup.js

@@ -0,0 +1,120 @@
+/**
+ * The comment popup shell (Track T3, filled in by T4): ONE shared `dj-popup` holding a
+ * `dj-text-area` and Save/Cancel/"Remove note"/"Remove highlight" controls, opened against
+ * whichever control triggered it — the toolbar's add-comment button, a bare `CommentNode`'s own
+ * button, or a `HighlightNode` with a comment. Built once by the plugin's `setup()` (decision 15's
+ * "the popup and its focus handling exist in one place"), not per node instance.
+ *
+ * Focus management (decision 15): opening moves focus to the text area; Escape closes without
+ * saving; Save and Cancel both return focus to the control that opened the popup.
+ */
+import "@dojo-ng/popup";
+import "@dojo-ng/text-area";
+import "@dojo-ng/button";
+import { editComment, insertComment, removeComment, removeHighlight } from "./comment-authoring.js";
+export function createCommentPopupController(editor, msg) {
+    const popup = document.createElement("dj-popup");
+    popup.position = "below";
+    popup.className = "dj-cm-comment-popup";
+    const panel = document.createElement("div");
+    panel.className = "dj-cm-comment-popup-panel";
+    const textArea = document.createElement("dj-text-area");
+    textArea.setAttribute("label", msg("comment"));
+    textArea.setAttribute("label-hidden", "");
+    textArea.setAttribute("rows", "3");
+    const error = document.createElement("div");
+    error.className = "dj-cm-comment-popup-error";
+    error.setAttribute("role", "alert");
+    error.hidden = true;
+    const actions = document.createElement("div");
+    actions.className = "dj-cm-comment-popup-actions";
+    const saveButton = document.createElement("dj-button");
+    saveButton.setAttribute("kind", "contained");
+    saveButton.textContent = msg("save");
+    const cancelButton = document.createElement("dj-button");
+    cancelButton.setAttribute("kind", "text");
+    cancelButton.textContent = msg("cancel");
+    const removeNoteButton = document.createElement("dj-button");
+    removeNoteButton.setAttribute("kind", "text");
+    removeNoteButton.textContent = msg("removeNote");
+    const removeHighlightButton = document.createElement("dj-button");
+    removeHighlightButton.setAttribute("kind", "text");
+    removeHighlightButton.textContent = msg("removeHighlight");
+    actions.append(saveButton, cancelButton, removeNoteButton, removeHighlightButton);
+    panel.append(textArea, error, actions);
+    popup.append(panel);
+    let state = {
+        mode: "insert-bare",
+        node: null,
+        returnFocus: null,
+    };
+    function showError(message) {
+        error.textContent = message;
+        error.hidden = false;
+    }
+    function clearError() {
+        error.hidden = true;
+        error.textContent = "";
+    }
+    function close() {
+        popup.open = false;
+        state.returnFocus?.focus();
+    }
+    function save() {
+        clearError();
+        const text = textArea.value;
+        try {
+            switch (state.mode) {
+                case "insert-bare":
+                case "insert-anchored":
+                    insertComment(editor, text);
+                    break;
+                case "edit-comment":
+                case "edit-highlight":
+                    if (state.node)
+                        editComment(editor, state.node, text);
+                    break;
+            }
+        }
+        catch (err) {
+            showError(err instanceof Error ? err.message : String(err));
+            return;
+        }
+        close();
+    }
+    function doRemoveNote() {
+        if (state.node)
+            removeComment(editor, state.node);
+        close();
+    }
+    function doRemoveHighlight() {
+        if (state.node)
+            removeHighlight(editor, state.node);
+        close();
+    }
+    saveButton.addEventListener("click", save);
+    cancelButton.addEventListener("click", close);
+    removeNoteButton.addEventListener("click", doRemoveNote);
+    removeHighlightButton.addEventListener("click", doRemoveHighlight);
+    popup.addEventListener("dj-close", () => {
+        state.returnFocus?.focus();
+    });
+    textArea.addEventListener("keydown", (e) => {
+        if (e.key === "Escape") {
+            e.stopPropagation();
+            close();
+        }
+    });
+    function open(options) {
+        state = { mode: options.mode, node: options.node ?? null, returnFocus: options.anchor };
+        clearError();
+        textArea.value = options.text;
+        const showDeletes = options.mode === "edit-highlight";
+        removeNoteButton.hidden = !showDeletes;
+        removeHighlightButton.hidden = !showDeletes;
+        popup.anchor = options.anchor;
+        popup.open = true;
+        queueMicrotask(() => textArea.focus());
+    }
+    return { element: popup, open };
+}

package/dist/format.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The "criticmarkup" format's import/export walk (Track N3). Decision 13: this plugin registers its
+ * own `criticmarkup` format so `format="criticmarkup"` works with no markdown plugin loaded at all —
+ * these functions match `RichTextFormat`'s `serialize`/`deserialize` shape but stay free of a
+ * `@dojo-ng/rich-text` dependency; whichever track assembles the full plugin object wires them into
+ * `formats: { criticmarkup: { serialize, deserialize } }`.
+ *
+ * Both functions are `$`-prefixed-helper callers, not scope-openers: `deserializeCriticMarkup` runs
+ * inside an `editor.update`, `serializeCriticMarkup` inside an `editor.getEditorState().read` — the
+ * same contract every other `RichTextFormat` in this codebase follows.
+ */
+import { type LexicalEditor } from "lexical";
+export interface CriticMarkupRefusedDetail {
+    /** "nested": a same- or different-kind nested mark, masked rather than imported as its own node.
+     * "block-spanning": a mark `tokenizeBlockSpanning` left spanning a block — unreachable with the
+     * default paragraph token, since tokenizing eliminates every case that reason describes; kept for
+     * a host that configures `paragraphToken: ""` and gets the pre-decision-16 behavior back. */
+    reason: "nested" | "block-spanning";
+    /** Offsets into the tokenized text this pipeline actually masked and imported — not the caller's
+     * original `data`, which tokenizing may have shortened. */
+    start: number;
+    end: number;
+}
+declare global {
+    interface GlobalEventHandlersEventMap {
+        "dj-criticmarkup-refused": CustomEvent<CriticMarkupRefusedDetail>;
+    }
+}
+export interface DeserializeCriticMarkupOptions {
+    /** The paragraph-break token (decision 16). Default `PARAGRAPH_TOKEN`. */
+    paragraphToken?: string;
+}
+/**
+ * Import `data` as CriticMarkup: `tokenizeBlockSpanning`, then `maskNested`, then the markdown
+ * conversion through `criticMarkupTransformers`, then an unmask walk over the resulting text nodes.
+ * Emits `dj-criticmarkup-refused` on `editor.getRootElement()` for anything the grammar reports as
+ * nested or (in the `paragraphToken: ""` case) still block-spanning — computed from the tokenized
+ * text BEFORE masking, since masking is what makes those marks invisible to `parseMarks` afterward.
+ */
+export declare function deserializeCriticMarkup(editor: LexicalEditor, data: string, options?: DeserializeCriticMarkupOptions): void;
+/** The plain export walk: the markdown conversion through `criticMarkupTransformers`. */
+export declare function serializeCriticMarkup(_editor: LexicalEditor): string;

package/dist/format.js

@@ -0,0 +1,65 @@
+/**
+ * The "criticmarkup" format's import/export walk (Track N3). Decision 13: this plugin registers its
+ * own `criticmarkup` format so `format="criticmarkup"` works with no markdown plugin loaded at all —
+ * these functions match `RichTextFormat`'s `serialize`/`deserialize` shape but stay free of a
+ * `@dojo-ng/rich-text` dependency; whichever track assembles the full plugin object wires them into
+ * `formats: { criticmarkup: { serialize, deserialize } }`.
+ *
+ * Both functions are `$`-prefixed-helper callers, not scope-openers: `deserializeCriticMarkup` runs
+ * inside an `editor.update`, `serializeCriticMarkup` inside an `editor.getEditorState().read` — the
+ * same contract every other `RichTextFormat` in this codebase follows.
+ */
+import { $getRoot, $isElementNode, $isTextNode } from "lexical";
+import { $convertFromMarkdownString, $convertToMarkdownString } from "@lexical/markdown";
+import { parseMarks, tokenizeBlockSpanning, maskNested, unmaskNested, PARAGRAPH_TOKEN } from "./grammar.js";
+import { criticMarkupTransformers } from "./transformers.js";
+/**
+ * Import `data` as CriticMarkup: `tokenizeBlockSpanning`, then `maskNested`, then the markdown
+ * conversion through `criticMarkupTransformers`, then an unmask walk over the resulting text nodes.
+ * Emits `dj-criticmarkup-refused` on `editor.getRootElement()` for anything the grammar reports as
+ * nested or (in the `paragraphToken: ""` case) still block-spanning — computed from the tokenized
+ * text BEFORE masking, since masking is what makes those marks invisible to `parseMarks` afterward.
+ */
+export function deserializeCriticMarkup(editor, data, options = {}) {
+    const token = options.paragraphToken ?? PARAGRAPH_TOKEN;
+    const tokenized = tokenizeBlockSpanning(data, token);
+    const refusals = refusalsIn(tokenized);
+    const { masked } = maskNested(tokenized);
+    $convertFromMarkdownString(masked, criticMarkupTransformers);
+    unmaskTextNodes($getRoot());
+    for (const detail of refusals)
+        dispatchRefused(editor, detail);
+}
+/** The plain export walk: the markdown conversion through `criticMarkupTransformers`. */
+export function serializeCriticMarkup(_editor) {
+    return $convertToMarkdownString(criticMarkupTransformers);
+}
+function refusalsIn(text) {
+    const marks = parseMarks(text);
+    const refusals = [];
+    for (const mark of marks) {
+        const container = marks.find((p) => p !== mark && p.start <= mark.start && mark.end <= p.end);
+        if (container)
+            refusals.push({ reason: "nested", start: mark.start, end: mark.end });
+        else if (mark.spansBlock)
+            refusals.push({ reason: "block-spanning", start: mark.start, end: mark.end });
+    }
+    return refusals;
+}
+function unmaskTextNodes(node) {
+    if ($isTextNode(node)) {
+        const current = node.getTextContent();
+        const unmasked = unmaskNested(current);
+        if (unmasked !== current)
+            node.setTextContent(unmasked);
+        return;
+    }
+    if ($isElementNode(node)) {
+        for (const child of node.getChildren())
+            unmaskTextNodes(child);
+    }
+}
+function dispatchRefused(editor, detail) {
+    const root = editor.getRootElement();
+    root?.dispatchEvent(new CustomEvent("dj-criticmarkup-refused", { detail, bubbles: true, composed: true }));
+}

package/dist/grammar.d.ts

@@ -0,0 +1,122 @@
+/**
+ * CriticMarkup grammar: parsing the five marks, and resolving them.
+ *
+ * No Lexical import here — this module is a plain string API so a consumer with markdown in hand
+ * and no editor (a build step, a server, a CLI) can parse and resolve CriticMarkup too. The editor
+ * package (Track N) calls into this rather than keeping its own copy.
+ *
+ * Not a regex per mark: a lazily-matched regex pairs the FIRST close token it finds, so
+ * `{--a {--b--} c--}` mis-pairs with the INNER close and leaves ` c--}` sitting in the prose as
+ * literal characters. `parseMarks` is a small stack machine instead: it opens a frame on any of the
+ * five open tokens and closes the frame ON TOP OF THE STACK on its matching close token, so a nested
+ * mark — same kind or different — always closes before the mark around it does.
+ */
+export type MarkKind = "insertion" | "deletion" | "substitution" | "comment" | "highlight";
+export interface Mark {
+    kind: MarkKind;
+    /** Offsets into the ORIGINAL string; text.slice(start, end) is the mark as written. */
+    start: number;
+    end: number;
+    /** True when a blank line falls inside the mark's own span. */
+    spansBlock: boolean;
+    /** True when this mark contains another mark. */
+    nested: boolean;
+    /** insertion | deletion | comment | highlight */
+    text?: string;
+    /** substitution only */
+    old?: string;
+    new?: string;
+}
+/**
+ * Every CriticMarkup mark in `text`, in reading order — nested marks included as their own entries,
+ * alongside the outer mark that contains them.
+ *
+ * An unterminated mark — an open token with no matching close anywhere after it — produces no entry
+ * at all, and is left as the literal characters it is. The alternative, scanning until some LATER,
+ * unrelated mark's close token turns up, would swallow everything in between as one giant mark,
+ * which is worse than finding nothing.
+ */
+export declare function parseMarks(text: string): Mark[];
+/**
+ * Apply `mark`: keep an insertion's (or a substitution's new) text; drop a deletion; keep a
+ * highlight's text, its own anchored comment going with it; leave a bare comment untouched.
+ */
+export declare function accept(text: string, mark: Mark): string;
+/**
+ * Reject `mark`: restore a deletion's (or a substitution's old) text; drop an insertion; keep a
+ * highlight's text (and its own anchored comment, if any); leave a bare comment untouched.
+ */
+export declare function decline(text: string, mark: Mark): string;
+/**
+ * Resolve every mark as `accept` would, nested ones included. Idempotent: a body with no marks is
+ * returned unchanged.
+ *
+ * Re-parses after each single resolution rather than applying a batch of offsets: resolving an
+ * outer mark moves everything after its opening delimiter, so a stale offset for a nested mark would
+ * land on the wrong span.
+ */
+export declare function acceptAll(text: string): string;
+/** `acceptAll`'s opposite. See its docstring for why this re-parses. */
+export declare function declineAll(text: string): string;
+/** Remove every bare comment mark, right to left, leaving everything else untouched. */
+export declare function stripComments(text: string): string;
+/**
+ * Split a block-spanning insertion, deletion, or highlight into one mark per block, so every mark
+ * ends up on a single line: `{++A\n\nB++}` becomes `{++A++}\n\n{++B++}`, which renders identically.
+ *
+ * Superseded as the import-time normalization by `tokenizeBlockSpanning` (decision 16); this
+ * function is unchanged from decision 8 and survives only as the step `toPortableCriticMarkup`
+ * uses to turn the dialect back into plain CriticMarkup.
+ *
+ * A substitution is left alone — splitting one means deciding how `old` and `new` pair up block for
+ * block, which is not always well defined — and so is a comment, which has no per-block content to
+ * repeat. Both arrive as literal delimiter characters: visible to the author, never silently merged
+ * into the prose.
+ *
+ * Declining the SPLIT form leaves the blank line between the pieces where declining the unsplit form
+ * would have removed it too — no prose is lost either way, but it is a known, accepted cost of this
+ * route, not an oversight.
+ */
+export declare function normalizeBlockSpanning(text: string): string;
+/** The paragraph-break token: a break carried inside a mark instead of a real newline. */
+export declare const PARAGRAPH_TOKEN = "\u00B6";
+/** A literal token character in prose is escaped by doubling, so it round-trips through a mark. */
+export declare function escapeToken(text: string, token?: string): string;
+/** The exact inverse of `escapeToken`: a doubled token becomes one literal character again. */
+export declare function unescapeToken(text: string, token?: string): string;
+/**
+ * Real newlines inside a mark become the paragraph token, one mark's content at a time — decision
+ * 16's replacement for `normalizeBlockSpanning`'s splitting at import time. Unlike that route, this
+ * applies to all five kinds: a block-spanning substitution or comment tokenizes too, since the break
+ * is now an ordinary character inside a one-line mark rather than a structural split.
+ *
+ * Escapes any existing literal token character WITHIN a spanning mark's own content first, so a
+ * literal pilcrow sitting next to the blank line being converted is not confused with the new
+ * structural break — scoped to that one mark's content, not the whole document: a document that
+ * ROUND-TRIPS through this dialect already satisfies "single token is structural, doubled token is
+ * literal" everywhere else (decision 16's own invariant, kept by `escapeToken` on every export), and
+ * escaping the whole text here would re-double a break token that already exists in some OTHER,
+ * non-spanning mark — corrupting exactly the values this function is meant to leave alone.
+ */
+export declare function tokenizeBlockSpanning(text: string, token?: string): string;
+/**
+ * Convert a dialect document back to plain CriticMarkup, for handing to a tool that does not know
+ * the paragraph token: structural tokens become real newlines (and escaped literal tokens become the
+ * single character they stand for), then `normalizeBlockSpanning` splits the resulting block-spanning
+ * marks the decision-8 way — accepting that route's blank-line-on-decline cost as the price of
+ * portability.
+ */
+export declare function toPortableCriticMarkup(text: string, token?: string): string;
+/**
+ * Replace the delimiter characters of every mark nested inside another mark with a sentinel from the
+ * U+E000 private-use block, one code point per delimiter character — leaving the nested mark's own
+ * content untouched. The editor's import path is regex-based and cannot see a same-kind nested mark
+ * correctly (`parseMarks` can); masking lets the OUTER mark import correctly, with the inner
+ * delimiters arriving as ordinary text. `unmaskNested` is this function's exact inverse.
+ */
+export declare function maskNested(text: string): {
+    masked: string;
+    masks: number;
+};
+/** The exact inverse of `maskNested`: every sentinel code point becomes its real delimiter character. */
+export declare function unmaskNested(text: string): string;