@dojo-ng/rich-text-criticmarkup 0.1.0

package/dist/grammar.js

@@ -0,0 +1,399 @@
+/**
+ * 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.
+ */
+const OPEN = {
+    "{++": "insertion",
+    "{--": "deletion",
+    "{~~": "substitution",
+    "{>>": "comment",
+    "{==": "highlight",
+};
+const CLOSE = {
+    insertion: "++}",
+    deletion: "--}",
+    substitution: "~~}",
+    comment: "<<}",
+    highlight: "==}",
+};
+// The `old~>new` separator inside a substitution. Its own token because a substitution's close
+// token, `~~}`, must not fire until this has been seen — see the frame's `sepPos` below.
+const SEP = "~>";
+// Every open and close token is exactly 3 characters, which the masking and tokenizing code below
+// relies on rather than looking each one up by kind.
+const TOKEN_LEN = 3;
+// A code fence hides CriticMarkup the same way it hides any other markdown instruction: a novel
+// legitimately containing `{--` inside a fenced snippet must not become a tracked change.
+const FENCE = /^\s{0,3}(```|~~~)/;
+// A blank line — one line that is empty or all whitespace — is a block boundary in CommonMark.
+// `@lexical/markdown` splits the document on `\n` before any transformer runs, so a mark whose span
+// crosses one can never be seen by a text-match transformer (see decisions 8 and 16).
+const BLANK_LINE = /\n[ \t]*\n/;
+const BLANK_LINE_G = /\n[ \t]*\n/g;
+function fenceMask(text) {
+    const mask = new Uint8Array(text.length);
+    let inFence = false;
+    let offset = 0;
+    for (const line of splitKeepEnds(text)) {
+        const fenceLine = FENCE.test(line);
+        const hide = fenceLine || inFence;
+        if (fenceLine)
+            inFence = !inFence;
+        if (hide)
+            for (let i = offset; i < offset + line.length; i++)
+                mask[i] = 1;
+        offset += line.length;
+    }
+    return mask;
+}
+function splitKeepEnds(text) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\n") {
+            lines.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    if (start < text.length)
+        lines.push(text.slice(start));
+    return lines;
+}
+class Frame {
+    constructor(kind, start, contentStart) {
+        this.sepPos = null; // substitution only
+        this.nested = false; // set when a mark closes while this frame is still open beneath it
+        this.kind = kind;
+        this.start = start;
+        this.contentStart = contentStart;
+    }
+}
+/**
+ * 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 function parseMarks(text) {
+    const fence = fenceMask(text);
+    const stack = [];
+    const results = [];
+    const n = text.length;
+    let i = 0;
+    while (i < n) {
+        if (fence[i]) {
+            i++;
+            continue;
+        }
+        const top = stack.length ? stack[stack.length - 1] : null;
+        if (top) {
+            const close = CLOSE[top.kind];
+            const ready = top.kind !== "substitution" || top.sepPos !== null;
+            if (ready && text.startsWith(close, i)) {
+                results.push(finish(text, top, i, close.length));
+                stack.pop();
+                if (stack.length)
+                    stack[stack.length - 1].nested = true;
+                i += close.length;
+                continue;
+            }
+            if (top.kind === "substitution" && top.sepPos === null && text.startsWith(SEP, i)) {
+                top.sepPos = i;
+                i += SEP.length;
+                continue;
+            }
+        }
+        const openToken = Object.keys(OPEN).find((token) => text.startsWith(token, i));
+        if (openToken) {
+            stack.push(new Frame(OPEN[openToken], i, i + openToken.length));
+            i += openToken.length;
+            continue;
+        }
+        i++;
+    }
+    // Frames still open at EOF are the unterminated case: abandoned, not reported.
+    results.sort((a, b) => a.start - b.start);
+    return results;
+}
+function finish(text, frame, closePos, closeLen) {
+    const end = closePos + closeLen;
+    const mark = {
+        kind: frame.kind,
+        start: frame.start,
+        end,
+        spansBlock: BLANK_LINE.test(text.slice(frame.start, end)),
+        nested: frame.nested,
+    };
+    if (frame.kind === "substitution") {
+        mark.old = text.slice(frame.contentStart, frame.sepPos);
+        mark.new = text.slice(frame.sepPos + SEP.length, closePos);
+    }
+    else {
+        mark.text = text.slice(frame.contentStart, closePos);
+    }
+    return mark;
+}
+// --- accept, decline, and the bulk forms ------------------------------------------------------
+/**
+ * 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 function accept(text, mark) {
+    return resolve(text, mark, "new");
+}
+/**
+ * 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 function decline(text, mark) {
+    return resolve(text, mark, "old");
+}
+function resolve(text, mark, side) {
+    if (mark.kind === "comment") {
+        // Only a BARE comment reaches this branch — an anchored one is consumed by its highlight's
+        // own resolution below, before it would ever be resolved on its own.
+        return text;
+    }
+    const end = mark.kind === "highlight" ? highlightEnd(text, mark) : mark.end;
+    return text.slice(0, mark.start) + keptText(mark, side) + text.slice(end);
+}
+/**
+ * `mark`'s own `end`, extended to swallow an immediately adjacent `{>>...<<}` — CriticMarkup's
+ * anchored-comment convention. Re-parses the text right after `mark` rather than matching a regex,
+ * so a comment containing its own delimiters is still found correctly.
+ */
+function highlightEnd(text, mark) {
+    if (!text.startsWith("{>>", mark.end))
+        return mark.end;
+    const following = parseMarks(text.slice(mark.end));
+    if (following.length && following[0].kind === "comment" && following[0].start === 0) {
+        return mark.end + following[0].end;
+    }
+    return mark.end;
+}
+function keptText(mark, side) {
+    switch (mark.kind) {
+        case "highlight":
+            return resolveParagraphTokens(mark.text);
+        case "substitution":
+            return resolveParagraphTokens(side === "new" ? mark.new : mark.old);
+        case "insertion":
+            return side === "new" ? resolveParagraphTokens(mark.text) : "";
+        case "deletion":
+            return side === "new" ? "" : resolveParagraphTokens(mark.text);
+        default:
+            throw new Error(`unknown mark kind ${mark.kind}`);
+    }
+}
+/**
+ * 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 function acceptAll(text) {
+    return resolveAll(text, accept);
+}
+/** `acceptAll`'s opposite. See its docstring for why this re-parses. */
+export function declineAll(text) {
+    return resolveAll(text, decline);
+}
+function resolveAll(text, resolveOne) {
+    let marks = parseMarks(text);
+    let i = 0;
+    while (i < marks.length) {
+        const mark = marks[i];
+        if (mark.kind === "comment") {
+            // A bare comment is left standing (decision 10), skipped in place rather than resolved —
+            // resolving it would return the text unchanged for this same mark and spin forever.
+            i++;
+            continue;
+        }
+        text = resolveOne(text, mark);
+        marks = parseMarks(text);
+        i = 0;
+    }
+    return text;
+}
+/** Remove every bare comment mark, right to left, leaving everything else untouched. */
+export function stripComments(text) {
+    const marks = parseMarks(text).filter((m) => m.kind === "comment");
+    marks.sort((a, b) => b.start - a.start);
+    for (const mark of marks)
+        text = text.slice(0, mark.start) + text.slice(mark.end);
+    return text;
+}
+// --- decision 8, route 1: split a block-spanning mark into one mark per block -----------------
+const SPLITTABLE = {
+    insertion: ["{++", "++}"],
+    deletion: ["{--", "--}"],
+    highlight: ["{==", "==}"],
+};
+/**
+ * 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 function normalizeBlockSpanning(text) {
+    const marks = parseMarks(text).filter((m) => m.spansBlock && m.kind in SPLITTABLE);
+    marks.sort((a, b) => b.start - a.start); // right to left: splitting changes the body's length
+    for (const mark of marks) {
+        const [openTok, closeTok] = SPLITTABLE[mark.kind];
+        const blocks = mark.text.split(BLANK_LINE_G);
+        const rewritten = blocks.map((block) => `${openTok}${block}${closeTok}`).join("\n\n");
+        text = text.slice(0, mark.start) + rewritten + text.slice(mark.end);
+    }
+    return text;
+}
+// --- decision 16: the paragraph-break token -----------------------------------------------------
+/** The paragraph-break token: a break carried inside a mark instead of a real newline. */
+export const PARAGRAPH_TOKEN = "¶";
+/** A literal token character in prose is escaped by doubling, so it round-trips through a mark. */
+export function escapeToken(text, token = PARAGRAPH_TOKEN) {
+    if (token === "")
+        return text;
+    return text.split(token).join(token + token);
+}
+/** The exact inverse of `escapeToken`: a doubled token becomes one literal character again. */
+export function unescapeToken(text, token = PARAGRAPH_TOKEN) {
+    if (token === "")
+        return text;
+    return text.split(token + token).join(token);
+}
+/**
+ * Resolve a piece of KEPT mark text: an unpaired (structural) token becomes a real paragraph break,
+ * and a doubled (escaped) token becomes the single literal character it stands for. Scans
+ * left-to-right so a doubled pair is consumed as a unit and never mistaken for two lone tokens.
+ */
+function resolveParagraphTokens(text, token = PARAGRAPH_TOKEN) {
+    if (token === "")
+        return text;
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        if (text.startsWith(token, i)) {
+            if (text.startsWith(token, i + token.length)) {
+                out += token + token; // escaped pair — unescapeToken folds it below
+                i += token.length * 2;
+            }
+            else {
+                out += "\n\n"; // unpaired: a structural break
+                i += token.length;
+            }
+        }
+        else {
+            out += text[i];
+            i++;
+        }
+    }
+    return unescapeToken(out, token);
+}
+/**
+ * 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 function tokenizeBlockSpanning(text, token = PARAGRAPH_TOKEN) {
+    if (token === "")
+        return text; // disabled, matching escapeToken/unescapeToken's own convention
+    const marks = parseMarks(text).filter((m) => m.spansBlock);
+    if (!marks.length)
+        return text;
+    marks.sort((a, b) => b.start - a.start); // right to left: rewriting changes the body's length
+    let body = text;
+    for (const mark of marks) {
+        const contentStart = mark.start + TOKEN_LEN;
+        const contentEnd = mark.end - TOKEN_LEN;
+        const content = escapeToken(body.slice(contentStart, contentEnd), token).replace(BLANK_LINE_G, token);
+        body = body.slice(0, contentStart) + content + body.slice(contentEnd);
+    }
+    return body;
+}
+/**
+ * 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 function toPortableCriticMarkup(text, token = PARAGRAPH_TOKEN) {
+    return normalizeBlockSpanning(resolveParagraphTokens(text, token));
+}
+// --- decision 11: nesting is detected and masked, not mangled ----------------------------------
+// One private-use sentinel per CriticMarkup delimiter character, so masking is a plain,
+// length-preserving character substitution with a trivial exact inverse.
+const DELIMITER_CHARS = ["{", "}", "+", "-", "~", ">", "<", "="];
+const MASK_OF = new Map(DELIMITER_CHARS.map((ch, i) => [ch, String.fromCodePoint(0xe000 + i)]));
+const UNMASK_OF = new Map(DELIMITER_CHARS.map((ch, i) => [String.fromCodePoint(0xe000 + i), ch]));
+/**
+ * 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 function maskNested(text) {
+    const marks = parseMarks(text);
+    const nested = marks.filter((m) => marks.some((p) => p !== m && p.start <= m.start && m.end <= p.end));
+    if (!nested.length)
+        return { masked: text, masks: 0 };
+    const units = text.split("");
+    for (const mark of nested) {
+        maskRange(units, mark.start, mark.start + TOKEN_LEN);
+        maskRange(units, mark.end - TOKEN_LEN, mark.end);
+        if (mark.kind === "substitution") {
+            const sepPos = mark.start + TOKEN_LEN + mark.old.length;
+            maskRange(units, sepPos, sepPos + SEP.length);
+        }
+    }
+    return { masked: units.join(""), masks: nested.length };
+}
+function maskRange(units, start, end) {
+    for (let i = start; i < end; i++) {
+        const masked = MASK_OF.get(units[i]);
+        if (masked)
+            units[i] = masked;
+    }
+}
+/** The exact inverse of `maskNested`: every sentinel code point becomes its real delimiter character. */
+export function unmaskNested(text) {
+    let out = "";
+    for (const ch of text)
+        out += UNMASK_OF.get(ch) ?? ch;
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./grammar.js";
+export * from "./nodes.js";
+export * from "./transformers.js";
+export * from "./format.js";
+export * from "./suggestion-mode.js";
+export * from "./resolution.js";
+export * from "./comment-authoring.js";
+export * from "./comment-popup.js";
+export * from "./plugin.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./grammar.js";
+export * from "./nodes.js";
+export * from "./transformers.js";
+export * from "./format.js";
+export * from "./suggestion-mode.js";
+export * from "./resolution.js";
+export * from "./comment-authoring.js";
+export * from "./comment-popup.js";
+export * from "./plugin.js";

package/dist/nodes.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The five CriticMarkup node classes (decisions 4-6, 16).
+ *
+ * `InsertionNode`, `DeletionNode`, and `HighlightNode` are `ElementNode`s wrapping ordinary text —
+ * the shape `@lexical/link`'s `LinkNode` uses for an inline span with its own markdown delimiters —
+ * so they can hold a `BreakNode` alongside plain `TextNode` children. `CommentNode` is a
+ * `DecoratorNode`: a bare comment has no text of its own to put a caret in. `BreakNode` is a break
+ * carried inside an insertion or a deletion, not a mark kind of its own (decision 16) — the fifth
+ * node class, on a different axis from the other four.
+ *
+ * No markdown import/export here — that is `transformers.ts` (Track N2). No DOM paste/export
+ * override either; nothing in the spec asks for one.
+ */
+import { DecoratorNode, ElementNode, type DOMExportOutput, type EditorConfig, type LexicalEditor, type LexicalNode, type NodeKey, type SerializedElementNode, type SerializedLexicalNode, type Spread } from "lexical";
+/**
+ * Shared behavior for the three ElementNode marks. Inline, never empty, and typing at its own
+ * boundary must not silently extend it (decision 6) — Lexical asks the node AT the selection
+ * boundary whether it accepts typed text, independent of where a prior `.select()` call pointed, so
+ * this has to be a node-level override, not a caret-placement fix. `InsertionNode` overrides both
+ * back to `true`: absorbing typing at its own edge is what lets "keep typing" extend one suggestion
+ * instead of a new mark per keystroke.
+ */
+declare abstract class MarkNode extends ElementNode {
+    isInline(): boolean;
+    canBeEmpty(): boolean;
+    updateDOM(_prevNode: this, _dom: HTMLElement, _config: EditorConfig): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+}
+export type SerializedInsertionNode = SerializedElementNode;
+/** `{++inserted++}`. Renders as `<ins class="dj-cm-insertion">`. */
+export declare class InsertionNode extends MarkNode {
+    static getType(): string;
+    static clone(node: InsertionNode): InsertionNode;
+    createDOM(): HTMLElement;
+    static importJSON(serializedNode: SerializedInsertionNode): InsertionNode;
+    exportJSON(): SerializedInsertionNode;
+    /** The one exception to decision 6: typing at either edge extends the insertion. */
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+}
+export declare function $createInsertionNode(): InsertionNode;
+export declare function $isInsertionNode(node: LexicalNode | null | undefined): node is InsertionNode;
+export type SerializedDeletionNode = SerializedElementNode;
+/** `{--deleted--}`. Renders as `<del class="dj-cm-deletion">`. */
+export declare class DeletionNode extends MarkNode {
+    static getType(): string;
+    static clone(node: DeletionNode): DeletionNode;
+    createDOM(): HTMLElement;
+    static importJSON(serializedNode: SerializedDeletionNode): DeletionNode;
+    exportJSON(): SerializedDeletionNode;
+}
+export declare function $createDeletionNode(): DeletionNode;
+export declare function $isDeletionNode(node: LexicalNode | null | undefined): node is DeletionNode;
+export type SerializedHighlightNode = Spread<{
+    comment: string | null;
+}, SerializedElementNode>;
+/**
+ * `{==highlight==}`, optionally carrying an anchored comment (`{>>note<<}`) as state rather than as
+ * a sibling node — decision 4: an anchored comment is a highlight CARRYING a note, not two marks.
+ * Renders as `<mark class="dj-cm-highlight">`, plus `dj-cm-has-comment` when a comment is set.
+ */
+export declare class HighlightNode extends MarkNode {
+    __comment: string | null;
+    static getType(): string;
+    static clone(node: HighlightNode): HighlightNode;
+    createDOM(): HTMLElement;
+    /** Only the comment presence can change post-creation; patch the class in place. */
+    updateDOM(_prevNode: this, dom: HTMLElement, _config: EditorConfig): boolean;
+    static importJSON(serializedNode: SerializedHighlightNode): HighlightNode;
+    exportJSON(): SerializedHighlightNode;
+    getComment(): string | null;
+    setComment(comment: string | null): this;
+}
+export declare function $createHighlightNode(): HighlightNode;
+export declare function $isHighlightNode(node: LexicalNode | null | undefined): node is HighlightNode;
+export type SerializedCommentNode = Spread<{
+    text: string;
+}, SerializedLexicalNode>;
+/**
+ * `{>>note<<}`, bare or anchored (anchored state lives on the `HighlightNode` it follows, per
+ * decision 4 — this class only ever represents a BARE comment). A `DecoratorNode`: it has no text of
+ * its own to put a caret in. Renders as an operable `<button>`, not a styled span (decision 5) — the
+ * popup behavior belongs to Track T3/T4; this is the minimal, correct shell it builds on.
+ */
+export declare class CommentNode extends DecoratorNode<HTMLElement> {
+    #private;
+    __text: string;
+    static getType(): string;
+    static clone(node: CommentNode): CommentNode;
+    constructor(text: string, key?: NodeKey);
+    isInline(): boolean;
+    static importJSON(serializedNode: SerializedCommentNode): CommentNode;
+    exportJSON(): SerializedCommentNode;
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    exportDOM(): DOMExportOutput;
+    /** The button the container mounts; accessible name is the comment text itself. */
+    decorate(_editor: LexicalEditor): HTMLElement;
+    getText(): string;
+    setText(text: string): this;
+}
+export declare function $createCommentNode(text: string): CommentNode;
+export declare function $isCommentNode(node: LexicalNode | null | undefined): node is CommentNode;
+export type SerializedBreakNode = SerializedLexicalNode;
+/**
+ * A proposed paragraph break, carried as a token inside an insertion or a deletion (decision 16) —
+ * never a top-level mark kind of its own. Renders as a pilcrow pill.
+ *
+ * MUST override `getTextContent()`: a `DecoratorNode` returns `""` by default, and the insertion and
+ * deletion transformers export their content THROUGH `getTextContent()` — so without this override an
+ * insertion holding a break exports as `{++++}`, an empty mark, with nothing thrown to say why.
+ */
+export declare class BreakNode extends DecoratorNode<HTMLElement> {
+    static getType(): string;
+    static clone(node: BreakNode): BreakNode;
+    isInline(): boolean;
+    static importJSON(_serializedNode: SerializedBreakNode): BreakNode;
+    exportJSON(): SerializedBreakNode;
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    decorate(): HTMLElement;
+    getTextContent(): string;
+}
+export declare function $createBreakNode(): BreakNode;
+export declare function $isBreakNode(node: LexicalNode | null | undefined): node is BreakNode;
+/** Any of the four MARK classes (decision 4) — `BreakNode` is a different axis, not a mark kind. */
+export declare function $isCriticMark(node: LexicalNode | null | undefined): node is InsertionNode | DeletionNode | HighlightNode | CommentNode;
+/**
+ * Content CSS: insertion underlined, deletion struck through, highlight background, comment as an
+ * operable control, break as a small pill — all from `--dj-*` tokens, with a forced-colors fallback
+ * so every mark stays distinguishable when backgrounds flatten. Injected once via
+ * `ensureEditorStyles("dj-rich-text-criticmarkup", CONTENT_CSS)`, called from the plugin's own
+ * `setup()` (Track T), not from this module — node files don't touch the DOM at import time.
+ */
+export declare const CONTENT_CSS = "\ndj-rich-text ins.dj-cm-insertion { text-decoration: underline; text-decoration-thickness: 2px; text-decoration-color: var(--dj-color-success, #16a34a); text-decoration-skip-ink: none; background: var(--dj-color-success-100, #dcfce7); }\ndj-rich-text del.dj-cm-deletion { text-decoration: line-through; text-decoration-thickness: 2px; text-decoration-color: var(--dj-color-danger, #dc2626); background: var(--dj-color-danger-100, #fee2e2); }\ndj-rich-text mark.dj-cm-highlight { background: var(--dj-color-warning-100, #fef3c7); color: inherit; }\ndj-rich-text mark.dj-cm-highlight.dj-cm-has-comment { box-shadow: inset 0 -2px 0 var(--dj-color-warning, #d97706); }\ndj-rich-text .dj-cm-comment-button { display: inline-flex; align-items: center; justify-content: center; width: 1.1em; height: 1.1em; padding: 0; border: none; border-radius: 999px; background: var(--dj-color-primary, #2563eb); color: var(--dj-color-on-primary, #fff); font-size: .75em; line-height: 1; cursor: pointer; }\ndj-rich-text .dj-cm-comment-button::before { content: \"\\1F4AC\"; }\ndj-rich-text .dj-cm-break-pill { display: inline-block; padding: 0 .3em; border-radius: 3px; background: var(--dj-color-primary-100, #dbeafe); color: var(--dj-color-primary, #2563eb); font-size: .85em; }\n@media (forced-colors: active) {\n\tdj-rich-text ins.dj-cm-insertion, dj-rich-text del.dj-cm-deletion { background: transparent; text-decoration-color: CanvasText; }\n\tdj-rich-text mark.dj-cm-highlight { background: Mark; color: MarkText; border: 1px solid CanvasText; }\n\tdj-rich-text mark.dj-cm-highlight.dj-cm-has-comment { box-shadow: none; border-style: dashed; }\n\tdj-rich-text .dj-cm-comment-button { forced-color-adjust: none; background: Highlight; color: HighlightText; border: 1px solid CanvasText; }\n\tdj-rich-text .dj-cm-break-pill { forced-color-adjust: none; background: Canvas; color: CanvasText; border: 1px solid CanvasText; }\n}\n";
+export {};