@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.6

package/dist/extensions.d.ts

@@ -840,19 +840,6 @@ interface ITranslations {
     } | undefined;
 }
 
-/**
- * Represents the source code (module) of an extension.
- */
-interface IExtensionModule {
-    activate?(ctx: vscode.ExtensionContext): Promise<IExtensionAPI>;
-    deactivate?(): void;
-}
-/**
- * Represents the API of an extension (return value of `activate`).
- */
-interface IExtensionAPI {
-}
-
 declare const onExtHostInitialized: Event<void>;
 
 declare function consoleExtensionMessageHandler(msg: IMessage): void;
@@ -861,12 +848,9 @@ declare function initialize(extension?: IExtensionDescription): Promise<void>;
 declare function createApi(extension: IExtensionDescription): typeof vscode;
 interface RegisterExtensionResult extends IDisposable {
     api: typeof vscode;
-    runCode(): Promise<void>;
-    registerFile: (path: string, getContent: () => Promise<Uint8Array | string>) => IDisposable;
-    registerSyncFile: (path: string, content: Uint8Array | string) => IDisposable;
+    registerFile: (path: string, getContent: () => Promise<string>) => IDisposable;
     dispose(): void;
 }
-declare function runExtensionCode(api: typeof vscode, code: string): IExtensionModule;
 declare function registerExtension(manifest: IExtensionManifest, defaultNLS?: ITranslations): RegisterExtensionResult;
 
-export { IExtensionContributions, IExtensionManifest, ITranslations, consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, onExtHostInitialized, registerExtension, runExtensionCode };
+export { IExtensionContributions, IExtensionManifest, ITranslations, consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, onExtHostInitialized, registerExtension };

package/dist/extensions.js

@@ -11,15 +11,8 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { localizeManifest } from './vscode/vs/platform/extensionManagement/common/extensionNls.js';
-import { joinPath, originalFSPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
-import { ExtensionMode, ExtensionKind } from './vscode/vs/workbench/api/common/extHostTypes.js';
-import { ExtensionGlobalMemento, ExtensionMemento } from './vscode/vs/workbench/api/common/extHostMemento.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import * as api from './api.js';
 import { registerExtensionFile } from './service-override/files.js';
-import create$7 from './vscode-services/l10n.js';
 import create$6 from './vscode-services/languages.js';
 import create$3 from './vscode-services/commands.js';
 import create$5 from './vscode-services/workspace.js';
@@ -27,9 +20,8 @@ import create$4 from './vscode-services/window.js';
 import create$2 from './vscode-services/env.js';
 import create$1 from './vscode-services/debug.js';
 import create from './vscode-services/extensions.js';
-import { initialize as initialize$1, getExtHostServices } from './vscode-services/extHost.js';
+import { initialize as initialize$1 } from './vscode-services/extHost.js';
 export { onExtHostInitialized } from './vscode-services/extHost.js';
-import { unsupported } from './tools.js';
 function consoleExtensionMessageHandler(msg) {
     if (msg.type === Severity.Error) {
         console.error(msg);
@@ -88,8 +80,7 @@ function createApi(extension) {
         commands: create$3(() => extension),
         window: create$4(() => extension, workspace),
         workspace: create$5(() => extension),
-        languages: create$6(() => extension),
-        l10n: create$7(() => extension)
+        languages: create$6(() => extension)
     };
 }
 const hasOwnProperty = Object.hasOwnProperty;
@@ -127,73 +118,6 @@ function deltaExtensions(toAdd, toRemove) {
         }
     });
 }
-const extensionFileBlobUrls = new Map();
-function registerExtensionFileBlob(extensionLocation, filePath, content, mimeType) {
-    const blob = new Blob([content instanceof Uint8Array ? content : new TextEncoder().encode(content)], {
-        type: mimeType
-    });
-    extensionFileBlobUrls.set(( joinPath(extensionLocation, filePath).toString()), URL.createObjectURL(blob));
-}
-const original = FileAccess.uriToBrowserUri;
-FileAccess.uriToBrowserUri = function (uri) {
-    if (uri.scheme === 'extension') {
-        const extensionFile = extensionFileBlobUrls.get(( uri.toString()));
-        if (extensionFile != null) {
-            return ( URI.parse(extensionFile));
-        }
-    }
-    return original.call(this, uri);
-};
-async function createExtensionContext(extensionDescription) {
-    const { extHostStorage, extHostInitData } = getExtHostServices();
-    const globalState = new ExtensionGlobalMemento(extensionDescription, extHostStorage);
-    const workspaceState = new ExtensionMemento(extensionDescription.identifier.value, false, extHostStorage);
-    await Promise.all([
-        globalState.whenReady,
-        workspaceState.whenReady
-    ]);
-    return {
-        globalState,
-        workspaceState,
-        get secrets() { return unsupported(); },
-        subscriptions: [],
-        get extensionUri() { return extensionDescription.extensionLocation; },
-        get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
-        asAbsolutePath(relativePath) { return path.join(extensionDescription.extensionLocation.fsPath, relativePath); },
-        get storagePath() { return unsupported(); },
-        get globalStoragePath() { return unsupported(); },
-        get logPath() { return path.join(extHostInitData.logsLocation.fsPath, extensionDescription.identifier.value); },
-        get logUri() { return URI.joinPath(extHostInitData.logsLocation, extensionDescription.identifier.value); },
-        get storageUri() { return unsupported(); },
-        get globalStorageUri() { return unsupported(); },
-        extensionMode: ExtensionMode.Production,
-        extension: {
-            activate: unsupported,
-            id: extensionDescription.identifier.value,
-            extensionUri: extensionDescription.extensionLocation,
-            extensionPath: path.normalize(originalFSPath(extensionDescription.extensionLocation)),
-            isActive: true,
-            packageJSON: extensionDescription,
-            extensionKind: ExtensionKind.UI,
-            exports: null
-        },
-        get environmentVariableCollection() { return unsupported(); }
-    };
-}
-function runExtensionCode(api, code) {
-    const initFn = new Function('module', 'exports', 'require', code);
-    const _exports = {};
-    const _module = { exports: _exports };
-    const _require = (request) => {
-        if (request === 'vscode') {
-            return api;
-        }
-        throw new Error(`Cannot load module '${request}'`);
-    };
-    initFn(_module, _exports, _require);
-    const module = (_module.exports !== _exports ? _module.exports : _exports);
-    return module;
-}
 function registerExtension(manifest, defaultNLS) {
     const uuid = generateUuid();
     const location = ( URI.from({ scheme: 'extension', path: `/${uuid}` }));
@@ -213,33 +137,14 @@ function registerExtension(manifest, defaultNLS) {
     };
     const extensionDescription = toExtensionDescription(extension);
     deltaExtensions([extensionDescription], []);
-    const api = createApi(extensionDescription);
     return {
-        api,
-        async runCode() {
-            if (extension.manifest.browser == null) {
-                return;
-            }
-            let module = joinPath(location, extension.manifest.browser);
-            module = module.with({ path: ensureSuffix(module.path, '.js') });
-            const content = ( (await StandaloneServices.get(IFileService).readFile(module)).value.toString());
-            const extensionModule = runExtensionCode(api, content);
-            const context = await createExtensionContext(extensionDescription);
-            await extensionModule.activate?.(context);
-        },
+        api: createApi(extensionDescription),
         registerFile: (path, getContent) => {
             return registerExtensionFile(location, path, getContent);
         },
-        registerSyncFile: (path, content, mimeType) => {
-            registerExtensionFileBlob(location, path, content, mimeType);
-            return registerExtensionFile(location, path, async () => content);
-        },
         dispose() {
             deltaExtensions([], [extensionDescription]);
         }
     };
 }
-function ensureSuffix(path, suffix) {
-    return path.endsWith(suffix) ? path : path + suffix;
-}
-export { consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, registerExtension, runExtensionCode };
+export { consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, registerExtension };

package/dist/rollup-extension-directory-plugin.d.ts

@@ -1,13 +1,10 @@
 import { FilterPattern } from '@rollup/pluginutils';
-import { Plugin, InputPluginOption } from 'rollup';
+import { Plugin } from 'rollup';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
-    isDefaultExtension?: boolean;
-    withCode?: (extensionPath: string) => boolean;
-    rollupPlugins: InputPluginOption[];
 }
-declare function plugin({ include, exclude, isDefaultExtension, withCode, rollupPlugins }: Options): Plugin;
+declare function plugin(options: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-extension-directory-plugin.js

@@ -1,19 +1,11 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
-import { p as parseJson, l as localizeManifest, b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-40a69515.js';
+import { e as extractPathsFromExtensionManifest, p as parseJson, l as localizeManifest } from './extension-tools-b68a64de.js';
 import * as path from 'path';
 import * as fsPromise from 'fs/promises';
-import * as require$$0$1 from 'fs';
-import 'util';
-import 'node:path';
-import 'node:process';
-import 'node:perf_hooks';
-import 'node:crypto';
-import 'node:fs/promises';
-import 'node:events';
-import 'tty';
+import * as fs from 'fs';
 
-function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins }) {
-    const filter = createFilter(include, exclude);
+function plugin(options) {
+    const filter = createFilter(options.include, options.exclude);
     return {
         name: 'default-extensions-loader',
         resolveId(source) {
@@ -27,15 +19,47 @@ function plugin({ include, exclude, isDefaultExtension = false, withCode = () =>
             if (!filter(id)) {
                 return;
             }
-            // Load extension resources
+            // load extension directory as a module that loads the extension
+            const stat = await fsPromise.stat(id);
+            if (!stat.isDirectory()) {
+                return;
+            }
+            const manifestPath = path.resolve(id, 'package.json');
+            const manifest = JSON.parse((await fsPromise.readFile(manifestPath)).toString('utf8'));
+            try {
+                const filePaths = extractPathsFromExtensionManifest(manifest);
+                return `
+import manifest from '${manifestPath}'
+import { registerExtension } from '../src/extensions'
+import { onExtHostInitialized } from '../src/vscode-services/extHost'
+onExtHostInitialized(() => {
+const { registerFile } = registerExtension(manifest)
+${filePaths.map(filePath => (`
+registerFile('${filePath}', async () => await import('${path.resolve(id, filePath)}'))`))}
+})
+      `;
+            }
+            catch (err) {
+                console.error(err, err.stack);
+                throw err;
+            }
+        },
+        async transform(code, id) {
+            if (!filter(id)) {
+                return code;
+            }
+            const stat = await fsPromise.stat(id);
+            if (stat.isDirectory()) {
+                return code;
+            }
             const basename = path.basename(id);
             if (basename === 'package.json') {
-                const content = await fsPromise.readFile(id);
-                let parsed = parseJson(id, content.toString('utf-8'));
+                let parsed = parseJson(id, code);
                 const nlsFile = path.resolve(path.dirname(id), 'package.nls.json');
-                if (require$$0$1.existsSync(nlsFile)) {
+                if (fs.existsSync(nlsFile)) {
                     parsed = localizeManifest(parsed, parseJson(id, (await fsPromise.readFile(nlsFile)).toString()));
                 }
+                // Load extension package.json and package.nls.json as a json
                 return {
                     code: dataToEsm(parsed, {
                         compact: true,
@@ -44,65 +68,13 @@ function plugin({ include, exclude, isDefaultExtension = false, withCode = () =>
                     })
                 };
             }
-            const extensionResourceMatch = /^(.*)\.extensionResource$/.exec(id);
-            if (extensionResourceMatch != null) {
-                const resourcePath = extensionResourceMatch[1];
-                if (resourcePath.endsWith('.js')) {
-                    const code = await buildExtensionCode(resourcePath, rollupPlugins);
-                    return {
-                        code: `export default ${JSON.stringify(code)};`,
-                        map: { mappings: '' }
-                    };
-                }
-                const content = await fsPromise.readFile(resourcePath);
-                if (isBinaryFileSync_1(content)) {
-                    return {
-                        code: `export default Uint8Array.from(window.atob(${JSON.stringify(content.toString('base64'))}), v => v.charCodeAt(0));`,
-                        map: { mappings: '' }
-                    };
-                }
-                else {
-                    return {
-                        code: `export default ${JSON.stringify(compressResource(id, content.toString('utf-8')))};`,
-                        map: { mappings: '' }
-                    };
-                }
-            }
-            // load extension directory as a module that loads the extension
-            const stat = await fsPromise.stat(id);
-            if (stat.isDirectory()) {
-                // Load the extension directory as a module importing the required files and registering the extension
-                const manifestPath = path.resolve(id, 'package.json');
-                const manifest = JSON.parse((await fsPromise.readFile(manifestPath)).toString('utf8'));
-                try {
-                    const extensionResources = await extractResourcesFromExtensionManifest(manifest, async (resourcePath) => {
-                        return (await fsPromise.readFile(path.join(id, resourcePath)));
-                    });
-                    const syncPaths = extensionResources.filter(resource => resource.sync).map(r => r.path);
-                    const asyncPaths = extensionResources.filter(resource => !resource.sync).map(r => r.path);
-                    return `
-import manifest from '${manifestPath}'
-import { registerExtension, onExtHostInitialized } from '${isDefaultExtension ? '../src/extensions' : 'vscode/extensions'}'
-${syncPaths.map((resourcePath, index) => (`
-import resource_${index} from '${path.resolve(id, resourcePath)}.extensionResource'`)).join('\n')}
-
-onExtHostInitialized(() => {
-  const { registerFile, registerSyncFile, runCode } = registerExtension(manifest)
-${asyncPaths.map(resourcePath => (`
-  registerFile('${resourcePath}', async () => await import('${path.resolve(id, resourcePath)}.extensionResource'))`)).join('\n')}
-${syncPaths.map((resourcePath, index) => (`
-  registerSyncFile('${resourcePath}', resource_${index}, '${mimeTypes.lookup(resourcePath)}')`)).join('\n')}
-
-  ${withCode(id) ? '  runCode()' : ''}
-})
-        `;
-                }
-                catch (err) {
-                    console.error(err, err.stack);
-                    throw err;
-                }
+            else {
+                // transform extension files to strings
+                return {
+                    code: `export default ${JSON.stringify(code)};`,
+                    map: { mappings: '' }
+                };
             }
-            return undefined;
         }
     };
 }

package/dist/rollup-vsix-plugin.d.ts

@@ -1,12 +1,10 @@
 import { FilterPattern } from '@rollup/pluginutils';
-import { Plugin, InputPluginOption } from 'rollup';
+import { Plugin } from 'rollup';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
-    withCode?: (extensionPath: string) => boolean;
-    rollupPlugins: InputPluginOption[];
 }
-declare function plugin({ include, exclude, rollupPlugins, withCode }: Options): Plugin;
+declare function plugin(options?: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-vsix-plugin.js

@@ -1,16 +1,7 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
 import * as yauzl from 'yauzl';
-import { b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, p as parseJson, l as localizeManifest, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-40a69515.js';
+import { p as parseJson, l as localizeManifest, e as extractPathsFromExtensionManifest } from './extension-tools-b68a64de.js';
 import * as path from 'path';
-import 'fs';
-import 'util';
-import 'node:path';
-import 'node:process';
-import 'node:perf_hooks';
-import 'node:crypto';
-import 'node:fs/promises';
-import 'node:events';
-import 'tty';
 
 function read(stream) {
     const bufs = [];
@@ -51,11 +42,11 @@ async function readVsix(file) {
         });
     });
 }
-function getVsixPath(file) {
-    return path.relative('/', path.resolve('/', file));
-}
-function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () => true }) {
-    const filter = createFilter(include, exclude);
+const defaultOptions = {
+    include: '**/*.vsix'
+};
+function plugin(options = defaultOptions) {
+    const filter = createFilter(options.include, options.exclude);
     const vsixFiles = {};
     return {
         name: 'vsix-loader',
@@ -69,34 +60,12 @@ function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () =
             return undefined;
         },
         async load(id) {
-            const rawMatch = /^vsix:(.*):(.*)\.raw$/.exec(id);
+            const rawMatch = /vsix:(.*):(.*)\.raw/.exec(id);
             if (rawMatch != null) {
-                const vsixFile = vsixFiles[rawMatch[1]];
-                const resourcePath = rawMatch[2];
-                if (resourcePath.endsWith('.js')) {
-                    const code = await buildExtensionCode(resourcePath, rollupPlugins, async (resourcePath) => {
-                        return vsixFile[getVsixPath(resourcePath)]?.toString('utf-8') ?? 'export default ""';
-                    });
-                    return {
-                        code: `export default ${JSON.stringify(code)};`,
-                        map: { mappings: '' }
-                    };
-                }
-                const content = vsixFile[resourcePath];
-                if (isBinaryFileSync_1(content)) {
-                    return {
-                        code: `export default Uint8Array.from(window.atob(${JSON.stringify(content.toString('base64'))}), v => v.charCodeAt(0));`,
-                        map: { mappings: '' }
-                    };
-                }
-                else {
-                    return {
-                        code: `export default ${JSON.stringify(compressResource(id, content.toString('utf-8')))};`,
-                        map: { mappings: '' }
-                    };
-                }
+                const content = vsixFiles[rawMatch[1]][rawMatch[2]].toString('utf8');
+                return `export default ${JSON.stringify(content)};`;
             }
-            const match = /^vsix:(.*):(.*)\.vsjson$/.exec(id);
+            const match = /vsix:(.*):(.*)\.vsjson/.exec(id);
             if (match != null) {
                 const file = match[2];
                 const vsixFile = vsixFiles[match[1]];
@@ -116,32 +85,25 @@ function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () =
                 return null;
             const files = await readVsix(id);
             const manifest = parseJson(id, files['package.json'].toString('utf8'));
-            const extensionResources = (await extractResourcesFromExtensionManifest(manifest, async (path) => {
-                return files[getVsixPath(path)];
-            })).filter(resource => getVsixPath(resource.path) in files);
-            const vsixFile = Object.keys(files).reduce((acc, usedFile) => {
+            function getVsixPath(file) {
+                return path.relative('/', path.resolve('/', file));
+            }
+            const usedFiles = extractPathsFromExtensionManifest(manifest).filter(file => getVsixPath(file) in files);
+            const allFiles = ['package.json', 'package.nls.json', ...usedFiles].filter(file => getVsixPath(file) in files);
+            const vsixFile = allFiles.reduce((acc, usedFile) => {
                 return ({
                     ...acc,
                     [usedFile]: files[getVsixPath(usedFile)]
                 });
             }, {});
             vsixFiles[id] = vsixFile;
-            const syncPaths = extensionResources.filter(resource => resource.sync).map(r => r.path);
-            const asyncPaths = extensionResources.filter(resource => !resource.sync).map(r => r.path);
             return `
 import manifest from 'vsix:${id}:package.json.vsjson'
 import { registerExtension, onExtHostInitialized } from 'vscode/extensions'
-${syncPaths.map((resourcePath, index) => (`
-import resource_${index} from 'vsix:${id}:${resourcePath}.raw'`)).join('\n')}
-
 onExtHostInitialized(() => {
-  const { registerFile, registerSyncFile, runCode } = registerExtension(manifest)
-${asyncPaths.map((filePath) => (`
-  registerFile('${filePath}', async () => (await import('vsix:${id}:${filePath}.raw')).default)`)).join('\n')}
-${syncPaths.map((resourcePath, index) => (`
-  registerSyncFile('${resourcePath}', resource_${index}, '${mimeTypes.lookup(resourcePath)}')`)).join('\n')}
-
-${withCode(id) ? '  runCode()' : ''}
+  const { registerFile } = registerExtension(manifest)
+${usedFiles.map((filePath) => (`
+  registerFile('${filePath}', async () => (await import('vsix:${id}:${filePath}.raw')).default)`))}
 })
 `;
         }

package/dist/service-override/configuration.js

@@ -6,7 +6,6 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
 import { TextResourceConfigurationService } from '../vscode/vs/editor/common/services/textResourceConfigurationService.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-export { ConfigurationScope } from '../vscode/vs/platform/configuration/common/configurationRegistry.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
@@ -32,7 +31,7 @@ import { AbstractWorkspaceEditingService } from '../vscode/vs/workbench/services
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import '../vscode/vs/workbench/api/common/configurationExtensionPoint.js';
 import getServiceOverride$1 from './files.js';
-import { memoizedConstructor, unsupported } from '../tools.js';
+import { memoizedConstructor } from '../tools.js';
 import { registerServiceInitializeParticipant } from '../services.js';
 async function updateUserConfiguration(configurationJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
@@ -68,32 +67,21 @@ InjectedConfigurationService = __decorate([
     ( __param(7, IPolicyService))
 ], InjectedConfigurationService);
 class MonacoWorkspaceEditingService extends AbstractWorkspaceEditingService {
-    constructor() {
-        super(...arguments);
-        this.enterWorkspace = unsupported;
+    async enterWorkspace() {
     }
 }
 let _defaultWorkspaceUri = URI.file('/workspace');
 registerServiceInitializeParticipant(async (accessor) => {
     const workspaceService = accessor.get(IWorkspaceContextService);
     workspaceService.acquireInstantiationService(accessor.get(IInstantiationService));
-    const configPath = _defaultWorkspaceUri.with({ path: '/workspace.code-workspace' });
     try {
-        const fileService = accessor.get(IFileService);
-        await fileService.createFolder(_defaultWorkspaceUri);
-        await fileService.writeFile(configPath, VSBuffer.fromString(JSON.stringify({
-            folders: [
-                {
-                    path: _defaultWorkspaceUri.path
-                }
-            ]
-        })));
+        await accessor.get(IFileService).createFolder(_defaultWorkspaceUri);
     }
     catch (err) {
     }
     await workspaceService.initialize({
         id: generateUuid(),
-        configPath
+        uri: _defaultWorkspaceUri
     });
 });
 const MemoizedInjectedConfigurationService = memoizedConstructor(InjectedConfigurationService);

package/dist/service-override/files.d.ts

@@ -1,14 +1,6 @@
 import * as monaco from 'monaco-editor';
 import * as vscode from 'vscode';
 
-/**
- * Identifies a service of type `T`.
- */
-interface ServiceIdentifier<T> {
-    (...args: any[]): void;
-    type: T;
-}
-
 /**
  * An object that performs a cleanup operation when `.dispose()` is called.
  *
@@ -537,33 +529,6 @@ interface IRelativePattern {
     readonly pattern: string;
 }
 
-declare enum LogLevel {
-    Off = 0,
-    Trace = 1,
-    Debug = 2,
-    Info = 3,
-    Warning = 4,
-    Error = 5
-}
-interface ILogger extends IDisposable {
-    onDidChangeLogLevel: Event<LogLevel>;
-    getLevel(): LogLevel;
-    setLevel(level: LogLevel): void;
-    trace(message: string, ...args: any[]): void;
-    debug(message: string, ...args: any[]): void;
-    info(message: string, ...args: any[]): void;
-    warn(message: string, ...args: any[]): void;
-    error(message: string | Error, ...args: any[]): void;
-    /**
-     * An operation to flush the contents. Can be synchronous.
-     */
-    flush(): void;
-}
-declare const ILogService: ServiceIdentifier<ILogService>;
-interface ILogService extends ILogger {
-    readonly _serviceBrand: undefined;
-}
-
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
 interface ReadableStreamEvents<T> {
@@ -814,9 +779,6 @@ interface IFileSystemProviderWithFileReadWriteCapability extends IFileSystemProv
     readFile(resource: URI): Promise<Uint8Array>;
     writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
 }
-interface IFileSystemProviderWithFileReadStreamCapability extends IFileSystemProvider {
-    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
-}
 declare enum FileSystemProviderErrorCode {
     FileExists = "EntryExists",
     FileNotFound = "EntryNotFound",
@@ -860,55 +822,6 @@ interface IFileChange {
     readonly resource: URI;
 }
 
-declare class IndexedDB {
-    private readonly name;
-    static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
-    private static openDatabase;
-    private static doOpenDatabase;
-    private static deleteDatabase;
-    private database;
-    private readonly pendingTransactions;
-    constructor(database: IDBDatabase, name: string);
-    hasPendingTransactions(): boolean;
-    close(): void;
-    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>[]): Promise<T[]>;
-    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
-    getKeyValues<V>(store: string, isValid: (value: unknown) => value is V): Promise<Map<string, V>>;
-}
-
-declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability {
-    private indexedDB;
-    private readonly store;
-    private logService;
-    readonly onDidChangeCapabilities: Event<any>;
-    readonly onDidChangeFile: Event<any>;
-    private extUri;
-    private _capabilities;
-    get capabilities(): FileSystemProviderCapabilities;
-    constructor(indexedDB: IndexedDB | undefined, store: string, logService: ILogService);
-    stat(resource: URI): Promise<IStat>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
-    readFile(resource: URI): Promise<Uint8Array>;
-    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
-    mkdir(resource: URI): Promise<void>;
-    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
-    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
-    watch(resource: URI, opts: IWatchOptions): IDisposable;
-    private readonly _files;
-    private readonly _directories;
-    registerFileHandle(handle: FileSystemFileHandle): Promise<URI>;
-    registerDirectoryHandle(handle: FileSystemDirectoryHandle): Promise<URI>;
-    get directories(): Iterable<FileSystemDirectoryHandle>;
-    private registerHandle;
-    getHandle(resource: URI): Promise<FileSystemHandle | undefined>;
-    private getFileHandle;
-    private getDirectoryHandle;
-    private doGetHandle;
-    private toFileSystemProviderError;
-    private createFileSystemProviderError;
-}
-
 declare abstract class SimpleTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
     onDidChangeCapabilities: Event<any>;
     capabilities: number;
@@ -920,13 +833,13 @@ declare abstract class SimpleTextFileSystemProvider implements IFileSystemProvid
     watch(): IDisposable;
     stat(resource: URI): Promise<IStat>;
     mkdir(): Promise<void>;
-    readdir(directory: URI): Promise<[string, FileType][]>;
+    readdir(): Promise<[string, FileType][]>;
     delete(): Promise<void>;
     rename(): Promise<void>;
     onDidWatchError: Event<any>;
 }
 declare function getServiceOverride(): IEditorOverrideServices;
-declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
+declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string>): IDisposable;
 declare function registerFileSystemOverlay(provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-export { FileChangeType, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FileChangeType, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };