@adecore/editor 0.22.1 → 0.23.0

package/src/editor.css

@@ -12,10 +12,14 @@
     --editor-guide-active: color-mix(in srgb, var(--text) 24%, transparent);
     --editor-margin: color-mix(in srgb, var(--text) 14%, transparent);
     --editor-whitespace: color-mix(in srgb, var(--text) 30%, transparent);
+    --editor-bidi: var(--status-needs-you);
     --editor-hatch: color-mix(in srgb, var(--text) 12%, transparent);
     --editor-added: var(--status-idle);
     --editor-modified: var(--accent);
     --editor-deleted: var(--status-error);
+    --editor-mark-number-mix: 72%;
+    --editor-mark-bar-width: 3px;
+    --editor-mark-gap: 4px;
     --editor-sticky-shadow: color-mix(in srgb, black 12%, transparent);
     --agent-1: #c4602f;
     --agent-2: #7c4dd8;
@@ -34,6 +38,7 @@
     --editor-margin: color-mix(in srgb, var(--text) 16%, transparent);
     --editor-whitespace: color-mix(in srgb, var(--text) 32%, transparent);
     --editor-hatch: color-mix(in srgb, var(--text) 10%, transparent);
+    --editor-mark-number-mix: 82%;
     --editor-sticky-shadow: color-mix(in srgb, black 60%, transparent);
 }
 
@@ -69,6 +74,7 @@
     overflow: auto;
     overflow-anchor: none;
     overscroll-behavior: contain;
+    touch-action: pan-x pan-y pinch-zoom;
     scrollbar-width: thin;
     scrollbar-color: color-mix(in srgb, var(--text) 25%, transparent) transparent;
 }
@@ -177,10 +183,23 @@
     white-space: pre;
     letter-spacing: 0;
     direction: ltr;
+    unicode-bidi: bidi-override;
 }
 .se-run {
     position: absolute;
     white-space: pre;
+    unicode-bidi: bidi-override;
+}
+.se-bidi {
+    position: absolute;
+    box-sizing: border-box;
+    overflow: hidden;
+    border-radius: var(--radius-xs);
+    box-shadow: inset 0 0 0 1px var(--editor-bidi);
+    color: var(--editor-bidi);
+    text-align: center;
+    user-select: none;
+    pointer-events: none;
 }
 
 .se-gutter {
@@ -216,6 +235,31 @@
 .se-active-number {
     color: var(--text-muted);
 }
+/* A line a host marked with a bar: the number in a shade of the mark that reads on the tint, and a bar along the edge. */
+/* The tint stops short of the code, so the cell and the line read as two surfaces. */
+.se-line-marked {
+    align-items: flex-start;
+    background: linear-gradient(to right, var(--se-tint, transparent) calc(100% - var(--editor-mark-gap)), transparent 0);
+}
+.se-line-marked > span:first-child {
+    display: flex;
+    align-items: center;
+    height: var(--se-line);
+    color: color-mix(in srgb, var(--se-mark) var(--editor-mark-number-mix), var(--text));
+}
+.se-line-bar {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: var(--editor-mark-bar-width);
+    height: 100%;
+}
+.se-line-bar-solid {
+    background: var(--se-mark);
+}
+.se-line-bar-hatched {
+    background: repeating-linear-gradient(135deg, var(--se-mark) 0 2px, transparent 2px 4px);
+}
 .se-fold-toggle {
     position: absolute;
     top: 0;
@@ -299,6 +343,14 @@
     mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z'/%3E%3C/svg%3E")
         center / contain no-repeat;
 }
+.se-gutter-marker[aria-pressed='true'] {
+    color: var(--accent);
+}
+/* Lucide's book-open. */
+.se-gutter-marker[data-icon='book-open']::before {
+    mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M12 7v14'/%3E%3Cpath d='M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z'/%3E%3C/svg%3E")
+        center / contain no-repeat;
+}
 .se-change {
     position: absolute;
     top: 0;
@@ -337,9 +389,13 @@
     font-size: max(12px, calc(var(--code-font-size, 13px) - 2px));
     line-height: 1;
 }
-.se-line-highlight {
+.se-line-highlight,
+.se-line-emphasis {
     position: absolute;
 }
+.se-line-emphasis {
+    border-radius: 2px;
+}
 
 /* Code a host draws in a widget row: the editor's face, with the gutter column the document has. */
 .se-code-block {
@@ -685,6 +741,11 @@
     white-space: pre;
     cursor: default;
 }
+.se-inlay-link {
+    text-decoration: underline;
+    text-underline-offset: 2px;
+    cursor: pointer;
+}
 .se-composition {
     position: absolute;
     white-space: pre;
@@ -717,6 +778,13 @@
     white-space: pre-wrap;
     overflow-wrap: anywhere;
 }
+/* Lines the host drew in place of the text: a row in the text column that scrolls with the code, selectable as the page's own text is. */
+.se-block.se-replacement {
+    padding: 0;
+    color: var(--text);
+    white-space: normal;
+    user-select: text;
+}
 /* The host's own row runs the width of the editor over the gutter and under the pinned headers, so the code layer has no stacking of its own. */
 .se-block.se-widget {
     z-index: 4;
@@ -790,6 +858,18 @@
     white-space: pre;
     pointer-events: none;
 }
+.se-sr-only,
+.se-live {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+}
 .se-notice {
     position: absolute;
     right: 16px;

package/src/engine.ts

@@ -1,4 +1,6 @@
 import { changedSpans, DocumentModel, type EditorSnapshot, type FoldHints, replacementText } from '@adecore/editor-core';
+import { MAX_REPLACEMENT_CHARACTERS } from './search-protocol.ts';
+import { GrammarPreparation } from './grammar-preparation.ts';
 import { InputController } from './controller.ts';
 import { resolveSmartKeys } from './smart-keys.ts';
 import { emit, type Listener, subscribe } from './listeners.ts';
@@ -10,6 +12,7 @@ import type {
     EditorCodeBlockOptions,
     EditorLineAction,
     EditorLineHighlight,
+    LineToken,
     EditorChangeMark,
     EditorCodeVision,
     EditorClickHandler,
@@ -25,12 +28,17 @@ import type {
     EditorReplaceOptions,
     EditorGutterAction,
     EditorGutterMarker,
+    EditorReplacement,
     EditorHighlight,
     EditorHover,
     EditorGhostText,
+    EditorInlayClickHandler,
     EditorInlayHint,
+    EditorInlayTarget,
     EditorKeyHandler,
+    EditorInputPopup,
     EditorMarker,
+    EditorMessages,
     EditorOptions,
     EditorPosition,
     EditorRemoteCursor,
@@ -41,6 +49,7 @@ import type {
     EditorSelectionRanges,
     EditorSemanticToken,
     EditorSmartKeys,
+    EditorApplyEditsOptions,
     EditorTextChange,
     EditorTrackedRange,
     EditorTheme,
@@ -53,12 +62,15 @@ import { EditorView, type ViewSettings } from './view.ts';
 const DEFAULT_TAB_SIZE = 4;
 const DEFAULT_LABEL = 'Code editor';
 const DEFAULT_WIDGET_OWNER = 'default';
+/* The space a hint's padding keeps clear; a whole pixel count so the pill stays on the pixel grid. */
+const INLAY_GAP = 4;
 
 class SmartEditor implements Editor {
     private readonly model: DocumentModel;
     private readonly settings: ViewSettings;
     private readonly view: EditorView;
     private readonly controller: InputController;
+    private readonly grammarPreparation: GrammarPreparation;
     private readonly changes = new Set<Listener>();
     private readonly textChanges = new Set<(change: EditorTextChange) => void>();
     private readonly carets = new Set<(position: EditorPosition) => void>();
@@ -83,6 +95,7 @@ class SmartEditor implements Editor {
         this.language = options.language;
         this.theme = options.theme;
         this.settings = {
+            searchWorker: engine.searchWorker,
             language: options.language,
             tabSize: options.indentation?.tabSize ?? DEFAULT_TAB_SIZE,
             insertSpaces: options.indentation?.insertSpaces ?? true,
@@ -95,11 +108,13 @@ class SmartEditor implements Editor {
             guides: options.guides !== false,
             whitespace: options.whitespace === true,
             rightMargin: options.rightMargin ?? null,
-            foldOutline: options.foldOutline ?? 'hover'
+            foldOutline: options.foldOutline ?? 'hover',
+            folding: options.folding !== false
         };
         this.view = new EditorView(element, this.model, this.settings);
+        this.grammarPreparation = new GrammarPreparation(this.model, () => this.view.grammarChanged());
         this.controller = new InputController(this.view, {
-            handBack: engine.handBack ?? [],
+            handBack: [...(engine.handBack ?? []), ...(options.handBack ?? [])],
             keymap: engine.keymap,
             apple: engine.apple ?? false,
             save: () => emit(this.saves),
@@ -111,8 +126,9 @@ class SmartEditor implements Editor {
             this.caretMoved(snapshot.selections.at(-1)!.head);
             if (snapshot.revision !== this.revision) {
                 this.revision = snapshot.revision;
+                this.grammarPreparation.edited(snapshot.changes ?? []);
                 if (snapshot.contentEdits !== undefined && snapshot.contentEdits.length > 0) {
-                    this.announceTextChange(snapshot.contentEdits, snapshot.source ?? 'external');
+                    this.announceTextChange(snapshot.contentEdits, snapshot.source ?? 'external', snapshot.typed === true);
                 }
                 if (!this.settingText) {
                     emit(this.changes);
@@ -147,6 +163,7 @@ class SmartEditor implements Editor {
 
     private loadTokenizer(): void {
         const request = ++this.tokenizerRequest;
+        this.grammarPreparation.begin();
         void this.engine
             .scopeColors?.(this.theme)
             .catch(() => null)
@@ -161,6 +178,7 @@ class SmartEditor implements Editor {
             .then((tokenizer) => {
                 if (!this.disposed && request === this.tokenizerRequest) {
                     this.view.setTokenizer(tokenizer);
+                    this.grammarPreparation.ready(tokenizer);
                 }
             });
     }
@@ -194,9 +212,10 @@ class SmartEditor implements Editor {
         return subscribe(this.textChanges, listener);
     }
 
-    private announceTextChange(edits: NonNullable<EditorSnapshot['contentEdits']>, source: EditorTextChange['source']): void {
+    private announceTextChange(edits: NonNullable<EditorSnapshot['contentEdits']>, source: EditorTextChange['source'], typed: boolean): void {
         const change: EditorTextChange = {
             source,
+            ...(typed ? { typed } : {}),
             changes: edits.map((edit) => ({
                 range: { start: { line: edit.start.line, character: edit.start.column }, end: { line: edit.end.line, character: edit.end.column } },
                 text: edit.text
@@ -222,6 +241,26 @@ class SmartEditor implements Editor {
         return this.view.scrollPlace.y;
     }
 
+    setScrollTop(top: number): void {
+        this.view.setScrollTop(top);
+    }
+
+    getLineHeight(line: number): number {
+        return this.view.getLineHeight(line);
+    }
+
+    getBaseLineHeight(): number {
+        return this.view.layout.metrics.lineHeight;
+    }
+
+    onLineHeights(listener: Listener): () => void {
+        return this.view.onLineHeights(listener);
+    }
+
+    getContentHeight(): number {
+        return this.view.contentHeight;
+    }
+
     getSelection(): EditorRange {
         return this.rangeOf(this.model.getPrimary());
     }
@@ -295,14 +334,32 @@ class SmartEditor implements Editor {
         this.controller.setSelectionRanges(provider);
     }
 
-    applyEdits(edits: readonly EditorContentChange[]): boolean {
+    applyEdits(edits: readonly EditorContentChange[], options: EditorApplyEditsOptions = {}): boolean {
         if (this.settings.readOnly || edits.length === 0) {
             return false;
         }
         try {
+            const { mapSelections } = options;
             return this.model.applyEdits(
                 edits.map((edit) => ({ from: this.offsetAt(edit.range.start), to: this.offsetAt(edit.range.end), text: edit.text })),
-                { source: 'command' }
+                {
+                    source: 'command',
+                    joinPrevious: options.mergeUndo === true,
+                    selectionPositions:
+                        mapSelections &&
+                        this.model.getSelections().map((selection) => {
+                            const { start, end } = mapSelections(this.rangeOf(selection));
+                            const from = { line: start.line, column: start.character };
+                            const to = { line: end.line, column: end.character };
+                            if (selection.head < selection.anchor) {
+                                return { anchor: to, head: from };
+                            }
+                            return {
+                                anchor: from,
+                                head: selection.head === selection.anchor && start.line === end.line && start.character === end.character ? from : to
+                            };
+                        })
+                }
             );
         } catch {
             return false;
@@ -323,7 +380,28 @@ class SmartEditor implements Editor {
     }
 
     setInlayHints(hints: readonly EditorInlayHint[]): void {
-        this.view.setInlays(hints.map((hint, index) => ({ id: `hint-${index}`, at: this.offsetAt(hint.position), text: hint.label })));
+        this.view.setInlays(
+            hints.map((hint, index) => ({
+                id: hint.id ?? `hint-${index}`,
+                at: this.offsetAt(hint.position),
+                text: hint.label,
+                ...(hint.parts === undefined ? {} : { parts: hint.parts }),
+                ...(hint.paddingLeft ? { gapLeft: INLAY_GAP } : {}),
+                ...(hint.paddingRight ? { gapRight: INLAY_GAP } : {})
+            }))
+        );
+    }
+
+    onInlayHover(listener: (target: EditorInlayTarget | null) => void): () => void {
+        return this.view.onInlayHover(listener);
+    }
+
+    onInlayClick(handler: EditorInlayClickHandler): () => void {
+        return this.controller.onInlayClick(handler);
+    }
+
+    setInlayLink(target: { readonly id: string; readonly part: number | null } | null): void {
+        this.view.setInlayLink(target);
     }
 
     setGhostText(ghost: EditorGhostText | null): void {
@@ -336,7 +414,7 @@ class SmartEditor implements Editor {
                 ? null
                 : tokens.map((token) => {
                       const from = this.offsetAt({ line: token.line, character: token.character });
-                      return { from, to: from + token.length, scopes: token.scopes };
+                      return { from, to: from + token.length, scopes: token.scopes, within: token.within };
                   })
         );
     }
@@ -393,19 +471,23 @@ class SmartEditor implements Editor {
 
     replace(replacement: string, replaceOptions: EditorReplaceOptions = {}): boolean {
         const { find } = this.view;
-        const mark = find.currentMark;
-        const query = find.activeQuery;
-        if (mark === null || query === null || this.blockedByReadOnly()) {
+        const match = find.currentMatch;
+        if (this.blockedByReadOnly()) {
             return false;
         }
-        try {
-            const options = { caseSensitive: query.caseSensitive, wholeWord: query.wholeWord, regex: query.regex, from: mark.from, to: mark.to, maxResults: 1 };
-            const match = this.model.find(query.text, options)[0];
-            if (match === undefined) {
+        if (find.activeQuery?.regex === true) {
+            if (find.currentMark === null) {
                 return false;
             }
+            void find.replaceOne(replacement, replaceOptions.preserveCase === true, () => !this.disposed && !this.settings.readOnly);
+            return true;
+        }
+        if (match === null) {
+            return false;
+        }
+        try {
             // The next match is looked for after what was written, or a replacement that holds the query would find itself again.
-            find.pendingAnchor = mark.from + replacementText(this.model.getText(), match, replacement, false, replaceOptions.preserveCase).length;
+            find.pendingAnchor = match.to;
             if (!this.model.replace(match, replacement, { preserveCase: replaceOptions.preserveCase })) {
                 find.pendingAnchor = undefined;
                 return false;
@@ -420,23 +502,49 @@ class SmartEditor implements Editor {
     }
 
     replaceAll(replacement: string, options: EditorReplaceOptions = {}): number {
-        const query = this.view.find.activeQuery;
-        if (query === null || this.blockedByReadOnly()) {
+        const { find } = this.view;
+        const query = find.activeQuery;
+        if (query === null || find.state.noSelection === true || this.blockedByReadOnly()) {
             return 0;
         }
         try {
-            return this.model.replaceAll(query.text, replacement, {
-                caseSensitive: query.caseSensitive,
-                wholeWord: query.wholeWord,
-                regex: query.regex,
-                preserveCase: options.preserveCase,
-                ...this.view.find.scope
-            });
-        } catch {
+            const matches = find.completeMatches;
+            if (matches !== null) {
+                let characters = 0;
+                for (const match of matches) {
+                    characters += replacementText('', match, replacement, false, options.preserveCase, MAX_REPLACEMENT_CHARACTERS).length;
+                    if (characters > MAX_REPLACEMENT_CHARACTERS) {
+                        find.reportReplaceFailed('limit');
+                        return 0;
+                    }
+                }
+                const count = this.model.replaceMatches(matches, replacement, { preserveCase: options.preserveCase });
+                find.reportReplaced(count);
+                return count;
+            }
+            void this.replaceAllAsync(replacement, options);
+            return 0;
+        } catch (error) {
+            find.reportReplaceFailed(error instanceof RangeError ? 'limit' : 'error');
             return 0;
         }
     }
 
+    async replaceAllAsync(replacement: string, options: EditorReplaceOptions = {}): Promise<number> {
+        const { find } = this.view;
+        if (this.disposed || this.blockedByReadOnly() || find.activeQuery === null || find.state.noSelection) {
+            return 0;
+        }
+        if (find.state.limited) {
+            find.reportReplaceFailed('limit');
+            return 0;
+        }
+        if (find.completeMatches !== null) {
+            return this.replaceAll(replacement, options);
+        }
+        return find.replaceAll(replacement, options.preserveCase === true, () => !this.disposed && !this.settings.readOnly);
+    }
+
     setReplacePreview(replacement: string | null, options: EditorReplaceOptions = {}): void {
         this.view.setReplacePreview(replacement, options.preserveCase === true);
     }
@@ -462,24 +570,39 @@ class SmartEditor implements Editor {
         if (query.text === '') {
             return false;
         }
-        let matches;
+        const { anchor, head } = this.model.getPrimary();
+        const offset = direction === 1 ? Math.max(anchor, head) : Math.min(anchor, head);
+        const reveal = (target: { from: number; to: number } | null): boolean => {
+            if (target === null || this.disposed) {
+                return false;
+            }
+            this.view.ensureVisible(target.from);
+            this.model.setSelections([direction === 1 ? { anchor: target.from, head: target.to } : { anchor: target.to, head: target.from }]);
+            this.view.revealCaret(target.from > head ? 'centerDown' : 'centerUp');
+            return true;
+        };
+        if (query.regex) {
+            const revision = this.model.getRevision();
+            void this.view.find.nextFromCursor(query, offset, direction).then((target) => {
+                const current = this.model.getPrimary();
+                if (this.model.getRevision() === revision && current.anchor === anchor && current.head === head) {
+                    reveal(target);
+                }
+            });
+            return true;
+        }
         try {
-            matches = this.model.find(query.text, { caseSensitive: query.caseSensitive, wholeWord: query.wholeWord, regex: query.regex });
+            return reveal(
+                this.model.findNext(query.text, offset, {
+                    caseSensitive: query.caseSensitive,
+                    wholeWord: query.wholeWord,
+                    backwards: direction === -1,
+                    wrap: true
+                })
+            );
         } catch {
             return false;
         }
-        if (matches.length === 0) {
-            return false;
-        }
-        const { anchor, head } = this.model.getPrimary();
-        const from = Math.min(anchor, head);
-        const to = Math.max(anchor, head);
-        const target =
-            direction === 1 ? (matches.find((match) => match.from >= to) ?? matches[0]!) : (matches.findLast((match) => match.to <= from) ?? matches.at(-1)!);
-        this.view.ensureVisible(target.from);
-        this.model.setSelections([direction === 1 ? { anchor: target.from, head: target.to } : { anchor: target.to, head: target.from }]);
-        this.view.revealCaret(target.from > head ? 'centerDown' : 'centerUp');
-        return true;
     }
 
     private blockedByReadOnly(): boolean {
@@ -514,8 +637,8 @@ class SmartEditor implements Editor {
         this.view.applySettings();
     }
 
-    setChangeMarks(marks: readonly EditorChangeMark[]): void {
-        this.view.setChangeMarks(marks);
+    setChangeMarks(marks: readonly EditorChangeMark[], layer?: string): void {
+        this.view.setChangeMarks(marks, layer);
     }
 
     setAttributionMarks(marks: readonly EditorAttributionMark[]): void {
@@ -526,6 +649,32 @@ class SmartEditor implements Editor {
         this.view.setLineHighlights(highlights);
     }
 
+    setLineLabels(labels: ((line: number) => string | null) | null): void {
+        this.view.setLineLabels(labels);
+    }
+
+    setInputPopup(popup: EditorInputPopup | null): void {
+        this.view.setInputPopup(popup);
+    }
+
+    announce(message: string): void {
+        this.view.announce(message);
+    }
+
+    setMessages(messages: Partial<EditorMessages>): void {
+        this.settings.messages = { ...this.settings.messages, ...messages };
+        this.view.repaint();
+    }
+
+    setLineNumbers(labels: ((line: number) => string | null) | null): void {
+        this.view.setLineNumbers(labels);
+    }
+
+    setLineTokens(tokens: ((line: number) => readonly LineToken[] | null | undefined) | null): void {
+        this.grammarPreparation.pause(tokens !== null);
+        this.view.setLineTokens(tokens);
+    }
+
     renderCode(container: HTMLElement, text: string, options: EditorCodeBlockOptions = {}): void {
         this.view.renderCode(container, text, options);
     }
@@ -546,6 +695,7 @@ class SmartEditor implements Editor {
                 at: this.offsetAt({ line: widget.line, character: 0 }),
                 placement: widget.placement ?? 'below',
                 height: widget.height,
+                fixed: widget.fixed,
                 render: (container: HTMLElement) => {
                     container.classList.add('se-widget');
                     widget.render(container);
@@ -554,6 +704,25 @@ class SmartEditor implements Editor {
         );
     }
 
+    setReplacements(replacements: readonly EditorReplacement[], owner: string = DEFAULT_WIDGET_OWNER): void {
+        this.view.setReplacements(
+            owner,
+            replacements.map((replacement) => ({
+                id: `replacement:${owner}:${replacement.id}`,
+                from: this.offsetAt({ line: replacement.startLine, character: 0 }),
+                to: this.model.getLine(Math.max(0, Math.min(replacement.endLine, this.model.getLineCount() - 1))).end,
+                height: replacement.height,
+                label: replacement.label,
+                enterable: replacement.enterable,
+                onReveal: replacement.onReveal === undefined ? undefined : () => replacement.onReveal!(),
+                render: (container: HTMLElement) => {
+                    container.classList.add('se-widget-replacement');
+                    replacement.render(container);
+                }
+            }))
+        );
+    }
+
     setLineActions(actions: readonly EditorLineAction[], owner: string = DEFAULT_WIDGET_OWNER): void {
         this.view.setLineActions(
             owner,
@@ -714,6 +883,10 @@ class SmartEditor implements Editor {
         this.view.applySettings();
     }
 
+    isReadOnly(): boolean {
+        return this.settings.readOnly;
+    }
+
     runCommand(command: EditorRunCommand): boolean {
         return this.controller.command(command);
     }
@@ -731,6 +904,7 @@ class SmartEditor implements Editor {
             return;
         }
         this.disposed = true;
+        this.grammarPreparation.dispose();
         this.changes.clear();
         this.textChanges.clear();
         this.carets.clear();