monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,299 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 };