monaco-editor11 1.0.9 → 1.1.0

package/dist/workers/editor/common/editorTheme.js

@@ -1,23 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class EditorTheme {
-    get type() {
-        return this._theme.type;
-    }
-    get value() {
-        return this._theme;
-    }
-    constructor(theme) {
-        this._theme = theme;
-    }
-    update(theme) {
-        this._theme = theme;
-    }
-    getColor(color) {
-        return this._theme.getColor(color);
-    }
-}
-
-export { EditorTheme };

package/dist/workers/editor/common/editorWebWorker.js

@@ -1,299 +0,0 @@
-import { stringDiff } from '../../../base/common/diff/diff.js';
-import { Range } from '../core/range.js';
-import { computeLinks } from '../languages/linkComputer.js';
-import { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';
-import { createMonacoBaseAPI } from './editorBaseApi.js';
-import { StopWatch } from '../../../base/common/stopwatch.js';
-import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
-import { linesDiffComputers } from '../diff/linesDiffComputers.js';
-import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
-import { findSectionHeaders } from './findSectionHeaders.js';
-import { WorkerTextModelSyncServer } from './textModelSync/textModelSync.impl.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * @internal
- */
-class EditorWorker {
-    constructor(_foreignModule = null) {
-        this._foreignModule = _foreignModule;
-        this._requestHandlerBrand = undefined;
-        this._workerTextModelSyncServer = new WorkerTextModelSyncServer();
-    }
-    dispose() {
-    }
-    async $ping() {
-        return 'pong';
-    }
-    _getModel(uri) {
-        return this._workerTextModelSyncServer.getModel(uri);
-    }
-    getModels() {
-        return this._workerTextModelSyncServer.getModels();
-    }
-    $acceptNewModel(data) {
-        this._workerTextModelSyncServer.$acceptNewModel(data);
-    }
-    $acceptModelChanged(uri, e) {
-        this._workerTextModelSyncServer.$acceptModelChanged(uri, e);
-    }
-    $acceptRemovedModel(uri) {
-        this._workerTextModelSyncServer.$acceptRemovedModel(uri);
-    }
-    async $computeUnicodeHighlights(url, options, range) {
-        const model = this._getModel(url);
-        if (!model) {
-            return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };
-        }
-        return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);
-    }
-    async $findSectionHeaders(url, options) {
-        const model = this._getModel(url);
-        if (!model) {
-            return [];
-        }
-        return findSectionHeaders(model, options);
-    }
-    // ---- BEGIN diff --------------------------------------------------------------------------
-    async $computeDiff(originalUrl, modifiedUrl, options, algorithm) {
-        const original = this._getModel(originalUrl);
-        const modified = this._getModel(modifiedUrl);
-        if (!original || !modified) {
-            return null;
-        }
-        const result = EditorWorker.computeDiff(original, modified, options, algorithm);
-        return result;
-    }
-    static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {
-        const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();
-        const originalLines = originalTextModel.getLinesContent();
-        const modifiedLines = modifiedTextModel.getLinesContent();
-        const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, options);
-        const identical = (result.changes.length > 0 ? false : this._modelsAreIdentical(originalTextModel, modifiedTextModel));
-        function getLineChanges(changes) {
-            return changes.map(m => ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, m.innerChanges?.map(m => [
-                    m.originalRange.startLineNumber,
-                    m.originalRange.startColumn,
-                    m.originalRange.endLineNumber,
-                    m.originalRange.endColumn,
-                    m.modifiedRange.startLineNumber,
-                    m.modifiedRange.startColumn,
-                    m.modifiedRange.endLineNumber,
-                    m.modifiedRange.endColumn,
-                ])]));
-        }
-        return {
-            identical,
-            quitEarly: result.hitTimeout,
-            changes: getLineChanges(result.changes),
-            moves: result.moves.map(m => ([
-                m.lineRangeMapping.original.startLineNumber,
-                m.lineRangeMapping.original.endLineNumberExclusive,
-                m.lineRangeMapping.modified.startLineNumber,
-                m.lineRangeMapping.modified.endLineNumberExclusive,
-                getLineChanges(m.changes)
-            ])),
-        };
-    }
-    static _modelsAreIdentical(original, modified) {
-        const originalLineCount = original.getLineCount();
-        const modifiedLineCount = modified.getLineCount();
-        if (originalLineCount !== modifiedLineCount) {
-            return false;
-        }
-        for (let line = 1; line <= originalLineCount; line++) {
-            const originalLine = original.getLineContent(line);
-            const modifiedLine = modified.getLineContent(line);
-            if (originalLine !== modifiedLine) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // ---- END diff --------------------------------------------------------------------------
-    // ---- BEGIN minimal edits ---------------------------------------------------------------
-    static { this._diffLimit = 100000; }
-    async $computeMoreMinimalEdits(modelUrl, edits, pretty) {
-        const model = this._getModel(modelUrl);
-        if (!model) {
-            return edits;
-        }
-        const result = [];
-        let lastEol = undefined;
-        edits = edits.slice(0).sort((a, b) => {
-            if (a.range && b.range) {
-                return Range.compareRangesUsingStarts(a.range, b.range);
-            }
-            // eol only changes should go to the end
-            const aRng = a.range ? 0 : 1;
-            const bRng = b.range ? 0 : 1;
-            return aRng - bRng;
-        });
-        // merge adjacent edits
-        let writeIndex = 0;
-        for (let readIndex = 1; readIndex < edits.length; readIndex++) {
-            if (Range.getEndPosition(edits[writeIndex].range).equals(Range.getStartPosition(edits[readIndex].range))) {
-                edits[writeIndex].range = Range.fromPositions(Range.getStartPosition(edits[writeIndex].range), Range.getEndPosition(edits[readIndex].range));
-                edits[writeIndex].text += edits[readIndex].text;
-            }
-            else {
-                writeIndex++;
-                edits[writeIndex] = edits[readIndex];
-            }
-        }
-        edits.length = writeIndex + 1;
-        for (let { range, text, eol } of edits) {
-            if (typeof eol === 'number') {
-                lastEol = eol;
-            }
-            if (Range.isEmpty(range) && !text) {
-                // empty change
-                continue;
-            }
-            const original = model.getValueInRange(range);
-            text = text.replace(/\r\n|\n|\r/g, model.eol);
-            if (original === text) {
-                // noop
-                continue;
-            }
-            // make sure diff won't take too long
-            if (Math.max(text.length, original.length) > EditorWorker._diffLimit) {
-                result.push({ range, text });
-                continue;
-            }
-            // compute diff between original and edit.text
-            const changes = stringDiff(original, text, pretty);
-            const editOffset = model.offsetAt(Range.lift(range).getStartPosition());
-            for (const change of changes) {
-                const start = model.positionAt(editOffset + change.originalStart);
-                const end = model.positionAt(editOffset + change.originalStart + change.originalLength);
-                const newEdit = {
-                    text: text.substr(change.modifiedStart, change.modifiedLength),
-                    range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }
-                };
-                if (model.getValueInRange(newEdit.range) !== newEdit.text) {
-                    result.push(newEdit);
-                }
-            }
-        }
-        if (typeof lastEol === 'number') {
-            result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });
-        }
-        return result;
-    }
-    // ---- END minimal edits ---------------------------------------------------------------
-    async $computeLinks(modelUrl) {
-        const model = this._getModel(modelUrl);
-        if (!model) {
-            return null;
-        }
-        return computeLinks(model);
-    }
-    // --- BEGIN default document colors -----------------------------------------------------------
-    async $computeDefaultDocumentColors(modelUrl) {
-        const model = this._getModel(modelUrl);
-        if (!model) {
-            return null;
-        }
-        return computeDefaultDocumentColors(model);
-    }
-    // ---- BEGIN suggest --------------------------------------------------------------------------
-    static { this._suggestionsLimit = 10000; }
-    async $textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
-        const sw = new StopWatch();
-        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
-        const seen = new Set();
-        outer: for (const url of modelUrls) {
-            const model = this._getModel(url);
-            if (!model) {
-                continue;
-            }
-            for (const word of model.words(wordDefRegExp)) {
-                if (word === leadingWord || !isNaN(Number(word))) {
-                    continue;
-                }
-                seen.add(word);
-                if (seen.size > EditorWorker._suggestionsLimit) {
-                    break outer;
-                }
-            }
-        }
-        return { words: Array.from(seen), duration: sw.elapsed() };
-    }
-    // ---- END suggest --------------------------------------------------------------------------
-    //#region -- word ranges --
-    async $computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
-        const model = this._getModel(modelUrl);
-        if (!model) {
-            return Object.create(null);
-        }
-        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
-        const result = Object.create(null);
-        for (let line = range.startLineNumber; line < range.endLineNumber; line++) {
-            const words = model.getLineWords(line, wordDefRegExp);
-            for (const word of words) {
-                if (!isNaN(Number(word.word))) {
-                    continue;
-                }
-                let array = result[word.word];
-                if (!array) {
-                    array = [];
-                    result[word.word] = array;
-                }
-                array.push({
-                    startLineNumber: line,
-                    startColumn: word.startColumn,
-                    endLineNumber: line,
-                    endColumn: word.endColumn
-                });
-            }
-        }
-        return result;
-    }
-    //#endregion
-    async $navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
-        const model = this._getModel(modelUrl);
-        if (!model) {
-            return null;
-        }
-        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
-        if (range.startColumn === range.endColumn) {
-            range = {
-                startLineNumber: range.startLineNumber,
-                startColumn: range.startColumn,
-                endLineNumber: range.endLineNumber,
-                endColumn: range.endColumn + 1
-            };
-        }
-        const selectionText = model.getValueInRange(range);
-        const wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);
-        if (!wordRange) {
-            return null;
-        }
-        const word = model.getValueInRange(wordRange);
-        const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
-        return result;
-    }
-    // ---- BEGIN foreign module support --------------------------------------------------------------------------
-    // foreign method request
-    $fmr(method, args) {
-        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
-            return Promise.reject(new Error('Missing requestHandler or method: ' + method));
-        }
-        try {
-            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
-    }
-}
-if (typeof importScripts === 'function') {
-    // Running in a web worker
-    globalThis.monaco = createMonacoBaseAPI();
-}
-
-export { EditorWorker };

package/dist/workers/editor/common/editorWorker.js

@@ -1,9 +0,0 @@
-import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const IEditorWorkerService = createDecorator('editorWorkerService');
-
-export { IEditorWorkerService };

package/dist/workers/editor/common/editorWorkerHost.js

@@ -1,15 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class EditorWorkerHost {
-    static { this.CHANNEL_NAME = 'editorWorkerHost'; }
-    static getChannel(workerServer) {
-        return workerServer.getChannel(EditorWorkerHost.CHANNEL_NAME);
-    }
-    static setChannel(workerClient, obj) {
-        workerClient.setChannel(EditorWorkerHost.CHANNEL_NAME, obj);
-    }
-}
-
-export { EditorWorkerHost };

package/dist/workers/editor/common/editorZoom.js

@@ -1,26 +0,0 @@
-import { Emitter } from '../../../base/common/event.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const EditorZoom = new class {
-    constructor() {
-        this._zoomLevel = 0;
-        this._onDidChangeZoomLevel = new Emitter();
-        this.onDidChangeZoomLevel = this._onDidChangeZoomLevel.event;
-    }
-    getZoomLevel() {
-        return this._zoomLevel;
-    }
-    setZoomLevel(zoomLevel) {
-        zoomLevel = Math.min(Math.max(-5, zoomLevel), 20);
-        if (this._zoomLevel === zoomLevel) {
-            return;
-        }
-        this._zoomLevel = zoomLevel;
-        this._onDidChangeZoomLevel.fire(this._zoomLevel);
-    }
-};
-
-export { EditorZoom };

package/dist/workers/editor/common/electricCharacter.js

@@ -1,55 +0,0 @@
-import { distinct } from '../../../../base/common/arrays.js';
-import { ignoreBracketsInToken } from '../supports.js';
-import { BracketsUtils } from './richEditBrackets.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class BracketElectricCharacterSupport {
-    constructor(richEditBrackets) {
-        this._richEditBrackets = richEditBrackets;
-    }
-    getElectricCharacters() {
-        const result = [];
-        if (this._richEditBrackets) {
-            for (const bracket of this._richEditBrackets.brackets) {
-                for (const close of bracket.close) {
-                    const lastChar = close.charAt(close.length - 1);
-                    result.push(lastChar);
-                }
-            }
-        }
-        return distinct(result);
-    }
-    onElectricCharacter(character, context, column) {
-        if (!this._richEditBrackets || this._richEditBrackets.brackets.length === 0) {
-            return null;
-        }
-        const tokenIndex = context.findTokenIndexAtOffset(column - 1);
-        if (ignoreBracketsInToken(context.getStandardTokenType(tokenIndex))) {
-            return null;
-        }
-        const reversedBracketRegex = this._richEditBrackets.reversedRegex;
-        const text = context.getLineContent().substring(0, column - 1) + character;
-        const r = BracketsUtils.findPrevBracketInRange(reversedBracketRegex, 1, text, 0, text.length);
-        if (!r) {
-            return null;
-        }
-        const bracketText = text.substring(r.startColumn - 1, r.endColumn - 1).toLowerCase();
-        const isOpen = this._richEditBrackets.textIsOpenBracket[bracketText];
-        if (isOpen) {
-            return null;
-        }
-        const textBeforeBracket = context.getActualLineContentBefore(r.startColumn - 1);
-        if (!/^\s*$/.test(textBeforeBracket)) {
-            // There is other text on the line before the bracket
-            return null;
-        }
-        return {
-            matchOpenBracket: bracketText
-        };
-    }
-}
-
-export { BracketElectricCharacterSupport };

package/dist/workers/editor/common/encodedTokenAttributes.js

@@ -1,79 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- */
-class TokenMetadata {
-    static getLanguageId(metadata) {
-        return (metadata & 255 /* MetadataConsts.LANGUAGEID_MASK */) >>> 0 /* MetadataConsts.LANGUAGEID_OFFSET */;
-    }
-    static getTokenType(metadata) {
-        return (metadata & 768 /* MetadataConsts.TOKEN_TYPE_MASK */) >>> 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */;
-    }
-    static containsBalancedBrackets(metadata) {
-        return (metadata & 1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */) !== 0;
-    }
-    static getFontStyle(metadata) {
-        return (metadata & 30720 /* MetadataConsts.FONT_STYLE_MASK */) >>> 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
-    }
-    static getForeground(metadata) {
-        return (metadata & 16744448 /* MetadataConsts.FOREGROUND_MASK */) >>> 15 /* MetadataConsts.FOREGROUND_OFFSET */;
-    }
-    static getBackground(metadata) {
-        return (metadata & 4278190080 /* MetadataConsts.BACKGROUND_MASK */) >>> 24 /* MetadataConsts.BACKGROUND_OFFSET */;
-    }
-    static getClassNameFromMetadata(metadata) {
-        const foreground = this.getForeground(metadata);
-        let className = 'mtk' + foreground;
-        const fontStyle = this.getFontStyle(metadata);
-        if (fontStyle & 1 /* FontStyle.Italic */) {
-            className += ' mtki';
-        }
-        if (fontStyle & 2 /* FontStyle.Bold */) {
-            className += ' mtkb';
-        }
-        if (fontStyle & 4 /* FontStyle.Underline */) {
-            className += ' mtku';
-        }
-        if (fontStyle & 8 /* FontStyle.Strikethrough */) {
-            className += ' mtks';
-        }
-        return className;
-    }
-    static getInlineStyleFromMetadata(metadata, colorMap) {
-        const foreground = this.getForeground(metadata);
-        const fontStyle = this.getFontStyle(metadata);
-        let result = `color: ${colorMap[foreground]};`;
-        if (fontStyle & 1 /* FontStyle.Italic */) {
-            result += 'font-style: italic;';
-        }
-        if (fontStyle & 2 /* FontStyle.Bold */) {
-            result += 'font-weight: bold;';
-        }
-        let textDecoration = '';
-        if (fontStyle & 4 /* FontStyle.Underline */) {
-            textDecoration += ' underline';
-        }
-        if (fontStyle & 8 /* FontStyle.Strikethrough */) {
-            textDecoration += ' line-through';
-        }
-        if (textDecoration) {
-            result += `text-decoration:${textDecoration};`;
-        }
-        return result;
-    }
-    static getPresentationFromMetadata(metadata) {
-        const foreground = this.getForeground(metadata);
-        const fontStyle = this.getFontStyle(metadata);
-        return {
-            foreground: foreground,
-            italic: Boolean(fontStyle & 1 /* FontStyle.Italic */),
-            bold: Boolean(fontStyle & 2 /* FontStyle.Bold */),
-            underline: Boolean(fontStyle & 4 /* FontStyle.Underline */),
-            strikethrough: Boolean(fontStyle & 8 /* FontStyle.Strikethrough */),
-        };
-    }
-}
-
-export { TokenMetadata };

package/dist/workers/editor/common/enterAction.js

@@ -1,53 +0,0 @@
-import { IndentAction } from './languageConfiguration.js';
-import { getIndentationAtPosition } from './languageConfigurationRegistry.js';
-import { IndentationContextProcessor } from './supports/indentationLineProcessor.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function getEnterAction(autoIndent, model, range, languageConfigurationService) {
-    model.tokenization.forceTokenization(range.startLineNumber);
-    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);
-    const richEditSupport = languageConfigurationService.getLanguageConfiguration(languageId);
-    if (!richEditSupport) {
-        return null;
-    }
-    const indentationContextProcessor = new IndentationContextProcessor(model, languageConfigurationService);
-    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);
-    const previousLineText = processedContextTokens.previousLineProcessedTokens.getLineContent();
-    const beforeEnterText = processedContextTokens.beforeRangeProcessedTokens.getLineContent();
-    const afterEnterText = processedContextTokens.afterRangeProcessedTokens.getLineContent();
-    const enterResult = richEditSupport.onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText);
-    if (!enterResult) {
-        return null;
-    }
-    const indentAction = enterResult.indentAction;
-    let appendText = enterResult.appendText;
-    const removeText = enterResult.removeText || 0;
-    // Here we add `\t` to appendText first because enterAction is leveraging appendText and removeText to change indentation.
-    if (!appendText) {
-        if ((indentAction === IndentAction.Indent) ||
-            (indentAction === IndentAction.IndentOutdent)) {
-            appendText = '\t';
-        }
-        else {
-            appendText = '';
-        }
-    }
-    else if (indentAction === IndentAction.Indent) {
-        appendText = '\t' + appendText;
-    }
-    let indentation = getIndentationAtPosition(model, range.startLineNumber, range.startColumn);
-    if (removeText) {
-        indentation = indentation.substring(0, indentation.length - removeText);
-    }
-    return {
-        indentAction: indentAction,
-        appendText: appendText,
-        removeText: removeText,
-        indentation: indentation
-    };
-}
-
-export { getEnterAction };

package/dist/workers/editor/common/eolCounter.js

@@ -1,44 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function countEOL(text) {
-    let eolCount = 0;
-    let firstLineLength = 0;
-    let lastLineStart = 0;
-    let eol = 0 /* StringEOL.Unknown */;
-    for (let i = 0, len = text.length; i < len; i++) {
-        const chr = text.charCodeAt(i);
-        if (chr === 13 /* CharCode.CarriageReturn */) {
-            if (eolCount === 0) {
-                firstLineLength = i;
-            }
-            eolCount++;
-            if (i + 1 < len && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
-                // \r\n... case
-                eol |= 2 /* StringEOL.CRLF */;
-                i++; // skip \n
-            }
-            else {
-                // \r... case
-                eol |= 3 /* StringEOL.Invalid */;
-            }
-            lastLineStart = i + 1;
-        }
-        else if (chr === 10 /* CharCode.LineFeed */) {
-            // \n... case
-            eol |= 1 /* StringEOL.LF */;
-            if (eolCount === 0) {
-                firstLineLength = i;
-            }
-            eolCount++;
-            lastLineStart = i + 1;
-        }
-    }
-    if (eolCount === 0) {
-        firstLineLength = text.length;
-    }
-    return [eolCount, firstLineLength, text.length - lastLineStart, eol];
-}
-
-export { countEOL };