@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/base/browser/ui/splitview/paneview.js

@@ -1,6 +1,6 @@
 import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
 import { DataTransfers } from 'monaco-editor/esm/vs/base/browser/dnd.js';
-import { $, append, trackFocus, EventType, addDisposableListener, EventHelper } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { $, append, trackFocus, EventType, addDisposableListener, EventHelper, clearNode } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
 import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
@@ -9,6 +9,7 @@ import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import "../../../../../../assets/paneview.css";
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
 class Pane extends Disposable {
     get ariaHeaderLabel() {
         return this._ariaHeaderLabel;
@@ -286,4 +287,152 @@ class PaneDraggable extends Disposable {
     }
 }
 PaneDraggable.DefaultDragOverBackgroundColor = ( new Color(( new RGBA(128, 128, 128, 0.5))));
-export { Pane };
+class PaneView extends Disposable {
+    constructor(container, options = {}) {
+        super();
+        this.dndContext = { draggable: null };
+        this.paneItems = [];
+        this.orthogonalSize = 0;
+        this.size = 0;
+        this.animationTimer = undefined;
+        this._onDidDrop = this._register(( new Emitter()));
+        this.onDidDrop = this._onDidDrop.event;
+        this.dnd = options.dnd;
+        this.orientation = options.orientation ?? 0 ;
+        this.element = append(container, $('.monaco-pane-view'));
+        this.splitview = this._register(( new SplitView(this.element, { orientation: this.orientation })));
+        this.onDidSashReset = this.splitview.onDidSashReset;
+        this.onDidSashChange = this.splitview.onDidSashChange;
+        this.onDidScroll = this.splitview.onDidScroll;
+        const eventDisposables = this._register(( new DisposableStore()));
+        const onKeyDown = this._register(( new DomEmitter(this.element, 'keydown')));
+        const onHeaderKeyDown = ( Event.map(
+            Event.filter(onKeyDown.event, e => e.target instanceof HTMLElement && e.target.classList.contains('pane-header'), eventDisposables),
+            e => ( new StandardKeyboardEvent(e)),
+            eventDisposables
+        ));
+        this._register(Event.filter(onHeaderKeyDown, e => e.keyCode === 16 , eventDisposables)(() => this.focusPrevious()));
+        this._register(Event.filter(onHeaderKeyDown, e => e.keyCode === 18 , eventDisposables)(() => this.focusNext()));
+    }
+    addPane(pane, size, index = this.splitview.length) {
+        const disposables = ( new DisposableStore());
+        pane.onDidChangeExpansionState(this.setupAnimation, this, disposables);
+        const paneItem = { pane: pane, disposable: disposables };
+        this.paneItems.splice(index, 0, paneItem);
+        pane.orientation = this.orientation;
+        pane.orthogonalSize = this.orthogonalSize;
+        this.splitview.addView(pane, size, index);
+        if (this.dnd) {
+            const draggable = ( new PaneDraggable(pane, this.dnd, this.dndContext));
+            disposables.add(draggable);
+            disposables.add(draggable.onDidDrop(this._onDidDrop.fire, this._onDidDrop));
+        }
+    }
+    removePane(pane) {
+        const index = this.paneItems.findIndex(item => item.pane === pane);
+        if (index === -1) {
+            return;
+        }
+        this.splitview.removeView(index, pane.isExpanded() ? Sizing.Distribute : undefined);
+        const paneItem = this.paneItems.splice(index, 1)[0];
+        paneItem.disposable.dispose();
+    }
+    movePane(from, to) {
+        const fromIndex = this.paneItems.findIndex(item => item.pane === from);
+        const toIndex = this.paneItems.findIndex(item => item.pane === to);
+        if (fromIndex === -1 || toIndex === -1) {
+            return;
+        }
+        const [paneItem] = this.paneItems.splice(fromIndex, 1);
+        this.paneItems.splice(toIndex, 0, paneItem);
+        this.splitview.moveView(fromIndex, toIndex);
+    }
+    resizePane(pane, size) {
+        const index = this.paneItems.findIndex(item => item.pane === pane);
+        if (index === -1) {
+            return;
+        }
+        this.splitview.resizeView(index, size);
+    }
+    getPaneSize(pane) {
+        const index = this.paneItems.findIndex(item => item.pane === pane);
+        if (index === -1) {
+            return -1;
+        }
+        return this.splitview.getViewSize(index);
+    }
+    layout(height, width) {
+        this.orthogonalSize = this.orientation === 0  ? width : height;
+        this.size = this.orientation === 1  ? width : height;
+        for (const paneItem of this.paneItems) {
+            paneItem.pane.orthogonalSize = this.orthogonalSize;
+        }
+        this.splitview.layout(this.size);
+    }
+    setBoundarySashes(sashes) {
+        this.boundarySashes = sashes;
+        this.updateSplitviewOrthogonalSashes(sashes);
+    }
+    updateSplitviewOrthogonalSashes(sashes) {
+        if (this.orientation === 0 ) {
+            this.splitview.orthogonalStartSash = sashes?.left;
+            this.splitview.orthogonalEndSash = sashes?.right;
+        }
+        else {
+            this.splitview.orthogonalEndSash = sashes?.bottom;
+        }
+    }
+    flipOrientation(height, width) {
+        this.orientation = this.orientation === 0  ? 1  : 0 ;
+        const paneSizes = ( this.paneItems.map(pane => this.getPaneSize(pane.pane)));
+        this.splitview.dispose();
+        clearNode(this.element);
+        this.splitview = this._register(( new SplitView(this.element, { orientation: this.orientation })));
+        this.updateSplitviewOrthogonalSashes(this.boundarySashes);
+        const newOrthogonalSize = this.orientation === 0  ? width : height;
+        const newSize = this.orientation === 1  ? width : height;
+        this.paneItems.forEach((pane, index) => {
+            pane.pane.orthogonalSize = newOrthogonalSize;
+            pane.pane.orientation = this.orientation;
+            const viewSize = this.size === 0 ? 0 : (newSize * paneSizes[index]) / this.size;
+            this.splitview.addView(pane.pane, viewSize, index);
+        });
+        this.size = newSize;
+        this.orthogonalSize = newOrthogonalSize;
+        this.splitview.layout(this.size);
+    }
+    setupAnimation() {
+        if (typeof this.animationTimer === 'number') {
+            window.clearTimeout(this.animationTimer);
+        }
+        this.element.classList.add('animated');
+        this.animationTimer = window.setTimeout(() => {
+            this.animationTimer = undefined;
+            this.element.classList.remove('animated');
+        }, 200);
+    }
+    getPaneHeaderElements() {
+        return [...this.element.querySelectorAll('.pane-header')];
+    }
+    focusPrevious() {
+        const headers = this.getPaneHeaderElements();
+        const index = headers.indexOf(document.activeElement);
+        if (index === -1) {
+            return;
+        }
+        headers[Math.max(index - 1, 0)].focus();
+    }
+    focusNext() {
+        const headers = this.getPaneHeaderElements();
+        const index = headers.indexOf(document.activeElement);
+        if (index === -1) {
+            return;
+        }
+        headers[Math.min(index + 1, headers.length - 1)].focus();
+    }
+    dispose() {
+        super.dispose();
+        this.paneItems.forEach(i => i.disposable.dispose());
+    }
+}
+export { Pane, PaneView };

package/dist/vscode/vs/base/browser/ui/tree/treeDefaults.js

@@ -0,0 +1,14 @@
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+class CollapseAllAction extends Action {
+    constructor(viewer, enabled) {
+        super('vs.tree.collapse', ( nls.localize('collapse all', "Collapse All")), 'collapse-all', enabled);
+        this.viewer = viewer;
+    }
+    async run() {
+        this.viewer.collapseAll();
+        this.viewer.setSelection([]);
+        this.viewer.setFocus([]);
+    }
+}
+export { CollapseAllAction };

package/dist/vscode/vs/platform/backup/common/backup.js

@@ -0,0 +1,7 @@
+function isFolderBackupInfo(curr) {
+    return curr && curr.hasOwnProperty('folderUri');
+}
+function isWorkspaceBackupInfo(curr) {
+    return curr && curr.hasOwnProperty('workspace');
+}
+export { isFolderBackupInfo, isWorkspaceBackupInfo };

package/dist/vscode/vs/platform/configuration/common/configurationRegistry.js

@@ -0,0 +1,10 @@
+var ConfigurationScope;
+( (function(ConfigurationScope) {
+    ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
+    ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
+    ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
+    ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
+    ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
+    ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
+})(ConfigurationScope || (ConfigurationScope = {})));
+export { ConfigurationScope };

package/dist/vscode/vs/platform/credentials/common/credentials.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ICredentialsService = ( createDecorator('credentialsService'));
+export { ICredentialsService };

package/dist/vscode/vs/platform/extensionManagement/common/extensionManagementUtil.js

@@ -11,4 +11,7 @@ function areSameExtensions(a, b) {
 function getExtensionId(publisher, name) {
     return `${publisher}.${name}`;
 }
-export { areSameExtensions, getExtensionId };
+function adoptToGalleryExtensionId(id) {
+    return id.toLowerCase();
+}
+export { adoptToGalleryExtensionId, areSameExtensions, getExtensionId };

package/dist/vscode/vs/platform/extensionManagement/common/extensionStorage.js

@@ -0,0 +1,174 @@
+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 { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { adoptToGalleryExtensionId, areSameExtensions, getExtensionId } from './extensionManagementUtil.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+const IExtensionStorageService = ( createDecorator('IExtensionStorageService'));
+const EXTENSION_KEYS_ID_VERSION_REGEX = /^extensionKeys\/([^.]+\..+)@(\d+\.\d+\.\d+(-.*)?)$/;
+let ExtensionStorageService = class ExtensionStorageService extends Disposable {
+    static toKey(extension) {
+        return `extensionKeys/${adoptToGalleryExtensionId(extension.id)}@${extension.version}`;
+    }
+    static fromKey(key) {
+        const matches = EXTENSION_KEYS_ID_VERSION_REGEX.exec(key);
+        if (matches && matches[1]) {
+            return { id: matches[1], version: matches[2] };
+        }
+        return undefined;
+    }
+    static async removeOutdatedExtensionVersions(extensionManagementService, storageService) {
+        const extensions = await extensionManagementService.getInstalled();
+        const extensionVersionsToRemove = [];
+        for (const [id, versions] of ExtensionStorageService.readAllExtensionsWithKeysForSync(storageService)) {
+            const extensionVersion = extensions.find(e => areSameExtensions(e.identifier, { id }))?.manifest.version;
+            for (const version of versions) {
+                if (extensionVersion !== version) {
+                    extensionVersionsToRemove.push(ExtensionStorageService.toKey({ id, version }));
+                }
+            }
+        }
+        for (const key of extensionVersionsToRemove) {
+            storageService.remove(key, 0 );
+        }
+    }
+    static readAllExtensionsWithKeysForSync(storageService) {
+        const extensionsWithKeysForSync = ( new Map());
+        const keys = ( storageService.keys(0 , 1 ));
+        for (const key of keys) {
+            const extensionIdWithVersion = ExtensionStorageService.fromKey(key);
+            if (extensionIdWithVersion) {
+                let versions = extensionsWithKeysForSync.get(extensionIdWithVersion.id.toLowerCase());
+                if (!versions) {
+                    extensionsWithKeysForSync.set(extensionIdWithVersion.id.toLowerCase(), versions = []);
+                }
+                versions.push(extensionIdWithVersion.version);
+            }
+        }
+        return extensionsWithKeysForSync;
+    }
+    constructor(storageService, productService, logService) {
+        super();
+        this.storageService = storageService;
+        this.productService = productService;
+        this.logService = logService;
+        this._onDidChangeExtensionStorageToSync = this._register(( new Emitter()));
+        this.onDidChangeExtensionStorageToSync = this._onDidChangeExtensionStorageToSync.event;
+        this.extensionsWithKeysForSync = ExtensionStorageService.readAllExtensionsWithKeysForSync(storageService);
+        this._register(this.storageService.onDidChangeValue(e => this.onDidChangeStorageValue(e)));
+    }
+    onDidChangeStorageValue(e) {
+        if (e.scope !== 0 ) {
+            return;
+        }
+        if (( this.extensionsWithKeysForSync.has(e.key.toLowerCase()))) {
+            this._onDidChangeExtensionStorageToSync.fire();
+            return;
+        }
+        const extensionIdWithVersion = ExtensionStorageService.fromKey(e.key);
+        if (extensionIdWithVersion) {
+            if (this.storageService.get(e.key, 0 ) === undefined) {
+                this.extensionsWithKeysForSync.delete(extensionIdWithVersion.id.toLowerCase());
+            }
+            else {
+                let versions = this.extensionsWithKeysForSync.get(extensionIdWithVersion.id.toLowerCase());
+                if (!versions) {
+                    this.extensionsWithKeysForSync.set(extensionIdWithVersion.id.toLowerCase(), versions = []);
+                }
+                versions.push(extensionIdWithVersion.version);
+                this._onDidChangeExtensionStorageToSync.fire();
+            }
+            return;
+        }
+    }
+    getExtensionId(extension) {
+        if (isString(extension)) {
+            return extension;
+        }
+        const publisher = extension.manifest ? extension.manifest.publisher : extension.publisher;
+        const name = extension.manifest ? extension.manifest.name : extension.name;
+        return getExtensionId(publisher, name);
+    }
+    getExtensionState(extension, global) {
+        const extensionId = this.getExtensionId(extension);
+        const jsonValue = this.getExtensionStateRaw(extension, global);
+        if (jsonValue) {
+            try {
+                return JSON.parse(jsonValue);
+            }
+            catch (error) {
+                this.logService.error(`[mainThreadStorage] unexpected error parsing storage contents (extensionId: ${extensionId}, global: ${global}): ${error}`);
+            }
+        }
+        return undefined;
+    }
+    getExtensionStateRaw(extension, global) {
+        const extensionId = this.getExtensionId(extension);
+        const rawState = this.storageService.get(extensionId, global ? 0  : 1 );
+        if (rawState && rawState?.length > ExtensionStorageService.LARGE_STATE_WARNING_THRESHOLD) {
+            this.logService.warn(`[mainThreadStorage] large extension state detected (extensionId: ${extensionId}, global: ${global}): ${rawState.length / 1024}kb. Consider to use 'storageUri' or 'globalStorageUri' to store this data on disk instead.`);
+        }
+        return rawState;
+    }
+    setExtensionState(extension, state, global) {
+        const extensionId = this.getExtensionId(extension);
+        if (state === undefined) {
+            this.storageService.remove(extensionId, global ? 0  : 1 );
+        }
+        else {
+            this.storageService.store(extensionId, JSON.stringify(state), global ? 0  : 1 , 1 );
+        }
+    }
+    setKeysForSync(extensionIdWithVersion, keys) {
+        this.storageService.store(ExtensionStorageService.toKey(extensionIdWithVersion), JSON.stringify(keys), 0 , 1 );
+    }
+    getKeysForSync(extensionIdWithVersion) {
+        const extensionKeysForSyncFromProduct = this.productService.extensionSyncedKeys?.[extensionIdWithVersion.id.toLowerCase()];
+        const extensionKeysForSyncFromStorageValue = this.storageService.get(ExtensionStorageService.toKey(extensionIdWithVersion), 0 );
+        const extensionKeysForSyncFromStorage = extensionKeysForSyncFromStorageValue ? JSON.parse(extensionKeysForSyncFromStorageValue) : undefined;
+        return extensionKeysForSyncFromStorage && extensionKeysForSyncFromProduct
+            ? distinct([...extensionKeysForSyncFromStorage, ...extensionKeysForSyncFromProduct])
+            : (extensionKeysForSyncFromStorage || extensionKeysForSyncFromProduct);
+    }
+    addToMigrationList(from, to) {
+        if (from !== to) {
+            const migrationList = this.migrationList.filter(entry => !entry.includes(from) && !entry.includes(to));
+            migrationList.push([from, to]);
+            this.migrationList = migrationList;
+        }
+    }
+    getSourceExtensionToMigrate(toExtensionId) {
+        const entry = this.migrationList.find(([, to]) => toExtensionId === to);
+        return entry ? entry[0] : undefined;
+    }
+    get migrationList() {
+        const value = this.storageService.get('extensionStorage.migrationList', -1 , '[]');
+        try {
+            const migrationList = JSON.parse(value);
+            if (Array.isArray(migrationList)) {
+                return migrationList;
+            }
+        }
+        catch (error) {  }
+        return [];
+    }
+    set migrationList(migrationList) {
+        if (migrationList.length) {
+            this.storageService.store('extensionStorage.migrationList', JSON.stringify(migrationList), -1 , 1 );
+        }
+        else {
+            this.storageService.remove('extensionStorage.migrationList', -1 );
+        }
+    }
+};
+ExtensionStorageService.LARGE_STATE_WARNING_THRESHOLD = 512 * 1024;
+ExtensionStorageService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IProductService)),
+    ( __param(2, ILogService))
+], ExtensionStorageService));
+export { ExtensionStorageService, IExtensionStorageService };

package/dist/vscode/vs/platform/files/common/fileService.js

@@ -444,17 +444,8 @@ let FileService = class FileService extends Disposable {
         return stat;
     }
     validateReadFileLimits(resource, size, options) {
-        if (options?.limits) {
-            let tooLargeErrorResult = undefined;
-            if (typeof options.limits.memory === 'number' && size > options.limits.memory) {
-                tooLargeErrorResult = 9 ;
-            }
-            if (typeof options.limits.size === 'number' && size > options.limits.size) {
-                tooLargeErrorResult = 7 ;
-            }
-            if (typeof tooLargeErrorResult === 'number') {
-                throw new TooLargeFileOperationError(localize('fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), tooLargeErrorResult, size, options);
-            }
+        if (typeof options?.limits?.size === 'number' && size > options.limits.size) {
+            throw new TooLargeFileOperationError(localize('fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), 7 , size, options);
         }
     }
     async canMove(source, target, overwrite) {

package/dist/vscode/vs/platform/files/common/files.js

@@ -0,0 +1,28 @@
+var FileType;
+( (function(FileType) {
+    FileType[FileType["Unknown"] = 0] = "Unknown";
+    FileType[FileType["File"] = 1] = "File";
+    FileType[FileType["Directory"] = 2] = "Directory";
+    FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+})(FileType || (FileType = {})));
+var FileSystemProviderCapabilities;
+( (function(FileSystemProviderCapabilities) {
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["None"] = 0] = "None";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadWrite"] = 2] = "FileReadWrite";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileOpenReadWriteClose"] = 4] = "FileOpenReadWriteClose";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadStream"] = 16] = "FileReadStream";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileFolderCopy"] = 8] = "FileFolderCopy";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["PathCaseSensitive"] = 1024] = "PathCaseSensitive";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Readonly"] = 2048] = "Readonly";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileWriteUnlock"] = 8192] = "FileWriteUnlock";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicRead"] = 16384] = "FileAtomicRead";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 32768] = "FileClone";
+})(FileSystemProviderCapabilities || (FileSystemProviderCapabilities = {})));
+var FileChangeType;
+( (function(FileChangeType) {
+    FileChangeType[FileChangeType["UPDATED"] = 0] = "UPDATED";
+    FileChangeType[FileChangeType["ADDED"] = 1] = "ADDED";
+    FileChangeType[FileChangeType["DELETED"] = 2] = "DELETED";
+})(FileChangeType || (FileChangeType = {})));
+export { FileChangeType, FileSystemProviderCapabilities, FileType };

package/dist/vscode/vs/platform/files/common/io.js

@@ -67,13 +67,8 @@ function throwIfCancelled(token) {
     return true;
 }
 function throwIfTooLarge(totalBytesRead, options) {
-    if (options?.limits) {
-        if (typeof options.limits.memory === 'number' && totalBytesRead > options.limits.memory) {
-            throw createFileSystemProviderError(localize('fileTooLargeForHeapError', "To open a file of this size, you need to restart and allow to use more memory"), FileSystemProviderErrorCode.FileExceedsMemoryLimit);
-        }
-        if (typeof options.limits.size === 'number' && totalBytesRead > options.limits.size) {
-            throw createFileSystemProviderError(localize('fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
-        }
+    if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
+        throw createFileSystemProviderError(localize('fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

package/dist/vscode/vs/platform/languagePacks/common/languagePacks.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ILanguagePackService = ( createDecorator('languagePackService'));
+export { ILanguagePackService };

package/dist/vscode/vs/platform/remote/common/remoteAuthorityResolver.js

@@ -1,3 +1,5 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IRemoteAuthorityResolverService = ( createDecorator('remoteAuthorityResolverService'));
 var RemoteAuthorityResolverErrorCode;
 ( (function(RemoteAuthorityResolverErrorCode) {
     RemoteAuthorityResolverErrorCode["Unknown"] = "Unknown";
@@ -14,4 +16,4 @@ function getRemoteAuthorityPrefix(remoteAuthority) {
     }
     return remoteAuthority.substring(0, plusIndex);
 }
-export { RemoteAuthorityResolverErrorCode, getRemoteAuthorityPrefix };
+export { IRemoteAuthorityResolverService, RemoteAuthorityResolverErrorCode, getRemoteAuthorityPrefix };