@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/api/common/extHostDecorations.js

@@ -0,0 +1,94 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { Disposable, FileDecoration } from './extHostTypes.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { asArray, groupBy } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { compare, count } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/path.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+let ExtHostDecorations = class ExtHostDecorations {
+    constructor(extHostRpc, _logService) {
+        this._logService = _logService;
+        this._provider = ( new Map());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadDecorations));
+    }
+    registerFileDecorationProvider(provider, extensionDescription) {
+        const handle = ExtHostDecorations._handlePool++;
+        this._provider.set(handle, { provider, extensionDescription });
+        this._proxy.$registerDecorationProvider(handle, extensionDescription.identifier.value);
+        const listener = provider.onDidChangeFileDecorations && provider.onDidChangeFileDecorations(e => {
+            if (!e) {
+                this._proxy.$onDidChange(handle, null);
+                return;
+            }
+            const array = asArray(e);
+            if (array.length <= ExtHostDecorations._maxEventSize) {
+                this._proxy.$onDidChange(handle, array);
+                return;
+            }
+            this._logService.warn('[Decorations] CAPPING events from decorations provider', extensionDescription.identifier.value, array.length);
+            const mapped = ( array.map(uri => ({ uri, rank: count(uri.path, '/') })));
+            const groups = groupBy(mapped, (a, b) => a.rank - b.rank || compare(a.uri.path, b.uri.path));
+            const picked = [];
+            outer: for (const uris of groups) {
+                let lastDirname;
+                for (const obj of uris) {
+                    const myDirname = dirname(obj.uri.path);
+                    if (lastDirname !== myDirname) {
+                        lastDirname = myDirname;
+                        if (picked.push(obj.uri) >= ExtHostDecorations._maxEventSize) {
+                            break outer;
+                        }
+                    }
+                }
+            }
+            this._proxy.$onDidChange(handle, picked);
+        });
+        return ( new Disposable(() => {
+            listener?.dispose();
+            this._proxy.$unregisterDecorationProvider(handle);
+            this._provider.delete(handle);
+        }));
+    }
+    async $provideDecorations(handle, requests, token) {
+        if (!this._provider.has(handle)) {
+            return Object.create(null);
+        }
+        const result = Object.create(null);
+        const { provider, extensionDescription: extensionId } = this._provider.get(handle);
+        await Promise.all(( requests.map(async (request) => {
+            try {
+                const { uri, id } = request;
+                const data = await Promise.resolve(provider.provideFileDecoration(URI.revive(uri), token));
+                if (!data) {
+                    return;
+                }
+                try {
+                    FileDecoration.validate(data);
+                    if (data.badge && typeof data.badge !== 'string') {
+                        checkProposedApiEnabled(extensionId, 'codiconDecoration');
+                    }
+                    result[id] = [data.propagate, data.tooltip, data.badge, data.color];
+                }
+                catch (e) {
+                    this._logService.warn(`INVALID decoration from extension '${extensionId}': ${e}`);
+                }
+            }
+            catch (err) {
+                this._logService.error(err);
+            }
+        })));
+        return result;
+    }
+};
+ExtHostDecorations._handlePool = 0;
+ExtHostDecorations._maxEventSize = 250;
+ExtHostDecorations = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, ILogService))
+], ExtHostDecorations));
+const IExtHostDecorations = ( createDecorator('IExtHostDecorations'));
+export { ExtHostDecorations, IExtHostDecorations };

package/dist/vscode/vs/workbench/api/common/extHostDiagnostics.js

@@ -0,0 +1,292 @@
+import { __decorate, __param, __classPrivateFieldSet, __classPrivateFieldGet } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { DiagnosticSeverity } from './extHostTypes.js';
+import { Diagnostic } from './extHostTypeConverters.js';
+import { DebounceEmitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IExtHostFileSystemInfo } from './extHostFileSystemInfo.js';
+var _DiagnosticCollection_proxy, _DiagnosticCollection_onDidChangeDiagnostics, _DiagnosticCollection_data;
+class DiagnosticCollection {
+    constructor(_name, _owner, _maxDiagnosticsPerFile, _modelVersionIdProvider, extUri, proxy, onDidChangeDiagnostics) {
+        this._name = _name;
+        this._owner = _owner;
+        this._maxDiagnosticsPerFile = _maxDiagnosticsPerFile;
+        this._modelVersionIdProvider = _modelVersionIdProvider;
+        _DiagnosticCollection_proxy.set(this, void 0);
+        _DiagnosticCollection_onDidChangeDiagnostics.set(this, void 0);
+        _DiagnosticCollection_data.set(this, void 0);
+        this._isDisposed = false;
+        __classPrivateFieldSet(this, _DiagnosticCollection_data, ( new ResourceMap(uri => extUri.getComparisonKey(uri))), "f");
+        __classPrivateFieldSet(this, _DiagnosticCollection_proxy, proxy, "f");
+        __classPrivateFieldSet(this, _DiagnosticCollection_onDidChangeDiagnostics, onDidChangeDiagnostics, "f");
+    }
+    dispose() {
+        if (!this._isDisposed) {
+            __classPrivateFieldGet(this, _DiagnosticCollection_onDidChangeDiagnostics, "f").fire([...( __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").keys())]);
+            __classPrivateFieldGet(this, _DiagnosticCollection_proxy, "f")?.$clear(this._owner);
+            __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").clear();
+            this._isDisposed = true;
+        }
+    }
+    get name() {
+        this._checkDisposed();
+        return this._name;
+    }
+    set(first, diagnostics) {
+        if (!first) {
+            this.clear();
+            return;
+        }
+        this._checkDisposed();
+        let toSync = [];
+        if (URI.isUri(first)) {
+            if (!diagnostics) {
+                this.delete(first);
+                return;
+            }
+            __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").set(first, diagnostics.slice());
+            toSync = [first];
+        }
+        else if (Array.isArray(first)) {
+            toSync = [];
+            let lastUri;
+            first = [...first].sort(DiagnosticCollection._compareIndexedTuplesByUri);
+            for (const tuple of first) {
+                const [uri, diagnostics] = tuple;
+                if (!lastUri || ( uri.toString()) !== ( lastUri.toString())) {
+                    if (lastUri && __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").get(lastUri).length === 0) {
+                        __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").delete(lastUri);
+                    }
+                    lastUri = uri;
+                    toSync.push(uri);
+                    __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").set(uri, []);
+                }
+                if (!diagnostics) {
+                    const currentDiagnostics = __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").get(uri);
+                    if (currentDiagnostics) {
+                        currentDiagnostics.length = 0;
+                    }
+                }
+                else {
+                    const currentDiagnostics = __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").get(uri);
+                    currentDiagnostics?.push(...diagnostics);
+                }
+            }
+        }
+        __classPrivateFieldGet(this, _DiagnosticCollection_onDidChangeDiagnostics, "f").fire(toSync);
+        if (!__classPrivateFieldGet(this, _DiagnosticCollection_proxy, "f")) {
+            return;
+        }
+        const entries = [];
+        for (const uri of toSync) {
+            let marker = [];
+            const diagnostics = __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").get(uri);
+            if (diagnostics) {
+                if (diagnostics.length > this._maxDiagnosticsPerFile) {
+                    marker = [];
+                    const order = [DiagnosticSeverity.Error, DiagnosticSeverity.Warning, DiagnosticSeverity.Information, DiagnosticSeverity.Hint];
+                    orderLoop: for (let i = 0; i < 4; i++) {
+                        for (const diagnostic of diagnostics) {
+                            if (diagnostic.severity === order[i]) {
+                                const len = marker.push({ ...Diagnostic.from(diagnostic), modelVersionId: this._modelVersionIdProvider(uri) });
+                                if (len === this._maxDiagnosticsPerFile) {
+                                    break orderLoop;
+                                }
+                            }
+                        }
+                    }
+                    marker.push({
+                        severity: MarkerSeverity.Info,
+                        message: ( localize(
+                            { key: 'limitHit', comment: ['amount of errors/warning skipped due to limits'] },
+                            "Not showing {0} further errors and warnings.",
+                            diagnostics.length - this._maxDiagnosticsPerFile
+                        )),
+                        startLineNumber: marker[marker.length - 1].startLineNumber,
+                        startColumn: marker[marker.length - 1].startColumn,
+                        endLineNumber: marker[marker.length - 1].endLineNumber,
+                        endColumn: marker[marker.length - 1].endColumn
+                    });
+                }
+                else {
+                    marker = ( diagnostics.map(
+                        diag => ({ ...Diagnostic.from(diag), modelVersionId: this._modelVersionIdProvider(uri) })
+                    ));
+                }
+            }
+            entries.push([uri, marker]);
+        }
+        __classPrivateFieldGet(this, _DiagnosticCollection_proxy, "f").$changeMany(this._owner, entries);
+    }
+    delete(uri) {
+        this._checkDisposed();
+        __classPrivateFieldGet(this, _DiagnosticCollection_onDidChangeDiagnostics, "f").fire([uri]);
+        __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").delete(uri);
+        __classPrivateFieldGet(this, _DiagnosticCollection_proxy, "f")?.$changeMany(this._owner, [[uri, undefined]]);
+    }
+    clear() {
+        this._checkDisposed();
+        __classPrivateFieldGet(this, _DiagnosticCollection_onDidChangeDiagnostics, "f").fire([...( __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").keys())]);
+        __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").clear();
+        __classPrivateFieldGet(this, _DiagnosticCollection_proxy, "f")?.$clear(this._owner);
+    }
+    forEach(callback, thisArg) {
+        this._checkDisposed();
+        for (const [uri, values] of this) {
+            callback.call(thisArg, uri, values, this);
+        }
+    }
+    *[(_DiagnosticCollection_proxy = ( new WeakMap()), _DiagnosticCollection_onDidChangeDiagnostics = ( new WeakMap()), _DiagnosticCollection_data = ( new WeakMap()), Symbol.iterator)]() {
+        this._checkDisposed();
+        for (const uri of ( __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").keys())) {
+            yield [uri, this.get(uri)];
+        }
+    }
+    get(uri) {
+        this._checkDisposed();
+        const result = __classPrivateFieldGet(this, _DiagnosticCollection_data, "f").get(uri);
+        if (Array.isArray(result)) {
+            return ( Object.freeze(result.slice(0)));
+        }
+        return [];
+    }
+    has(uri) {
+        this._checkDisposed();
+        return Array.isArray(__classPrivateFieldGet(this, _DiagnosticCollection_data, "f").get(uri));
+    }
+    _checkDisposed() {
+        if (this._isDisposed) {
+            throw new Error('illegal state - object is disposed');
+        }
+    }
+    static _compareIndexedTuplesByUri(a, b) {
+        if (( a[0].toString()) < ( b[0].toString())) {
+            return -1;
+        }
+        else if (( a[0].toString()) > ( b[0].toString())) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+let ExtHostDiagnostics = class ExtHostDiagnostics {
+    static _mapper(last) {
+        const map = ( new ResourceMap());
+        for (const uri of last) {
+            map.set(uri, uri);
+        }
+        return { uris: ( Object.freeze(Array.from(( map.values())))) };
+    }
+    constructor(mainContext, _logService, _fileSystemInfoService, _extHostDocumentsAndEditors) {
+        this._logService = _logService;
+        this._fileSystemInfoService = _fileSystemInfoService;
+        this._extHostDocumentsAndEditors = _extHostDocumentsAndEditors;
+        this._collections = ( new Map());
+        this._onDidChangeDiagnostics = ( new DebounceEmitter({ merge: all => all.flat(), delay: 50 }));
+        this.onDidChangeDiagnostics = ( Event.map(this._onDidChangeDiagnostics.event, ExtHostDiagnostics._mapper));
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadDiagnostics));
+    }
+    createDiagnosticCollection(extensionId, name) {
+        const { _collections, _proxy, _onDidChangeDiagnostics, _logService, _fileSystemInfoService, _extHostDocumentsAndEditors } = this;
+        const loggingProxy = new (class {
+            $changeMany(owner, entries) {
+                _proxy.$changeMany(owner, entries);
+                _logService.trace('[DiagnosticCollection] change many (extension, owner, uris)', extensionId.value, owner, entries.length === 0 ? 'CLEARING' : entries);
+            }
+            $clear(owner) {
+                _proxy.$clear(owner);
+                _logService.trace('[DiagnosticCollection] remove all (extension, owner)', extensionId.value, owner);
+            }
+            dispose() {
+                _proxy.dispose();
+            }
+        });
+        let owner;
+        if (!name) {
+            name = '_generated_diagnostic_collection_name_#' + ExtHostDiagnostics._idPool++;
+            owner = name;
+        }
+        else if (!_collections.has(name)) {
+            owner = name;
+        }
+        else {
+            this._logService.warn(`DiagnosticCollection with name '${name}' does already exist.`);
+            do {
+                owner = name + ExtHostDiagnostics._idPool++;
+            } while (_collections.has(owner));
+        }
+        const result = new (class extends DiagnosticCollection {
+            constructor() {
+                super(name, owner, ExtHostDiagnostics._maxDiagnosticsPerFile, uri => _extHostDocumentsAndEditors.getDocument(uri)?.version, _fileSystemInfoService.extUri, loggingProxy, _onDidChangeDiagnostics);
+                _collections.set(owner, this);
+            }
+            dispose() {
+                super.dispose();
+                _collections.delete(owner);
+            }
+        });
+        return result;
+    }
+    getDiagnostics(resource) {
+        if (resource) {
+            return this._getDiagnostics(resource);
+        }
+        else {
+            const index = ( new Map());
+            const res = [];
+            for (const collection of ( this._collections.values())) {
+                collection.forEach((uri, diagnostics) => {
+                    let idx = index.get(( uri.toString()));
+                    if (typeof idx === 'undefined') {
+                        idx = res.length;
+                        index.set(( uri.toString()), idx);
+                        res.push([uri, []]);
+                    }
+                    res[idx][1] = res[idx][1].concat(...diagnostics);
+                });
+            }
+            return res;
+        }
+    }
+    _getDiagnostics(resource) {
+        let res = [];
+        for (const collection of ( this._collections.values())) {
+            if (collection.has(resource)) {
+                res = res.concat(collection.get(resource));
+            }
+        }
+        return res;
+    }
+    $acceptMarkersChange(data) {
+        if (!this._mirrorCollection) {
+            const name = '_generated_mirror';
+            const collection = ( new DiagnosticCollection(
+                name,
+                name,
+                ExtHostDiagnostics._maxDiagnosticsPerFile,
+                _uri => undefined,
+                this._fileSystemInfoService.extUri,
+                undefined,
+                this._onDidChangeDiagnostics
+            ));
+            this._collections.set(name, collection);
+            this._mirrorCollection = collection;
+        }
+        for (const [uri, markers] of data) {
+            this._mirrorCollection.set(URI.revive(uri), ( markers.map(Diagnostic.to)));
+        }
+    }
+};
+ExtHostDiagnostics._idPool = 0;
+ExtHostDiagnostics._maxDiagnosticsPerFile = 1000;
+ExtHostDiagnostics = ( __decorate([
+    ( __param(1, ILogService)),
+    ( __param(2, IExtHostFileSystemInfo))
+], ExtHostDiagnostics));
+export { DiagnosticCollection, ExtHostDiagnostics };

package/dist/vscode/vs/workbench/api/common/extHostDocumentContentProviders.js

@@ -0,0 +1,65 @@
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable } from './extHostTypes.js';
+import { MainContext } from './extHost.protocol.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { splitLines } from 'monaco-editor/esm/vs/base/common/strings.js';
+class ExtHostDocumentContentProvider {
+    constructor(mainContext, _documentsAndEditors, _logService) {
+        this._documentsAndEditors = _documentsAndEditors;
+        this._logService = _logService;
+        this._documentContentProviders = ( new Map());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadDocumentContentProviders));
+    }
+    registerTextDocumentContentProvider(scheme, provider) {
+        if (( Object.keys(Schemas)).indexOf(scheme) >= 0) {
+            throw new Error(`scheme '${scheme}' already registered`);
+        }
+        const handle = ExtHostDocumentContentProvider._handlePool++;
+        this._documentContentProviders.set(handle, provider);
+        this._proxy.$registerTextContentProvider(handle, scheme);
+        let subscription;
+        if (typeof provider.onDidChange === 'function') {
+            subscription = provider.onDidChange(uri => {
+                if (uri.scheme !== scheme) {
+                    this._logService.warn(`Provider for scheme '${scheme}' is firing event for schema '${uri.scheme}' which will be IGNORED`);
+                    return;
+                }
+                if (this._documentsAndEditors.getDocument(uri)) {
+                    this.$provideTextDocumentContent(handle, uri).then(value => {
+                        if (!value && typeof value !== 'string') {
+                            return;
+                        }
+                        const document = this._documentsAndEditors.getDocument(uri);
+                        if (!document) {
+                            return;
+                        }
+                        const lines = splitLines(value);
+                        if (!document.equalLines(lines)) {
+                            return this._proxy.$onVirtualDocumentChange(uri, value);
+                        }
+                    }, onUnexpectedError);
+                }
+            });
+        }
+        return ( new Disposable(() => {
+            if (this._documentContentProviders.delete(handle)) {
+                this._proxy.$unregisterTextContentProvider(handle);
+            }
+            if (subscription) {
+                subscription.dispose();
+                subscription = undefined;
+            }
+        }));
+    }
+    $provideTextDocumentContent(handle, uri) {
+        const provider = this._documentContentProviders.get(handle);
+        if (!provider) {
+            return Promise.reject(( new Error(`unsupported uri-scheme: ${uri.scheme}`)));
+        }
+        return Promise.resolve(provider.provideTextDocumentContent(URI.revive(uri), CancellationToken.None));
+    }
+}
+ExtHostDocumentContentProvider._handlePool = 0;
+export { ExtHostDocumentContentProvider };

package/dist/vscode/vs/workbench/api/common/extHostDocumentData.js

@@ -0,0 +1,212 @@
+import { ok } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { regExpLeadsToEndlessLoop } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { MirrorTextModel } from 'monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js';
+import { getWordAtText, ensureValidWordDefinition } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { EndOfLine, Position, Range } from './extHostTypes.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+const _languageId2WordDefinition = ( new Map());
+function setWordDefinitionFor(languageId, wordDefinition) {
+    if (!wordDefinition) {
+        _languageId2WordDefinition.delete(languageId);
+    }
+    else {
+        _languageId2WordDefinition.set(languageId, wordDefinition);
+    }
+}
+function getWordDefinitionFor(languageId) {
+    return _languageId2WordDefinition.get(languageId);
+}
+class ExtHostDocumentData extends MirrorTextModel {
+    constructor(_proxy, uri, lines, eol, versionId, _languageId, _isDirty, notebook) {
+        super(uri, lines, eol, versionId);
+        this._proxy = _proxy;
+        this._languageId = _languageId;
+        this._isDirty = _isDirty;
+        this.notebook = notebook;
+        this._isDisposed = false;
+    }
+    dispose() {
+        ok(!this._isDisposed);
+        this._isDisposed = true;
+        this._isDirty = false;
+    }
+    equalLines(lines) {
+        return equals(this._lines, lines);
+    }
+    get document() {
+        if (!this._document) {
+            const that = this;
+            this._document = {
+                get uri() { return that._uri; },
+                get fileName() { return that._uri.fsPath; },
+                get isUntitled() { return that._uri.scheme === Schemas.untitled; },
+                get languageId() { return that._languageId; },
+                get version() { return that._versionId; },
+                get isClosed() { return that._isDisposed; },
+                get isDirty() { return that._isDirty; },
+                save() { return that._save(); },
+                getText(range) { return range ? that._getTextInRange(range) : that.getText(); },
+                get eol() { return that._eol === '\n' ? EndOfLine.LF : EndOfLine.CRLF; },
+                get lineCount() { return that._lines.length; },
+                lineAt(lineOrPos) { return that._lineAt(lineOrPos); },
+                offsetAt(pos) { return that._offsetAt(pos); },
+                positionAt(offset) { return that._positionAt(offset); },
+                validateRange(ran) { return that._validateRange(ran); },
+                validatePosition(pos) { return that._validatePosition(pos); },
+                getWordRangeAtPosition(pos, regexp) { return that._getWordRangeAtPosition(pos, regexp); },
+            };
+        }
+        return ( Object.freeze(this._document));
+    }
+    _acceptLanguageId(newLanguageId) {
+        ok(!this._isDisposed);
+        this._languageId = newLanguageId;
+    }
+    _acceptIsDirty(isDirty) {
+        ok(!this._isDisposed);
+        this._isDirty = isDirty;
+    }
+    _save() {
+        if (this._isDisposed) {
+            return Promise.reject(( new Error('Document has been closed')));
+        }
+        return this._proxy.$trySaveDocument(this._uri);
+    }
+    _getTextInRange(_range) {
+        const range = this._validateRange(_range);
+        if (range.isEmpty) {
+            return '';
+        }
+        if (range.isSingleLine) {
+            return this._lines[range.start.line].substring(range.start.character, range.end.character);
+        }
+        const lineEnding = this._eol, startLineIndex = range.start.line, endLineIndex = range.end.line, resultLines = [];
+        resultLines.push(this._lines[startLineIndex].substring(range.start.character));
+        for (let i = startLineIndex + 1; i < endLineIndex; i++) {
+            resultLines.push(this._lines[i]);
+        }
+        resultLines.push(this._lines[endLineIndex].substring(0, range.end.character));
+        return resultLines.join(lineEnding);
+    }
+    _lineAt(lineOrPosition) {
+        let line;
+        if (lineOrPosition instanceof Position) {
+            line = lineOrPosition.line;
+        }
+        else if (typeof lineOrPosition === 'number') {
+            line = lineOrPosition;
+        }
+        if (typeof line !== 'number' || line < 0 || line >= this._lines.length || Math.floor(line) !== line) {
+            throw new Error('Illegal value for `line`');
+        }
+        return ( new ExtHostDocumentLine(line, this._lines[line], line === this._lines.length - 1));
+    }
+    _offsetAt(position) {
+        position = this._validatePosition(position);
+        this._ensureLineStarts();
+        return this._lineStarts.getPrefixSum(position.line - 1) + position.character;
+    }
+    _positionAt(offset) {
+        offset = Math.floor(offset);
+        offset = Math.max(0, offset);
+        this._ensureLineStarts();
+        const out = this._lineStarts.getIndexOf(offset);
+        const lineLength = this._lines[out.index].length;
+        return ( new Position(out.index, Math.min(out.remainder, lineLength)));
+    }
+    _validateRange(range) {
+        if (!(range instanceof Range)) {
+            throw new Error('Invalid argument');
+        }
+        const start = this._validatePosition(range.start);
+        const end = this._validatePosition(range.end);
+        if (start === range.start && end === range.end) {
+            return range;
+        }
+        return ( new Range(start.line, start.character, end.line, end.character));
+    }
+    _validatePosition(position) {
+        if (!(position instanceof Position)) {
+            throw new Error('Invalid argument');
+        }
+        if (this._lines.length === 0) {
+            return position.with(0, 0);
+        }
+        let { line, character } = position;
+        let hasChanged = false;
+        if (line < 0) {
+            line = 0;
+            character = 0;
+            hasChanged = true;
+        }
+        else if (line >= this._lines.length) {
+            line = this._lines.length - 1;
+            character = this._lines[line].length;
+            hasChanged = true;
+        }
+        else {
+            const maxCharacter = this._lines[line].length;
+            if (character < 0) {
+                character = 0;
+                hasChanged = true;
+            }
+            else if (character > maxCharacter) {
+                character = maxCharacter;
+                hasChanged = true;
+            }
+        }
+        if (!hasChanged) {
+            return position;
+        }
+        return ( new Position(line, character));
+    }
+    _getWordRangeAtPosition(_position, regexp) {
+        const position = this._validatePosition(_position);
+        if (!regexp) {
+            regexp = getWordDefinitionFor(this._languageId);
+        }
+        else if (regExpLeadsToEndlessLoop(regexp)) {
+            throw new Error(`[getWordRangeAtPosition]: ignoring custom regexp '${regexp.source}' because it matches the empty string.`);
+        }
+        const wordAtText = getWordAtText(position.character + 1, ensureValidWordDefinition(regexp), this._lines[position.line], 0);
+        if (wordAtText) {
+            return ( new Range(
+                position.line,
+                wordAtText.startColumn - 1,
+                position.line,
+                wordAtText.endColumn - 1
+            ));
+        }
+        return undefined;
+    }
+}
+class ExtHostDocumentLine {
+    constructor(line, text, isLastLine) {
+        this._line = line;
+        this._text = text;
+        this._isLastLine = isLastLine;
+    }
+    get lineNumber() {
+        return this._line;
+    }
+    get text() {
+        return this._text;
+    }
+    get range() {
+        return ( new Range(this._line, 0, this._line, this._text.length));
+    }
+    get rangeIncludingLineBreak() {
+        if (this._isLastLine) {
+            return this.range;
+        }
+        return ( new Range(this._line, 0, this._line + 1, 0));
+    }
+    get firstNonWhitespaceCharacterIndex() {
+        return /^(\s*)/.exec(this._text)[1].length;
+    }
+    get isEmptyOrWhitespace() {
+        return this.firstNonWhitespaceCharacterIndex === this._text.length;
+    }
+}
+export { ExtHostDocumentData, ExtHostDocumentLine, setWordDefinitionFor };