fixed text search highlighting. fixed first typed characfter of note to have marks.

1 files changed, 187 insertions, 159 deletions

diff --git a/src/client/views/nodes/formattedText/FormattedTextBox.tsx b/src/client/views/nodes/formattedText/FormattedTextBox.tsx
index 31252e0ab..c7543560d 100644
--- a/src/client/views/nodes/formattedText/FormattedTextBox.tsx
+++ b/src/client/views/nodes/formattedText/FormattedTextBox.tsx
@@ -13,7 +13,7 @@ import { EditorState, NodeSelection, Plugin, TextSelection, Transaction } from '
 import { EditorView } from 'prosemirror-view';
 import * as React from 'react';
 import { BsMarkdownFill } from 'react-icons/bs';
-import { addStyleSheet, addStyleSheetRule, clearStyleSheetRules, ClientUtils, DivWidth, returnFalse, returnZero, setupMoveUpEvents, smoothScroll } from '../../../../ClientUtils';
+import { addStyleSheet, addStyleSheetRule, clearStyleSheetRules, ClientUtils, DivWidth, returnFalse, returnZero, setupMoveUpEvents, smoothScroll, StopEvent } from '../../../../ClientUtils';
 import { DateField } from '../../../../fields/DateField';
 import { Doc, DocListCast, Field, FieldType, Opt, StrListCast } from '../../../../fields/Doc';
 import { AclAdmin, AclAugment, AclEdit, AclSelfEdit, DocCss, DocData, ForceServerWrite, UpdatingFromServer } from '../../../../fields/DocSymbols';
@@ -82,6 +82,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         return FieldView.LayoutString(FormattedTextBox, fieldStr);
     }
     public static blankState = () => EditorState.create(FormattedTextBox.Instance.config);
+    // eslint-disable-next-line no-use-before-define
     public static Instance: FormattedTextBox;
     public static LiveTextUndo: UndoManager.Batch | undefined;
     static _globalHighlightsCache: string = '';
@@ -100,7 +101,6 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     private _inDrop = false;
     private _finishingLink = false;
     private _searchIndex = 0;
-    private _lastTimedMark: Mark | undefined = undefined;
     private _cachedLinks: Doc[] = [];
     private _undoTyping?: UndoManager.Batch;
     private _disposers: { [name: string]: IReactionDisposer } = {};
@@ -111,10 +111,6 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     private _keymap: any = undefined;
     private _rules: RichTextRules | undefined;
     private _forceUncollapse = true; // if the cursor doesn't move between clicks, then the selection will disappear for some reason.  This flags the 2nd click as happening on a selection which allows bullet points to toggle
-    private _forceDownNode: Node | undefined;
-    private _downX = 0;
-    private _downY = 0;
-    private _downTime = 0;
     private _break = true;
     public ProseRef?: HTMLDivElement;
     public get EditorView() {
@@ -173,8 +169,8 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 keymap(baseKeymap),
                 new Plugin({ props: { attributes: { class: 'ProseMirror-example-setup-style' } } }),
                 new Plugin({
-                    view(editorView) {
-                        return new FormattedTextBoxComment(editorView);
+                    view(/* editorView */) {
+                        return new FormattedTextBoxComment();
                     },
                 }),
             ],
@@ -220,13 +216,13 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     public RemoveLinkFromDoc(linkDoc?: Doc) {
         this.unhighlightSearchTerms();
         const state = this._editorView?.state;
-        const a1 = linkDoc?.link_anchor_1 as Doc;
-        const a2 = linkDoc?.link_anchor_2 as Doc;
+        const a1 = DocCast(linkDoc?.link_anchor_1);
+        const a2 = DocCast(linkDoc?.link_anchor_2);
         if (state && a1 && a2 && this._editorView) {
             this.removeDocument(a1);
             this.removeDocument(a2);
-            var allFoundLinkAnchors: any[] = [];
-            state.doc.nodesBetween(0, state.doc.nodeSize - 2, (node: any, pos: number, parent: any) => {
+            let allFoundLinkAnchors: any[] = [];
+            state.doc.nodesBetween(0, state.doc.nodeSize - 2, (node: any /* , pos: number, parent: any */) => {
                 const foundLinkAnchors = findLinkMark(node.marks)?.attrs.allAnchors.filter((a: any) => a.anchorId === a1[Id] || a.anchorId === a2[Id]) || [];
                 allFoundLinkAnchors = foundLinkAnchors.length ? foundLinkAnchors : allFoundLinkAnchors;
                 return true;
@@ -249,7 +245,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     }
 
     getAnchor = (addAsAnnotation: boolean, pinProps?: PinProps) => {
-        const rootDoc = Doc.isTemplateDoc(this._props.docViewPath().lastElement()?.Document) ? this.Document : DocCast(this.Document.rootDocument, this.Document);
+        const rootDoc: Doc = Doc.isTemplateDoc(this._props.docViewPath().lastElement()?.Document) ? this.Document : DocCast(this.Document.rootDocument, this.Document);
         if (!pinProps && this._editorView?.state.selection.empty) return rootDoc;
         const anchor = Docs.Create.ConfigDocument({ title: StrCast(rootDoc.title), annotationOn: rootDoc });
         this.addDocument(anchor);
@@ -264,11 +260,11 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     setupAnchorMenu = () => {
         AnchorMenu.Instance.Status = 'marquee';
 
-        AnchorMenu.Instance.OnClick = (e: PointerEvent) => {
+        AnchorMenu.Instance.OnClick = () => {
             !this.layoutDoc.layout_showSidebar && this.toggleSidebar();
             setTimeout(() => this._sidebarRef.current?.anchorMenuClick(this.makeLinkAnchor(undefined, OpenWhere.addRight, undefined, 'Anchored Selection', true))); // give time for sidebarRef to be created
         };
-        AnchorMenu.Instance.OnAudio = (e: PointerEvent) => {
+        AnchorMenu.Instance.OnAudio = () => {
             !this.layoutDoc.layout_showSidebar && this.toggleSidebar();
             const anchor = this.makeLinkAnchor(undefined, OpenWhere.addRight, undefined, 'Anchored Selection', true, true);
 
@@ -279,7 +275,8 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                     let stopFunc: any;
                     const targetData = target[DocData];
                     targetData.mediaState = mediaState.Recording;
-                    DocumentViewInternal.recordAudioAnnotation(targetData, Doc.LayoutFieldKey(target), stop => (stopFunc = stop));
+                    DocumentViewInternal.recordAudioAnnotation(targetData, Doc.LayoutFieldKey(target), stop => { stopFunc = stop }); // prettier-ignore
+
                     const reactionDisposer = reaction(
                         () => target.mediaState,
                         dictation => {
@@ -324,7 +321,9 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 ele.append(contents);
             }
             this._selectionHTML = ele?.innerHTML;
-        } catch (e) {}
+        } catch (e) {
+            /* empty */
+        }
     };
 
     leafText = (node: Node) => {
@@ -339,7 +338,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         return '';
     };
     dispatchTransaction = (tx: Transaction) => {
-        if (this._editorView && (this._editorView as any).docView) {
+        if (this._editorView) {
             const state = this._editorView.state.apply(tx);
             this._editorView.updateState(state);
             this.tryUpdateDoc(false);
@@ -347,13 +346,12 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     };
 
     tryUpdateDoc = (force: boolean) => {
-        if (this._editorView && (this._editorView as any).docView) {
+        if (this._editorView) {
             const { state } = this._editorView;
             const { dataDoc } = this;
             const newText = state.doc.textBetween(0, state.doc.content.size, ' \n', this.leafText);
             const newJson = JSON.stringify(state.toJSON());
             const prevData = Cast(this.layoutDoc[this.fieldKey], RichTextField, null); // the actual text in the text box
-            const templateData = this.Document !== this.layoutDoc ? prevData : undefined; // the default text stored in a layout template
             const protoData = Cast(Cast(dataDoc.proto, Doc, null)?.[this.fieldKey], RichTextField, null); // the default text inherited from a prototype
             const layoutData = this.layoutDoc.isTemplateDoc ? Cast(this.layoutDoc[this.fieldKey], RichTextField, null) : undefined; // the default text inherited from a prototype
             const effectiveAcl = GetEffectiveAcl(dataDoc);
@@ -362,7 +360,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
 
             if ([AclEdit, AclAdmin, AclSelfEdit, AclAugment].includes(effectiveAcl)) {
                 const accumTags = [] as string[];
-                state.tr.doc.nodesBetween(0, state.doc.content.size, (node: any, pos: number, parent: any) => {
+                state.tr.doc.nodesBetween(0, state.doc.content.size, (node: any /* , pos: number, parent: any */) => {
                     if (node.type === schema.nodes.dashField && node.attrs.fieldKey.startsWith('#')) {
                         accumTags.push(node.attrs.fieldKey);
                     }
@@ -417,37 +415,22 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     insertTime = () => {
         let linkTime;
         let linkAnchor;
-        let link;
-        LinkManager.Links(this.dataDoc).forEach((l, i) => {
-            const anchor = (l.link_anchor_1 as Doc).annotationOn ? (l.link_anchor_1 as Doc) : (l.link_anchor_2 as Doc).annotationOn ? (l.link_anchor_2 as Doc) : undefined;
+        LinkManager.Links(this.dataDoc).forEach(l => {
+            const anchor = DocCast(l.link_anchor_1)?.annotationOn ? DocCast(l.link_anchor_1) : DocCast(l.link_anchor_2)?.annotationOn ? DocCast(l.link_anchor_2) : undefined;
             if (anchor && (anchor.annotationOn as Doc).mediaState === mediaState.Recording) {
                 linkTime = NumCast(anchor._timecodeToShow /* audioStart */);
                 linkAnchor = anchor;
-                link = l;
             }
         });
         if (this._editorView && linkTime) {
-            const state = this._editorView.state;
-            const now = Date.now();
-            let mark = schema.marks.user_mark.create({ userid: ClientUtils.CurrentUserEmail, modified: Math.floor(now / 1000) });
-            if (!this._break && state.selection.to !== state.selection.from) {
-                for (let i = state.selection.from; i <= state.selection.to; i++) {
-                    const pos = state.doc.resolve(i);
-                    const um = Array.from(pos.marks()).find(m => m.type === schema.marks.user_mark);
-                    if (um) {
-                        mark = um;
-                        break;
-                    }
-                }
-            }
-
-            const path = (this._editorView.state.selection.$from as any).path;
-            if (linkAnchor && path[path.length - 3].type !== this._editorView.state.schema.nodes.code_block) {
+            const { state } = this._editorView;
+            const { path } = state.selection.$from as any;
+            if (linkAnchor && path[path.length - 3].type !== state.schema.nodes.code_block) {
                 const time = linkTime + Date.now() / 1000 - this._recordingStart / 1000;
                 this._break = false;
-                const from = state.selection.from;
-                const value = this._editorView.state.schema.nodes.audiotag.create({ timeCode: time, audioId: linkAnchor[Id] });
-                const replaced = this._editorView.state.tr.insert(from - 1, value);
+                const { from } = state.selection;
+                const value = state.schema.nodes.audiotag.create({ timeCode: time, audioId: linkAnchor[Id] });
+                const replaced = state.tr.insert(from - 1, value);
                 this._editorView.dispatch(replaced.setSelection(new TextSelection(replaced.doc.resolve(from + 1))));
             }
         }
@@ -464,14 +447,14 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 link.link_relationship === LinkManager.AutoKeywords
         ); // prettier-ignore
         if (this._editorView?.state.doc.textContent) {
-            const f = this._editorView.state.selection.from;
-
-            const t = this._editorView.state.selection.to;
-            var tr = this._editorView.state.tr as any;
-            const autoAnch = this._editorView.state.schema.marks.autoLinkAnchor;
-            tr = tr.removeMark(0, tr.doc.content.size, autoAnch);
-            Doc.MyPublishedDocs.filter(term => term.title).forEach(term => (tr = this.hyperlinkTerm(tr, term, newAutoLinks)));
-            tr = tr.setSelection(new TextSelection(tr.doc.resolve(f), tr.doc.resolve(t)));
+            let { tr } = this._editorView.state;
+            const { from, to } = this._editorView.state.selection;
+            const { autoLinkAnchor } = this._editorView.state.schema.marks;
+            tr = tr.removeMark(0, tr.doc.content.size, autoLinkAnchor);
+            Doc.MyPublishedDocs.filter(term => term.title).forEach(term => {
+                tr = this.hyperlinkTerm(tr, term, newAutoLinks);
+            });
+            tr = tr.setSelection(new TextSelection(tr.doc.resolve(from), tr.doc.resolve(to)));
             this._editorView?.dispatch(tr);
         }
         oldAutoLinks.filter(oldLink => !newAutoLinks.has(oldLink) && oldLink.link_anchor_2 !== this.Document).forEach(LinkManager.Instance.deleteLink);
@@ -507,11 +490,12 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
      * function of a freeform view that is driven by the text box's text.  The include directive will copy the code of the published
      * document into the code being evaluated.
      */
-    hyperlinkTerm = (tr: any, target: Doc, newAutoLinks: Set<Doc>) => {
+    hyperlinkTerm = (trIn: any, target: Doc, newAutoLinks: Set<Doc>) => {
+        let tr = trIn;
         const editorView = this._editorView;
-        if (editorView && (editorView as any).docView && !Doc.AreProtosEqual(target, this.Document)) {
+        if (editorView && !Doc.AreProtosEqual(target, this.Document)) {
             const autoLinkTerm = Field.toString(target.title as FieldType).replace(/^@/, '');
-            var alink: Doc | undefined;
+            let alink: Doc | undefined;
             this.findInNode(editorView, editorView.state.doc, autoLinkTerm).forEach(sel => {
                 if (
                     !sel.$anchor.pos ||
@@ -523,7 +507,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 ) {
                     const splitter = editorView.state.schema.marks.splitter.create({ id: Utils.GenerateGuid() });
                     tr = tr.addMark(sel.from, sel.to, splitter);
-                    tr.doc.nodesBetween(sel.from, sel.to, (node: any, pos: number, parent: any) => {
+                    tr.doc.nodesBetween(sel.from, sel.to, (node: any, pos: number /* , parent: any */) => {
                         if (node.firstChild === null && !node.marks.find((m: Mark) => m.type.name === schema.marks.noAutoLinkAnchor.name) && node.marks.find((m: Mark) => m.type.name === schema.marks.splitter.name)) {
                             alink =
                                 alink ??
@@ -554,12 +538,14 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         return true;
     };
     highlightSearchTerms = (terms: string[], backward: boolean) => {
-        if (this._editorView && (this._editorView as any).docView && terms.some(t => t)) {
-            const mark = this._editorView.state.schema.mark(this._editorView.state.schema.marks.search_highlight);
-            const activeMark = this._editorView.state.schema.mark(this._editorView.state.schema.marks.search_highlight, { selected: true });
-            const res = terms.filter(t => t).map(term => this.findInNode(this._editorView!, this._editorView!.state.doc, term));
-            const length = res[0].length;
-            let tr = this._editorView.state.tr;
+        const { _editorView } = this;
+        if (_editorView && terms.some(t => t)) {
+            const { state } = _editorView;
+            let { tr } = state;
+            const mark = state.schema.mark(state.schema.marks.search_highlight);
+            const activeMark = state.schema.mark(state.schema.marks.search_highlight, { selected: true });
+            const res = terms.filter(t => t).map(term => this.findInNode(_editorView, state.doc, term));
+            const { length } = res[0];
             const flattened: TextSelection[] = [];
             res.map(r => r.map(h => flattened.push(h)));
             this._searchIndex = ++this._searchIndex > flattened.length - 1 ? 0 : this._searchIndex;
@@ -574,18 +560,22 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             }
 
             const lastSel = Math.min(flattened.length - 1, this._searchIndex);
-            flattened.forEach((h: TextSelection, ind: number) => (tr = tr.addMark(h.from, h.to, ind === lastSel ? activeMark : mark)));
-            flattened[lastSel] && this._editorView.dispatch(tr.setSelection(new TextSelection(tr.doc.resolve(flattened[lastSel].from), tr.doc.resolve(flattened[lastSel].to))).scrollIntoView());
+            flattened.forEach((h: TextSelection, ind: number) => {
+                tr = tr.addMark(h.from, h.to, ind === lastSel ? activeMark : mark);
+            });
+            flattened[lastSel] && _editorView.dispatch(tr.setSelection(new TextSelection(tr.doc.resolve(flattened[lastSel].from), tr.doc.resolve(flattened[lastSel].to))).scrollIntoView());
         }
     };
 
     unhighlightSearchTerms = () => {
-        if (window.screen.width < 600) null;
-        else if (this._editorView && (this._editorView as any).docView) {
-            const mark = this._editorView.state.schema.mark(this._editorView.state.schema.marks.search_highlight);
-            const activeMark = this._editorView.state.schema.mark(this._editorView.state.schema.marks.search_highlight, { selected: true });
-            const end = this._editorView.state.doc.nodeSize - 2;
-            this._editorView.dispatch(this._editorView.state.tr.removeMark(0, end, mark).removeMark(0, end, activeMark));
+        if (this._editorView) {
+            const { state } = this._editorView;
+            if (state) {
+                const mark = state.schema.mark(state.schema.marks.search_highlight);
+                const activeMark = state.schema.mark(state.schema.marks.search_highlight, { selected: true });
+                const end = state.doc.nodeSize - 2;
+                this._editorView.dispatch(state.tr.removeMark(0, end, mark).removeMark(0, end, activeMark));
+            }
         }
     };
     adoptAnnotation = (start: number, end: number, mark: Mark) => {
@@ -634,7 +624,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                         float: 'unset',
                     });
                     if (!de.embedKey && ![dropActionType.embed, dropActionType.copy].includes(dropAction ?? dropActionType.move)) {
-                        added = dragData.removeDocument?.(draggedDoc) ? true : false;
+                        added = !!dragData.removeDocument?.(draggedDoc);
                     } else {
                         added = true;
                     }
@@ -646,7 +636,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                             this._inDrop = true;
                             const pos = view.posAtCoords({ left: de.x, top: de.y })?.pos;
                             pos && view.dispatch(view.state.tr.insert(pos, node));
-                            added = pos ? true : false; // pos will be null if you don't drop onto an actual text location
+                            added = !!pos; // pos will be null if you don't drop onto an actual text location
                         } catch (e) {
                             console.log('Drop failed', e);
                             added = false;
@@ -680,29 +670,28 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 }
                 offset += (context.content as any).content[i].nodeSize;
             }
-            return null;
-        } else {
-            return null;
         }
+        return null;
     }
 
-    //Recursively finds matches within a given node
+    // Recursively finds matches within a given node
     findInNode(pm: EditorView, node: Node, find: string) {
         let ret: TextSelection[] = [];
 
         if (node.isTextblock) {
-            let index = 0,
-                foundAt;
+            let index = 0;
+            let foundAt;
             const ep = this.getNodeEndpoints(pm.state.doc, node);
             const regexp = new RegExp(find, 'i');
             if (regexp) {
-                var blockOffset = 0;
-                for (var i = 0; i < node.childCount; i++) {
-                    var textContent = '';
+                let blockOffset = 0;
+                for (let i = 0; i < node.childCount; i++) {
+                    let textContent = '';
                     while (i < node.childCount && node.child(i).type === pm.state.schema.nodes.text) {
                         textContent += node.child(i).textContent;
                         i++;
                     }
+                    // eslint-disable-next-line no-cond-assign
                     while (ep && (foundAt = textContent.slice(index).search(regexp)) > -1) {
                         const sel = new TextSelection(pm.state.doc.resolve(ep.from + index + blockOffset + foundAt + 1), pm.state.doc.resolve(ep.from + index + blockOffset + foundAt + find.length + 1));
                         ret.push(sel);
@@ -713,14 +702,18 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 }
             }
         } else {
-            node.content.forEach((child, i) => (ret = ret.concat(this.findInNode(pm, child, find))));
+            node.content.forEach(child => {
+                ret = ret.concat(this.findInNode(pm, child, find));
+            });
         }
         return ret;
     }
 
     updateHighlights = (highlights: string[]) => {
         if (Array.from(highlights).join('') === FormattedTextBox._globalHighlightsCache) return;
-        setTimeout(() => (FormattedTextBox._globalHighlightsCache = Array.from(highlights).join('')));
+        setTimeout(() => {
+            FormattedTextBox._globalHighlightsCache = Array.from(highlights).join('');
+        });
         clearStyleSheetRules(FormattedTextBox._userStyleSheet);
         if (!highlights.includes('Audio Tags')) {
             addStyleSheetRule(FormattedTextBox._userStyleSheet, 'audiotag', { display: 'none' }, '');
@@ -757,12 +750,13 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             const hr = Math.round(Date.now() / 1000 / 60 / 60);
             numberRange(10).map(i => addStyleSheetRule(FormattedTextBox._userStyleSheet, 'UM-hr-' + (hr - i), { opacity: ((10 - i - 1) / 10).toString() }));
         }
+        // eslint-disable-next-line operator-assignment
         this.layoutDoc[DocCss] = this.layoutDoc[DocCss] + 1; // css changes happen outside of react/mobx.  so we need to set a flag that will notify anyone interested in layout changes triggered by css changes (eg., CollectionLinkView)
     };
 
     @observable _showSidebar = false;
     @computed get SidebarShown() {
-        return this._showSidebar || this.layoutDoc._layout_showSidebar ? true : false;
+        return !!(this._showSidebar || this.layoutDoc._layout_showSidebar);
     }
 
     @action
@@ -820,7 +814,9 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     pinToPres = (anchor: Doc) => this._props.pinToPres(anchor, {});
 
     @undoBatch
-    makeTargetToggle = (anchor: Doc) => (anchor.followLinkToggle = !anchor.followLinkToggle);
+    makeTargetToggle = (anchor: Doc) => {
+        anchor.followLinkToggle = !anchor.followLinkToggle;
+    };
 
     @undoBatch
     showTargetTrail = (anchor: Doc) => {
@@ -836,11 +832,10 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     specificContextMenu = (e: React.MouseEvent): void => {
         const cm = ContextMenu.Instance;
 
-        const editor = this._editorView!;
-        const pcords = editor.posAtCoords({ left: e.clientX, top: e.clientY });
         let target = e.target as any; // hrefs are stored on the database of the <a> node that wraps the hyerlink <span>
         while (target && !target.dataset?.targethrefs) target = target.parentElement;
-        if (target && !(e.nativeEvent as any).dash) {
+        const editor = this._editorView;
+        if (editor && target && !(e.nativeEvent as any).dash) {
             const hrefs = (target.dataset?.targethrefs as string)
                 ?.trim()
                 .split(' ')
@@ -850,8 +845,8 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 .replace(Doc.localServerPath(), '')
                 .split('?')[0];
             const deleteMarkups = undoBatch(() => {
-                const sel = editor.state.selection;
-                editor.dispatch(editor.state.tr.removeMark(sel.from, sel.to, editor.state.schema.marks.linkAnchor));
+                const { selection } = editor.state;
+                editor.dispatch(editor.state.tr.removeMark(selection.from, selection.to, editor.state.schema.marks.linkAnchor));
             });
             e.persist();
             anchorDoc &&
@@ -887,7 +882,9 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             event: undoBatch(() => {
                 this.dataDoc.layout_meta = Cast(Doc.UserDoc().emptyHeader, Doc, null)?.layout;
                 this.Document.layout_fieldKey = 'layout_meta';
-                setTimeout(() => (this.layoutDoc._header_height = this.layoutDoc._layout_autoHeightMargins = 50), 50);
+                setTimeout(() => {
+                    this.layoutDoc._header_height = this.layoutDoc._layout_autoHeightMargins = 50;
+                }, 50);
             }),
             icon: 'eye',
         });
@@ -926,19 +923,26 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
 
         appearanceItems.push({
             description: !this.Document._layout_noSidebar ? 'Hide Sidebar Handle' : 'Show Sidebar Handle',
-            event: () => (this.layoutDoc._layout_noSidebar = !this.layoutDoc._layout_noSidebar),
+            event: () => {
+                this.layoutDoc._layout_noSidebar = !this.layoutDoc._layout_noSidebar;
+            },
             icon: !this.Document._layout_noSidebar ? 'eye-slash' : 'eye',
         });
         appearanceItems.push({
             description: (this.Document._layout_enableAltContentUI ? 'Hide' : 'Show') + ' Alt Content UI',
-            event: () => (this.layoutDoc._layout_enableAltContentUI = !this.layoutDoc._layout_enableAltContentUI),
+            event: () => {
+                this.layoutDoc._layout_enableAltContentUI = !this.layoutDoc._layout_enableAltContentUI;
+            },
             icon: !this.Document._layout_enableAltContentUI ? 'eye-slash' : 'eye',
         });
         !Doc.noviceMode && appearanceItems.push({ description: 'Show Highlights...', noexpand: true, subitems: highlighting, icon: 'hand-point-right' });
         !Doc.noviceMode &&
             appearanceItems.push({
                 description: 'Broadcast Message',
-                event: () => DocServer.GetRefField('rtfProto').then(proto => proto instanceof Doc && (proto.BROADCAST_MESSAGE = Cast(this.dataDoc[this.fieldKey], RichTextField)?.Text)),
+                event: () =>
+                    DocServer.GetRefField('rtfProto').then(proto => {
+                        proto instanceof Doc && (proto.BROADCAST_MESSAGE = Cast(this.dataDoc[this.fieldKey], RichTextField)?.Text);
+                    }),
                 icon: 'expand-arrows-alt',
             });
 
@@ -960,19 +964,29 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
 
         const options = cm.findByDescription('Options...');
         const optionItems = options && 'subitems' in options ? options.subitems : [];
-        optionItems.push({ description: `Toggle auto update from template`, event: () => (this.dataDoc[this.fieldKey + '_autoUpdate'] = !this.dataDoc[this.fieldKey + '_autoUpdate']), icon: 'star' });
+        optionItems.push({
+            description: `Toggle auto update from template`,
+            event: () => {
+                this.dataDoc[this.fieldKey + '_autoUpdate'] = !this.dataDoc[this.fieldKey + '_autoUpdate'];
+            },
+            icon: 'star',
+        });
         optionItems.push({ description: `Generate Dall-E Image`, event: () => this.generateImage(), icon: 'star' });
         optionItems.push({ description: `Ask GPT-3`, event: () => this.askGPT(), icon: 'lightbulb' });
         this._props.renderDepth &&
             optionItems.push({
                 description: !this.Document._createDocOnCR ? 'Create New Doc on Carriage Return' : 'Allow Carriage Returns',
-                event: () => (this.layoutDoc._createDocOnCR = !this.layoutDoc._createDocOnCR),
+                event: () => {
+                    this.layoutDoc._createDocOnCR = !this.layoutDoc._createDocOnCR;
+                },
                 icon: !this.Document._createDocOnCR ? 'grip-lines' : 'bars',
             });
         !Doc.noviceMode &&
             optionItems.push({
                 description: `${this.Document._layout_autoHeight ? 'Lock' : 'Auto'} Height`,
-                event: () => (this.layoutDoc._layout_autoHeight = !this.layoutDoc._layout_autoHeight),
+                event: () => {
+                    this.layoutDoc._layout_autoHeight = !this.layoutDoc._layout_autoHeight;
+                },
                 icon: this.Document._layout_autoHeight ? 'lock' : 'unlock',
             });
         !options && cm.addItem({ description: 'Options...', subitems: optionItems, icon: 'eye' });
@@ -980,7 +994,6 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         const helpItems = help && 'subitems' in help ? help.subitems : [];
         helpItems.push({ description: `show markdown options`, event: RTFMarkup.Instance.open, icon: <BsMarkdownFill /> });
         !help && cm.addItem({ description: 'Help...', subitems: helpItems, icon: 'eye' });
-        this._downX = this._downY = Number.NaN;
     };
 
     animateRes = (resIndex: number, newText: string) => {
@@ -995,7 +1008,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
 
     askGPT = action(async () => {
         try {
-            let res = await gptAPICall((this.dataDoc.text as RichTextField)?.Text, GPTCallType.COMPLETION);
+            const res = await gptAPICall((this.dataDoc.text as RichTextField)?.Text, GPTCallType.COMPLETION);
             if (!res) {
                 console.error('GPT call failed');
                 this.animateRes(0, 'Something went wrong.');
@@ -1020,8 +1033,8 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         if (this._editorView && this._recordingDictation) {
             this.stopDictation(true);
             this._break = true;
-            const state = this._editorView.state;
-            const to = state.selection.to;
+            const { state } = this._editorView;
+            const { to } = state.selection;
             const updated = TextSelection.create(state.doc, to, to);
             this._editorView.dispatch(state.tr.setSelection(updated).insert(to, state.schema.nodes.paragraph.create({})));
             if (this._recordingDictation) {
@@ -1067,7 +1080,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                     }
                 }
             }
-            const from = this._editorView.state.selection.from;
+            const { from } = this._editorView.state.selection;
             this._break = false;
             const tr = this._editorView.state.tr.insertText(value);
             this._editorView.dispatch(tr.setSelection(TextSelection.create(tr.doc, from, tr.doc.content.size)).scrollIntoView());
@@ -1076,23 +1089,24 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
 
     // TODO: nda -- Look at how link anchors are added
     makeLinkAnchor(anchorDoc?: Doc, location?: string, targetHref?: string, title?: string, noPreview?: boolean, addAsAnnotation?: boolean) {
-        const state = this._editorView?.state;
-        if (state) {
+        const { _editorView } = this;
+        if (_editorView) {
+            const { state } = _editorView;
             let selectedText = '';
-            const sel = state.selection;
+            const { selection } = state;
             const splitter = state.schema.marks.splitter.create({ id: Utils.GenerateGuid() });
-            let tr = state.tr.addMark(sel.from, sel.to, splitter);
-            if (sel.from !== sel.to) {
+            let tr = state.tr.addMark(selection.from, selection.to, splitter);
+            if (selection.from !== selection.to) {
                 const anchor =
                     anchorDoc ??
                     Docs.Create.ConfigDocument({
                         //
-                        title: 'text(' + this._editorView?.state.doc.textBetween(sel.from, sel.to) + ')',
+                        title: 'text(' + state.doc.textBetween(selection.from, selection.to) + ')',
                         annotationOn: this.dataDoc,
                     });
                 const href = targetHref ?? Doc.localServerPath(anchor);
                 if (anchor !== anchorDoc && addAsAnnotation) this.addDocument(anchor);
-                tr.doc.nodesBetween(sel.from, sel.to, (node: any, pos: number, parent: any) => {
+                tr.doc.nodesBetween(selection.from, selection.to, (node: any, pos: number /* , parent: any */) => {
                     if (node.firstChild === null && node.marks.find((m: Mark) => m.type.name === schema.marks.splitter.name)) {
                         const allAnchors = [{ href, title, anchorId: anchor[Id] }];
                         allAnchors.push(...(node.marks.find((m: Mark) => m.type.name === schema.marks.linkAnchor.name)?.attrs.allAnchors ?? []));
@@ -1102,7 +1116,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                     }
                 });
                 this.dataDoc[ForceServerWrite] = this.dataDoc[UpdatingFromServer] = true; // need to allow permissions for adding links to readonly/augment only documents
-                this._editorView!.dispatch(tr.removeMark(sel.from, sel.to, splitter));
+                this._editorView!.dispatch(tr.removeMark(selection.from, selection.to, splitter));
                 this.dataDoc[UpdatingFromServer] = this.dataDoc[ForceServerWrite] = false;
                 anchor.text = selectedText;
                 anchor.text_html = this._selectionHTML ?? selectedText;
@@ -1123,15 +1137,19 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             }
             setTimeout(() => this._sidebarRef?.current?.makeDocUnfiltered(doc));
         }
-        return new Promise<Opt<DocumentView>>(res => DocumentManager.Instance.AddViewRenderedCb(doc, dv => res(dv)));
+        return new Promise<Opt<DocumentView>>(res => {
+            DocumentManager.Instance.AddViewRenderedCb(doc, dv => res(dv));
+        });
     };
     focus = (textAnchor: Doc, options: FocusViewOptions) => {
         const focusSpeed = options.zoomTime ?? 500;
         const textAnchorId = textAnchor[Id];
+        let start = 0;
         const findAnchorFrag = (frag: Fragment, editor: EditorView) => {
             const nodes: Node[] = [];
             let hadStart = start !== 0;
             frag.forEach((node, index) => {
+                // eslint-disable-next-line no-use-before-define
                 const examinedNode = findAnchorNode(node, editor);
                 if (examinedNode?.node && (examinedNode.node.textContent || examinedNode.node.type === this._editorView?.state.schema.nodes.dashDoc || examinedNode.node.type === this._editorView?.state.schema.nodes.audiotag)) {
                     nodes.push(examinedNode.node);
@@ -1163,7 +1181,6 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             return linkIndex !== -1 && marks[linkIndex].attrs.allAnchors.find((item: { href: string }) => textAnchorId === item.href.replace(/.*\/doc\//, '')) ? { node, start: 0 } : undefined;
         };
 
-        let start = 0;
         this._didScroll = false; // assume we don't need to scroll.  if we do, this will get set to true in handleScrollToSelextion when we dispatch the setSelection below
         if (this._editorView && textAnchorId) {
             const editor = this._editorView;
@@ -1179,13 +1196,15 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 editor.dispatch(editor.state.tr.setSelection(new TextSelection(selection.$from, selection.$from)).scrollIntoView());
                 const escAnchorId = textAnchorId[0] >= '0' && textAnchorId[0] <= '9' ? `\\3${textAnchorId[0]} ${textAnchorId.substr(1)}` : textAnchorId;
                 addStyleSheetRule(FormattedTextBox._highlightStyleSheet, `${escAnchorId}`, { background: 'yellow', transform: 'scale(3)', 'transform-origin': 'left bottom' });
-                setTimeout(() => (this._focusSpeed = undefined), this._focusSpeed);
+                setTimeout(() => {
+                    this._focusSpeed = undefined;
+                }, this._focusSpeed);
                 setTimeout(() => clearStyleSheetRules(FormattedTextBox._highlightStyleSheet), Math.max(this._focusSpeed || 0, 3000));
                 return focusSpeed;
-            } else {
-                return this._props.focus(this.Document, options);
             }
+            return this._props.focus(this.Document, options);
         }
+        return undefined;
     };
 
     // if the scroll height has changed and we're in layout_autoHeight mode, then we need to update the textHeight component of the doc.
@@ -1205,7 +1224,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         this._disposers.breakupDictation = reaction(() => Doc.RecordingEvent, this.breakupDictation);
         this._disposers.layout_autoHeight = reaction(
             () => ({ autoHeight: this.layout_autoHeight, fontSize: this.fontSize, css: this.Document[DocCss] }),
-            (autoHeight, fontSize) => setTimeout(() => autoHeight && this.tryUpdateScrollHeight())
+            autoHeight => setTimeout(() => autoHeight && this.tryUpdateScrollHeight())
         );
         this._disposers.highlights = reaction(
             () => Array.from(FormattedTextBox._globalHighlights).slice(),
@@ -1214,7 +1233,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         );
         this._disposers.width = reaction(
             () => this._props.PanelWidth(),
-            width => this.tryUpdateScrollHeight()
+            () => this.tryUpdateScrollHeight()
         );
         this._disposers.scrollHeight = reaction(
             () => ({ scrollHeight: this.scrollHeight, layoutAutoHeight: this.layout_autoHeight, width: NumCast(this.layoutDoc._width) }),
@@ -1348,7 +1367,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         return text;
     };
 
-    handlePaste = (view: EditorView, event: Event, slice: Slice): boolean => {
+    handlePaste = (view: EditorView, event: Event /* , slice: Slice */): boolean => {
         const pdfAnchorId = (event as ClipboardEvent).clipboardData?.getData('dash/pdfAnchor');
         return !!(pdfAnchorId && this.addPdfReference(pdfAnchorId));
     };
@@ -1381,7 +1400,8 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         return false;
     };
 
-    isActiveTab(el: Element | null | undefined) {
+    isActiveTab(elIn: Element | null | undefined) {
+        let el = elIn;
         while (el && el !== document.body) {
             if (getComputedStyle(el).display === 'none') return false;
             el = el.parentNode as any;
@@ -1477,9 +1497,18 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 const tr = tr2.setStoredMarks(storedMarks);
 
                 this._editorView.dispatch(tr.setSelection(new TextSelection(tr.doc.resolve(tr.doc.content.size))));
+                this.tryUpdateDoc(true); // calling select() above will make isContentActive() true only after a render .. which means the selectAll() above won't write to the Document and the incomingValue will overwrite the selection with the non-updated data
             } else if (curText && !FormattedTextBox.DontSelectInitialText) {
                 selectAll(this._editorView.state, this._editorView?.dispatch);
                 this.tryUpdateDoc(true); // calling select() above will make isContentActive() true only after a render .. which means the selectAll() above won't write to the Document and the incomingValue will overwrite the selection with the non-updated data
+            } else {
+                const $from = this._editorView.state.selection.anchor ? this._editorView.state.doc.resolve(this._editorView.state.selection.anchor - 1) : undefined;
+                const mark = schema.marks.user_mark.create({ userid: ClientUtils.CurrentUserEmail, modified: Math.floor(Date.now() / 1000) });
+                const curMarks = this._editorView.state.storedMarks ?? $from?.marksAcross(this._editorView.state.selection.$head) ?? [];
+                const storedMarks = [...curMarks.filter(m => m.type !== mark.type), mark];
+                const { tr } = this._editorView.state;
+                this._editorView.dispatch(tr.setSelection(new TextSelection(tr.doc.resolve(tr.doc.content.size))).setStoredMarks(storedMarks));
+                this.tryUpdateDoc(true); // calling select() above will make isContentActive() true only after a render .. which means the selectAll() above won't write to the Document and the incomingValue will overwrite the selection with the non-updated data
             }
         }
         if (selectOnLoad) {
@@ -1526,8 +1555,9 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
 
     onPointerDown = (e: React.PointerEvent): void => {
         if ((e.nativeEvent as any).handledByInnerReactInstance) {
-            return; //e.stopPropagation();
-        } else (e.nativeEvent as any).handledByInnerReactInstance = true;
+            return; // e.stopPropagation();
+        }
+        (e.nativeEvent as any).handledByInnerReactInstance = true;
 
         if (this.Document.forceActive) e.stopPropagation();
         this.tryUpdateScrollHeight(); // if a doc a fitWidth doc is being viewed in different embedContainer (eg freeform & lightbox), then it will have conflicting heights.  so when the doc is clicked on, we want to make sure it has the appropriate height for the selected view.
@@ -1553,9 +1583,6 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         if (this._recordingDictation && !e.ctrlKey && e.button === 0) {
             this.breakupDictation();
         }
-        this._downX = e.clientX;
-        this._downY = e.clientY;
-        this._downTime = Date.now();
         FormattedTextBoxComment.textBox = this;
         if (e.button === 0 && this._props.rootSelected?.() && !e.altKey && !e.ctrlKey && !e.metaKey) {
             if (e.clientX < this.ProseRef!.getBoundingClientRect().right) {
@@ -1569,9 +1596,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             e.preventDefault();
         }
     };
-    onSelectEnd = (e: PointerEvent) => {
-        document.removeEventListener('pointerup', this.onSelectEnd);
-    };
+    onSelectEnd = (): void => document.removeEventListener('pointerup', this.onSelectEnd);
     onPointerUp = (e: React.PointerEvent): void => {
         const state = this.EditorView?.state;
         if (state && this.ProseRef?.children[0].className.includes('-focused') && this._props.isContentActive() && !e.button) {
@@ -1607,7 +1632,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     };
     @action
     onFocused = (e: React.FocusEvent): void => {
-        //applyDevTools.applyDevTools(this._editorView);
+        // applyDevTools.applyDevTools(this._editorView);
         this.ProseRef?.children[0] === e.nativeEvent.target && this._editorView && RichTextMenu.Instance?.updateMenu(this._editorView, undefined, this._props, this.layoutDoc);
         e.stopPropagation();
     };
@@ -1618,10 +1643,6 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             e.stopPropagation();
             return;
         }
-        if (Math.abs(e.clientX - this._downX) > 4 || Math.abs(e.clientY - this._downY) > 4) {
-            this._forceDownNode = undefined;
-            return;
-        }
         if (!this._forceUncollapse || (this._editorView!.root as any).getSelection().isCollapsed) {
             // this is a hack to allow the cursor to be placed at the end of a document when the document ends in an inline dash comment.  Apparently Chrome on Windows has a bug/feature which breaks this when clicking after the end of the text.
             const pcords = this._editorView!.posAtCoords({ left: e.clientX, top: e.clientY });
@@ -1645,13 +1666,12 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         if (this._props.rootSelected?.()) {
             // if text box is selected, then it consumes all click events
             (e.nativeEvent as any).handledByInnerReactInstance = true;
-            this.hitBulletTargets(e.clientX, e.clientY, !this._editorView?.state.selection.empty || this._forceUncollapse, false, this._forceDownNode, e.shiftKey);
+            this.hitBulletTargets(e.clientX, e.clientY, !this._editorView?.state.selection.empty || this._forceUncollapse, false, e.shiftKey);
         }
         this._forceUncollapse = !(this._editorView!.root as any).getSelection().isCollapsed;
-        this._forceDownNode = (this._editorView!.state.selection as NodeSelection)?.node;
     };
     // this hackiness handles clicking on the list item bullets to do expand/collapse.  the bullets are ::before pseudo elements so there's no real way to hit test against them.
-    hitBulletTargets(x: number, y: number, collapse: boolean, highlightOnly: boolean, downNode: Node | undefined = undefined, selectOrderedList: boolean = false) {
+    hitBulletTargets(x: number, y: number, collapse: boolean, highlightOnly: boolean, selectOrderedList: boolean = false) {
         this._forceUncollapse = false;
         clearStyleSheetRules(FormattedTextBox._bulletStyleSheet);
         const clickPos = this._editorView!.posAtCoords({ left: x, top: y });
@@ -1721,6 +1741,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         const match = RTFCast(this.Document[this.fieldKey])?.Text.match(/^(@[a-zA-Z][a-zA-Z_0-9 -]*[a-zA-Z_0-9-]+)/);
         if (match) {
             this.dataDoc.title_custom = true;
+            // eslint-disable-next-line prefer-destructuring
             this.dataDoc.title = match[1]; // this triggers the collectionDockingView to publish this Doc
             this.EditorView?.dispatch(this.EditorView?.state.tr.deleteRange(0, match[1].length + 1));
         }
@@ -1730,31 +1751,29 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         FormattedTextBox.LiveTextUndo?.end();
         FormattedTextBox.LiveTextUndo = undefined;
 
-        const state = this._editorView!.state;
         // if the text box blurs and none of its contents are focused(), then pass the blur along
         setTimeout(() => !this.ProseRef?.contains(document.activeElement) && this._props.onBlur?.());
     };
 
     onKeyDown = (e: React.KeyboardEvent) => {
+        const { _editorView } = this;
+        if (!_editorView) return;
         if ((e.altKey || e.ctrlKey) && e.key === 't') {
-            e.preventDefault();
-            e.stopPropagation();
             this._props.setTitleFocus?.();
+            StopEvent(e);
             return;
         }
-        const state = this._editorView!.state;
+        const { state } = _editorView;
         if (!state.selection.empty && e.key === '%') {
             this._rules!.EnteringStyle = true;
-            e.preventDefault();
-            e.stopPropagation();
+            StopEvent(e);
             return;
         }
 
         if (state.selection.empty || !this._rules!.EnteringStyle) {
             this._rules!.EnteringStyle = false;
         }
-        let stopPropagation = true;
-        for (var i = state.selection.from; i <= state.selection.to; i++) {
+        for (let i = state.selection.from; i <= state.selection.to; i++) {
             const node = state.doc.resolve(i);
             if (state.doc.content.size - 1 > i && node?.marks?.().some(mark => mark.type === schema.marks.user_mark && mark.attrs.userid !== ClientUtils.CurrentUserEmail) && [AclAugment, AclSelfEdit].includes(GetEffectiveAcl(this.Document))) {
                 e.preventDefault();
@@ -1769,22 +1788,22 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 return;
             case 'Enter':
                 this.insertTime();
+            // eslint-disable-next-line no-fallthrough
             case 'Tab':
                 e.preventDefault();
                 break;
-            case 'c':
-                this._editorView?.state.selection.empty && (stopPropagation = false);
+            case 'Space':
+            case 'Backspace':
                 break;
             default:
-                if (this._lastTimedMark?.attrs.userid === ClientUtils.CurrentUserEmail) break;
-            case ' ':
-                if (e.code !== 'Space' && e.code !== 'Backspace') {
-                    [AclEdit, AclAugment, AclAdmin].includes(GetEffectiveAcl(this.Document)) &&
-                        this._editorView!.dispatch(this._editorView!.state.tr.removeStoredMark(schema.marks.user_mark).addStoredMark(schema.marks.user_mark.create({ userid: ClientUtils.CurrentUserEmail, modified: Math.floor(Date.now() / 1000) })));
+                if ([AclEdit, AclAugment, AclAdmin].includes(GetEffectiveAcl(this.Document))) {
+                    const modified = Math.floor(Date.now() / 1000);
+                    const mark = state.selection.$to.marks().find(m => m.type === schema.marks.user_mark && m.attrs.modified === modified);
+                    _editorView.dispatch(state.tr.removeStoredMark(schema.marks.user_mark).addStoredMark(mark ?? schema.marks.user_mark.create({ userid: ClientUtils.CurrentUserEmail, modified })));
                 }
                 break;
         }
-        if (stopPropagation) e.stopPropagation();
+        e.stopPropagation();
         this.startUndoTypingBatch();
     };
     ondrop = (e: React.DragEvent) => {
@@ -1804,6 +1823,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
         const margins = 2 * NumCast(this.layoutDoc._yMargin, this._props.yPadding || 0);
         const children = this.ProseRef?.children.length ? Array.from(this.ProseRef.children[0].children) : undefined;
         if (children && !SnappingManager.IsDragging) {
+            // eslint-disable-next-line no-use-before-define
             const getChildrenHeights = (kids: Element[] | undefined) => kids?.reduce((p, child) => p + toHgt(child), margins) ?? 0;
             const toNum = (val: string) => Number(val.replace('px', ''));
             const toHgt = (node: Element): number => {
@@ -1815,7 +1835,9 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             const scrollHeight = this.ProseRef && proseHeight;
             if (this._props.setHeight && !this._props.suppressSetHeight && scrollHeight && !this._props.dontRegisterView) {
                 // if top === 0, then the text box is growing upward (as the overlay caption) which doesn't contribute to the height computation
-                const setScrollHeight = () => (this.dataDoc[this.fieldKey + '_scrollHeight'] = scrollHeight);
+                const setScrollHeight = () => {
+                    this.dataDoc[this.fieldKey + '_scrollHeight'] = scrollHeight;
+                };
 
                 if (this.Document === this.layoutDoc || this.layoutDoc.resolvedDataDoc) {
                     setScrollHeight();
@@ -1833,7 +1855,9 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
     };
     sidebarMoveDocument = (doc: Doc | Doc[], targetCollection: Doc | undefined, addDocument: (doc: Doc | Doc[]) => boolean) => this.moveDocument(doc, targetCollection, addDocument, this.SidebarKey);
     sidebarRemDocument = (doc: Doc | Doc[]) => this.removeDocument(doc, this.SidebarKey);
-    setSidebarHeight = (height: number) => (this.dataDoc[this.SidebarKey + '_height'] = height);
+    setSidebarHeight = (height: number) => {
+        this.dataDoc[this.SidebarKey + '_height'] = height;
+    };
     sidebarWidth = () => (Number(this.layout_sidebarWidthPercent.substring(0, this.layout_sidebarWidthPercent.length - 1)) / 100) * this._props.PanelWidth();
     sidebarScreenToLocal = () =>
         this._props
@@ -1851,10 +1875,12 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                         e,
                         returnFalse,
                         emptyFunction,
-                        action(e => (this._recordingDictation = !this._recordingDictation))
+                        action(() => {
+                            this._recordingDictation = !this._recordingDictation;
+                        })
                     )
                 }>
-                <FontAwesomeIcon className="formattedTextBox-audioFont" style={{ color: 'red' }} icon={'microphone'} size="sm" />
+                <FontAwesomeIcon className="formattedTextBox-audioFont" style={{ color: 'red' }} icon="microphone" size="sm" />
             </div>
         );
     }
@@ -1883,6 +1909,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             return ComponentTag === CollectionStackingView ? (
                 <SidebarAnnos
                     ref={this._sidebarRef}
+                    // eslint-disable-next-line react/jsx-props-no-spreading
                     {...this._props}
                     Document={this.Document}
                     layoutDoc={this.layoutDoc}
@@ -1902,6 +1929,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             ) : (
                 <div onPointerDown={e => setupMoveUpEvents(this, e, returnFalse, emptyFunction, () => SelectionManager.SelectView(this.DocumentView?.()!, false), true)}>
                     <ComponentTag
+                        // eslint-disable-next-line react/jsx-props-no-spreading
                         {...this._props}
                         ref={this._sidebarTagRef as any}
                         setContentView={emptyFunction}
@@ -1924,8 +1952,8 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                         renderDepth={this._props.renderDepth + 1}
                         setHeight={this.setSidebarHeight}
                         fitContentsToBox={this.fitContentsToBox}
-                        noSidebar={true}
-                        treeViewHideTitle={true}
+                        noSidebar
+                        treeViewHideTitle
                         fieldKey={this.layoutDoc[this.SidebarKey + '_type_collection'] === 'translation' ? `${this.fieldKey}_translation` : `${this.fieldKey}_sidebar`}
                     />
                 </div>
@@ -1963,7 +1991,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
                 }>
                 <div
                     className="formattedTextBox-alternateButton"
-                    onPointerDown={e => setupMoveUpEvents(e.target, e, returnFalse, emptyFunction, e => this.cycleAlternateText())}
+                    onPointerDown={e => setupMoveUpEvents(e.target, e, returnFalse, emptyFunction, () => this.cycleAlternateText())}
                     style={{
                         display: this._props.isContentActive() && !SnappingManager.IsDragging ? 'flex' : 'none',
                         background: usePath === undefined ? 'white' : usePath === 'alternate' ? 'black' : 'gray',
@@ -2000,7 +2028,7 @@ export class FormattedTextBox extends ViewBoxAnnotatableComponent<FormattedTextB
             // prevent default if selected || child is active  but this doc isn't scrollable
             if (
                 !isNaN(height) &&
-                (this._scrollRef?.scrollHeight ?? 0) <= Math.ceil((height ? height : this._props.PanelHeight()) / scale) && //
+                (this._scrollRef?.scrollHeight ?? 0) <= Math.ceil((height || this._props.PanelHeight()) / scale) && //
                 (this._props.rootSelected?.() || this.isAnyChildContentActive())
             ) {
                 e.preventDefault();