@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/terminalContrib/quickFix/browser/terminalQuickFixService.js

@@ -0,0 +1,143 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { isProposedApiEnabled } from '../../../../services/extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../../../services/extensions/common/extensionsRegistry.js';
+class TerminalQuickFixService {
+    get providers() { return this._providers; }
+    constructor() {
+        this._selectors = ( new Map());
+        this._providers = ( new Map());
+        this._onDidRegisterProvider = ( new Emitter());
+        this.onDidRegisterProvider = this._onDidRegisterProvider.event;
+        this._onDidRegisterCommandSelector = ( new Emitter());
+        this.onDidRegisterCommandSelector = this._onDidRegisterCommandSelector.event;
+        this._onDidUnregisterProvider = ( new Emitter());
+        this.onDidUnregisterProvider = this._onDidUnregisterProvider.event;
+        this.extensionQuickFixes = ( new Promise((r) => quickFixExtensionPoint.setHandler(fixes => {
+            r(( fixes.filter(c => isProposedApiEnabled(c.description, 'terminalQuickFixProvider')).map(c => {
+                if (!c.value) {
+                    return [];
+                }
+                return ( c.value.map(
+                    fix => { return { ...fix, extensionIdentifier: c.description.identifier.value }; }
+                ));
+            })).flat());
+        })));
+        this.extensionQuickFixes.then(selectors => {
+            for (const selector of selectors) {
+                this.registerCommandSelector(selector);
+            }
+        });
+    }
+    registerCommandSelector(selector) {
+        this._selectors.set(selector.id, selector);
+        this._onDidRegisterCommandSelector.fire(selector);
+    }
+    registerQuickFixProvider(id, provider) {
+        let disposed = false;
+        this.extensionQuickFixes.then(() => {
+            if (disposed) {
+                return;
+            }
+            this._providers.set(id, provider);
+            const selector = this._selectors.get(id);
+            if (!selector) {
+                throw new Error(`No registered selector for ID: ${id}`);
+            }
+            this._onDidRegisterProvider.fire({ selector, provider });
+        });
+        return toDisposable(() => {
+            disposed = true;
+            this._providers.delete(id);
+            const selector = this._selectors.get(id);
+            if (selector) {
+                this._selectors.delete(id);
+                this._onDidUnregisterProvider.fire(selector.id);
+            }
+        });
+    }
+}
+const quickFixExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'terminalQuickFixes',
+    defaultExtensionKind: ['workspace'],
+    activationEventsGenerator: (terminalQuickFixes, result) => {
+        for (const quickFixContrib of terminalQuickFixes ?? []) {
+            result.push(`onTerminalQuickFixRequest:${quickFixContrib.id}`);
+        }
+    },
+    jsonSchema: {
+        description: ( localize(
+            'vscode.extension.contributes.terminalQuickFixes',
+            'Contributes terminal quick fixes.'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'commandLineMatcher', 'outputMatcher', 'commandExitResult'],
+            defaultSnippets: [{
+                    body: {
+                        id: '$1',
+                        commandLineMatcher: '$2',
+                        outputMatcher: '$3',
+                        exitStatus: '$4'
+                    }
+                }],
+            properties: {
+                id: {
+                    description: ( localize(
+                        'vscode.extension.contributes.terminalQuickFixes.id',
+                        "The ID of the quick fix provider"
+                    )),
+                    type: 'string',
+                },
+                commandLineMatcher: {
+                    description: ( localize(
+                        'vscode.extension.contributes.terminalQuickFixes.commandLineMatcher',
+                        "A regular expression or string to test the command line against"
+                    )),
+                    type: 'string',
+                },
+                outputMatcher: {
+                    markdownDescription: ( localize(
+                        'vscode.extension.contributes.terminalQuickFixes.outputMatcher',
+                        "A regular expression or string to match a single line of the output against, which provides groups to be referenced in terminalCommand and uri.\n\nFor example:\n\n `lineMatcher: /git push --set-upstream origin (?<branchName>[^\s]+)/;`\n\n`terminalCommand: 'git push --set-upstream origin ${group:branchName}';`\n"
+                    )),
+                    type: 'object',
+                    required: ['lineMatcher', 'anchor', 'offset', 'length'],
+                    properties: {
+                        lineMatcher: {
+                            description: 'A regular expression or string to test the command line against',
+                            type: 'string'
+                        },
+                        anchor: {
+                            description: 'Where the search should begin in the buffer',
+                            enum: ['top', 'bottom']
+                        },
+                        offset: {
+                            description: 'The number of lines vertically from the anchor in the buffer to start matching against',
+                            type: 'number'
+                        },
+                        length: {
+                            description: 'The number of rows to match against, this should be as small as possible for performance reasons',
+                            type: 'number'
+                        }
+                    }
+                },
+                commandExitResult: {
+                    description: ( localize(
+                        'vscode.extension.contributes.terminalQuickFixes.commandExitResult',
+                        "The command exit result to match on"
+                    )),
+                    enum: ['success', 'error'],
+                    enumDescriptions: [
+                        'The command exited with an exit code of zero.',
+                        'The command exited with a non-zero exit code.'
+                    ]
+                }
+            },
+        }
+    },
+}));
+export { TerminalQuickFixService };

package/dist/vscode/vs/workbench/contrib/typeHierarchy/browser/media/typeHierarchy.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .type-hierarchy .message,.monaco-workbench .type-hierarchy .results{display:none}.monaco-workbench .type-hierarchy[data-state=data] .results{display:inherit;height:100%}.monaco-workbench .type-hierarchy[data-state=message] .message{align-items:center;display:flex;height:100%;justify-content:center}.monaco-workbench .type-hierarchy .editor,.monaco-workbench .type-hierarchy .tree{height:100%}.monaco-editor .type-hierarchy .tree{background-color:var(--vscode-peekViewResult-background);color:var(--vscode-peekViewResult-fileForeground)}.monaco-editor .type-hierarchy .tree .monaco-list:focus .monaco-list-rows>.monaco-list-row.selected:not(.highlighted){background-color:var(--vscode-peekViewResult-selectionBackground);color:var(--vscode-peekViewResult-selectionForeground)!important}.monaco-workbench .type-hierarchy .tree .typehierarchy-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .type-hierarchy .tree .typehierarchy-element .monaco-icon-label{padding-left:4px}.monaco-editor .type-hierarchy .type-decoration{background-color:var(--vscode-peekViewEditor-matchHighlightBackground);border:2px solid var(--vscode-peekViewEditor-matchHighlightBorder);box-sizing:border-box}.monaco-editor .type-hierarchy .editor .monaco-editor .inputarea.ime-input,.monaco-editor .type-hierarchy .editor .monaco-editor .monaco-editor-background{background-color:var(--vscode-peekViewEditor-background)}.monaco-editor .type-hierarchy .editor .monaco-editor .margin{background-color:var(--vscode-peekViewEditorGutter-background)}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/typeHierarchy/browser/typeHierarchyPeek.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/typeHierarchy.css";
+import './media/typeHierarchy.css.js';
 import { Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
 import { TreeMouseEventTarget } from 'monaco-editor/esm/vs/base/browser/ui/tree/tree.js';

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput.js

@@ -0,0 +1,85 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+class WebviewInput extends EditorInput {
+    get typeId() {
+        return WebviewInput.typeId;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        return 2  | 8  | 128 ;
+    }
+    get resource() {
+        return ( URI.from({
+            scheme: Schemas.webviewPanel,
+            path: `webview-panel/webview-${this._resourceId}`
+        }));
+    }
+    constructor(init, webview, _iconManager) {
+        super();
+        this._iconManager = _iconManager;
+        this._resourceId = generateUuid();
+        this._hasTransfered = false;
+        this.viewType = init.viewType;
+        this.providedId = init.providedId;
+        this._name = init.name;
+        this._webview = webview;
+    }
+    dispose() {
+        if (!this.isDisposed()) {
+            if (!this._hasTransfered) {
+                this._webview?.dispose();
+            }
+        }
+        super.dispose();
+    }
+    getName() {
+        return this._name;
+    }
+    getTitle(_verbosity) {
+        return this.getName();
+    }
+    getDescription() {
+        return undefined;
+    }
+    setName(value) {
+        this._name = value;
+        this.webview.setTitle(value);
+        this._onDidChangeLabel.fire();
+    }
+    get webview() {
+        return this._webview;
+    }
+    get extension() {
+        return this.webview.extension;
+    }
+    get iconPath() {
+        return this._iconPath;
+    }
+    set iconPath(value) {
+        this._iconPath = value;
+        this._iconManager.setIcons(this._resourceId, value);
+    }
+    matches(other) {
+        return super.matches(other) || other === this;
+    }
+    get group() {
+        return this._group;
+    }
+    updateGroup(group) {
+        this._group = group;
+    }
+    transfer(other) {
+        if (this._hasTransfered) {
+            return undefined;
+        }
+        this._hasTransfered = true;
+        other._webview = this._webview;
+        return other;
+    }
+}
+WebviewInput.typeId = 'workbench.editors.webviewInput';
+export { WebviewInput };

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.js

@@ -0,0 +1,52 @@
+import { __decorate, __classPrivateFieldGet, __classPrivateFieldSet, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { createCancelablePromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WebviewInput } from './webviewEditorInput.js';
+var _LazilyResolvedWebviewEditorInput_resolved, _LazilyResolvedWebviewEditorInput_resolvePromise;
+const IWebviewWorkbenchService = ( createDecorator('webviewEditorService'));
+let LazilyResolvedWebviewEditorInput = class LazilyResolvedWebviewEditorInput extends WebviewInput {
+    constructor(init, webview, _webviewWorkbenchService) {
+        super(init, webview, _webviewWorkbenchService.iconManager);
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+        _LazilyResolvedWebviewEditorInput_resolved.set(this, false);
+        _LazilyResolvedWebviewEditorInput_resolvePromise.set(this, void 0);
+    }
+    dispose() {
+        super.dispose();
+        __classPrivateFieldGet(this, _LazilyResolvedWebviewEditorInput_resolvePromise, "f")?.cancel();
+        __classPrivateFieldSet(this, _LazilyResolvedWebviewEditorInput_resolvePromise, undefined, "f");
+    }
+    async resolve() {
+        if (!__classPrivateFieldGet(this, _LazilyResolvedWebviewEditorInput_resolved, "f")) {
+            __classPrivateFieldSet(this, _LazilyResolvedWebviewEditorInput_resolved, true, "f");
+            __classPrivateFieldSet(this, _LazilyResolvedWebviewEditorInput_resolvePromise, createCancelablePromise(token => this._webviewWorkbenchService.resolveWebview(this, token)), "f");
+            try {
+                await __classPrivateFieldGet(this, _LazilyResolvedWebviewEditorInput_resolvePromise, "f");
+            }
+            catch (e) {
+                if (!isCancellationError(e)) {
+                    throw e;
+                }
+            }
+        }
+        return super.resolve();
+    }
+    transfer(other) {
+        if (!super.transfer(other)) {
+            return;
+        }
+        __classPrivateFieldSet(other, _LazilyResolvedWebviewEditorInput_resolved, __classPrivateFieldGet(this, _LazilyResolvedWebviewEditorInput_resolved, "f"), "f");
+        return other;
+    }
+};
+_LazilyResolvedWebviewEditorInput_resolved = ( new WeakMap());
+_LazilyResolvedWebviewEditorInput_resolvePromise = ( new WeakMap());
+LazilyResolvedWebviewEditorInput.__decorator = ( __decorate([
+    memoize
+], LazilyResolvedWebviewEditorInput.prototype, "resolve", null));
+LazilyResolvedWebviewEditorInput = ( __decorate([
+    ( __param(2, IWebviewWorkbenchService))
+], LazilyResolvedWebviewEditorInput));
+export { IWebviewWorkbenchService, LazilyResolvedWebviewEditorInput };

package/dist/vscode/vs/workbench/services/actions/common/menusExtensionPoint.js

@@ -796,12 +796,20 @@ commandsExtensionPoint.setHandler(extensions => {
                 };
             }
         }
-        if (MenuRegistry.getCommand(command)) {
-            extension.collector.info(( localize(
-                'dup',
-                "Command `{0}` appears multiple times in the `commands` section.",
-                userFriendlyCommand.command
-            )));
+        const existingCmd = MenuRegistry.getCommand(command);
+        if (existingCmd) {
+            if (existingCmd.source) {
+                extension.collector.info(( localize(
+                    'dup1',
+                    "Command `{0}` already registered by {1} ({2})",
+                    userFriendlyCommand.command,
+                    existingCmd.source.title,
+                    existingCmd.source.id
+                )));
+            }
+            else {
+                extension.collector.info(( localize('dup0', "Command `{0}` already registered", userFriendlyCommand.command)));
+            }
         }
         _commandRegistrations.add(MenuRegistry.addCommand({
             id: command,

package/dist/vscode/vs/workbench/services/assignment/common/assignmentService.js

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

package/dist/vscode/vs/workbench/services/configuration/browser/configurationService.js

@@ -293,7 +293,7 @@ class WorkspaceService extends Disposable {
             const application = await this.reloadApplicationConfiguration(true);
             const { local, remote } = await this.reloadUserConfiguration();
             await this.reloadWorkspaceConfiguration();
-            await this.loadConfiguration(application, local, remote);
+            await this.loadConfiguration(application, local, remote, true);
             return;
         }
         if (isWorkspaceFolder(target)) {
@@ -306,7 +306,7 @@ class WorkspaceService extends Disposable {
                 return;
             case 2 : {
                 const { local, remote } = await this.reloadUserConfiguration();
-                await this.loadConfiguration(this._configuration.applicationConfiguration, local, remote);
+                await this.loadConfiguration(this._configuration.applicationConfiguration, local, remote, true);
                 return;
             }
             case 3 :
@@ -337,8 +337,10 @@ class WorkspaceService extends Disposable {
     }
     async initialize(arg) {
         mark('code/willInitWorkspaceService');
+        const trigger = this.initialized;
+        this.initialized = false;
         const workspace = await this.createWorkspace(arg);
-        await this.updateWorkspaceAndInitializeConfiguration(workspace);
+        await this.updateWorkspaceAndInitializeConfiguration(workspace, trigger);
         this.checkAndMarkWorkspaceComplete(false);
         mark('code/didInitWorkspaceService');
     }
@@ -437,7 +439,7 @@ class WorkspaceService extends Disposable {
             this.validateWorkspaceFoldersAndReload(fromCache);
         }
     }
-    async updateWorkspaceAndInitializeConfiguration(workspace) {
+    async updateWorkspaceAndInitializeConfiguration(workspace, trigger) {
         const hasWorkspaceBefore = !!this.workspace;
         let previousState;
         let previousWorkspacePath;
@@ -451,7 +453,7 @@ class WorkspaceService extends Disposable {
         else {
             this.workspace = workspace;
         }
-        await this.initializeConfiguration();
+        await this.initializeConfiguration(trigger);
         if (hasWorkspaceBefore) {
             const newState = this.getWorkbenchState();
             if (previousState && newState !== previousState) {
@@ -491,7 +493,7 @@ class WorkspaceService extends Disposable {
         }
         return result;
     }
-    async initializeConfiguration() {
+    async initializeConfiguration(trigger) {
         await this.defaultConfiguration.initialize();
         const [, application, user] = await Promise.all([
             this.policyConfiguration.initialize(),
@@ -504,7 +506,7 @@ class WorkspaceService extends Disposable {
             })()
         ]);
         mark('code/willInitWorkspaceConfiguration');
-        await this.loadConfiguration(application, user.local, user.remote);
+        await this.loadConfiguration(application, user.local, user.remote, trigger);
         mark('code/didInitWorkspaceConfiguration');
     }
     async initializeApplicationConfiguration() {
@@ -564,7 +566,7 @@ class WorkspaceService extends Disposable {
     reloadWorkspaceFolderConfiguration(folder) {
         return this.onWorkspaceFolderConfigurationChanged(folder);
     }
-    async loadConfiguration(applicationConfigurationModel, userConfigurationModel, remoteUserConfigurationModel) {
+    async loadConfiguration(applicationConfigurationModel, userConfigurationModel, remoteUserConfigurationModel, trigger) {
         this.cachedFolderConfigs = ( (new ResourceMap()));
         const folders = this.workspace.folders;
         const folderConfigurations = await this.loadFolderConfigurations(folders);
@@ -584,13 +586,11 @@ class WorkspaceService extends Disposable {
              (new ResourceMap()),
             this.workspace
         )));
-        if (this.initialized) {
+        this.initialized = true;
+        if (trigger) {
             const change = this._configuration.compare(currentConfiguration);
             this.triggerConfigurationChange(change, { data: currentConfiguration.toData(), workspace: this.workspace }, 5 );
         }
-        else {
-            this.initialized = true;
-        }
         this.updateRestrictedSettings();
     }
     getWorkspaceConfigurationModel(folderConfigurations) {
@@ -622,7 +622,7 @@ class WorkspaceService extends Disposable {
                 }
             }
             const [localUser, application] = await Promise.all(promises);
-            await this.loadConfiguration(application ?? this._configuration.applicationConfiguration, localUser, this._configuration.remoteUserConfiguration);
+            await this.loadConfiguration(application ?? this._configuration.applicationConfiguration, localUser, this._configuration.remoteUserConfiguration, true);
         })());
     }
     async copyProfileSettings(from, to) {

package/dist/vscode/vs/workbench/services/configuration/common/configuration.js

@@ -11,6 +11,7 @@ const workspaceSettingsSchemaId = 'vscode://schemas/settings/workspace';
 const folderSettingsSchemaId = 'vscode://schemas/settings/folder';
 const launchSchemaId = 'vscode://schemas/launch';
 const tasksSchemaId = 'vscode://schemas/tasks';
+const APPLICATION_SCOPES = [1 ];
 const PROFILE_SCOPES = [2 , 3 , 4 , 5 , 6 ];
 const LOCAL_MACHINE_PROFILE_SCOPES = [3 , 4 , 5 ];
 const LOCAL_MACHINE_SCOPES = [1 , ...LOCAL_MACHINE_PROFILE_SCOPES];
@@ -26,4 +27,4 @@ const USER_STANDALONE_CONFIGURATIONS = Object.create(null);
 USER_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${TASKS_CONFIGURATION_KEY}.json`;
 const IWorkbenchConfigurationService = refineServiceDecorator(IConfigurationService);
 const TASKS_DEFAULT = '{\n\t\"version\": \"2.0.0\",\n\t\"tasks\": []\n}';
-export { FOLDER_CONFIG_FOLDER_NAME, FOLDER_SCOPES, FOLDER_SETTINGS_NAME, FOLDER_SETTINGS_PATH, IWorkbenchConfigurationService, LAUNCH_CONFIGURATION_KEY, LOCAL_MACHINE_PROFILE_SCOPES, LOCAL_MACHINE_SCOPES, PROFILE_SCOPES, REMOTE_MACHINE_SCOPES, TASKS_CONFIGURATION_KEY, TASKS_DEFAULT, USER_STANDALONE_CONFIGURATIONS, WORKSPACE_SCOPES, WORKSPACE_STANDALONE_CONFIGURATIONS, defaultSettingsSchemaId, folderSettingsSchemaId, launchSchemaId, machineSettingsSchemaId, profileSettingsSchemaId, tasksSchemaId, userSettingsSchemaId, workspaceSettingsSchemaId };
+export { APPLICATION_SCOPES, FOLDER_CONFIG_FOLDER_NAME, FOLDER_SCOPES, FOLDER_SETTINGS_NAME, FOLDER_SETTINGS_PATH, IWorkbenchConfigurationService, LAUNCH_CONFIGURATION_KEY, LOCAL_MACHINE_PROFILE_SCOPES, LOCAL_MACHINE_SCOPES, PROFILE_SCOPES, REMOTE_MACHINE_SCOPES, TASKS_CONFIGURATION_KEY, TASKS_DEFAULT, USER_STANDALONE_CONFIGURATIONS, WORKSPACE_SCOPES, WORKSPACE_STANDALONE_CONFIGURATIONS, defaultSettingsSchemaId, folderSettingsSchemaId, launchSchemaId, machineSettingsSchemaId, profileSettingsSchemaId, tasksSchemaId, userSettingsSchemaId, workspaceSettingsSchemaId };

package/dist/vscode/vs/workbench/services/configuration/common/configurationEditing.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { setProperty } from '../../../../base/common/jsonEdit.js';
 import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
@@ -447,7 +447,7 @@ let ConfigurationEditing = class ConfigurationEditing {
             return false;
         }
         const parseErrors = [];
-        Json.parse(content, parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+        json.parse(content, parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
         return parseErrors.length > 0;
     }
     async validate(target, operation, checkDirty, overrides) {

package/dist/vscode/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { setProperty } from '../../../../base/common/jsonEdit.js';
 import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
@@ -84,7 +84,7 @@ let JSONEditingService = class JSONEditingService {
     }
     hasParseErrors(model) {
         const parseErrors = [];
-        Json.parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+        json.parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
         return parseErrors.length > 0;
     }
     async resolveAndValidate(resource, checkDirty) {

package/dist/vscode/vs/workbench/services/editor/browser/editorDropService.js

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