@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/base/parts/request/browser/request.js

@@ -0,0 +1,60 @@
+import { bufferToStream, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { OfflineError } from '../common/request.js';
+function request(options, token) {
+    if (options.proxyAuthorization) {
+        options.headers = {
+            ...(options.headers || {}),
+            'Proxy-Authorization': options.proxyAuthorization
+        };
+    }
+    const xhr = ( new XMLHttpRequest());
+    return ( new Promise((resolve, reject) => {
+        xhr.open(options.type || 'GET', options.url || '', true, options.user, options.password);
+        setRequestHeaders(xhr, options);
+        xhr.responseType = 'arraybuffer';
+        xhr.onerror = e => reject(navigator.onLine ? ( new Error(xhr.statusText && ('XHR failed: ' + xhr.statusText) || 'XHR failed')) : ( new OfflineError()));
+        xhr.onload = (e) => {
+            resolve({
+                res: {
+                    statusCode: xhr.status,
+                    headers: getResponseHeaders(xhr)
+                },
+                stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(xhr.response))))
+            });
+        };
+        xhr.ontimeout = e => reject(( new Error(`XHR timeout: ${options.timeout}ms`)));
+        if (options.timeout) {
+            xhr.timeout = options.timeout;
+        }
+        xhr.send(options.data);
+        token.onCancellationRequested(() => {
+            xhr.abort();
+            reject(canceled());
+        });
+    }));
+}
+function setRequestHeaders(xhr, options) {
+    if (options.headers) {
+        outer: for (const k in options.headers) {
+            switch (k) {
+                case 'User-Agent':
+                case 'Accept-Encoding':
+                case 'Content-Length':
+                    continue outer;
+            }
+            xhr.setRequestHeader(k, options.headers[k]);
+        }
+    }
+}
+function getResponseHeaders(xhr) {
+    const headers = Object.create(null);
+    for (const line of xhr.getAllResponseHeaders().split(/\r\n|\n|\r/g)) {
+        if (line) {
+            const idx = line.indexOf(':');
+            headers[line.substr(0, idx).trim().toLowerCase()] = line.substr(idx + 1).trim();
+        }
+    }
+    return headers;
+}
+export { request };

package/dist/vscode/vs/base/parts/request/common/request.js

@@ -0,0 +1,8 @@
+const offlineName = 'Offline';
+class OfflineError extends Error {
+    constructor() {
+        super(offlineName);
+        this.name = this.message;
+    }
+}
+export { OfflineError };

package/dist/vscode/vs/editor/browser/config/editorConfiguration.js

@@ -0,0 +1,91 @@
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { editorOptionsRegistry, ConfigurationChangedEvent } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+class ValidatedEditorOptions {
+    constructor() {
+        this._values = [];
+    }
+    _read(option) {
+        return this._values[option];
+    }
+    get(id) {
+        return this._values[id];
+    }
+    _write(option, value) {
+        this._values[option] = value;
+    }
+}
+class ComputedEditorOptions {
+    constructor() {
+        this._values = [];
+    }
+    _read(id) {
+        if (id >= this._values.length) {
+            throw new Error('Cannot read uninitialized value');
+        }
+        return this._values[id];
+    }
+    get(id) {
+        return this._read(id);
+    }
+    _write(id, value) {
+        this._values[id] = value;
+    }
+}
+class EditorOptionsUtil {
+    static validateOptions(options) {
+        const result = ( new ValidatedEditorOptions());
+        for (const editorOption of editorOptionsRegistry) {
+            const value = (editorOption.name === '_never_' ? undefined : options[editorOption.name]);
+            result._write(editorOption.id, editorOption.validate(value));
+        }
+        return result;
+    }
+    static computeOptions(options, env) {
+        const result = ( new ComputedEditorOptions());
+        for (const editorOption of editorOptionsRegistry) {
+            result._write(editorOption.id, editorOption.compute(env, result, options._read(editorOption.id)));
+        }
+        return result;
+    }
+    static _deepEquals(a, b) {
+        if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
+            return a === b;
+        }
+        if (Array.isArray(a) || Array.isArray(b)) {
+            return (Array.isArray(a) && Array.isArray(b) ? arrays.equals(a, b) : false);
+        }
+        if (( Object.keys(a)).length !== ( Object.keys(b)).length) {
+            return false;
+        }
+        for (const key in a) {
+            if (!EditorOptionsUtil._deepEquals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static checkEquals(a, b) {
+        const result = [];
+        let somethingChanged = false;
+        for (const editorOption of editorOptionsRegistry) {
+            const changed = !EditorOptionsUtil._deepEquals(a._read(editorOption.id), b._read(editorOption.id));
+            result[editorOption.id] = changed;
+            if (changed) {
+                somethingChanged = true;
+            }
+        }
+        return (somethingChanged ? ( new ConfigurationChangedEvent(result)) : null);
+    }
+    static applyUpdate(options, update) {
+        let changed = false;
+        for (const editorOption of editorOptionsRegistry) {
+            if (update.hasOwnProperty(editorOption.name)) {
+                const result = editorOption.applyUpdate(options[editorOption.name], update[editorOption.name]);
+                options[editorOption.name] = result.newValue;
+                changed = changed || result.didChange;
+            }
+        }
+        return changed;
+    }
+}
+export { ComputedEditorOptions, EditorOptionsUtil };

package/dist/vscode/vs/editor/common/services/languageFeaturesService.js

@@ -0,0 +1,41 @@
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+class LanguageFeaturesService {
+    constructor() {
+        this.referenceProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.renameProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.codeActionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.definitionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.typeDefinitionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.declarationProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.implementationProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentSymbolProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlayHintsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.colorProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.codeLensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentRangeFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.onTypeFormattingEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.signatureHelpProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.hoverProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentHighlightProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.selectionRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.foldingRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.linkProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlineCompletionsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.completionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.linkedEditingRangeProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.inlineValuesProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.evaluatableExpressionProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentRangeSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentOnDropEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+        this.documentPasteEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
+    }
+    setNotebookTypeResolver(resolver) {
+        this._notebookTypeResolver = resolver;
+    }
+    _score(uri) {
+        return this._notebookTypeResolver?.(uri);
+    }
+}
+export { LanguageFeaturesService };

package/dist/vscode/vs/editor/common/services/modelUndoRedoParticipant.js

@@ -0,0 +1,56 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { MultiModelEditStackElement } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
+let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable {
+    constructor(_modelService, _textModelService, _undoRedoService) {
+        super();
+        this._modelService = _modelService;
+        this._textModelService = _textModelService;
+        this._undoRedoService = _undoRedoService;
+        this._register(this._modelService.onModelRemoved((model) => {
+            const elements = this._undoRedoService.getElements(model.uri);
+            if (elements.past.length === 0 && elements.future.length === 0) {
+                return;
+            }
+            for (const element of elements.past) {
+                if (element instanceof MultiModelEditStackElement) {
+                    element.setDelegate(this);
+                }
+            }
+            for (const element of elements.future) {
+                if (element instanceof MultiModelEditStackElement) {
+                    element.setDelegate(this);
+                }
+            }
+        }));
+    }
+    prepareUndoRedo(element) {
+        const missingModels = element.getMissingModels();
+        if (missingModels.length === 0) {
+            return Disposable.None;
+        }
+        const disposablesPromises = ( missingModels.map(async (uri) => {
+            try {
+                const reference = await this._textModelService.createModelReference(uri);
+                return reference;
+            }
+            catch (err) {
+                return Disposable.None;
+            }
+        }));
+        return Promise.all(disposablesPromises).then(disposables => {
+            return {
+                dispose: () => dispose(disposables)
+            };
+        });
+    }
+};
+ModelUndoRedoParticipant = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, IUndoRedoService))
+], ModelUndoRedoParticipant));
+export { ModelUndoRedoParticipant };

package/dist/vscode/vs/editor/common/services/textResourceConfigurationService.js

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+let TextResourceConfigurationService = class TextResourceConfigurationService extends Disposable {
+    constructor(configurationService, modelService, languageService) {
+        super();
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._register(this.configurationService.onDidChangeConfiguration(e => this._onDidChangeConfiguration.fire(this.toResourceConfigurationChangeEvent(e))));
+    }
+    getValue(resource, arg2, arg3) {
+        if (typeof arg3 === 'string') {
+            return this._getValue(resource, Position.isIPosition(arg2) ? arg2 : null, arg3);
+        }
+        return this._getValue(resource, null, typeof arg2 === 'string' ? arg2 : undefined);
+    }
+    updateValue(resource, key, value, configurationTarget) {
+        const language = this.getLanguage(resource, null);
+        const configurationValue = this.configurationService.inspect(key, { resource, overrideIdentifier: language });
+        if (configurationTarget === undefined) {
+            configurationTarget = this.deriveConfigurationTarget(configurationValue, language);
+        }
+        switch (configurationTarget) {
+            case 8 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.memory?.override, resource, language);
+            case 6 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.workspaceFolder?.override, resource, language);
+            case 5 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.workspace?.override, resource, language);
+            case 4 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.userRemote?.override, resource, language);
+            default:
+                return this._updateValue(key, value, configurationTarget, configurationValue.userLocal?.override, resource, language);
+        }
+    }
+    _updateValue(key, value, configurationTarget, overriddenValue, resource, language) {
+        if (language && overriddenValue !== undefined) {
+            return this.configurationService.updateValue(key, value, { resource, overrideIdentifier: language }, configurationTarget);
+        }
+        else {
+            return this.configurationService.updateValue(key, value, { resource }, configurationTarget);
+        }
+    }
+    deriveConfigurationTarget(configurationValue, language) {
+        if (language) {
+            if (configurationValue.memory?.override !== undefined) {
+                return 8 ;
+            }
+            if (configurationValue.workspaceFolder?.override !== undefined) {
+                return 6 ;
+            }
+            if (configurationValue.workspace?.override !== undefined) {
+                return 5 ;
+            }
+            if (configurationValue.userRemote?.override !== undefined) {
+                return 4 ;
+            }
+            if (configurationValue.userLocal?.override !== undefined) {
+                return 3 ;
+            }
+        }
+        if (configurationValue.memory?.value !== undefined) {
+            return 8 ;
+        }
+        if (configurationValue.workspaceFolder?.value !== undefined) {
+            return 6 ;
+        }
+        if (configurationValue.workspace?.value !== undefined) {
+            return 5 ;
+        }
+        if (configurationValue.userRemote?.value !== undefined) {
+            return 4 ;
+        }
+        return 3 ;
+    }
+    _getValue(resource, position, section) {
+        const language = resource ? this.getLanguage(resource, position) : undefined;
+        if (typeof section === 'undefined') {
+            return this.configurationService.getValue({ resource, overrideIdentifier: language });
+        }
+        return this.configurationService.getValue(section, { resource, overrideIdentifier: language });
+    }
+    getLanguage(resource, position) {
+        const model = this.modelService.getModel(resource);
+        if (model) {
+            return position ? model.getLanguageIdAtPosition(position.lineNumber, position.column) : model.getLanguageId();
+        }
+        return this.languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+    }
+    toResourceConfigurationChangeEvent(configurationChangeEvent) {
+        return {
+            affectedKeys: configurationChangeEvent.affectedKeys,
+            affectsConfiguration: (resource, configuration) => {
+                const overrideIdentifier = resource ? this.getLanguage(resource, null) : undefined;
+                return configurationChangeEvent.affectsConfiguration(configuration, { resource, overrideIdentifier });
+            }
+        };
+    }
+};
+TextResourceConfigurationService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageService))
+], TextResourceConfigurationService));
+export { TextResourceConfigurationService };

package/dist/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem.js

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { BaseActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+let DropdownWithPrimaryActionViewItem = class DropdownWithPrimaryActionViewItem extends BaseActionViewItem {
+    get onDidChangeDropdownVisibility() {
+        return this._dropdown.onDidChangeVisibility;
+    }
+    constructor(primaryAction, dropdownAction, dropdownMenuActions, className, _contextMenuProvider, _options, _keybindingService, _notificationService, _contextKeyService, _themeService) {
+        super(null, primaryAction);
+        this._contextMenuProvider = _contextMenuProvider;
+        this._options = _options;
+        this._container = null;
+        this._dropdownContainer = null;
+        this._primaryAction = ( new MenuEntryActionViewItem(
+            primaryAction,
+            undefined,
+            _keybindingService,
+            _notificationService,
+            _contextKeyService,
+            _themeService,
+            _contextMenuProvider
+        ));
+        this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
+            menuAsChild: true,
+            classNames: className ? ['codicon', 'codicon-chevron-down', className] : ['codicon', 'codicon-chevron-down'],
+            keybindingProvider: this._options?.getKeyBinding
+        }));
+    }
+    setActionContext(newContext) {
+        super.setActionContext(newContext);
+        this._primaryAction.setActionContext(newContext);
+        this._dropdown.setActionContext(newContext);
+    }
+    render(container) {
+        this._container = container;
+        super.render(this._container);
+        this._container.classList.add('monaco-dropdown-with-primary');
+        const primaryContainer = dom.$('.action-container');
+        this._primaryAction.render(dom.append(this._container, primaryContainer));
+        this._dropdownContainer = dom.$('.dropdown-action-container');
+        this._dropdown.render(dom.append(this._container, this._dropdownContainer));
+        this._register(dom.addDisposableListener(primaryContainer, dom.EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(17 )) {
+                this._primaryAction.element.tabIndex = -1;
+                this._dropdown.focus();
+                event.stopPropagation();
+            }
+        }));
+        this._register(dom.addDisposableListener(this._dropdownContainer, dom.EventType.KEY_DOWN, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(15 )) {
+                this._primaryAction.element.tabIndex = 0;
+                this._dropdown.setFocusable(false);
+                this._primaryAction.element?.focus();
+                event.stopPropagation();
+            }
+        }));
+    }
+    focus(fromRight) {
+        if (fromRight) {
+            this._dropdown.focus();
+        }
+        else {
+            this._primaryAction.element.tabIndex = 0;
+            this._primaryAction.element.focus();
+        }
+    }
+    blur() {
+        this._primaryAction.element.tabIndex = -1;
+        this._dropdown.blur();
+        this._container.blur();
+    }
+    setFocusable(focusable) {
+        if (focusable) {
+            this._primaryAction.element.tabIndex = 0;
+        }
+        else {
+            this._primaryAction.element.tabIndex = -1;
+            this._dropdown.setFocusable(false);
+        }
+    }
+    update(dropdownAction, dropdownMenuActions, dropdownIcon) {
+        this._dropdown.dispose();
+        this._dropdown = ( new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, {
+            menuAsChild: true,
+            classNames: ['codicon', dropdownIcon || 'codicon-chevron-down']
+        }));
+        if (this._dropdownContainer) {
+            this._dropdown.render(this._dropdownContainer);
+        }
+    }
+    dispose() {
+        this._primaryAction.dispose();
+        this._dropdown.dispose();
+        super.dispose();
+    }
+};
+DropdownWithPrimaryActionViewItem = ( __decorate([
+    ( __param(6, IKeybindingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IThemeService))
+], DropdownWithPrimaryActionViewItem));
+export { DropdownWithPrimaryActionViewItem };

package/dist/vscode/vs/platform/debug/common/extensionHostDebug.js

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

package/dist/{extensionManagement.js → vscode/vs/platform/extensionManagement/common/extensionManagement.js}

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const EXTENSION_IDENTIFIER_PATTERN = '^([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$';
 const IExtensionGalleryService = ( createDecorator('extensionGalleryService'));
-export { EXTENSION_IDENTIFIER_PATTERN, IExtensionGalleryService };
+const IExtensionManagementService = ( createDecorator('extensionManagementService'));
+export { EXTENSION_IDENTIFIER_PATTERN, IExtensionGalleryService, IExtensionManagementService };

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

@@ -0,0 +1,14 @@
+import { compareIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+function areSameExtensions(a, b) {
+    if (a.uuid && b.uuid) {
+        return a.uuid === b.uuid;
+    }
+    if (a.id === b.id) {
+        return true;
+    }
+    return compareIgnoreCase(a.id, b.id) === 0;
+}
+function getExtensionId(publisher, name) {
+    return `${publisher}.${name}`;
+}
+export { areSameExtensions, getExtensionId };

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

@@ -0,0 +1,66 @@
+import { isString, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+function localizeManifest(extensionManifest, translations, fallbackTranslations) {
+    try {
+        replaceNLStrings(extensionManifest, translations, fallbackTranslations);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+    }
+    return extensionManifest;
+}
+function replaceNLStrings(extensionManifest, messages, originalMessages) {
+    const processEntry = (obj, key, command) => {
+        const value = obj[key];
+        if (isString(value)) {
+            const str = value;
+            const length = str.length;
+            if (length > 1 && str[0] === '%' && str[length - 1] === '%') {
+                const messageKey = str.substr(1, length - 2);
+                let translated = messages[messageKey];
+                if (translated === undefined && originalMessages) {
+                    translated = originalMessages[messageKey];
+                }
+                const message = typeof translated === 'string' ? translated : translated?.message;
+                const original = originalMessages?.[messageKey];
+                const originalMessage = typeof original === 'string' ? original : original?.message;
+                if (!message) {
+                    if (!originalMessage) {
+                        console.warn(`[${extensionManifest.name}]: ${( ( localize('missingNLSKey', "Couldn't find message for key {0}.", messageKey)))}`);
+                    }
+                    return;
+                }
+                if (
+                command && (key === 'title' || key === 'category') &&
+                    originalMessage && originalMessage !== message) {
+                    const localizedString = {
+                        value: message,
+                        original: originalMessage
+                    };
+                    obj[key] = localizedString;
+                }
+                else {
+                    obj[key] = message;
+                }
+            }
+        }
+        else if (isObject(value)) {
+            for (const k in value) {
+                if (value.hasOwnProperty(k)) {
+                    k === 'commands' ? processEntry(value, k, true) : processEntry(value, k, command);
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                processEntry(value, i, command);
+            }
+        }
+    };
+    for (const key in extensionManifest) {
+        if (extensionManifest.hasOwnProperty(key)) {
+            processEntry(extensionManifest, key);
+        }
+    }
+}
+export { localizeManifest };

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

@@ -0,0 +1,53 @@
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+class ImplicitActivationEventsImpl {
+    constructor() {
+        this._generators = ( new Map());
+        this._cache = ( new WeakMap());
+    }
+    register(extensionPointName, generator) {
+        this._generators.set(extensionPointName, generator);
+    }
+    readActivationEvents(extensionDescription) {
+        if (!this._cache.has(extensionDescription)) {
+            this._cache.set(extensionDescription, this._readActivationEvents(extensionDescription));
+        }
+        return this._cache.get(extensionDescription);
+    }
+    createActivationEventsMap(extensionDescriptions) {
+        const result = Object.create(null);
+        for (const extensionDescription of extensionDescriptions) {
+            const activationEvents = this.readActivationEvents(extensionDescription);
+            if (activationEvents.length > 0) {
+                result[ExtensionIdentifier.toKey(extensionDescription.identifier)] = activationEvents;
+            }
+        }
+        return result;
+    }
+    _readActivationEvents(desc) {
+        if (typeof desc.main === 'undefined' && typeof desc.browser === 'undefined') {
+            return [];
+        }
+        const activationEvents = (Array.isArray(desc.activationEvents) ? desc.activationEvents.slice(0) : []);
+        if (!desc.contributes) {
+            return activationEvents;
+        }
+        for (const extPointName in desc.contributes) {
+            const generator = this._generators.get(extPointName);
+            if (!generator) {
+                continue;
+            }
+            const contrib = desc.contributes[extPointName];
+            const contribArr = Array.isArray(contrib) ? contrib : [contrib];
+            try {
+                generator(contribArr, activationEvents);
+            }
+            catch (err) {
+                onUnexpectedError(err);
+            }
+        }
+        return activationEvents;
+    }
+}
+const ImplicitActivationEvents = ( new ImplicitActivationEventsImpl());
+export { ImplicitActivationEvents, ImplicitActivationEventsImpl };