@dojo-ng/rich-text-criticmarkup 0.1.0 → 0.1.1

package/dist/grammar.js

@@ -167,7 +167,14 @@ function resolve(text, mark, side) {
         return text;
     }
     const end = mark.kind === "highlight" ? highlightEnd(text, mark) : mark.end;
-    return text.slice(0, mark.start) + keptText(mark, side) + text.slice(end);
+    // Decision 18: only an ACCEPT adjusts whitespace at a paragraph-break seam. A decline restores
+    // the original text verbatim — `run{++¶++}together` declines back to `runtogether`, not to
+    // `run together` — and a highlight is kept unchanged in both directions, so neither touches the
+    // seam. `settleSeams` is a no-op on a string with no sentinel in it, which is every other case.
+    const adjusts = side === "new" && mark.kind !== "highlight";
+    const kept = keptText(mark, side, adjusts ? BREAK_SEAM : PARAGRAPH_BREAK);
+    const dropped = adjusts && kept === "" && hasStructuralToken(droppedText(mark, side));
+    return settleSeams(text.slice(0, mark.start) + (dropped ? JOIN_SEAM : kept) + text.slice(end));
 }
 /**
  * `mark`'s own `end`, extended to swallow an immediately adjacent `{>>...<<}` — CriticMarkup's
@@ -183,20 +190,34 @@ function highlightEnd(text, mark) {
     }
     return mark.end;
 }
-function keptText(mark, side) {
+function keptText(mark, side, breakAs = PARAGRAPH_BREAK) {
     switch (mark.kind) {
         case "highlight":
-            return resolveParagraphTokens(mark.text);
+            return resolveParagraphTokens(mark.text, PARAGRAPH_TOKEN, breakAs);
         case "substitution":
-            return resolveParagraphTokens(side === "new" ? mark.new : mark.old);
+            return resolveParagraphTokens(side === "new" ? mark.new : mark.old, PARAGRAPH_TOKEN, breakAs);
         case "insertion":
-            return side === "new" ? resolveParagraphTokens(mark.text) : "";
+            return side === "new" ? resolveParagraphTokens(mark.text, PARAGRAPH_TOKEN, breakAs) : "";
         case "deletion":
-            return side === "new" ? "" : resolveParagraphTokens(mark.text);
+            return side === "new" ? "" : resolveParagraphTokens(mark.text, PARAGRAPH_TOKEN, breakAs);
         default:
             throw new Error(`unknown mark kind ${mark.kind}`);
     }
 }
+/** The text this resolution DISCARDS — the mirror of `keptText`, and the only place a break that is
+ * about to disappear can still be seen. */
+function droppedText(mark, side) {
+    switch (mark.kind) {
+        case "insertion":
+            return side === "new" ? "" : mark.text;
+        case "deletion":
+            return side === "new" ? mark.text : "";
+        case "substitution":
+            return side === "new" ? mark.old : mark.new;
+        default:
+            return "";
+    }
+}
 /**
  * Resolve every mark as `accept` would, nested ones included. Idempotent: a body with no marks is
  * returned unchanged.
@@ -291,7 +312,7 @@ export function unescapeToken(text, token = PARAGRAPH_TOKEN) {
  * 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) {
+function resolveParagraphTokens(text, token = PARAGRAPH_TOKEN, breakAs = PARAGRAPH_BREAK) {
     if (token === "")
         return text;
     let out = "";
@@ -303,7 +324,7 @@ function resolveParagraphTokens(text, token = PARAGRAPH_TOKEN) {
                 i += token.length * 2;
             }
             else {
-                out += "\n\n"; // unpaired: a structural break
+                out += breakAs; // unpaired: a structural break
                 i += token.length;
             }
         }
@@ -354,6 +375,64 @@ export function tokenizeBlockSpanning(text, token = PARAGRAPH_TOKEN) {
 export function toPortableCriticMarkup(text, token = PARAGRAPH_TOKEN) {
     return normalizeBlockSpanning(resolveParagraphTokens(text, token));
 }
+// --- decision 18: whitespace at a paragraph-break seam ------------------------------------------
+/** A real paragraph break, as this grammar spells one. */
+const PARAGRAPH_BREAK = "\n\n";
+// Two sentinels, placed by `resolve` and consumed by `settleSeams` within that same call. They exist
+// so a seam adjustment can see the characters on BOTH sides of the mark — which a rule written over
+// the mark's own span cannot — without a regex sweep that would touch whitespace elsewhere in the
+// document that this resolution does not own (G2's "leaving all other text untouched"). Deliberately
+// outside the U+E000..U+E007 block `maskNested` uses; nothing outside this file ever sees one.
+const BREAK_SEAM = "\uE010"; // a break this resolution CREATES
+const JOIN_SEAM = "\uE011"; // a break this resolution REMOVES, with nothing kept in its place
+/** Horizontal whitespace only: a seam adjustment never eats a neighbouring line's newline. */
+const HORIZONTAL_WS = /[ \t]*/;
+/** True if `text` holds at least one UNPAIRED token — a structural break rather than a doubled
+ * literal. Scans in `resolveParagraphTokens`' left-to-right order so the two always agree on which
+ * tokens are structural. */
+function hasStructuralToken(text, token = PARAGRAPH_TOKEN) {
+    if (token === "")
+        return false;
+    let i = 0;
+    while (i < text.length) {
+        if (text.startsWith(token, i)) {
+            if (text.startsWith(token, i + token.length)) {
+                i += token.length * 2;
+                continue;
+            }
+            return true;
+        }
+        i++;
+    }
+    return false;
+}
+/**
+ * Turn the seam sentinels into real text, which is where decision 18's two rules actually live:
+ *
+ * - A break being CREATED absorbs the horizontal whitespace on either side of it, so accepting
+ *   `here. {++¶++}The` does not leave a space stranded at the end of the first paragraph.
+ * - A break being REMOVED becomes a single space, so accepting `here.{--¶--}The` reads
+ *   `here. The` rather than `here.The` — but only when real text sits hard against both sides, so a
+ *   merge into text that already has whitespace (or at the very start or end of the body) adds
+ *   nothing.
+ */
+function settleSeams(text) {
+    if (!text.includes(BREAK_SEAM) && !text.includes(JOIN_SEAM))
+        return text;
+    const broken = text.replace(new RegExp(`${HORIZONTAL_WS.source}${BREAK_SEAM}${HORIZONTAL_WS.source}`, "g"), PARAGRAPH_BREAK);
+    return settleJoinSeam(broken);
+}
+/** One join seam at a time, by index rather than by regex, so a character outside the Basic
+ * Multilingual Plane on either side of the seam is never split. */
+function settleJoinSeam(text) {
+    const at = text.indexOf(JOIN_SEAM);
+    if (at < 0)
+        return text;
+    const before = text.slice(0, at);
+    const after = text.slice(at + JOIN_SEAM.length);
+    const needsSpace = before !== "" && after !== "" && !/\s$/.test(before) && !/^\s/.test(after);
+    return settleJoinSeam(before + (needsSpace ? " " : "") + after);
+}
 // --- 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.

package/dist/resolution.js

@@ -14,7 +14,7 @@
  * No confirmation here — `dj-popup-confirmation` gating `confirmBulk` is a toolbar-level concern
  * (Track T3), not baked into these functions themselves.
  */
-import { $createParagraphNode, $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isRootOrShadowRoot } from "lexical";
+import { $createParagraphNode, $createTextNode, $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isRootOrShadowRoot, $isTextNode } from "lexical";
 import { $isBreakNode, $isCommentNode, $isCriticMark, $isDeletionNode, $isHighlightNode, $isInsertionNode, } from "./nodes.js";
 import { SKIP_TAG } from "./suggestion-mode.js";
 /** The nearest CriticMarkup mark (any of the four kinds) containing the selection's anchor, or
@@ -82,12 +82,14 @@ function resolveOne(editor, node, side, resolved) {
         resolved?.add(pair.deletion.getKey());
         resolved?.add(pair.insertion.getKey());
         if (side === "new") {
+            // No join seam here even when the deletion held a break (decision 18): the insertion's own
+            // text lands in its place, so the two sides are not becoming adjacent.
             pair.deletion.remove();
-            unwrapAndResolveBreaks(pair.insertion);
+            unwrapAndResolveBreaks(pair.insertion, true);
         }
         else {
             pair.insertion.remove();
-            unwrapAndResolveBreaks(pair.deletion);
+            unwrapAndResolveBreaks(pair.deletion, false);
         }
         dispatchChange(editor, "substitution", side === "new" ? "accept" : "decline");
         return;
@@ -104,10 +106,17 @@ function resolveOne(editor, node, side, resolved) {
     }
     else {
         const keep = $isInsertionNode(node) ? side === "new" : side === "old";
-        if (keep)
-            unwrapAndResolveBreaks(node);
-        else
+        if (keep) {
+            unwrapAndResolveBreaks(node, side === "new");
+        }
+        else {
+            // Decision 18: accepting a deletion that holds a break closes a real paragraph boundary, so
+            // the text on either side needs the space that boundary was providing. Declining an
+            // insertion drops a break that never existed in the document, so it changes nothing.
+            if (side === "new" && holdsBreak(node))
+                joinAtRemovedBreak(node);
             node.remove();
+        }
     }
     dispatchChange(editor, kind, side === "new" ? "accept" : "decline");
 }
@@ -149,14 +158,60 @@ function unwrap(node) {
  * children — a kept paragraph-break proposal (decision 16) stops being a decorator and becomes an
  * actual block boundary, mirroring what `grammar.accept`/`decline` do to the token at the string
  * level. */
-function unwrapAndResolveBreaks(node) {
+function unwrapAndResolveBreaks(node, creating) {
     const children = unwrap(node);
     for (const child of children) {
         if ($isBreakNode(child))
-            splitBlockAtBreak(child);
+            splitBlockAtBreak(child, creating);
+    }
+}
+/** True if `node` holds a `BreakNode` — the tree-side reading of `grammar.hasStructuralToken`. */
+function holdsBreak(node) {
+    return node.getChildren().some($isBreakNode);
+}
+/**
+ * Decision 18's join rule on the live tree: a single space where the removed break was, but only
+ * when real text sits hard against both sides of it. Inserted as its own text node rather than
+ * appended to the neighbour, so a formatted run keeps its own format and Lexical's own
+ * normalization merges the pair where they match.
+ */
+function joinAtRemovedBreak(node) {
+    const before = node.getPreviousSibling()?.getTextContent() ?? "";
+    const after = node.getNextSibling()?.getTextContent() ?? "";
+    if (before === "" || after === "")
+        return;
+    if (/\s$/.test(before) || /^\s/.test(after))
+        return;
+    node.insertBefore($createTextNode(" "));
+}
+/** Decision 18's absorb rule on the live tree: the horizontal whitespace on either side of a break
+ * being CREATED goes with it, so an accepted split does not strand a space at the end of the first
+ * block or open the second one with one. A break being RESTORED (a declined merge) is left exactly
+ * as the document had it. */
+function trimSeam(block, edge) {
+    // Walks inward from the edge over a SNAPSHOT of the children, rather than re-reading the edge
+    // child on each pass. The loop's progress has to come from the walk itself and never from
+    // `remove()` having taken effect: Lexical reinstates an empty text node at a block edge in some
+    // reconciliation paths, and a loop that re-read `getLastChild()` would then be handed the same
+    // node forever — a hung page rather than a failed assertion, which is the kind of bug a headless
+    // test with a simpler tree can miss entirely.
+    const children = block.getChildren();
+    const ordered = edge === "end" ? [...children].reverse() : children;
+    for (const child of ordered) {
+        if (!$isTextNode(child))
+            return;
+        const text = child.getTextContent();
+        const trimmed = edge === "end" ? text.replace(/[ \t]+$/, "") : text.replace(/^[ \t]+/, "");
+        if (trimmed === text)
+            return;
+        if (trimmed !== "") {
+            child.setTextContent(trimmed);
+            return;
+        }
+        child.remove();
     }
 }
-function splitBlockAtBreak(breakNode) {
+function splitBlockAtBreak(breakNode, creating) {
     const block = topLevelBlockOf(breakNode);
     if (!block) {
         breakNode.remove();
@@ -171,6 +226,10 @@ function splitBlockAtBreak(breakNode) {
     }
     block.insertAfter(newBlock);
     breakNode.remove();
+    if (creating) {
+        trimSeam(block, "end");
+        trimSeam(newBlock, "start");
+    }
 }
 function topLevelBlockOf(node) {
     let current = node;

package/fixtures/conformance.json

@@ -1,67 +1,458 @@
 [
-	{ "id": "parse-insertion", "op": "parse", "input": "{++foo++}",
-		"expected": [ { "kind": "insertion", "start": 0, "end": 9, "text": "foo", "spansBlock": false, "nested": false } ] },
-	{ "id": "parse-deletion", "op": "parse", "input": "{--bar--}",
-		"expected": [ { "kind": "deletion", "start": 0, "end": 9, "text": "bar", "spansBlock": false, "nested": false } ] },
-	{ "id": "parse-substitution", "op": "parse", "input": "{~~old~>new~~}",
-		"expected": [ { "kind": "substitution", "start": 0, "end": 14, "old": "old", "new": "new", "spansBlock": false, "nested": false } ] },
-	{ "id": "parse-comment", "op": "parse", "input": "{>>note<<}",
-		"expected": [ { "kind": "comment", "start": 0, "end": 10, "text": "note", "spansBlock": false, "nested": false } ] },
-	{ "id": "parse-highlight", "op": "parse", "input": "{==hl==}",
-		"expected": [ { "kind": "highlight", "start": 0, "end": 8, "text": "hl", "spansBlock": false, "nested": false } ] },
-	{ "id": "parse-nested-same-kind", "op": "parse", "input": "{--a {--b--} c--}",
+	{
+		"id": "parse-insertion",
+		"op": "parse",
+		"input": "{++foo++}",
 		"expected": [
-			{ "kind": "deletion", "start": 0, "end": 17, "text": "a {--b--} c", "spansBlock": false, "nested": true },
-			{ "kind": "deletion", "start": 5, "end": 12, "text": "b", "spansBlock": false, "nested": false }
-		] },
-	{ "id": "parse-nested-different-kind", "op": "parse", "input": "{++a {--b--} c++}",
+			{
+				"kind": "insertion",
+				"start": 0,
+				"end": 9,
+				"text": "foo",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-deletion",
+		"op": "parse",
+		"input": "{--bar--}",
 		"expected": [
-			{ "kind": "insertion", "start": 0, "end": 17, "text": "a {--b--} c", "spansBlock": false, "nested": true },
-			{ "kind": "deletion", "start": 5, "end": 12, "text": "b", "spansBlock": false, "nested": false }
-		] },
-	{ "id": "parse-unterminated", "op": "parse", "input": "{++foo", "expected": [] },
-	{ "id": "parse-fenced-code-skip", "op": "parse", "input": "```\n{--not tracked--}\n```", "expected": [] },
-	{ "id": "parse-reading-order", "op": "parse", "input": "{++a++}{--b--}{==c==}",
+			{
+				"kind": "deletion",
+				"start": 0,
+				"end": 9,
+				"text": "bar",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-substitution",
+		"op": "parse",
+		"input": "{~~old~>new~~}",
 		"expected": [
-			{ "kind": "insertion", "start": 0, "end": 7, "text": "a", "spansBlock": false, "nested": false },
-			{ "kind": "deletion", "start": 7, "end": 14, "text": "b", "spansBlock": false, "nested": false },
-			{ "kind": "highlight", "start": 14, "end": 21, "text": "c", "spansBlock": false, "nested": false }
-		] },
-	{ "id": "parse-spans-block", "op": "parse", "input": "{++A\n\nB++}",
-		"expected": [ { "kind": "insertion", "start": 0, "end": 10, "text": "A\n\nB", "spansBlock": true, "nested": false } ] },
-
-	{ "id": "accept-insertion", "op": "accept", "input": "{++foo++}", "mark": 0, "expected": "foo" },
-	{ "id": "decline-insertion", "op": "decline", "input": "{++foo++}", "mark": 0, "expected": "" },
-	{ "id": "accept-deletion", "op": "accept", "input": "{--bar--}", "mark": 0, "expected": "" },
-	{ "id": "decline-deletion", "op": "decline", "input": "{--bar--}", "mark": 0, "expected": "bar" },
-	{ "id": "accept-substitution", "op": "accept", "input": "{~~old~>new~~}", "mark": 0, "expected": "new" },
-	{ "id": "decline-substitution", "op": "decline", "input": "{~~old~>new~~}", "mark": 0, "expected": "old" },
-	{ "id": "accept-highlight-bare", "op": "accept", "input": "{==hl==}", "mark": 0, "expected": "hl" },
-	{ "id": "decline-highlight-bare", "op": "decline", "input": "{==hl==}", "mark": 0, "expected": "hl" },
-	{ "id": "accept-comment-bare", "op": "accept", "input": "{>>note<<}", "mark": 0, "expected": "{>>note<<}" },
-	{ "id": "decline-comment-bare", "op": "decline", "input": "{>>note<<}", "mark": 0, "expected": "{>>note<<}" },
-	{ "id": "accept-highlight-anchored-comment", "op": "accept", "input": "{==hl==}{>>note<<}", "mark": 0, "expected": "hl" },
-	{ "id": "decline-highlight-anchored-comment", "op": "decline", "input": "{==hl==}{>>note<<}", "mark": 0, "expected": "hl" },
-
-	{ "id": "acceptAll-nested-deletion", "op": "acceptAll", "input": "{--a {--b--} c--}", "expected": "" },
-	{ "id": "declineAll-nested-deletion", "op": "declineAll", "input": "{--a {--b--} c--}", "expected": "a b c" },
-	{ "id": "acceptAll-identity-no-marks", "op": "acceptAll", "input": "plain prose, no marks here.", "expected": "plain prose, no marks here." },
-	{ "id": "declineAll-identity-no-marks", "op": "declineAll", "input": "plain prose, no marks here.", "expected": "plain prose, no marks here." },
-	{ "id": "acceptAll-bare-comment-survives", "op": "acceptAll", "input": "{++x++}{>>note<<}", "expected": "x{>>note<<}" },
-	{ "id": "declineAll-bare-comment-survives", "op": "declineAll", "input": "{++x++}{>>note<<}", "expected": "{>>note<<}" },
-	{ "id": "stripComments-removes-bare-comment", "op": "stripComments", "input": "x{>>note<<}", "expected": "x" },
-
-	{ "id": "token-accept-insertion-break", "op": "accept", "input": "A{++¶++}B", "mark": 0, "expected": "A\n\nB" },
-	{ "id": "token-decline-insertion-break", "op": "decline", "input": "A{++¶++}B", "mark": 0, "expected": "AB" },
-	{ "id": "token-accept-deletion-break", "op": "accept", "input": "A{--¶--}B", "mark": 0, "expected": "AB" },
-	{ "id": "token-decline-deletion-break", "op": "decline", "input": "A{--¶--}B", "mark": 0, "expected": "A\n\nB" },
-	{ "id": "token-decline-insertion-no-orphan-blank-line", "op": "decline", "input": "{++A¶B++}", "mark": 0, "expected": "" },
-	{ "id": "token-accept-insertion-content-break", "op": "accept", "input": "{++A¶B++}", "mark": 0, "expected": "A\n\nB" },
-	{ "id": "token-accept-doubled-pilcrow-literal", "op": "accept", "input": "{++A¶¶B++}", "mark": 0, "expected": "A¶B" },
-
-	{ "id": "tokenize-insertion-block-spanning", "op": "tokenize", "input": "{++A\n\nB++}", "expected": "{++A¶B++}" },
-	{ "id": "tokenize-substitution-block-spanning", "op": "tokenize", "input": "{~~A\n\nB~>C~~}", "expected": "{~~A¶B~>C~~}" },
-
-	{ "id": "portable-insertion-tokenized-to-split", "op": "portable", "input": "{++A¶B++}", "expected": "{++A++}\n\n{++B++}" },
-	{ "id": "declineAll-portable-split-blank-line-cost", "op": "declineAll", "input": "{++A++}\n\n{++B++}", "expected": "\n\n" }
+			{
+				"kind": "substitution",
+				"start": 0,
+				"end": 14,
+				"old": "old",
+				"new": "new",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-comment",
+		"op": "parse",
+		"input": "{>>note<<}",
+		"expected": [
+			{
+				"kind": "comment",
+				"start": 0,
+				"end": 10,
+				"text": "note",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-highlight",
+		"op": "parse",
+		"input": "{==hl==}",
+		"expected": [
+			{
+				"kind": "highlight",
+				"start": 0,
+				"end": 8,
+				"text": "hl",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-nested-same-kind",
+		"op": "parse",
+		"input": "{--a {--b--} c--}",
+		"expected": [
+			{
+				"kind": "deletion",
+				"start": 0,
+				"end": 17,
+				"text": "a {--b--} c",
+				"spansBlock": false,
+				"nested": true
+			},
+			{
+				"kind": "deletion",
+				"start": 5,
+				"end": 12,
+				"text": "b",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-nested-different-kind",
+		"op": "parse",
+		"input": "{++a {--b--} c++}",
+		"expected": [
+			{
+				"kind": "insertion",
+				"start": 0,
+				"end": 17,
+				"text": "a {--b--} c",
+				"spansBlock": false,
+				"nested": true
+			},
+			{
+				"kind": "deletion",
+				"start": 5,
+				"end": 12,
+				"text": "b",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-unterminated",
+		"op": "parse",
+		"input": "{++foo",
+		"expected": []
+	},
+	{
+		"id": "parse-fenced-code-skip",
+		"op": "parse",
+		"input": "```\n{--not tracked--}\n```",
+		"expected": []
+	},
+	{
+		"id": "parse-reading-order",
+		"op": "parse",
+		"input": "{++a++}{--b--}{==c==}",
+		"expected": [
+			{
+				"kind": "insertion",
+				"start": 0,
+				"end": 7,
+				"text": "a",
+				"spansBlock": false,
+				"nested": false
+			},
+			{
+				"kind": "deletion",
+				"start": 7,
+				"end": 14,
+				"text": "b",
+				"spansBlock": false,
+				"nested": false
+			},
+			{
+				"kind": "highlight",
+				"start": 14,
+				"end": 21,
+				"text": "c",
+				"spansBlock": false,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "parse-spans-block",
+		"op": "parse",
+		"input": "{++A\n\nB++}",
+		"expected": [
+			{
+				"kind": "insertion",
+				"start": 0,
+				"end": 10,
+				"text": "A\n\nB",
+				"spansBlock": true,
+				"nested": false
+			}
+		]
+	},
+	{
+		"id": "accept-insertion",
+		"op": "accept",
+		"input": "{++foo++}",
+		"mark": 0,
+		"expected": "foo"
+	},
+	{
+		"id": "decline-insertion",
+		"op": "decline",
+		"input": "{++foo++}",
+		"mark": 0,
+		"expected": ""
+	},
+	{
+		"id": "accept-deletion",
+		"op": "accept",
+		"input": "{--bar--}",
+		"mark": 0,
+		"expected": ""
+	},
+	{
+		"id": "decline-deletion",
+		"op": "decline",
+		"input": "{--bar--}",
+		"mark": 0,
+		"expected": "bar"
+	},
+	{
+		"id": "accept-substitution",
+		"op": "accept",
+		"input": "{~~old~>new~~}",
+		"mark": 0,
+		"expected": "new"
+	},
+	{
+		"id": "decline-substitution",
+		"op": "decline",
+		"input": "{~~old~>new~~}",
+		"mark": 0,
+		"expected": "old"
+	},
+	{
+		"id": "accept-highlight-bare",
+		"op": "accept",
+		"input": "{==hl==}",
+		"mark": 0,
+		"expected": "hl"
+	},
+	{
+		"id": "decline-highlight-bare",
+		"op": "decline",
+		"input": "{==hl==}",
+		"mark": 0,
+		"expected": "hl"
+	},
+	{
+		"id": "accept-comment-bare",
+		"op": "accept",
+		"input": "{>>note<<}",
+		"mark": 0,
+		"expected": "{>>note<<}"
+	},
+	{
+		"id": "decline-comment-bare",
+		"op": "decline",
+		"input": "{>>note<<}",
+		"mark": 0,
+		"expected": "{>>note<<}"
+	},
+	{
+		"id": "accept-highlight-anchored-comment",
+		"op": "accept",
+		"input": "{==hl==}{>>note<<}",
+		"mark": 0,
+		"expected": "hl"
+	},
+	{
+		"id": "decline-highlight-anchored-comment",
+		"op": "decline",
+		"input": "{==hl==}{>>note<<}",
+		"mark": 0,
+		"expected": "hl"
+	},
+	{
+		"id": "acceptAll-nested-deletion",
+		"op": "acceptAll",
+		"input": "{--a {--b--} c--}",
+		"expected": ""
+	},
+	{
+		"id": "declineAll-nested-deletion",
+		"op": "declineAll",
+		"input": "{--a {--b--} c--}",
+		"expected": "a b c"
+	},
+	{
+		"id": "acceptAll-identity-no-marks",
+		"op": "acceptAll",
+		"input": "plain prose, no marks here.",
+		"expected": "plain prose, no marks here."
+	},
+	{
+		"id": "declineAll-identity-no-marks",
+		"op": "declineAll",
+		"input": "plain prose, no marks here.",
+		"expected": "plain prose, no marks here."
+	},
+	{
+		"id": "acceptAll-bare-comment-survives",
+		"op": "acceptAll",
+		"input": "{++x++}{>>note<<}",
+		"expected": "x{>>note<<}"
+	},
+	{
+		"id": "declineAll-bare-comment-survives",
+		"op": "declineAll",
+		"input": "{++x++}{>>note<<}",
+		"expected": "{>>note<<}"
+	},
+	{
+		"id": "stripComments-removes-bare-comment",
+		"op": "stripComments",
+		"input": "x{>>note<<}",
+		"expected": "x"
+	},
+	{
+		"id": "token-accept-insertion-break",
+		"op": "accept",
+		"input": "A{++¶++}B",
+		"mark": 0,
+		"expected": "A\n\nB"
+	},
+	{
+		"id": "token-decline-insertion-break",
+		"op": "decline",
+		"input": "A{++¶++}B",
+		"mark": 0,
+		"expected": "AB"
+	},
+	{
+		"id": "token-accept-deletion-break",
+		"op": "accept",
+		"input": "A{--¶--}B",
+		"mark": 0,
+		"expected": "A B"
+	},
+	{
+		"id": "token-decline-deletion-break",
+		"op": "decline",
+		"input": "A{--¶--}B",
+		"mark": 0,
+		"expected": "A\n\nB"
+	},
+	{
+		"id": "token-decline-insertion-no-orphan-blank-line",
+		"op": "decline",
+		"input": "{++A¶B++}",
+		"mark": 0,
+		"expected": ""
+	},
+	{
+		"id": "token-accept-insertion-content-break",
+		"op": "accept",
+		"input": "{++A¶B++}",
+		"mark": 0,
+		"expected": "A\n\nB"
+	},
+	{
+		"id": "token-accept-doubled-pilcrow-literal",
+		"op": "accept",
+		"input": "{++A¶¶B++}",
+		"mark": 0,
+		"expected": "A¶B"
+	},
+	{
+		"id": "tokenize-insertion-block-spanning",
+		"op": "tokenize",
+		"input": "{++A\n\nB++}",
+		"expected": "{++A¶B++}"
+	},
+	{
+		"id": "tokenize-substitution-block-spanning",
+		"op": "tokenize",
+		"input": "{~~A\n\nB~>C~~}",
+		"expected": "{~~A¶B~>C~~}"
+	},
+	{
+		"id": "portable-insertion-tokenized-to-split",
+		"op": "portable",
+		"input": "{++A¶B++}",
+		"expected": "{++A++}\n\n{++B++}"
+	},
+	{
+		"id": "declineAll-portable-split-blank-line-cost",
+		"op": "declineAll",
+		"input": "{++A++}\n\n{++B++}",
+		"expected": "\n\n"
+	},
+	{
+		"id": "seam-accept-merge-injects-space",
+		"op": "accept",
+		"input": "The first paragraph ends here.{--¶--}The second begins here.",
+		"mark": 0,
+		"expected": "The first paragraph ends here. The second begins here."
+	},
+	{
+		"id": "seam-accept-merge-space-already-before",
+		"op": "accept",
+		"input": "A. {--¶--}B",
+		"mark": 0,
+		"expected": "A. B"
+	},
+	{
+		"id": "seam-accept-merge-space-already-after",
+		"op": "accept",
+		"input": "A.{--¶--} B",
+		"mark": 0,
+		"expected": "A. B"
+	},
+	{
+		"id": "seam-accept-merge-at-body-start",
+		"op": "accept",
+		"input": "{--¶--}B",
+		"mark": 0,
+		"expected": "B"
+	},
+	{
+		"id": "seam-accept-merge-at-body-end",
+		"op": "accept",
+		"input": "A{--¶--}",
+		"mark": 0,
+		"expected": "A"
+	},
+	{
+		"id": "seam-accept-split-absorbs-space-before",
+		"op": "accept",
+		"input": "A. {++¶++}B",
+		"mark": 0,
+		"expected": "A.\n\nB"
+	},
+	{
+		"id": "seam-accept-split-absorbs-space-after",
+		"op": "accept",
+		"input": "A.{++¶++} B",
+		"mark": 0,
+		"expected": "A.\n\nB"
+	},
+	{
+		"id": "seam-decline-split-restores-verbatim",
+		"op": "decline",
+		"input": "run{++¶++}together",
+		"mark": 0,
+		"expected": "runtogether"
+	},
+	{
+		"id": "seam-decline-merge-restores-verbatim",
+		"op": "decline",
+		"input": "A. {--¶--}B",
+		"mark": 0,
+		"expected": "A. \n\nB"
+	},
+	{
+		"id": "seam-accept-deletion-without-break-joins-nothing",
+		"op": "accept",
+		"input": "A{--x--}B",
+		"mark": 0,
+		"expected": "AB"
+	},
+	{
+		"id": "seam-accept-substitution-replaces-the-break",
+		"op": "accept",
+		"input": "{~~A¶B~>C~~}",
+		"mark": 0,
+		"expected": "C"
+	}
 ]

package/package.json

@@ -1,5 +1,31 @@
-{ "name": "@dojo-ng/rich-text-criticmarkup", "version": "0.1.0", "license": "BSD-3-Clause", "description": "CriticMarkup tracked-changes plugin for @dojo-ng/rich-text", "type": "module",
-  "main": "./dist/index.js", "module": "./dist/index.js", "types": "./dist/index.d.ts",
-  "files": ["dist", "!dist/**/*.map", "fixtures"],
-  "scripts": { "build": "tsc -p tsconfig.json", "clean": "rm -rf dist" },
-  "dependencies": { "@dojo-ng/rich-text": "^0.1.0", "@dojo-ng/i18n": "^0.1.0", "@dojo-ng/popup-confirmation": "^0.1.0", "@dojo-ng/popup": "^0.1.0", "@dojo-ng/text-area": "^0.1.0", "@dojo-ng/button": "^0.1.0", "lexical": "^0.21.0", "@lexical/markdown": "^0.21.0", "@lexical/utils": "^0.21.0", "lit": "^3.3.0" } }
+{
+  "name": "@dojo-ng/rich-text-criticmarkup",
+  "version": "0.1.1",
+  "license": "BSD-3-Clause",
+  "description": "CriticMarkup tracked-changes plugin for @dojo-ng/rich-text",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "fixtures"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@dojo-ng/rich-text": "^0.1.0",
+    "@dojo-ng/i18n": "^0.1.0",
+    "@dojo-ng/popup-confirmation": "^0.1.0",
+    "@dojo-ng/popup": "^0.1.0",
+    "@dojo-ng/text-area": "^0.1.0",
+    "@dojo-ng/button": "^0.1.0",
+    "lexical": "^0.21.0",
+    "@lexical/markdown": "^0.21.0",
+    "@lexical/utils": "^0.21.0",
+    "lit": "^3.3.0"
+  }
+}