@fiduswriter/editor 0.2.6 → 0.2.9

package/src/dialogs/html_export.ts

@@ -1,10 +1,13 @@
 import {Dialog} from "fwtoolkit"
-import {htmlExportDialogTemplate} from "./templates.js"
+import {getExportTrackChangesValue, htmlExportDialogTemplate} from "./templates.js"
 
 export interface HtmlExportDialogResult {
     /** Render `equation`/`figure_equation` nodes as SVG images (MathJax)
         instead of MathML. */
     svgMath: boolean
+    /** Resolve all tracked changes (accept all) before exporting. When false,
+        the tracked changes are kept and rendered in the export. */
+    resolveTrackChanges: boolean
 }
 
 export class HtmlExportDialog {
@@ -28,8 +31,13 @@ export class HtmlExportDialog {
                                 ".html-svg-math"
                             ) as HTMLInputElement
                         )?.checked
+                        const resolveTrackChanges =
+                            getExportTrackChangesValue(
+                                dialogEl,
+                                "html-track-changes"
+                            ) !== "include"
                         ;(this.dialog as Dialog).close()
-                        return resolve({svgMath: !!svgMath})
+                        return resolve({svgMath: !!svgMath, resolveTrackChanges})
                     }
                 })
 
@@ -46,7 +54,7 @@ export class HtmlExportDialog {
         this.dialog = new Dialog({
             title: gettext("HTML export options"),
             body: htmlExportDialogTemplate(),
-            height: 220,
+            height: 330,
             width: 420,
             buttons,
             restoreActiveElement: false

package/src/dialogs/index.ts

@@ -8,5 +8,7 @@ export {TableDialog, TableConfigurationDialog} from "./table.js"
 export {RevisionDialog} from "./revision.js"
 export {PdfExportDialog} from "./pdf_export.js"
 export {HtmlExportDialog} from "./html_export.js"
+export {EpubExportDialog} from "./epub_export.js"
+export {TemplateExportDialog} from "./template_export.js"
 export {OrderedListStartDialog} from "./ordered_list.js"
 export {CodeBlockDialog} from "./code_block.js"

package/src/dialogs/template_export.ts

@@ -0,0 +1,66 @@
+import {Dialog} from "fwtoolkit"
+import {
+    exportTrackChangesTemplate,
+    getExportTrackChangesValue
+} from "./templates.js"
+
+export interface TemplateExportDialogResult {
+    /** Resolve all tracked changes (accept all) before exporting. When false,
+        the tracked changes are kept and rendered in the exported file. */
+    resolveTrackChanges: boolean
+}
+
+/** Ask how tracked changes should be handled before a DOCX/ODT template export. */
+export class TemplateExportDialog {
+    dialog: Dialog | false
+
+    constructor() {
+        this.dialog = false
+    }
+
+    init(fileType: "docx" | "odt"): Promise<TemplateExportDialogResult | false> {
+        const title =
+            fileType === "docx"
+                ? gettext("DOCX export options")
+                : gettext("ODT export options")
+        const buttons: Array<Record<string, unknown>> = []
+        const dialogDonePromise = new Promise<TemplateExportDialogResult | false>(
+            resolve => {
+                buttons.push({
+                    text: gettext("Export"),
+                    classes: "fw-dark",
+                    click: () => {
+                        const dialogEl = (this.dialog as Dialog).dialogEl
+                        const resolveTrackChanges =
+                            getExportTrackChangesValue(
+                                dialogEl,
+                                "template-track-changes"
+                            ) !== "include"
+                        ;(this.dialog as Dialog).close()
+                        return resolve({resolveTrackChanges})
+                    }
+                })
+
+                buttons.push({
+                    type: "cancel" as const,
+                    click: () => {
+                        ;(this.dialog as Dialog).close()
+                        resolve(false)
+                    }
+                })
+            }
+        )
+
+        this.dialog = new Dialog({
+            title,
+            body: exportTrackChangesTemplate("template-track-changes"),
+            height: 220,
+            width: 420,
+            buttons,
+            restoreActiveElement: false
+        })
+        this.dialog.open()
+
+        return dialogDonePromise
+    }
+}

package/src/dialogs/templates.ts

@@ -1,5 +1,5 @@
 import {CATS} from "@fiduswriter/document/schema/i18n"
-import {escapeText} from "fwtoolkit"
+import {escapeText, infoTooltip} from "fwtoolkit"
 
 interface InternalTarget {
     id: string
@@ -96,40 +96,143 @@ export const revisionDialogTemplate = ({dir}: {dir: string}): string =>
 export const pdfExportDialogTemplate = (): string => `
     <h4>${gettext("Tracked changes")}</h4>
     <div class="fw-radio">
-        <input type="radio" name="pdf-track-changes" value="resolve" class="pdf-track-resolve" checked="">
+        <input type="radio" name="pdf-track-changes" value="resolve" class="pdf-track-resolve" checked="" aria-describedby="pdf-track-resolve-help">
         <label class="pdf-track-resolve-label">${gettext("Resolve tracked changes (accept all)")}</label>
+        ${infoTooltip(
+            gettext(
+                "Applies all tracked changes so the PDF shows the document as if every change had already been accepted."
+            ),
+            "pdf-track-resolve-help"
+        )}
     </div>
     <div class="fw-radio">
-        <input type="radio" name="pdf-track-changes" value="include" class="pdf-track-include">
+        <input type="radio" name="pdf-track-changes" value="include" class="pdf-track-include" aria-describedby="pdf-track-include-help">
         <label class="pdf-track-include-label">${gettext("Include tracked changes in the PDF")}</label>
+        ${infoTooltip(
+            gettext(
+                "Prints the tracked changes so reviewers can see what was added, removed or altered."
+            ),
+            "pdf-track-include-help"
+        )}
     </div>
     <p>
         <label>
-            <input type="checkbox" class="pdf-embed-fidus">
+            <input type="checkbox" class="pdf-embed-fidus" aria-describedby="pdf-embed-fidus-help">
             ${gettext("Embed a Fidus Writer file of this document in the PDF")}
         </label>
+        ${infoTooltip(
+            gettext(
+                "Embeds the editable Fidus Writer document inside the PDF so it can be reopened for editing."
+            ),
+            "pdf-embed-fidus-help"
+        )}
     </p>
     <h4>${gettext("Print production")}</h4>
     <p>
-        <label><input type="checkbox" class="pdf-crop-marks"> ${gettext("Crop marks")}</label><br>
-        <label><input type="checkbox" class="pdf-trim-box"> ${gettext("Trim box")}</label><br>
-        <label><input type="checkbox" class="pdf-bleed-box"> ${gettext("Bleed box")}</label><br>
-        <label>${gettext("Bleed")}: <input type="number" class="pdf-bleed-mm" value="3" min="0" step="0.5"> ${gettext("mm")}</label><br>
-        <label><input type="checkbox" class="pdf-link-borders"> ${gettext("Show link annotation borders")}</label><br>
-        <label><input type="checkbox" class="pdf-rasterize-svgs"> ${gettext("Rasterize SVG images")}</label>
+        <label><input type="checkbox" class="pdf-crop-marks" aria-describedby="pdf-crop-marks-help"> ${gettext("Crop marks")}</label>
+        ${infoTooltip(
+            gettext("Small lines at the corners of the page that show printers where to cut the paper."),
+            "pdf-crop-marks-help"
+        )}<br>
+        <label><input type="checkbox" class="pdf-trim-box" aria-describedby="pdf-trim-box-help"> ${gettext("Trim box")}</label>
+        ${infoTooltip(
+            gettext("Marks the final size of the page after it has been cut."),
+            "pdf-trim-box-help"
+        )}<br>
+        <label><input type="checkbox" class="pdf-bleed-box" aria-describedby="pdf-bleed-box-help"> ${gettext("Bleed box")}</label>
+        ${infoTooltip(
+            gettext("Marks the area beyond the final page size where images and colors must extend so no white edges appear after cutting."),
+            "pdf-bleed-box-help"
+        )}<br>
+        <label>${gettext("Bleed")}: <input type="number" class="pdf-bleed-mm fw-inline" value="3" min="0" step="0.5" aria-describedby="pdf-bleed-mm-help"> ${gettext("mm")}</label>
+        ${infoTooltip(
+            gettext("How far, in millimeters, images and colors extend beyond the edge of the page."),
+            "pdf-bleed-mm-help"
+        )}<br>
+        <label><input type="checkbox" class="pdf-link-borders" aria-describedby="pdf-link-borders-help"> ${gettext("Show link annotation borders")}</label>
+        ${infoTooltip(
+            gettext("Draws a visible border around hyperlinks in the PDF so they are easier to find."),
+            "pdf-link-borders-help"
+        )}<br>
+        <label><input type="checkbox" class="pdf-rasterize-svgs" aria-describedby="pdf-rasterize-svgs-help"> ${gettext("Rasterize SVG images")}</label>
+        ${infoTooltip(
+            gettext("Converts SVG images to bitmap images in the PDF, which can help when PDF viewers or printers do not render SVG images correctly."),
+            "pdf-rasterize-svgs-help"
+        )}
     </p>
 `
 
+/**
+ * Radio group for choosing whether tracked changes are resolved (accepted) or
+ * kept in the exported file. `name` must be unique per dialog; the chosen value
+ * is read back with {@link getExportTrackChangesValue}.
+ */
+export const exportTrackChangesTemplate = (name: string): string => `
+    <h4>${gettext("Tracked changes")}</h4>
+    <div class="fw-radio">
+        <input type="radio" name="${name}" value="resolve" class="export-track-resolve" checked="" aria-describedby="${name}-resolve-help">
+        <label class="export-track-resolve-label">${gettext("Resolve tracked changes (accept all)")}</label>
+        ${infoTooltip(
+            gettext(
+                "Applies all tracked changes so the exported file shows the document as if every change had already been accepted."
+            ),
+            `${name}-resolve-help`
+        )}
+    </div>
+    <div class="fw-radio">
+        <input type="radio" name="${name}" value="include" class="export-track-include" aria-describedby="${name}-include-help">
+        <label class="export-track-include-label">${gettext("Include tracked changes in the export")}</label>
+        ${infoTooltip(
+            gettext(
+                "Keeps the tracked changes so reviewers can see what was added, removed or altered."
+            ),
+            `${name}-include-help`
+        )}
+    </div>
+`
+
+/** Read the tracked-changes radio group value ("resolve" or "include"). */
+export const getExportTrackChangesValue = (
+    dialogEl: Element,
+    name: string
+): string => {
+    return (
+        dialogEl.querySelector(
+            `input[name="${name}"]:checked`
+        ) as HTMLInputElement | null
+    )?.value || "resolve"
+}
+
 export const htmlExportDialogTemplate = (): string => `
+    ${exportTrackChangesTemplate("html-track-changes")}
+    <p>
+        <label>
+            <input type="checkbox" class="html-svg-math" aria-describedby="html-svg-math-help">
+            ${gettext("Render formulas as SVG images instead of MathML")}
+        </label>
+        ${infoTooltip(
+            gettext(
+                "SVG renders consistently across browsers; MathML keeps formulas as text that can be searched and copied, but only newer browsers support it."
+            ),
+            "html-svg-math-help"
+        )}
+    </p>
+`
+
+export const epubExportDialogTemplate = (): string => `
+    ${exportTrackChangesTemplate("epub-track-changes")}
     <p>
         <label>
-            <input type="checkbox" class="html-svg-math">
+            <input type="checkbox" class="epub-svg-math" aria-describedby="epub-svg-math-help">
             ${gettext("Render formulas as SVG images instead of MathML")}
         </label>
+        ${infoTooltip(
+            gettext(
+                "SVG renders consistently across browsers; MathML keeps formulas as text that can be searched and copied, but only newer browsers support it."
+            ),
+            "epub-svg-math-help"
+        )}
     </p>
-    <p class="formula-note">${gettext(
-        "SVG renders consistently across browsers and is used in PDF export; MathML keeps formulas as text that can be searched and copied, but only newer browsers support it."
-    )}</p>
 `
 
 export const tableInsertTemplate = (): string => `

package/src/document_template/index.ts

@@ -14,6 +14,7 @@ import {
 
 import type {Editor} from "../types.js"
 import {SaveCopy} from "../exporter/native/index.js"
+import {TemplateExportDialog} from "../dialogs/index.js"
 
 export {serializeHelp} from "./schema.js"
 
@@ -388,8 +389,17 @@ export class ModDocumentTemplate {
                     action: (editor: Editor) => {
                         import(
                             "@fiduswriter/document/exporter/docx/index"
-                        ).then(({DOCXExporter}: any) => {
-                            const doc = editor.getDoc() as any
+                        ).then(async ({DOCXExporter}: any) => {
+                            const dialog = new TemplateExportDialog()
+                            const options = await dialog.init("docx")
+                            if (!options) {
+                                return
+                            }
+                            const doc = editor.getDoc({
+                                changes: options.resolveTrackChanges
+                                    ? "acceptAllNoInsertions"
+                                    : undefined
+                            }) as any
                             const title = shortFileTitle(
                                 doc.title,
                                 doc.path || ""
@@ -426,8 +436,17 @@ export class ModDocumentTemplate {
                     ),
                     action: (editor: Editor) => {
                         import("@fiduswriter/document/exporter/odt/index").then(
-                            ({ODTExporter}: any) => {
-                                const doc = editor.getDoc() as any
+                            async ({ODTExporter}: any) => {
+                                const dialog = new TemplateExportDialog()
+                                const options = await dialog.init("odt")
+                                if (!options) {
+                                    return
+                                }
+                                const doc = editor.getDoc({
+                                    changes: options.resolveTrackChanges
+                                        ? "acceptAllNoInsertions"
+                                        : undefined
+                                }) as any
                                 const title = shortFileTitle(
                                     doc.title,
                                     doc.path || ""

package/src/index.ts

@@ -45,7 +45,6 @@ import {RequestAccessDialog} from "./documents/access_rights/request_access_dial
 import {E2EESnapshotManager} from "./e2ee/snapshot-manager.js"
 import {ExportFidusFile} from "./exporter/native/file.js"
 import {ModFootnotes} from "./footnotes/index.js"
-import {imageEditModel} from "./images/edit_dialog/model.js"
 import {buildEditorKeymap} from "./keymap.js"
 import {
     codeBlockMenuModel,
@@ -215,7 +214,6 @@ export class Editor {
             navigatorFilterModel: navigatorFilterModel(),
             orderedListMenuModel: orderedListMenuModel(),
             selectionMenuModel: selectionMenuModel(),
-            imageEditModel: imageEditModel(),
             tableMenuModel: tableMenuModel(),
             figureMenuModel: figureMenuModel(),
             toolbarModel: toolbarModel(),
@@ -291,7 +289,7 @@ export class Editor {
             staticUrl("css/bibliography/bibliography.css"),
             staticUrl("css/editor/dot_menu.css"),
             staticUrl("css/cropper.min.css"),
-            staticUrl("css/inline_tools.css"),
+            staticUrl("css/fwtoolkit/inline_tools.css"),
             staticUrl("css/editor/e2ee.css")
         ])
         new ModDocumentTemplate(this)

package/src/menus/headerbar/model.ts

@@ -14,7 +14,8 @@ import {
     LanguageDialog,
     PdfExportDialog,
     RevisionDialog,
-    HtmlExportDialog
+    HtmlExportDialog,
+    EpubExportDialog
 } from "../../dialogs/index.js"
 import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
 import {PassphraseManager} from "fwtoolkit/e2ee/passphrase-manager"
@@ -639,9 +640,20 @@ export const headerbarModel = () => ({
                             if (!options) {
                                 return
                             }
-                            const doc = getExportDoc(editor, {
-                                changes: "acceptAllNoInsertions"
-                            })
+                            const doc = getExportDoc(
+                                editor,
+                                options.resolveTrackChanges
+                                    ? {changes: "acceptAllNoInsertions"}
+                                    : undefined
+                            )
+                            const converterOptions: Record<string, unknown> = {}
+                            if (options.svgMath) {
+                                converterOptions.mathOutput = "svg"
+                            }
+                            if (!options.resolveTrackChanges) {
+                                // Keep the marks and render them in the output.
+                                converterOptions.trackChanges = true
+                            }
                             const exporter = new HTMLExporter(
                                 doc,
                                 db.bibDB,
@@ -649,7 +661,7 @@ export const headerbarModel = () => ({
                                 editor.app.csl,
                                 editor.docInfo.updated as Date,
                                 getDocumentTemplate(editor).documentStyles,
-                                options.svgMath ? {mathOutput: "svg"} : {}
+                                converterOptions
                             )
                             exporter.progressCallback = exportProgress(doc)
                             exporter.init()
@@ -732,18 +744,35 @@ export const headerbarModel = () => ({
                     action: (editor: Editor) => {
                         import(
                             "@fiduswriter/document/exporter/epub/index"
-                        ).then(({EpubExporter}) => {
+                        ).then(async ({EpubExporter}) => {
                             const db = getDB(editor)
-                            const doc = getExportDoc(editor, {
-                                changes: "acceptAllNoInsertions"
-                            })
+                            const dialog = new EpubExportDialog()
+                            const options = await dialog.init()
+                            if (!options) {
+                                return
+                            }
+                            const doc = getExportDoc(
+                                editor,
+                                options.resolveTrackChanges
+                                    ? {changes: "acceptAllNoInsertions"}
+                                    : undefined
+                            )
+                            const converterOptions: Record<string, unknown> = {}
+                            if (options.svgMath) {
+                                converterOptions.mathOutput = "svg"
+                            }
+                            if (!options.resolveTrackChanges) {
+                                // Keep the marks and render them in the output.
+                                converterOptions.trackChanges = true
+                            }
                             const exporter = new EpubExporter(
                                 doc,
                                 db.bibDB,
                                 db.imageDB,
                                 editor.app.csl,
                                 editor.docInfo.updated as Date,
-                                getDocumentTemplate(editor).documentStyles
+                                getDocumentTemplate(editor).documentStyles,
+                                converterOptions
                             )
                             exporter.progressCallback = exportProgress(doc)
                             exporter.init()

package/src/state_plugins/clipboard.ts

@@ -3,7 +3,7 @@ import fixUTF8 from "fix-utf8"
 import {Fragment, Slice} from "prosemirror-model"
 import {Plugin, PluginKey, TextSelection} from "prosemirror-state"
 import {ReplaceStep} from "prosemirror-transform"
-import type {Node} from "prosemirror-model"
+import type {Node, ResolvedPos} from "prosemirror-model"
 import type {EditorState, Transaction} from "prosemirror-state"
 import type {EditorView} from "prosemirror-view"
 
@@ -24,6 +24,70 @@ export const resetPasteRange = (tr: Transaction): void => {
     tr.setMeta(key, {pasteRange: null})
 }
 
+// Document section nodes. When content is copied from within the same editor,
+// prosemirror-view records these in the data-pm-slice attribute of the
+// clipboard HTML and wraps the pasted content in them again while parsing it.
+const sectionNodeTypes = new Set([
+    "richtext_part",
+    "heading_part",
+    "table_part",
+    "contributors_part",
+    "tags_part",
+    "table_of_contents",
+    "separator_part"
+])
+
+// Remove a section node wrapper from pasted content when it corresponds to an
+// ancestor node at the paste position. Content copied within the same document
+// arrives wrapped in such a wrapper. If it was not removed, the wrapper would
+// be treated like foreign content and be flattened during filtering below,
+// losing the structure and formatting of the copied content.
+const unwrapSectionWrapper = (slice: Slice, $pos: ResolvedPos): Slice => {
+    let {content, openStart, openEnd} = slice
+    // The outermost wrapper node corresponds to this ancestor of the position.
+    let wrapperDepth = $pos.depth - openStart + 1
+    while (
+        openStart > 0 &&
+        openEnd > 0 &&
+        wrapperDepth >= 1 &&
+        wrapperDepth <= $pos.depth &&
+        content.childCount === 1 &&
+        sectionNodeTypes.has(content.firstChild!.type.name) &&
+        content.firstChild!.type.name === $pos.node(wrapperDepth).type.name
+    ) {
+        content = content.firstChild!.content
+        openStart -= 1
+        openEnd -= 1
+        wrapperDepth += 1
+    }
+    return new Slice(content, openStart, openEnd)
+}
+
+// The number of node levels that are actually traversable openly at one side
+// of a fragment, limited to maxDepth. Filtering removes nodes from slices,
+// which can make their openStart/openEnd exceed the nesting depth of the
+// remaining content. Slices violating that constraint crash ProseMirror's
+// Selection.replace (it walks into non-existing child nodes when calculating
+// the insertion end position), so the open depths have to be reduced to fit.
+const openChainDepth = (
+    fragment: Fragment,
+    maxDepth: number,
+    side: "start" | "end"
+): number => {
+    let depth = 0
+    let node = side === "start" ? fragment.firstChild : fragment.lastChild
+    while (
+        node &&
+        !node.isLeaf &&
+        !node.type.spec.isolating &&
+        depth < maxDepth
+    ) {
+        depth += 1
+        node = side === "start" ? node.firstChild : node.lastChild
+    }
+    return depth
+}
+
 // Filter a fragment to only include allowed nodes and marks
 // parentNode is optional - used to check if converted nodes are valid children
 const filterFragment = (
@@ -271,6 +335,14 @@ export const clipboardPlugin = (options: {editor: Editor; viewType: string}) =>
                     return slice
                 }
 
+                const $pos = view.state.selection.$from
+
+                // Content copied within the same editor arrives wrapped in a
+                // section node corresponding to an ancestor of the paste
+                // position. Unwrap it so that it is handled like other pasted
+                // content rather than being flattened during filtering.
+                slice = unwrapSectionWrapper(slice, $pos)
+
                 // Get allowed elements and marks at the current selection position
                 const {elements, marks} = getAllowedElementsAndMarks(view.state)
 
@@ -280,7 +352,6 @@ export const clipboardPlugin = (options: {editor: Editor; viewType: string}) =>
                 }
 
                 // Get the parent node at the selection position to check compatibility
-                const $pos = view.state.selection.$from
                 const parentNode = $pos.parent
 
                 // Filter the slice content
@@ -292,11 +363,24 @@ export const clipboardPlugin = (options: {editor: Editor; viewType: string}) =>
                     parentNode
                 )
 
-                // Return new slice with filtered content
+                // All content may have been removed by the filtering.
+                if (!filteredContent.size) {
+                    return Slice.empty
+                }
+
+                // Return a new slice with the filtered content. Reduce the
+                // open depths to what the filtered content can actually
+                // provide, so that the slice remains insertable.
                 return new Slice(
                     filteredContent,
-                    slice.openStart,
-                    slice.openEnd
+                    Math.min(
+                        slice.openStart,
+                        openChainDepth(filteredContent, slice.openStart, "start")
+                    ),
+                    Math.min(
+                        slice.openEnd,
+                        openChainDepth(filteredContent, slice.openEnd, "end")
+                    )
                 )
             }
         }

package/src/track/accept.ts

@@ -19,7 +19,12 @@ export const accept = (
         return
     }
     const trackMark = nodeAtPos.marks.find(mark => mark.type.name === type)
-    if (!trackMark) {
+    // Block level track changes are stored in the node's track attribute
+    // rather than in marks (figures, tables, text blocks).
+    const blockTrack = (
+        nodeAtPos.attrs.track as Array<{type: string}> | undefined
+    )?.find(track => track.type === type)
+    if (!trackMark && !blockTrack) {
         return
     }
     view.state.doc.nodesBetween(
@@ -34,13 +39,22 @@ export const accept = (
             }
             if (!node.isInline) {
                 reachedEnd = true
-            } else if (!trackMark.isInSet(node.marks)) {
+            } else if (
+                trackMark &&
+                !trackMark.isInSet(node.marks) &&
+                !(
+                    node.attrs.track as Array<{type: string}> | undefined
+                )?.some(track => track.type === type)
+            ) {
                 reachedEnd = true
                 return false
             }
-            // Traverse only those nodes which have the track marks.
+            // Traverse only those nodes which have the track marks or
+            // corresponding block level track entries.
             if (
-                trackMark === undefined ||
+                (node.attrs.track as Array<{type: string}> | undefined)?.some(
+                    track => track.type === type
+                ) ||
                 (trackMark && trackMark.isInSet(node.marks))
             ) {
                 if (type === "deletion") {
@@ -68,6 +82,11 @@ export const accept = (
                             reachedEnd = false
                         }
                     } else {
+                        // The gate above guarantees the insertion mark is set
+                        // on nodes without a track attribute.
+                        if (!trackMark) {
+                            return true
+                        }
                         tr.step(
                             new AddMarkStep(
                                 map.map(nodePos),
@@ -81,6 +100,12 @@ export const accept = (
                         )
                     }
                 } else if (type === "format_change") {
+                    // format_change only exists as a mark, so trackMark is
+                    // guaranteed to be set here (the guard above would have
+                    // returned otherwise).
+                    if (!trackMark) {
+                        return
+                    }
                     tr.step(
                         new RemoveMarkStep(
                             map.map(nodePos),