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

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/monaco-treemending.js

@@ -832,10 +832,26 @@ function applyPatches(uniDiff, options) {
 
 const require = createRequire(import.meta.url);
 async function run() {
+    const ownPackageJson = JSON.parse((await fs.readFile(require.resolve('../package.json'))).toString('utf-8'));
+    const expectedMonacoVersion = ownPackageJson.peerDependencies['monaco-editor'];
     const patchContent = await fs.readFile(require.resolve('../monaco-editor-treemending.patch'));
-    const monacoDirectory = path.resolve(path.dirname(require.resolve('monaco-editor/monaco.d.ts', { paths: [process.cwd()] })), 'esm');
+    const monacoDirectory = path.dirname(require.resolve('monaco-editor/monaco.d.ts', { paths: [process.cwd()] }));
+    const monacoEsmDirectory = path.resolve(monacoDirectory, 'esm');
+    const monacoPackageJsonFile = path.resolve(monacoDirectory, 'package.json');
+    const monacoPackageJson = JSON.parse((await fs.readFile(monacoPackageJsonFile)).toString('utf-8'));
+    const monacoVersion = monacoPackageJson.version;
+    if (expectedMonacoVersion !== monacoVersion) {
+        console.error(`Wrong monaco-editor version: expecting ${expectedMonacoVersion}, got ${monacoVersion}`);
+        process.exit(1);
+    }
+    const alreadyPatched = monacoPackageJson.treemended ?? false;
+    if (alreadyPatched) {
+        // eslint-disable-next-line no-console
+        console.info('Monaco-editor has already been tree-mended, ignoring');
+        process.exit(0);
+    }
     function getMonacoFile(diff) {
-        return path.resolve(monacoDirectory, diff.oldFileName.slice('a/'.length));
+        return path.resolve(monacoEsmDirectory, diff.oldFileName.slice('a/'.length));
     }
     await new Promise((resolve, reject) => {
         applyPatches(patchContent.toString('utf-8'), {
@@ -873,10 +889,16 @@ async function run() {
             }
         });
     });
-}
-run().then(() => {
+    // Mark monaco as treemended
+    await fs.writeFile(monacoPackageJsonFile, JSON.stringify({
+        ...monacoPackageJson,
+        treemended: true
+    }, null, 2));
     // eslint-disable-next-line no-console
     console.info('Monaco-editor was tree-mended');
-}, err => {
+    process.exit(0);
+}
+run().catch(err => {
     console.error(err);
+    process.exit(1);
 });

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);