@jupyterlab/codemirror 4.0.0-alpha.10 → 4.0.0-alpha.13

package/lib/searchprovider.js

@@ -1,14 +1,44 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
+/*
+  Parts of the implementation of the search in this file were derived from
+  CodeMirror's search at:
+  https://github.com/codemirror/CodeMirror/blob/c2676685866c571a1c9c82cb25018cc08b4d42b2/addon/search/search.js
+  which is licensed with the following license:
+
+  MIT License
+
+  Copyright (C) 2017 by Marijn Haverbeke <marijnh@gmail.com> and others
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
 import { TextSearchEngine } from '@jupyterlab/documentsearch';
 import { JSONExt } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
-import * as CodeMirror from 'codemirror';
+import { RegExpCursor } from '@codemirror/search';
+import { Compartment, StateEffect, StateField } from '@codemirror/state';
+import { Decoration, EditorView } from '@codemirror/view';
 /**
  * CodeMirror search provider for file editor
  */
 export class CodeMirrorSearchProvider {
-    constructor() {
+    constructor(editor) {
         /**
          * Set to true if the widget under search is read-only, false
          * if it is editable.  Will be used to determine whether to show
@@ -18,6 +48,41 @@ export class CodeMirrorSearchProvider {
         this._matchState = {};
         this._changed = new Signal(this);
         this._disposed = false;
+        this.editor = editor;
+        this._highlightEffect = StateEffect.define({
+            map: (value, mapping) => ({
+                matches: value.matches.map(v => ({
+                    text: v.text,
+                    position: mapping.mapPos(v.position)
+                }))
+            })
+        });
+        this._highlightMark = Decoration.mark({ class: 'cm-searching' });
+        this._highlightField = StateField.define({
+            create: () => {
+                return Decoration.none;
+            },
+            update: (highlights, transaction) => {
+                highlights = highlights.map(transaction.changes);
+                for (let ef of transaction.effects) {
+                    if (ef.is(this._highlightEffect)) {
+                        const e = ef;
+                        if (e.value.matches.length) {
+                            highlights = highlights.update({
+                                add: e.value.matches.map(m => this._highlightMark.range(m.position, m.position + m.text.length))
+                            });
+                        }
+                        else {
+                            highlights = Decoration.none;
+                        }
+                    }
+                }
+                return highlights;
+            },
+            provide: f => EditorView.decorations.from(f)
+        });
+        this._listener = new Compartment();
+        this.editor.injectExtension(this._listener.of([]));
     }
     /**
      * Whether the search provider is disposed or not.
@@ -56,11 +121,17 @@ export class CodeMirrorSearchProvider {
         // no point in removing overlay in the middle of the search
         await this.endQuery(false);
         this._query = query;
-        CodeMirror.on(this.editor.doc, 'change', this._onDocChanged.bind(this));
+        this.editor.editor.dispatch({
+            effects: this._listener.reconfigure(EditorView.updateListener.of((v) => {
+                if (v.docChanged) {
+                    this._onDocChanged(v);
+                }
+            }))
+        });
+        await this._setInitialMatches(query);
         if (refreshOverlay) {
             this._refreshOverlay();
         }
-        await this._setInitialMatches(query);
         const matches = this._parseMatchesFromState();
         if (matches.length === 0) {
             return Promise.resolve();
@@ -69,6 +140,7 @@ export class CodeMirrorSearchProvider {
         const match = cursorMatch &&
             this._matchState[cursorMatch.from.line][cursorMatch.from.ch];
         this._currentMatch = match;
+        await this._highlightCurrentMatch(cursorMatch);
         return Promise.resolve();
     }
     /**
@@ -80,20 +152,19 @@ export class CodeMirrorSearchProvider {
     async endQuery(removeOverlay = true) {
         this._matchState = {};
         this._currentMatch = null;
-        if (removeOverlay) {
-            this.editor.removeOverlay(this._overlay);
-        }
-        const from = this.editor.getCursor('from');
-        const to = this.editor.getCursor('to');
+        const from = this.editor.getPositionAt(this.editor.state.selection.main.from);
+        const to = this.editor.getPositionAt(this.editor.state.selection.main.to);
         // Setting a reverse selection to allow search-as-you-type to maintain the
         // current selected match.  See comment in _findNext for more details.
         if (from !== to) {
             this.editor.setSelection({
-                start: this._toEditorPos(to),
-                end: this._toEditorPos(from)
+                start: to,
+                end: from
             });
         }
-        CodeMirror.off(this.editor.doc, 'change', this._onDocChanged.bind(this));
+        this.editor.editor.dispatch({
+            effects: this._listener.reconfigure([])
+        });
     }
     /**
      * Clear currently highlighted match.
@@ -113,13 +184,7 @@ export class CodeMirrorSearchProvider {
      * @returns A promise that resolves once the action has completed.
      */
     async highlightNext(loop) {
-        const cursorMatch = this._findNext(false);
-        if (!cursorMatch) {
-            return;
-        }
-        const match = this._matchState[cursorMatch.from.line][cursorMatch.from.ch];
-        this._currentMatch = match;
-        return match;
+        return this._highlightCurrentMatch(this._findNext(false));
     }
     /**
      * Move the current match indicator to the previous match.
@@ -129,12 +194,25 @@ export class CodeMirrorSearchProvider {
      * @returns A promise that resolves once the action has completed.
      */
     async highlightPrevious(loop) {
-        const cursorMatch = this._findNext(true);
+        return this._highlightCurrentMatch(this._findNext(true));
+    }
+    async _highlightCurrentMatch(cursorMatch) {
+        // Highlight the current index
         if (!cursorMatch) {
+            // Set cursor to remove any selection
+            this.editor.editor.dispatch({ selection: { anchor: 0 } });
             return;
         }
         const match = this._matchState[cursorMatch.from.line][cursorMatch.from.ch];
         this._currentMatch = match;
+        this.editor.editor.focus();
+        this.editor.editor.dispatch({
+            selection: {
+                anchor: match.position,
+                head: match.position + match.text.length
+            },
+            scrollIntoView: true
+        });
         return match;
     }
     /**
@@ -150,12 +228,15 @@ export class CodeMirrorSearchProvider {
         // replace it.  Otherwise, just select the next match after the cursor.
         let replaceOccurred = false;
         if (this._currentMatchIsSelected()) {
-            const cursor = this.editor.getSearchCursor(this._query, this.editor.getCursor('from'), !this._query.ignoreCase);
-            if (!cursor.findNext()) {
+            const cursor = new RegExpCursor(this.editor.doc, this._query.source, { ignoreCase: !this._query.ignoreCase }, this.editor.state.selection.main.from).next();
+            if (cursor.done) {
                 return replaceOccurred;
             }
+            const value = cursor.value;
             replaceOccurred = true;
-            cursor.replace(newText);
+            this.editor.editor.dispatch({
+                changes: { from: value.from, to: value.to, insert: newText }
+            });
         }
         await this.highlightNext();
         return replaceOccurred;
@@ -170,16 +251,23 @@ export class CodeMirrorSearchProvider {
     async replaceAllMatches(newText) {
         let replaceOccurred = false;
         return new Promise((resolve, _) => {
-            this.editor.operation(() => {
-                const cursor = this.editor.getSearchCursor(this._query, undefined, !this._query.ignoreCase);
-                while (cursor.findNext()) {
-                    replaceOccurred = true;
-                    cursor.replace(newText);
-                }
-                this._matchState = {};
-                this._currentMatch = null;
-                resolve(replaceOccurred);
-            });
+            let cursor = new RegExpCursor(this.editor.doc, this._query.source, {
+                ignoreCase: !this._query.ignoreCase
+            }).next();
+            let changeSpec = [];
+            while (!cursor.done) {
+                replaceOccurred = true;
+                changeSpec.push({
+                    from: cursor.value.from,
+                    to: cursor.value.to,
+                    insert: newText
+                });
+                cursor = cursor.next();
+            }
+            this.editor.editor.dispatch({ changes: changeSpec });
+            this._matchState = {};
+            this._currentMatch = null;
+            resolve(replaceOccurred);
         });
     }
     /**
@@ -220,11 +308,9 @@ export class CodeMirrorSearchProvider {
         // TODO make it more efficient
         return this.matches.indexOf(this._currentMatch);
     }
-    _onDocChanged(_, changeObj) {
-        var _a, _b;
-        // If we get newlines added/removed, the line numbers across the
-        // match state are all shifted, so here we need to recalculate it
-        if (changeObj.text.length > 1 || ((_b = (_a = changeObj.removed) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 1) {
+    _onDocChanged(update) {
+        // TODO: CM6 migration
+        if (update.changes.length) {
             this._setInitialMatches(this._query)
                 .then(() => {
                 this._changed.emit(undefined);
@@ -235,13 +321,14 @@ export class CodeMirrorSearchProvider {
         }
     }
     _refreshOverlay() {
-        this.editor.operation(() => {
-            // clear search first
-            this.editor.removeOverlay(this._overlay);
-            this._overlay = this._getSearchOverlay();
-            this.editor.addOverlay(this._overlay);
-            this._changed.emit(undefined);
-        });
+        let effects = [
+            this._highlightEffect.of({ matches: this.matches })
+        ];
+        if (!this.editor.state.field(this._highlightField, false)) {
+            effects.push(StateEffect.appendConfig.of([this._highlightField]));
+        }
+        this.editor.editor.dispatch({ effects });
+        this._changed.emit(undefined);
     }
     /**
      * Do a full search on the entire document.
@@ -258,125 +345,52 @@ export class CodeMirrorSearchProvider {
      */
     async _setInitialMatches(query) {
         this._matchState = {};
-        const content = this.editor.doc.getValue();
+        const content = this.editor.doc.toString();
         const matches = await TextSearchEngine.search(query, content);
         matches.forEach(match => {
-            const { line, ch } = this.editor.doc.posFromIndex(match.position);
+            const { line, ch } = this._getPosition(match.position);
             if (!this._matchState[line]) {
                 this._matchState[line] = {};
             }
             this._matchState[line][ch] = match;
         });
     }
-    _getSearchOverlay() {
-        return {
-            /**
-             * Token function is called when a line needs to be processed -
-             * when the overlay is initially created, it's called on all lines;
-             * when a line is modified and needs to be re-evaluated, it's called
-             * on just that line.
-             *
-             * This implementation of the token function both constructs/maintains
-             * the overlay and keeps track of the match state as the document is
-             * updated while a search is active.
-             */
-            token: (stream) => {
-                const currentPos = stream.pos;
-                this._query.lastIndex = currentPos;
-                const lineText = stream.string;
-                const match = this._query.exec(lineText);
-                const line = stream.lineOracle.line;
-                // If starting at position 0, the tokenization of this line has just started.
-                // Blow away everything on this line in the state so it can be updated.
-                if (stream.start === currentPos &&
-                    currentPos === 0 &&
-                    !!this._matchState[line]) {
-                    this._matchState[line] = {};
-                }
-                if (match && match.index === currentPos) {
-                    // found match, add it to state
-                    const matchLength = match[0].length;
-                    const matchObj = {
-                        text: lineText.slice(currentPos, currentPos + matchLength),
-                        position: this.editor.doc.indexFromPos({
-                            line,
-                            ch: currentPos
-                        })
-                    };
-                    if (!this._matchState[line]) {
-                        this._matchState[line] = {};
-                    }
-                    this._matchState[line][currentPos] = matchObj;
-                    // move the stream along and return searching style for the token
-                    stream.pos += matchLength || 1;
-                    // if the last thing on the line was a match, make sure we still
-                    // emit the changed signal so the display can pick up the updates
-                    if (stream.eol()) {
-                        this._changed.emit(undefined);
-                    }
-                    return 'searching';
-                }
-                else if (match) {
-                    // there's a match in the stream, advance the stream to its position
-                    stream.pos = match.index;
-                }
-                else {
-                    // no matches, consume the rest of the stream
-                    this._changed.emit(undefined);
-                    stream.skipToEnd();
-                }
+    _findNext(reverse) {
+        const caseSensitive = this._query.ignoreCase;
+        const state = this.editor.state;
+        // In order to support search-as-you-type, we needed a way to allow the first
+        // match to be selected when a search is started, but prevent the selected
+        // search to move for each new keypress.  To do this, when a search is ended,
+        // the cursor is reversed, putting the head at the 'from' position.  When a new
+        // search is started, the cursor we want is at the 'from' position, so that the same
+        // match is selected when the next key is entered (if it is still a match).
+        //
+        // When toggling through a search normally, the cursor is always set in the forward
+        // direction, so head is always at the 'to' position.  That way, if reverse = false,
+        // the search proceeds from the 'to' position during normal toggling.  If reverse = true,
+        // the search always proceeds from the 'anchor' position, which is at the 'from'.
+        const lastPosition = reverse
+            ? state.selection.main.anchor
+            : state.selection.main.head;
+        let cursor = new RegExpCursor(this.editor.doc, this._query.source, { ignoreCase: !caseSensitive }, lastPosition).next();
+        if (cursor.done) {
+            const startOrEnd = reverse ? this.editor.doc.length : 0;
+            cursor = new RegExpCursor(this.editor.doc, this._query.source, { ignoreCase: !caseSensitive }, startOrEnd).next();
+            if (cursor.done) {
+                return null;
             }
+        }
+        return {
+            from: this._getPosition(cursor.value.from),
+            to: this._getPosition(cursor.value.to)
         };
     }
-    _findNext(reverse) {
-        return this.editor.operation(() => {
-            const caseSensitive = this._query.ignoreCase;
-            // In order to support search-as-you-type, we needed a way to allow the first
-            // match to be selected when a search is started, but prevent the selected
-            // search to move for each new keypress.  To do this, when a search is ended,
-            // the cursor is reversed, putting the head at the 'from' position.  When a new
-            // search is started, the cursor we want is at the 'from' position, so that the same
-            // match is selected when the next key is entered (if it is still a match).
-            //
-            // When toggling through a search normally, the cursor is always set in the forward
-            // direction, so head is always at the 'to' position.  That way, if reverse = false,
-            // the search proceeds from the 'to' position during normal toggling.  If reverse = true,
-            // the search always proceeds from the 'anchor' position, which is at the 'from'.
-            const cursorToGet = reverse ? 'anchor' : 'head';
-            const lastPosition = this.editor.getCursor(cursorToGet);
-            let cursor = this.editor.getSearchCursor(this._query, lastPosition, !caseSensitive);
-            if (!cursor.find(reverse)) {
-                // if we do want to loop, try searching from the bottom/top
-                const startOrEnd = reverse
-                    ? CodeMirror.Pos(this.editor.lastLine())
-                    : CodeMirror.Pos(this.editor.firstLine(), 0);
-                cursor = this.editor.getSearchCursor(this._query, startOrEnd, !caseSensitive);
-                if (!cursor.find(reverse)) {
-                    return null;
-                }
-            }
-            const fromPos = cursor.from();
-            const toPos = cursor.to();
-            const selRange = {
-                start: {
-                    line: fromPos.line,
-                    column: fromPos.ch
-                },
-                end: {
-                    line: toPos.line,
-                    column: toPos.ch
-                }
-            };
-            this.editor.setSelection(selRange);
-            this.editor.scrollIntoView({
-                from: fromPos,
-                to: toPos
-            }, 100);
-            return {
-                from: fromPos,
-                to: toPos
-            };
-        });
+    // TODO: remove this when Position API are removed and we work with
+    // offsets only. Contrary to the functions in CodeMirrorEditor,
+    // these functions work with CM6 position (i.e. line number starting at 1).
+    _getPosition(offset) {
+        const line = this.editor.doc.lineAt(offset);
+        return { line: line.number, ch: offset - line.from };
     }
     _parseMatchesFromState() {
         // Flatten state map
@@ -389,12 +403,6 @@ export class CodeMirrorSearchProvider {
         }
         return matches;
     }
-    _toEditorPos(posIn) {
-        return {
-            line: posIn.line,
-            column: posIn.ch
-        };
-    }
     _currentMatchIsSelected() {
         if (!this._currentMatch) {
             return false;
@@ -405,10 +413,8 @@ export class CodeMirrorSearchProvider {
         return (selectionIsOneLine &&
             this._currentMatch.text.length === currentSelectionLength &&
             this._currentMatch.position ===
-                this.editor.doc.indexFromPos({
-                    line: currentSelection.start.line,
-                    ch: currentSelection.start.column
-                }));
+                this.editor.doc.line(currentSelection.start.line).from +
+                    currentSelection.start.column);
     }
 }
 /**
@@ -427,6 +433,38 @@ export class CodeMirrorSearchHighlighter {
         this._cm = editor;
         this._matches = new Array();
         this._currentIndex = null;
+        this._highlightEffect = StateEffect.define({
+            map: (value, mapping) => ({
+                matches: value.matches.map(v => ({
+                    text: v.text,
+                    position: mapping.mapPos(v.position)
+                }))
+            })
+        });
+        this._highlightMark = Decoration.mark({ class: 'cm-searching' });
+        this._highlightField = StateField.define({
+            create: () => {
+                return Decoration.none;
+            },
+            update: (highlights, transaction) => {
+                highlights = highlights.map(transaction.changes);
+                for (let ef of transaction.effects) {
+                    if (ef.is(this._highlightEffect)) {
+                        const e = ef;
+                        if (e.value.matches.length) {
+                            highlights = highlights.update({
+                                add: e.value.matches.map(m => this._highlightMark.range(m.position, m.position + m.text.length))
+                            });
+                        }
+                        else {
+                            highlights = Decoration.none;
+                        }
+                    }
+                }
+                return highlights;
+            },
+            provide: f => EditorView.decorations.from(f)
+        });
     }
     /**
      * The current index of the selected match.
@@ -444,7 +482,7 @@ export class CodeMirrorSearchHighlighter {
         if (!JSONExt.deepEqual(this._matches, v)) {
             this._matches = v;
         }
-        this.refresh();
+        this._refresh();
     }
     /**
      * Clear all highlighted matches
@@ -453,29 +491,22 @@ export class CodeMirrorSearchHighlighter {
         this._currentIndex = null;
         this._highlightCurrentMatch();
     }
-    /**
-     * Refresh the highlight matches overlay
-     */
-    refresh() {
-        this._refreshOverlay();
-    }
     /**
      * Clear the highlighted matches.
      */
     endQuery() {
         this._currentIndex = null;
         this._matches = [];
-        this._cm.removeOverlay('jp-searching');
-        this._overlay = null;
-        const from = this._cm.getCursor('from');
-        const to = this._cm.getCursor('to');
+        this._cm.editor.dispatch({
+            effects: this._highlightEffect.of({ matches: [] })
+        });
+        const selection = this._cm.state.selection.main;
+        const from = selection.from;
+        const to = selection.to;
         // Setting a reverse selection to allow search-as-you-type to maintain the
         // current selected match. See comment in _findNext for more details.
         if (from !== to) {
-            this._cm.setSelection({
-                start: this._toEditorPos(to),
-                end: this._toEditorPos(from)
-            });
+            this._cm.editor.dispatch({ selection: { anchor: to, head: from } });
         }
         return Promise.resolve();
     }
@@ -507,83 +538,28 @@ export class CodeMirrorSearchHighlighter {
         // Highlight the current index
         if (this._currentIndex !== null) {
             const match = this.matches[this._currentIndex];
-            this._cm.operation(() => {
-                const start = this._cm.doc.posFromIndex(match.position);
-                const from = {
-                    line: start.line,
-                    column: start.ch
-                };
-                const to = {
-                    // Matches is on the same line
-                    line: start.line,
-                    column: start.ch + match.text.length
-                };
-                // No need to scroll into view this is the default behavior
-                this._cm.setSelection({
-                    start: from,
-                    end: to
-                });
+            this._cm.editor.focus();
+            this._cm.editor.dispatch({
+                selection: {
+                    anchor: match.position,
+                    head: match.position + match.text.length
+                },
+                scrollIntoView: true
             });
         }
         else {
             // Set cursor to remove any selection
-            this._cm.setCursorPosition({ line: 0, column: 0 });
+            this._cm.editor.dispatch({ selection: { anchor: 0 } });
         }
     }
-    _refreshOverlay() {
-        // clear search first
-        this._cm.removeOverlay('jp-searching');
-        this._overlay = this._getSearchOverlay();
-        this._cm.addOverlay(this._overlay);
-    }
-    _getSearchOverlay() {
-        const token = (stream) => {
-            const position = this._cm.doc.indexFromPos({
-                line: stream.lineOracle.line,
-                ch: stream.pos
-            });
-            let found = this._matches.length > 0
-                ? Utils.findNext(this._matches, position, 0, // lastMatchIndex,
-                this._matches.length - 1)
-                : null;
-            if (found !== null) {
-                // lastMatchIndex = found;
-                const match = this._matches[found];
-                if (match.position > position + stream.string.length) {
-                    // next match not in this stream, consume the rest of the stream
-                    stream.skipToEnd();
-                    return null;
-                }
-                if (position === match.position) {
-                    // move the stream along and return searching style for the token
-                    stream.pos += match.text.length || 1;
-                    return 'searching';
-                }
-                else {
-                    // Move to the next match
-                    stream.pos += match.position - position;
-                }
-            }
-            else {
-                // no matches, consume the rest of the stream
-                stream.skipToEnd();
-            }
-            return null;
-        };
-        return {
-            name: 'jp-searching',
-            /**
-             * Token function is called when a line needs to be processed -
-             * when the overlay is initially created, it's called on all lines;
-             * when a line is modified and needs to be re-evaluated, it's called
-             * on just that line.
-             *
-             * This implementation of the token function both constructs/maintains
-             * the overlay and keeps track of the match state as the document is
-             * updated while a search is active.
-             */
-            token: token.bind(this)
-        };
+    _refresh() {
+        let effects = [
+            this._highlightEffect.of({ matches: this.matches })
+        ];
+        if (!this._cm.state.field(this._highlightField, false)) {
+            effects.push(StateEffect.appendConfig.of([this._highlightField]));
+        }
+        this._cm.editor.dispatch({ effects });
     }
     _findNext(reverse) {
         if (this._matches.length === 0) {
@@ -601,20 +577,13 @@ export class CodeMirrorSearchHighlighter {
         // direction, so head is always at the 'to' position.  That way, if reverse = false,
         // the search proceeds from the 'to' position during normal toggling.  If reverse = true,
         // the search always proceeds from the 'anchor' position, which is at the 'from'.
-        const cursorToGet = reverse ? 'anchor' : 'head';
-        let lastPosition = this._cm.getCursor(cursorToGet);
-        if (lastPosition.line === 0 &&
-            lastPosition.ch === 0 &&
-            reverse &&
-            this.currentIndex === null) {
+        const cursor = this._cm.state.selection.main;
+        let lastPosition = reverse ? cursor.anchor : cursor.head;
+        if (lastPosition === 0 && reverse && this.currentIndex === null) {
             // The default position is (0, 0) but we want to start from the end in that case
-            lastPosition = {
-                // Go to virtual next line so position got clamp to end
-                line: this._cm.lineCount,
-                ch: 0
-            };
+            lastPosition = this._cm.doc.length;
         }
-        const position = this._cm.doc.indexFromPos(lastPosition);
+        const position = lastPosition;
         let found = Utils.findNext(this._matches, position, 0, this._matches.length - 1);
         if (found === null) {
             // Don't loop
@@ -629,12 +598,6 @@ export class CodeMirrorSearchHighlighter {
         }
         return found;
     }
-    _toEditorPos(posIn) {
-        return {
-            line: posIn.line,
-            column: posIn.ch
-        };
-    }
 }
 /**
  * Helpers namespace