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

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

@@ -0,0 +1,511 @@
+import { ok } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { readonly, illegalArgument } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IdGenerator } from 'monaco-editor/esm/vs/base/common/idGenerator.js';
+import { Position as Position$1, Range as Range$1, isDecorationOptionsArr, fromRangeOrRangeWithMessage, ViewColumn, EndOfLine, TextEditorLineNumbersStyle, Selection as Selection$1, DecorationRenderOptions } from './extHostTypeConverters.js';
+import { Selection, Position, Range, TextEditorRevealType, EndOfLine as EndOfLine$1 } from './extHostTypes.js';
+class TextEditorDecorationType {
+    constructor(proxy, extension, options) {
+        const key = TextEditorDecorationType._Keys.nextId();
+        proxy.$registerTextEditorDecorationType(extension.identifier, key, DecorationRenderOptions.from(options));
+        this.value = ( Object.freeze({
+            key,
+            dispose() {
+                proxy.$removeTextEditorDecorationType(key);
+            }
+        }));
+    }
+}
+TextEditorDecorationType._Keys = ( new IdGenerator('TextEditorDecorationType'));
+class TextEditorEdit {
+    constructor(document, options) {
+        this._collectedEdits = [];
+        this._setEndOfLine = undefined;
+        this._finalized = false;
+        this._document = document;
+        this._documentVersionId = document.version;
+        this._undoStopBefore = options.undoStopBefore;
+        this._undoStopAfter = options.undoStopAfter;
+    }
+    finalize() {
+        this._finalized = true;
+        return {
+            documentVersionId: this._documentVersionId,
+            edits: this._collectedEdits,
+            setEndOfLine: this._setEndOfLine,
+            undoStopBefore: this._undoStopBefore,
+            undoStopAfter: this._undoStopAfter
+        };
+    }
+    _throwIfFinalized() {
+        if (this._finalized) {
+            throw new Error('Edit is only valid while callback runs');
+        }
+    }
+    replace(location, value) {
+        this._throwIfFinalized();
+        let range = null;
+        if (location instanceof Position) {
+            range = ( new Range(location, location));
+        }
+        else if (location instanceof Range) {
+            range = location;
+        }
+        else {
+            throw new Error('Unrecognized location');
+        }
+        this._pushEdit(range, value, false);
+    }
+    insert(location, value) {
+        this._throwIfFinalized();
+        this._pushEdit(( new Range(location, location)), value, true);
+    }
+    delete(location) {
+        this._throwIfFinalized();
+        let range = null;
+        if (location instanceof Range) {
+            range = location;
+        }
+        else {
+            throw new Error('Unrecognized location');
+        }
+        this._pushEdit(range, null, true);
+    }
+    _pushEdit(range, text, forceMoveMarkers) {
+        const validRange = this._document.validateRange(range);
+        this._collectedEdits.push({
+            range: validRange,
+            text: text,
+            forceMoveMarkers: forceMoveMarkers
+        });
+    }
+    setEndOfLine(endOfLine) {
+        this._throwIfFinalized();
+        if (endOfLine !== EndOfLine$1.LF && endOfLine !== EndOfLine$1.CRLF) {
+            throw illegalArgument('endOfLine');
+        }
+        this._setEndOfLine = endOfLine;
+    }
+}
+class ExtHostTextEditorOptions {
+    constructor(proxy, id, source, logService) {
+        this._proxy = proxy;
+        this._id = id;
+        this._accept(source);
+        this._logService = logService;
+        const that = this;
+        this.value = {
+            get tabSize() {
+                return that._tabSize;
+            },
+            set tabSize(value) {
+                that._setTabSize(value);
+            },
+            get indentSize() {
+                return that._indentSize;
+            },
+            set indentSize(value) {
+                that._setIndentSize(value);
+            },
+            get insertSpaces() {
+                return that._insertSpaces;
+            },
+            set insertSpaces(value) {
+                that._setInsertSpaces(value);
+            },
+            get cursorStyle() {
+                return that._cursorStyle;
+            },
+            set cursorStyle(value) {
+                that._setCursorStyle(value);
+            },
+            get lineNumbers() {
+                return that._lineNumbers;
+            },
+            set lineNumbers(value) {
+                that._setLineNumbers(value);
+            }
+        };
+    }
+    _accept(source) {
+        this._tabSize = source.tabSize;
+        this._indentSize = source.indentSize;
+        this._insertSpaces = source.insertSpaces;
+        this._cursorStyle = source.cursorStyle;
+        this._lineNumbers = TextEditorLineNumbersStyle.to(source.lineNumbers);
+    }
+    _validateTabSize(value) {
+        if (value === 'auto') {
+            return 'auto';
+        }
+        if (typeof value === 'number') {
+            const r = Math.floor(value);
+            return (r > 0 ? r : null);
+        }
+        if (typeof value === 'string') {
+            const r = parseInt(value, 10);
+            if (isNaN(r)) {
+                return null;
+            }
+            return (r > 0 ? r : null);
+        }
+        return null;
+    }
+    _setTabSize(value) {
+        const tabSize = this._validateTabSize(value);
+        if (tabSize === null) {
+            return;
+        }
+        if (typeof tabSize === 'number') {
+            if (this._tabSize === tabSize) {
+                return;
+            }
+            this._tabSize = tabSize;
+        }
+        this._warnOnError('setTabSize', this._proxy.$trySetOptions(this._id, {
+            tabSize: tabSize
+        }));
+    }
+    _validateIndentSize(value) {
+        if (value === 'tabSize') {
+            return 'tabSize';
+        }
+        if (typeof value === 'number') {
+            const r = Math.floor(value);
+            return (r > 0 ? r : null);
+        }
+        if (typeof value === 'string') {
+            const r = parseInt(value, 10);
+            if (isNaN(r)) {
+                return null;
+            }
+            return (r > 0 ? r : null);
+        }
+        return null;
+    }
+    _setIndentSize(value) {
+        const indentSize = this._validateIndentSize(value);
+        if (indentSize === null) {
+            return;
+        }
+        if (typeof indentSize === 'number') {
+            if (this._indentSize === indentSize) {
+                return;
+            }
+            this._indentSize = indentSize;
+        }
+        this._warnOnError('setIndentSize', this._proxy.$trySetOptions(this._id, {
+            indentSize: indentSize
+        }));
+    }
+    _validateInsertSpaces(value) {
+        if (value === 'auto') {
+            return 'auto';
+        }
+        return (value === 'false' ? false : Boolean(value));
+    }
+    _setInsertSpaces(value) {
+        const insertSpaces = this._validateInsertSpaces(value);
+        if (typeof insertSpaces === 'boolean') {
+            if (this._insertSpaces === insertSpaces) {
+                return;
+            }
+            this._insertSpaces = insertSpaces;
+        }
+        this._warnOnError('setInsertSpaces', this._proxy.$trySetOptions(this._id, {
+            insertSpaces: insertSpaces
+        }));
+    }
+    _setCursorStyle(value) {
+        if (this._cursorStyle === value) {
+            return;
+        }
+        this._cursorStyle = value;
+        this._warnOnError('setCursorStyle', this._proxy.$trySetOptions(this._id, {
+            cursorStyle: value
+        }));
+    }
+    _setLineNumbers(value) {
+        if (this._lineNumbers === value) {
+            return;
+        }
+        this._lineNumbers = value;
+        this._warnOnError('setLineNumbers', this._proxy.$trySetOptions(this._id, {
+            lineNumbers: TextEditorLineNumbersStyle.from(value)
+        }));
+    }
+    assign(newOptions) {
+        const bulkConfigurationUpdate = {};
+        let hasUpdate = false;
+        if (typeof newOptions.tabSize !== 'undefined') {
+            const tabSize = this._validateTabSize(newOptions.tabSize);
+            if (tabSize === 'auto') {
+                hasUpdate = true;
+                bulkConfigurationUpdate.tabSize = tabSize;
+            }
+            else if (typeof tabSize === 'number' && this._tabSize !== tabSize) {
+                this._tabSize = tabSize;
+                hasUpdate = true;
+                bulkConfigurationUpdate.tabSize = tabSize;
+            }
+        }
+        if (typeof newOptions.indentSize !== 'undefined') {
+            const indentSize = this._validateIndentSize(newOptions.indentSize);
+            if (indentSize === 'tabSize') {
+                hasUpdate = true;
+                bulkConfigurationUpdate.indentSize = indentSize;
+            }
+            else if (typeof indentSize === 'number' && this._indentSize !== indentSize) {
+                this._indentSize = indentSize;
+                hasUpdate = true;
+                bulkConfigurationUpdate.indentSize = indentSize;
+            }
+        }
+        if (typeof newOptions.insertSpaces !== 'undefined') {
+            const insertSpaces = this._validateInsertSpaces(newOptions.insertSpaces);
+            if (insertSpaces === 'auto') {
+                hasUpdate = true;
+                bulkConfigurationUpdate.insertSpaces = insertSpaces;
+            }
+            else if (this._insertSpaces !== insertSpaces) {
+                this._insertSpaces = insertSpaces;
+                hasUpdate = true;
+                bulkConfigurationUpdate.insertSpaces = insertSpaces;
+            }
+        }
+        if (typeof newOptions.cursorStyle !== 'undefined') {
+            if (this._cursorStyle !== newOptions.cursorStyle) {
+                this._cursorStyle = newOptions.cursorStyle;
+                hasUpdate = true;
+                bulkConfigurationUpdate.cursorStyle = newOptions.cursorStyle;
+            }
+        }
+        if (typeof newOptions.lineNumbers !== 'undefined') {
+            if (this._lineNumbers !== newOptions.lineNumbers) {
+                this._lineNumbers = newOptions.lineNumbers;
+                hasUpdate = true;
+                bulkConfigurationUpdate.lineNumbers = TextEditorLineNumbersStyle.from(newOptions.lineNumbers);
+            }
+        }
+        if (hasUpdate) {
+            this._warnOnError('setOptions', this._proxy.$trySetOptions(this._id, bulkConfigurationUpdate));
+        }
+    }
+    _warnOnError(action, promise) {
+        promise.catch(err => {
+            this._logService.warn(`ExtHostTextEditorOptions '${action}' failed:'`);
+            this._logService.warn(err);
+        });
+    }
+}
+class ExtHostTextEditor {
+    constructor(id, _proxy, _logService, document, selections, options, visibleRanges, viewColumn) {
+        this.id = id;
+        this._proxy = _proxy;
+        this._logService = _logService;
+        this._disposed = false;
+        this._hasDecorationsForKey = ( new Set());
+        this._selections = selections;
+        this._options = ( new ExtHostTextEditorOptions(this._proxy, this.id, options, _logService));
+        this._visibleRanges = visibleRanges;
+        this._viewColumn = viewColumn;
+        const that = this;
+        this.value = ( Object.freeze({
+            get document() {
+                return document.value;
+            },
+            set document(_value) {
+                throw readonly('document');
+            },
+            get selection() {
+                return that._selections && that._selections[0];
+            },
+            set selection(value) {
+                if (!(value instanceof Selection)) {
+                    throw illegalArgument('selection');
+                }
+                that._selections = [value];
+                that._trySetSelection();
+            },
+            get selections() {
+                return that._selections;
+            },
+            set selections(value) {
+                if (!Array.isArray(value) || ( value.some(a => !(a instanceof Selection)))) {
+                    throw illegalArgument('selections');
+                }
+                that._selections = value;
+                that._trySetSelection();
+            },
+            get visibleRanges() {
+                return that._visibleRanges;
+            },
+            set visibleRanges(_value) {
+                throw readonly('visibleRanges');
+            },
+            get options() {
+                return that._options.value;
+            },
+            set options(value) {
+                if (!that._disposed) {
+                    that._options.assign(value);
+                }
+            },
+            get viewColumn() {
+                return that._viewColumn;
+            },
+            set viewColumn(_value) {
+                throw readonly('viewColumn');
+            },
+            edit(callback, options = { undoStopBefore: true, undoStopAfter: true }) {
+                if (that._disposed) {
+                    return Promise.reject(( new Error('TextEditor#edit not possible on closed editors')));
+                }
+                const edit = ( new TextEditorEdit(document.value, options));
+                callback(edit);
+                return that._applyEdit(edit);
+            },
+            insertSnippet(snippet, where, options = { undoStopBefore: true, undoStopAfter: true }) {
+                if (that._disposed) {
+                    return Promise.reject(( new Error('TextEditor#insertSnippet not possible on closed editors')));
+                }
+                let ranges;
+                if (!where || (Array.isArray(where) && where.length === 0)) {
+                    ranges = ( that._selections.map(range => Range$1.from(range)));
+                }
+                else if (where instanceof Position) {
+                    const { lineNumber, column } = Position$1.from(where);
+                    ranges = [{ startLineNumber: lineNumber, startColumn: column, endLineNumber: lineNumber, endColumn: column }];
+                }
+                else if (where instanceof Range) {
+                    ranges = [Range$1.from(where)];
+                }
+                else {
+                    ranges = [];
+                    for (const posOrRange of where) {
+                        if (posOrRange instanceof Range) {
+                            ranges.push(Range$1.from(posOrRange));
+                        }
+                        else {
+                            const { lineNumber, column } = Position$1.from(posOrRange);
+                            ranges.push({ startLineNumber: lineNumber, startColumn: column, endLineNumber: lineNumber, endColumn: column });
+                        }
+                    }
+                }
+                return _proxy.$tryInsertSnippet(id, document.value.version, snippet.value, ranges, options);
+            },
+            setDecorations(decorationType, ranges) {
+                const willBeEmpty = (ranges.length === 0);
+                if (willBeEmpty && !that._hasDecorationsForKey.has(decorationType.key)) {
+                    return;
+                }
+                if (willBeEmpty) {
+                    that._hasDecorationsForKey.delete(decorationType.key);
+                }
+                else {
+                    that._hasDecorationsForKey.add(decorationType.key);
+                }
+                that._runOnProxy(() => {
+                    if (isDecorationOptionsArr(ranges)) {
+                        return _proxy.$trySetDecorations(id, decorationType.key, fromRangeOrRangeWithMessage(ranges));
+                    }
+                    else {
+                        const _ranges = ( new Array(4 * ranges.length));
+                        for (let i = 0, len = ranges.length; i < len; i++) {
+                            const range = ranges[i];
+                            _ranges[4 * i] = range.start.line + 1;
+                            _ranges[4 * i + 1] = range.start.character + 1;
+                            _ranges[4 * i + 2] = range.end.line + 1;
+                            _ranges[4 * i + 3] = range.end.character + 1;
+                        }
+                        return _proxy.$trySetDecorationsFast(id, decorationType.key, _ranges);
+                    }
+                });
+            },
+            revealRange(range, revealType) {
+                that._runOnProxy(() => _proxy.$tryRevealRange(id, Range$1.from(range), (revealType || TextEditorRevealType.Default)));
+            },
+            show(column) {
+                _proxy.$tryShowEditor(id, ViewColumn.from(column));
+            },
+            hide() {
+                _proxy.$tryHideEditor(id);
+            }
+        }));
+    }
+    dispose() {
+        ok(!this._disposed);
+        this._disposed = true;
+    }
+    _acceptOptions(options) {
+        ok(!this._disposed);
+        this._options._accept(options);
+    }
+    _acceptVisibleRanges(value) {
+        ok(!this._disposed);
+        this._visibleRanges = value;
+    }
+    _acceptViewColumn(value) {
+        ok(!this._disposed);
+        this._viewColumn = value;
+    }
+    _acceptSelections(selections) {
+        ok(!this._disposed);
+        this._selections = selections;
+    }
+    async _trySetSelection() {
+        const selection = ( this._selections.map(Selection$1.from));
+        await this._runOnProxy(() => this._proxy.$trySetSelections(this.id, selection));
+        return this.value;
+    }
+    _applyEdit(editBuilder) {
+        const editData = editBuilder.finalize();
+        if (editData.edits.length === 0 && !editData.setEndOfLine) {
+            return Promise.resolve(true);
+        }
+        const editRanges = ( editData.edits.map(edit => edit.range));
+        editRanges.sort((a, b) => {
+            if (a.end.line === b.end.line) {
+                if (a.end.character === b.end.character) {
+                    if (a.start.line === b.start.line) {
+                        return a.start.character - b.start.character;
+                    }
+                    return a.start.line - b.start.line;
+                }
+                return a.end.character - b.end.character;
+            }
+            return a.end.line - b.end.line;
+        });
+        for (let i = 0, count = editRanges.length - 1; i < count; i++) {
+            const rangeEnd = editRanges[i].end;
+            const nextRangeStart = editRanges[i + 1].start;
+            if (nextRangeStart.isBefore(rangeEnd)) {
+                return Promise.reject(( new Error('Overlapping ranges are not allowed!')));
+            }
+        }
+        const edits = ( editData.edits.map((edit) => {
+            return {
+                range: Range$1.from(edit.range),
+                text: edit.text,
+                forceMoveMarkers: edit.forceMoveMarkers
+            };
+        }));
+        return this._proxy.$tryApplyEdits(this.id, editData.documentVersionId, edits, {
+            setEndOfLine: typeof editData.setEndOfLine === 'number' ? EndOfLine.from(editData.setEndOfLine) : undefined,
+            undoStopBefore: editData.undoStopBefore,
+            undoStopAfter: editData.undoStopAfter
+        });
+    }
+    _runOnProxy(callback) {
+        if (this._disposed) {
+            this._logService.warn('TextEditor is closed/disposed');
+            return Promise.resolve(undefined);
+        }
+        return callback().then(() => this, err => {
+            if (!(err instanceof Error && err.name === 'DISPOSED')) {
+                this._logService.warn(err);
+            }
+            return null;
+        });
+    }
+}
+export { ExtHostTextEditor, ExtHostTextEditorOptions, TextEditorDecorationType };

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

@@ -0,0 +1,128 @@
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MainContext } from './extHost.protocol.js';
+import { TextEditorDecorationType } from './extHostTextEditor.js';
+import { ViewColumn, Range, TextEditorLineNumbersStyle, Selection } from './extHostTypeConverters.js';
+import { TextEditorSelectionChangeKind } from './extHostTypes.js';
+class ExtHostEditors {
+    constructor(mainContext, _extHostDocumentsAndEditors) {
+        this._extHostDocumentsAndEditors = _extHostDocumentsAndEditors;
+        this._onDidChangeTextEditorSelection = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this._onDidChangeTextEditorOptions = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this._onDidChangeTextEditorVisibleRanges = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this._onDidChangeTextEditorViewColumn = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this._onDidChangeActiveTextEditor = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this._onDidChangeVisibleTextEditors = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this.onDidChangeTextEditorSelection = this._onDidChangeTextEditorSelection.event;
+        this.onDidChangeTextEditorOptions = this._onDidChangeTextEditorOptions.event;
+        this.onDidChangeTextEditorVisibleRanges = this._onDidChangeTextEditorVisibleRanges.event;
+        this.onDidChangeTextEditorViewColumn = this._onDidChangeTextEditorViewColumn.event;
+        this.onDidChangeActiveTextEditor = this._onDidChangeActiveTextEditor.event;
+        this.onDidChangeVisibleTextEditors = this._onDidChangeVisibleTextEditors.event;
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadTextEditors));
+        this._extHostDocumentsAndEditors.onDidChangeVisibleTextEditors(e => this._onDidChangeVisibleTextEditors.fire(e));
+        this._extHostDocumentsAndEditors.onDidChangeActiveTextEditor(e => this._onDidChangeActiveTextEditor.fire(e));
+    }
+    getActiveTextEditor() {
+        return this._extHostDocumentsAndEditors.activeEditor();
+    }
+    getVisibleTextEditors(internal) {
+        const editors = this._extHostDocumentsAndEditors.allEditors();
+        return internal
+            ? editors
+            : ( editors.map(editor => editor.value));
+    }
+    async showTextDocument(document, columnOrOptions, preserveFocus) {
+        let options;
+        if (typeof columnOrOptions === 'number') {
+            options = {
+                position: ViewColumn.from(columnOrOptions),
+                preserveFocus
+            };
+        }
+        else if (typeof columnOrOptions === 'object') {
+            options = {
+                position: ViewColumn.from(columnOrOptions.viewColumn),
+                preserveFocus: columnOrOptions.preserveFocus,
+                selection: typeof columnOrOptions.selection === 'object' ? Range.from(columnOrOptions.selection) : undefined,
+                pinned: typeof columnOrOptions.preview === 'boolean' ? !columnOrOptions.preview : undefined
+            };
+        }
+        else {
+            options = {
+                preserveFocus: false
+            };
+        }
+        const editorId = await this._proxy.$tryShowTextDocument(document.uri, options);
+        const editor = editorId && this._extHostDocumentsAndEditors.getEditor(editorId);
+        if (editor) {
+            return editor.value;
+        }
+        if (editorId) {
+            throw new Error(`Could NOT open editor for "${document.uri.toString()}" because another editor opened in the meantime.`);
+        }
+        else {
+            throw new Error(`Could NOT open editor for "${document.uri.toString()}".`);
+        }
+    }
+    createTextEditorDecorationType(extension, options) {
+        return ( new TextEditorDecorationType(this._proxy, extension, options)).value;
+    }
+    $acceptEditorPropertiesChanged(id, data) {
+        const textEditor = this._extHostDocumentsAndEditors.getEditor(id);
+        if (!textEditor) {
+            throw new Error('unknown text editor');
+        }
+        if (data.options) {
+            textEditor._acceptOptions(data.options);
+        }
+        if (data.selections) {
+            const selections = ( data.selections.selections.map(Selection.to));
+            textEditor._acceptSelections(selections);
+        }
+        if (data.visibleRanges) {
+            const visibleRanges = arrays.coalesce(( data.visibleRanges.map(Range.to)));
+            textEditor._acceptVisibleRanges(visibleRanges);
+        }
+        if (data.options) {
+            this._onDidChangeTextEditorOptions.fire({
+                textEditor: textEditor.value,
+                options: { ...data.options, lineNumbers: TextEditorLineNumbersStyle.to(data.options.lineNumbers) }
+            });
+        }
+        if (data.selections) {
+            const kind = TextEditorSelectionChangeKind.fromValue(data.selections.source);
+            const selections = ( data.selections.selections.map(Selection.to));
+            this._onDidChangeTextEditorSelection.fire({
+                textEditor: textEditor.value,
+                selections,
+                kind
+            });
+        }
+        if (data.visibleRanges) {
+            const visibleRanges = arrays.coalesce(( data.visibleRanges.map(Range.to)));
+            this._onDidChangeTextEditorVisibleRanges.fire({
+                textEditor: textEditor.value,
+                visibleRanges
+            });
+        }
+    }
+    $acceptEditorPositionData(data) {
+        for (const id in data) {
+            const textEditor = this._extHostDocumentsAndEditors.getEditor(id);
+            if (!textEditor) {
+                throw new Error('Unknown text editor');
+            }
+            const viewColumn = ViewColumn.to(data[id]);
+            if (textEditor.value.viewColumn !== viewColumn) {
+                textEditor._acceptViewColumn(viewColumn);
+                this._onDidChangeTextEditorViewColumn.fire({ textEditor: textEditor.value, viewColumn });
+            }
+        }
+    }
+    getDiffInformation(id) {
+        return Promise.resolve(this._proxy.$getDiffInformation(id));
+    }
+}
+export { ExtHostEditors };

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

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+const IExtHostTunnelService = ( createDecorator('IExtHostTunnelService'));
+let ExtHostTunnelService = class ExtHostTunnelService {
+    constructor(extHostRpc) {
+        this.onDidChangeTunnels = (( new Emitter())).event;
+    }
+    async $applyCandidateFilter(candidates) {
+        return candidates;
+    }
+    async openTunnel(extension, forward) {
+        return undefined;
+    }
+    async getTunnels() {
+        return [];
+    }
+    async setTunnelFactory(provider) {
+        return { dispose: () => { } };
+    }
+    registerPortsAttributesProvider(portSelector, provider) {
+        return { dispose: () => { } };
+    }
+    async $providePortAttributes(handles, ports, pid, commandline, cancellationToken) {
+        return [];
+    }
+    async $forwardPort(tunnelOptions, tunnelCreationOptions) { return undefined; }
+    async $closeTunnel(remote) { }
+    async $onDidTunnelsChange() { }
+    async $registerCandidateFinder() { }
+};
+ExtHostTunnelService = ( __decorate([
+    ( __param(0, IExtHostRpcService))
+], ExtHostTunnelService));
+export { ExtHostTunnelService, IExtHostTunnelService };