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

package/dist/extensions.d.ts

@@ -840,6 +840,19 @@ 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;
@@ -848,9 +861,12 @@ declare function initialize(extension?: IExtensionDescription): Promise<void>;
 declare function createApi(extension: IExtensionDescription): typeof vscode;
 interface RegisterExtensionResult extends IDisposable {
     api: typeof vscode;
-    registerFile: (path: string, getContent: () => Promise<string>) => IDisposable;
+    runCode(): Promise<void>;
+    registerFile: (path: string, getContent: () => Promise<Uint8Array | string>) => IDisposable;
+    registerSyncFile: (path: string, content: Uint8Array | 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 };
+export { IExtensionContributions, IExtensionManifest, ITranslations, consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, onExtHostInitialized, registerExtension, runExtensionCode };

package/dist/extensions.js

@@ -11,8 +11,15 @@ 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';
@@ -20,8 +27,9 @@ 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 } from './vscode-services/extHost.js';
+import { initialize as initialize$1, getExtHostServices } 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);
@@ -80,7 +88,8 @@ function createApi(extension) {
         commands: create$3(() => extension),
         window: create$4(() => extension, workspace),
         workspace: create$5(() => extension),
-        languages: create$6(() => extension)
+        languages: create$6(() => extension),
+        l10n: create$7(() => extension)
     };
 }
 const hasOwnProperty = Object.hasOwnProperty;
@@ -118,6 +127,73 @@ 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}` }));
@@ -137,14 +213,33 @@ function registerExtension(manifest, defaultNLS) {
     };
     const extensionDescription = toExtensionDescription(extension);
     deltaExtensions([extensionDescription], []);
+    const api = createApi(extensionDescription);
     return {
-        api: createApi(extensionDescription),
+        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);
+        },
         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]);
         }
     };
 }
-export { consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, registerExtension };
+function ensureSuffix(path, suffix) {
+    return path.endsWith(suffix) ? path : path + suffix;
+}
+export { consoleExtensionMessageHandler, createApi, getDefaultExtension, initialize, registerExtension, runExtensionCode };

package/dist/node_modules/tslib/tslib.es6.js

@@ -9,13 +9,13 @@ function __param(paramIndex, decorator) {
 }
 function __classPrivateFieldGet(receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    if (typeof state === "function" ? receiver !== state || !f : !( state.has(receiver))) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 }
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    if (typeof state === "function" ? receiver !== state || !f : !( state.has(receiver))) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 export { __classPrivateFieldGet, __classPrivateFieldSet, __decorate, __param };

package/dist/override/vs/workbench/contrib/files/browser/views/openEditorsView.js

@@ -0,0 +1,2 @@
+class OpenEditorsView {}
+export { OpenEditorsView };

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

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

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

@@ -1,11 +1,19 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
-import { e as extractPathsFromExtensionManifest, p as parseJson, l as localizeManifest } from './extension-tools-b68a64de.js';
+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 * as path from 'path';
 import * as fsPromise from 'fs/promises';
-import * as fs from 'fs';
+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';
 
-function plugin(options) {
-    const filter = createFilter(options.include, options.exclude);
+function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins }) {
+    const filter = createFilter(include, exclude);
     return {
         name: 'default-extensions-loader',
         resolveId(source) {
@@ -19,47 +27,15 @@ function plugin(options) {
             if (!filter(id)) {
                 return;
             }
-            // 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;
-            }
+            // Load extension resources
             const basename = path.basename(id);
             if (basename === 'package.json') {
-                let parsed = parseJson(id, code);
+                const content = await fsPromise.readFile(id);
+                let parsed = parseJson(id, content.toString('utf-8'));
                 const nlsFile = path.resolve(path.dirname(id), 'package.nls.json');
-                if (fs.existsSync(nlsFile)) {
+                if (require$$0$1.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,
@@ -68,13 +44,65 @@ registerFile('${filePath}', async () => await import('${path.resolve(id, filePat
                     })
                 };
             }
-            else {
-                // transform extension files to strings
-                return {
-                    code: `export default ${JSON.stringify(code)};`,
-                    map: { mappings: '' }
-                };
+            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;
+                }
             }
+            return undefined;
         }
     };
 }

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

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

package/dist/rollup-vsix-plugin.js

@@ -1,7 +1,16 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
 import * as yauzl from 'yauzl';
-import { p as parseJson, l as localizeManifest, e as extractPathsFromExtensionManifest } from './extension-tools-b68a64de.js';
+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 * 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 = [];
@@ -42,11 +51,11 @@ async function readVsix(file) {
         });
     });
 }
-const defaultOptions = {
-    include: '**/*.vsix'
-};
-function plugin(options = defaultOptions) {
-    const filter = createFilter(options.include, options.exclude);
+function getVsixPath(file) {
+    return path.relative('/', path.resolve('/', file));
+}
+function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () => true }) {
+    const filter = createFilter(include, exclude);
     const vsixFiles = {};
     return {
         name: 'vsix-loader',
@@ -60,12 +69,34 @@ function plugin(options = defaultOptions) {
             return undefined;
         },
         async load(id) {
-            const rawMatch = /vsix:(.*):(.*)\.raw/.exec(id);
+            const rawMatch = /^vsix:(.*):(.*)\.raw$/.exec(id);
             if (rawMatch != null) {
-                const content = vsixFiles[rawMatch[1]][rawMatch[2]].toString('utf8');
-                return `export default ${JSON.stringify(content)};`;
+                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 match = /vsix:(.*):(.*)\.vsjson/.exec(id);
+            const match = /^vsix:(.*):(.*)\.vsjson$/.exec(id);
             if (match != null) {
                 const file = match[2];
                 const vsixFile = vsixFiles[match[1]];
@@ -85,25 +116,32 @@ function plugin(options = defaultOptions) {
                 return null;
             const files = await readVsix(id);
             const manifest = parseJson(id, files['package.json'].toString('utf8'));
-            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) => {
+            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) => {
                 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 } = registerExtension(manifest)
-${usedFiles.map((filePath) => (`
-  registerFile('${filePath}', async () => (await import('vsix:${id}:${filePath}.raw')).default)`))}
+  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()' : ''}
 })
 `;
         }

package/dist/service-override/configuration.js

@@ -6,6 +6,7 @@ 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';
@@ -31,7 +32,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 } from '../tools.js';
+import { memoizedConstructor, unsupported } from '../tools.js';
 import { registerServiceInitializeParticipant } from '../services.js';
 async function updateUserConfiguration(configurationJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
@@ -67,21 +68,32 @@ InjectedConfigurationService = __decorate([
     ( __param(7, IPolicyService))
 ], InjectedConfigurationService);
 class MonacoWorkspaceEditingService extends AbstractWorkspaceEditingService {
-    async enterWorkspace() {
+    constructor() {
+        super(...arguments);
+        this.enterWorkspace = unsupported;
     }
 }
 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 {
-        await accessor.get(IFileService).createFolder(_defaultWorkspaceUri);
+        const fileService = accessor.get(IFileService);
+        await fileService.createFolder(_defaultWorkspaceUri);
+        await fileService.writeFile(configPath, VSBuffer.fromString(JSON.stringify({
+            folders: [
+                {
+                    path: _defaultWorkspaceUri.path
+                }
+            ]
+        })));
     }
     catch (err) {
     }
     await workspaceService.initialize({
         id: generateUuid(),
-        uri: _defaultWorkspaceUri
+        configPath
     });
 });
 const MemoizedInjectedConfigurationService = memoizedConstructor(InjectedConfigurationService);