@magic-marker/prosemirror-suggest-changes 0.4.0 → 0.4.1-wrap-unwrap.2

package/dist/schema.js

@@ -166,6 +166,41 @@ export const modification = {
         }
     ]
 };
+export const structure = {
+    inclusive: false,
+    excludes: "deletion insertion modification",
+    attrs: {
+        id: {
+            validate: suggestionIdValidate
+        },
+        data: {
+            default: null
+        }
+    },
+    toDOM (mark) {
+        return [
+            "div",
+            {
+                "data-type": "structure",
+                "data-id": JSON.stringify(mark.attrs["id"]),
+                "data-data": JSON.stringify(mark.attrs["data"])
+            },
+            0
+        ];
+    },
+    parseDOM: [
+        {
+            tag: "div[data-type='structure']",
+            getAttrs (node) {
+                if (!node.dataset["id"]) return false;
+                return {
+                    id: JSON.parse(node.dataset["id"]),
+                    data: JSON.parse(node.dataset["data"] ?? "null")
+                };
+            }
+        }
+    ]
+};
 /**
  * Add the deletion, insertion, and modification marks to
  * the provided MarkSpec map.
@@ -174,6 +209,7 @@ export const modification = {
         ...marks,
         deletion: opts?.experimental_deletions === "hidden" ? hiddenDeletion : deletion,
         insertion,
-        modification
+        modification,
+        structure
     };
 }

package/dist/testing/e2eTestSchema.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "prosemirror-model";
+export declare function createSchema(deletionMarksVisibility?: "hidden" | "visible"): Schema<"blockquote" | "text" | "image" | "doc" | "orderedList" | "bulletList" | "listItem" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "hard_break" | "hardBreak", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong">;

package/dist/testing/testBuilders.d.ts

@@ -1,6 +1,6 @@
 import { Schema, type Node } from "prosemirror-model";
 import { type MarkBuilder, type NodeBuilder } from "prosemirror-test-builder";
-declare const schema: Schema<"blockquote" | "text" | "doc" | "paragraph" | "image" | "orderedList" | "bulletList" | "listItem" | "horizontal_rule" | "heading" | "code_block" | "hard_break", "insertion" | "deletion" | "modification" | "code" | "em" | "link" | "strong" | "difficulty">;
+export declare const schema: Schema<"blockquote" | "text" | "image" | "doc" | "orderedList" | "bulletList" | "listItem" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "hard_break", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong" | "difficulty">;
 export declare const testBuilders: { [NodeTypeName in keyof (typeof schema)["nodes"]]: NodeBuilder; } & { [MarkTypeName in keyof (typeof schema)["marks"]]: MarkBuilder; } & {
     schema: typeof schema;
 };
@@ -8,4 +8,3 @@ export type TaggedNode = Node & {
     flat: Node;
     tag: Record<string, number>;
 };
-export {};

package/dist/transformToSuggestionTransaction.d.ts

@@ -0,0 +1,22 @@
+import { type Node, type Schema } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type SuggestionId } from "./generateId.js";
+interface PreserveTransactionDataOptions {
+    selection?: "mapFromOriginalTransaction" | "currentDocument" | false;
+    preserveScroll?: boolean;
+    preserveStoredMarks?: boolean;
+    preserveMeta?: boolean;
+}
+export declare function preserveTransactionData(transaction: Transaction, originalTransaction: Transaction, options?: PreserveTransactionDataOptions): void;
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */
+export declare function transformToSuggestionTransaction(originalTransaction: Transaction, state: EditorState, generateId?: (schema: Schema, doc?: Node) => SuggestionId): Transaction;
+export {};

package/dist/transformToSuggestionTransaction.js

@@ -0,0 +1,101 @@
+import { AddMarkStep, AddNodeMarkStep, AttrStep, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
+import { trackAddMarkStep } from "./addMarkStep.js";
+import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
+import { trackAttrStep } from "./attrStep.js";
+import { generateNextNumberId } from "./generateId.js";
+import { suggestRemoveMarkStep } from "./removeMarkStep.js";
+import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
+import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
+import { suggestReplaceStep } from "./replaceStep.js";
+import { getSuggestionMarks } from "./utils.js";
+function getStepHandler(step) {
+    if (step instanceof ReplaceStep) {
+        return suggestReplaceStep;
+    }
+    if (step instanceof ReplaceAroundStep) {
+        return suggestReplaceAroundStep;
+    }
+    if (step instanceof AddMarkStep) {
+        return trackAddMarkStep;
+    }
+    if (step instanceof RemoveMarkStep) {
+        return suggestRemoveMarkStep;
+    }
+    if (step instanceof AddNodeMarkStep) {
+        return trackAddNodeMarkStep;
+    }
+    if (step instanceof RemoveNodeMarkStep) {
+        return suggestRemoveNodeMarkStep;
+    }
+    if (step instanceof AttrStep) {
+        return trackAttrStep;
+    }
+    // Default handler — simply rebase the step onto the
+    // tracked transaction and apply it.
+    return (trackedTransaction, _state, _doc, step, prevSteps)=>{
+        const reset = prevSteps.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
+        const rebased = trackedTransaction.steps.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
+        if (rebased) {
+            trackedTransaction.step(rebased);
+        }
+        return false;
+    };
+}
+export function preserveTransactionData(transaction, originalTransaction, options = {}) {
+    const { selection = "mapFromOriginalTransaction", preserveScroll = true, preserveStoredMarks = true, preserveMeta = true } = options;
+    if (selection && originalTransaction.selectionSet && !transaction.selectionSet) {
+        if (selection === "currentDocument") {
+            transaction.setSelection(originalTransaction.selection.map(transaction.doc, new Mapping()));
+        } else {
+            const originalBaseDoc = originalTransaction.docs[0];
+            const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
+            transaction.setSelection(base.map(transaction.doc, transaction.mapping));
+        }
+    }
+    if (preserveScroll && originalTransaction.scrolledIntoView) {
+        transaction.scrollIntoView();
+    }
+    if (preserveStoredMarks && originalTransaction.storedMarksSet) {
+        transaction.setStoredMarks(originalTransaction.storedMarks);
+    }
+    if (preserveMeta) {
+        // @ts-expect-error Preserve original transaction meta exactly as-is
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        transaction.meta = originalTransaction.meta;
+    }
+}
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */ export function transformToSuggestionTransaction(originalTransaction, state, generateId) {
+    getSuggestionMarks(state.schema);
+    let suggestionId = generateId ? generateId(state.schema, originalTransaction.docs[0]) : generateNextNumberId(state.schema, originalTransaction.docs[0]);
+    // Create a new transaction from scratch. The original transaction
+    // is going to be dropped in favor of this one.
+    const trackedTransaction = state.tr;
+    for(let i = 0; i < originalTransaction.steps.length; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const step = originalTransaction.steps[i];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const doc = originalTransaction.docs[i];
+        const stepTracker = getStepHandler(step);
+        if (stepTracker(trackedTransaction, state, doc, step, originalTransaction.steps.slice(0, i), suggestionId) && i < originalTransaction.steps.length - 1) {
+            // If the suggestionId was used by one of the step handlers,
+            // increment it so that it's not reused.
+            if (generateId) {
+                suggestionId = generateId(state.schema, trackedTransaction.doc);
+            } else if (typeof suggestionId === "number") {
+                suggestionId = suggestionId + 1;
+            }
+        }
+        continue;
+    }
+    preserveTransactionData(trackedTransaction, originalTransaction);
+    return trackedTransaction;
+}

package/dist/utils.d.ts

@@ -3,6 +3,7 @@ export interface SuggestionMarks {
     insertion: MarkType;
     deletion: MarkType;
     modification: MarkType;
+    structure: MarkType;
 }
 /**
  * Get the suggestion mark types from a schema, with proper error handling.

package/dist/utils.js

@@ -2,7 +2,7 @@
  * Get the suggestion mark types from a schema, with proper error handling.
  * Throws an error if any of the required marks are not found.
  */ export function getSuggestionMarks(schema) {
-    const { insertion, deletion, modification } = schema.marks;
+    const { insertion, deletion, modification, structure } = schema.marks;
     if (!insertion) {
         throw new Error("Failed to find insertion mark in schema. Did you forget to add it?");
     }
@@ -12,9 +12,13 @@
     if (!modification) {
         throw new Error("Failed to find modification mark in schema. Did you forget to add it?");
     }
+    if (!structure) {
+        throw new Error("Failed to find structure mark in schema. Did you forget to add it?");
+    }
     return {
         insertion,
         deletion,
-        modification
+        modification,
+        structure
     };
 }

package/dist/withSuggestChanges.d.ts

@@ -1,18 +1,11 @@
-import { type Schema, type Node } from "prosemirror-model";
-import { type EditorState, type Transaction } from "prosemirror-state";
+import { type Node, type Schema } from "prosemirror-model";
+import { type Transaction } from "prosemirror-state";
+import { type Transform } from "prosemirror-transform";
 import { type EditorView } from "prosemirror-view";
 import { type SuggestionId } from "./generateId.js";
-/**
- * Given a standard transaction from ProseMirror, produce
- * a new transaction that tracks the changes from the original,
- * rather than applying them.
- *
- * For each type of step, we implement custom behavior to prevent
- * deletions from being removed from the document, instead adding
- * deletion marks, and ensuring that all insertions have insertion
- * marks.
- */
-export declare function transformToSuggestionTransaction(originalTransaction: Transaction, state: EditorState, generateId?: (schema: Schema, doc?: Node) => SuggestionId): Transaction;
+import { type StructuralContextPath } from "./features/wrapUnwrap/types.js";
+export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
  * function with `withSuggestChanges`, or pass no arguments to use the default
@@ -24,4 +17,8 @@ export declare function transformToSuggestionTransaction(originalTransaction: Tr
  * applying them, e.g. by marking a range with the deletion mark rather
  * than removing it from the document.
  */
-export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId): EditorView["dispatch"];
+export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
+    experimental_trackStructureChanges?: boolean;
+    experimental_trackStructures?: StructuralContextPath[];
+    experimental_ensureUniqueNodeIds?: (transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform;
+}): EditorView["dispatch"];

package/dist/withSuggestChanges.js

@@ -1,97 +1,15 @@
-import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
-import { trackAddMarkStep } from "./addMarkStep.js";
-import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
-import { trackAttrStep } from "./attrStep.js";
-import { suggestRemoveMarkStep } from "./removeMarkStep.js";
-import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
-import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
-import { suggestReplaceStep } from "./replaceStep.js";
 import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
-import { generateNextNumberId } from "./generateId.js";
-import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
-function getStepHandler(step) {
-    if (step instanceof ReplaceStep) {
-        return suggestReplaceStep;
-    }
-    if (step instanceof ReplaceAroundStep) {
-        return suggestReplaceAroundStep;
-    }
-    if (step instanceof AddMarkStep) {
-        return trackAddMarkStep;
-    }
-    if (step instanceof RemoveMarkStep) {
-        return suggestRemoveMarkStep;
-    }
-    if (step instanceof AddNodeMarkStep) {
-        return trackAddNodeMarkStep;
-    }
-    if (step instanceof RemoveNodeMarkStep) {
-        return suggestRemoveNodeMarkStep;
-    }
-    if (step instanceof AttrStep) {
-        return trackAttrStep;
-    }
-    // Default handler — simply rebase the step onto the
-    // tracked transaction and apply it.
-    return (trackedTransaction, _state, _doc, step, prevSteps)=>{
-        const reset = prevSteps.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
-        const rebased = trackedTransaction.steps.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
-        if (rebased) {
-            trackedTransaction.step(rebased);
-        }
-        return false;
-    };
-}
-/**
- * Given a standard transaction from ProseMirror, produce
- * a new transaction that tracks the changes from the original,
- * rather than applying them.
- *
- * For each type of step, we implement custom behavior to prevent
- * deletions from being removed from the document, instead adding
- * deletion marks, and ensuring that all insertions have insertion
- * marks.
- */ export function transformToSuggestionTransaction(originalTransaction, state, generateId) {
-    getSuggestionMarks(state.schema);
-    let suggestionId = generateId ? generateId(state.schema, originalTransaction.docs[0]) : generateNextNumberId(state.schema, originalTransaction.docs[0]);
-    // Create a new transaction from scratch. The original transaction
-    // is going to be dropped in favor of this one.
-    const trackedTransaction = state.tr;
-    for(let i = 0; i < originalTransaction.steps.length; i++){
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const step = originalTransaction.steps[i];
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const doc = originalTransaction.docs[i];
-        const stepTracker = getStepHandler(step);
-        if (stepTracker(trackedTransaction, state, doc, step, originalTransaction.steps.slice(0, i), suggestionId) && i < originalTransaction.steps.length - 1) {
-            // If the suggestionId was used by one of the step handlers,
-            // increment it so that it's not reused.
-            if (generateId) {
-                suggestionId = generateId(state.schema, trackedTransaction.doc);
-            } else if (typeof suggestionId === "number") {
-                suggestionId = suggestionId + 1;
-            }
-        }
-        continue;
-    }
-    if (originalTransaction.selectionSet && !trackedTransaction.selectionSet) {
-        // Map the original selection backwards through the original transaction,
-        // and then forwards through the new one.
-        const originalBaseDoc = originalTransaction.docs[0];
-        const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
-        trackedTransaction.setSelection(base.map(trackedTransaction.doc, trackedTransaction.mapping));
-    }
-    if (originalTransaction.scrolledIntoView) {
-        trackedTransaction.scrollIntoView();
-    }
-    if (originalTransaction.storedMarksSet) {
-        trackedTransaction.setStoredMarks(originalTransaction.storedMarks);
-    }
-    // @ts-expect-error Preserve original transaction meta exactly as-is
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    trackedTransaction.meta = originalTransaction.meta;
-    return trackedTransaction;
+import { getRequiredStructuralContextPaths, suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+import { handleSpecialTransactionShape } from "./features/transactionShaping/index.js";
+import { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[withSuggestChanges]", ...args);
 }
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
@@ -103,13 +21,65 @@ function getStepHandler(step) {
  * These modified transactions will suggest changes instead of directly
  * applying them, e.g. by marking a range with the deletion mark rather
  * than removing it from the document.
- */ export function withSuggestChanges(dispatchTransaction, generateId) {
+ */ export function withSuggestChanges(dispatchTransaction, generateId, opts) {
     const dispatch = dispatchTransaction ?? function(tr) {
         this.updateState(this.state.apply(tr));
     };
     return function dispatchTransaction(tr) {
         const ySyncMeta = tr.getMeta("y-sync$") ?? {};
-        const transaction = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {})) ? transformToSuggestionTransaction(tr, this.state, generateId) : tr;
+        const isEnabled = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {}));
+        let transaction = tr;
+        if (isEnabled) {
+            let structureChangesResult = null;
+            const docBefore = transaction.docs[0];
+            const structuralContextPaths = opts?.experimental_trackStructureChanges ? getRequiredStructuralContextPaths(opts.experimental_trackStructures) : null;
+            const ensureUniqueNodeIds = opts?.experimental_ensureUniqueNodeIds;
+            const shapedTransaction = transaction.docChanged ? handleSpecialTransactionShape({
+                transaction,
+                state: this.state,
+                generateId,
+                structuralContextPaths,
+                ensureUniqueNodeIds
+            }) : null;
+            if (!shapedTransaction && transaction.docChanged && docBefore && structuralContextPaths && typeof ensureUniqueNodeIds === "function") {
+                trace("trying to track structure changes first...");
+                // after a transaction, some nodes may not yet have unique ids (they were just added, and the unique id plugin has not yet run)
+                // this hook allows to "post-process" the transaction and add the missing ids
+                // basically it allows to run the core logic of the unique ids plugin earlier
+                const perfUid = performance.now();
+                const uniqueNodeIdsTransform = ensureUniqueNodeIds([
+                    transaction
+                ], docBefore, transaction.doc);
+                trace("perf", "structure", "ensureUniqueNodsIds took", Number((performance.now() - perfUid).toFixed(2)), "ms");
+                const docAfter = uniqueNodeIdsTransform.doc;
+                trace("unique node ids set", docAfter);
+                // try running structure changes first
+                // if handled, then ignore the main plugin
+                // otherwise use the main plugin
+                const perfStructure = performance.now();
+                structureChangesResult = suggestStructureChanges(docBefore, docAfter, structuralContextPaths, generateId);
+                trace("perf", "structure", "suggestStructureChanges took", Number((performance.now() - perfStructure).toFixed(2)), "ms");
+                trace("structure changes transform completed", structureChangesResult.transform);
+                if (structureChangesResult.handled) {
+                    uniqueNodeIdsTransform.steps.forEach((step)=>{
+                        transaction.step(step);
+                    });
+                    structureChangesResult.transform.steps.forEach((step)=>{
+                        transaction.step(step);
+                    });
+                    trace("applied unique id transform and structure changes transform to the transaction", transaction);
+                }
+            }
+            if (shapedTransaction) {
+                transaction = shapedTransaction;
+            } else if (transaction.docChanged && structureChangesResult?.handled !== true) {
+                trace("running the main suggestions plugin...");
+                const perfSuggestions = performance.now();
+                transaction = transformToSuggestionTransaction(tr, this.state, generateId);
+                trace("perf", "suggestions", "transformToSuggestionTransaction took", Number((performance.now() - perfSuggestions).toFixed(2)), "ms");
+                trace("main suggestions plugin completed", transaction);
+            }
+        }
         if (transaction.docChanged) {
             prependDeletionsWithZWSP(transaction);
         }

package/dist/wrappingInputRule.d.ts

@@ -0,0 +1,4 @@
+import { InputRule } from "prosemirror-inputrules";
+import { type Node } from "prosemirror-model";
+import { type Attrs, type NodeType } from "prosemirror-model";
+export declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;

package/dist/wrappingInputRule.js

@@ -0,0 +1,28 @@
+import { InputRule } from "prosemirror-inputrules";
+import { canJoin, findWrapping } from "prosemirror-transform";
+import { getSuggestionMarks } from "./utils.js";
+import { ZWSP } from "./constants.js";
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end)=>{
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const tr = state.tr;
+        // check and try to preserve zwsp
+        const { insertion } = getSuggestionMarks(state.doc.type.schema);
+        let $start = tr.doc.resolve(start);
+        if (insertion.isInSet($start.nodeAfter?.marks ?? []) && match[0].startsWith(ZWSP)) {
+            // preserve a single ZWSP at the start
+            tr.delete(start + 1, end);
+        } else {
+            tr.delete(start, end);
+        }
+        // the rest of the rule unchanged
+        $start = tr.doc.resolve(start);
+        const range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping) return null;
+        tr.wrap(range, wrapping);
+        const before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before))) tr.join(start - 1);
+        return tr;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-marker/prosemirror-suggest-changes",
-  "version": "0.4.0",
+  "version": "0.4.1-wrap-unwrap.2",
   "license": "MIT",
   "type": "module",
   "module": "dist/index.js",

package/src/features/joinOnDelete/README.md

@@ -1,8 +0,0 @@
-When nodes are joined using backspace or delete, let the join happen normally,
-but mark former node boundaries with deletion mark of type="join".
-
-Save information about what nodes were at each side of the boundary before the
-join.
-
-Then on restore, use marks at join points to split the node and restore the node
-markup at each side of the split.