@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/monaco.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from './external/tslib/tslib.es6.js';
 import { StandaloneServices, StandaloneKeybindingService } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { StandaloneDiffEditor2, StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { StandaloneEditor, StandaloneDiffEditor2 } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
 import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { distinct, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
 export { errorHandler } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -66,25 +66,40 @@ ExtensionPoints = __decorate([
     ( __param(0, IInstantiationService))
 ], ExtensionPoints);
 ( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
-function computeConfiguration(configuration, isDiffEditor, overrides) {
+function computeConfiguration(configuration, overrides) {
     const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
-    if (isDiffEditor && isObject(configuration.diffEditor)) {
-        Object.assign(editorConfiguration, deepClone(configuration.diffEditor));
+    Object.assign(editorConfiguration, deepClone(overrides));
+    return editorConfiguration;
+}
+function computeDiffConfiguration(configuration, overrides) {
+    const editorConfiguration = computeConfiguration(configuration);
+    if (isObject(configuration.diffEditor)) {
+        const diffEditorConfiguration = deepClone(configuration.diffEditor);
+        diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+        delete diffEditorConfiguration.codeLens;
+        diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+        delete diffEditorConfiguration.wordWrap;
+        Object.assign(editorConfiguration, diffEditorConfiguration);
     }
+    editorConfiguration.accessibilityVerbose = configuration.accessibility?.verbosity?.diffEditor ?? false;
     Object.assign(editorConfiguration, deepClone(overrides));
     return editorConfiguration;
 }
 let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends createInjectedClass(StandaloneEditor) {
-    constructor(domElement, isDiffEditor, _options = {}, instantiationService, textResourceConfigurationService) {
+    constructor(domElement, _options = {}, instantiationService, textResourceConfigurationService) {
         const { theme, autoDetectHighContrast, model, value, language, accessibilityHelpUrl, ariaContainerElement, overflowWidgetsDomNode, dimension, ...options } = _options;
-        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options.model?.uri), isDiffEditor, options);
+        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options.model?.uri), options);
         super(instantiationService, domElement, { ...computedOptions, overflowWidgetsDomNode, dimension, theme, autoDetectHighContrast, model, value, language, accessibilityHelpUrl, ariaContainerElement });
-        this.isDiffEditor = isDiffEditor;
         this.textResourceConfigurationService = textResourceConfigurationService;
         this.optionsOverrides = {};
         this.lastAppliedEditorOptions = computedOptions;
         this.optionsOverrides = options;
-        this._register(textResourceConfigurationService.onDidChangeConfiguration(() => this.updateEditorConfiguration()));
+        this._register(textResourceConfigurationService.onDidChangeConfiguration((e) => {
+            const resource = this.getModel()?.uri;
+            if (resource != null && e.affectsConfiguration(resource, 'editor')) {
+                this.updateEditorConfiguration();
+            }
+        }));
         this._register(this.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
         this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
         this.updateEditorConfiguration();
@@ -98,7 +113,7 @@ let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends create
         if (configuration == null) {
             return;
         }
-        const editorConfiguration = computeConfiguration(configuration, this.isDiffEditor, this.optionsOverrides);
+        const editorConfiguration = computeConfiguration(configuration, this.optionsOverrides);
         let editorSettingsToApply = editorConfiguration;
         if (this.lastAppliedEditorOptions != null) {
             editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
@@ -118,14 +133,63 @@ let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends create
     }
 };
 ConfiguredStandaloneEditor = __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITextResourceConfigurationService))
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextResourceConfigurationService))
 ], ConfiguredStandaloneEditor);
-class ConfiguredStandaloneDiffEditor extends StandaloneDiffEditor2 {
+let ConfiguredStandaloneDiffEditor = class ConfiguredStandaloneDiffEditor extends createInjectedClass(StandaloneDiffEditor2) {
+    constructor(domElement, _options = {}, instantiationService, textResourceConfigurationService) {
+        const { theme, autoDetectHighContrast, modifiedAriaLabel, originalAriaLabel, overflowWidgetsDomNode, dimension, ...options } = _options;
+        const computedOptions = computeDiffConfiguration(textResourceConfigurationService.getValue(undefined), options);
+        super(instantiationService, domElement, { ...computedOptions, overflowWidgetsDomNode, dimension, theme, autoDetectHighContrast, modifiedAriaLabel, originalAriaLabel });
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.optionsOverrides = {};
+        this.lastAppliedEditorOptions = computedOptions;
+        this.optionsOverrides = options;
+        this._register(textResourceConfigurationService.onDidChangeConfiguration((e) => {
+            const resource = this._targetEditor.getModel()?.uri;
+            if (resource != null && (e.affectsConfiguration(resource, 'editor') || e.affectsConfiguration(resource, 'diffEditor') || e.affectsConfiguration(resource, 'accessibility.verbosity.diffEditor'))) {
+                this.updateEditorConfiguration();
+            }
+        }));
+        this._register(this._targetEditor.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
+        this.updateEditorConfiguration();
+    }
+    updateEditorConfiguration() {
+        if (this.getModel() == null || this.textResourceConfigurationService == null) {
+            return;
+        }
+        const resource = this._targetEditor.getModel()?.uri;
+        const configuration = this.textResourceConfigurationService.getValue(resource);
+        if (configuration == null) {
+            return;
+        }
+        const editorConfiguration = computeDiffConfiguration(configuration, this.optionsOverrides);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions != null) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (( Object.keys(editorSettingsToApply)).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            super.updateOptions(editorSettingsToApply);
+        }
+    }
+    updateOptions(newOptions) {
+        this.optionsOverrides ?? (this.optionsOverrides = {});
+        this.optionsOverrides = {
+            ...this.optionsOverrides,
+            ...newOptions
+        };
+        this.updateEditorConfiguration();
+    }
     _createInnerEditor(instantiationService, container, options) {
-        return instantiationService.createInstance(ConfiguredStandaloneEditor, container, true, options);
+        return instantiationService.createInstance(ConfiguredStandaloneEditor, container, options);
     }
-}
+};
+ConfiguredStandaloneDiffEditor = __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextResourceConfigurationService))
+], ConfiguredStandaloneDiffEditor);
 async function writeFile(uri, content) {
     await StandaloneServices.get(IFileService).writeFile(uri, VSBuffer.fromString(content));
 }
@@ -190,7 +254,7 @@ function getStandaloneEditorInstantiationService() {
 }
 const createConfiguredEditor = (domElement, options, override) => {
     StandaloneServices.initialize(override ?? {});
-    return getStandaloneEditorInstantiationService().createInstance(ConfiguredStandaloneEditor, domElement, false, options);
+    return getStandaloneEditorInstantiationService().createInstance(ConfiguredStandaloneEditor, domElement, options);
 };
 const createConfiguredDiffEditor = (domElement, options, override) => {
     StandaloneServices.initialize(override ?? {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.8",
+  "version": "1.83.10-next.0",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -16,6 +16,7 @@
   "private": false,
   "main": "api.js",
   "module": "api.js",
+  "types": "vscode.proposed.d.ts",
   "exports": {
     ".": {
       "default": "./api.js"
@@ -32,12 +33,14 @@
       "types": "./assets.d.ts",
       "default": "./assets.js"
     },
+    "./missing-services": {
+      "default": "./missing-services.js"
+    },
     "./lifecycle": {
       "types": "./lifecycle.d.ts",
       "default": "./lifecycle.js"
     },
     "./workbench": {
-      "types": "./workbench.d.ts",
       "default": "./workbench.js"
     },
     "./service-override/*": {
@@ -79,9 +82,6 @@
       "lifecycle": [
         "./lifecycle.d.ts"
       ],
-      "workbench": [
-        "./workbench.d.ts"
-      ],
       "l10n": [
         "./l10n.d.ts"
       ],
@@ -94,6 +94,12 @@
     "monaco-treemending": "./monaco-treemending.js"
   },
   "dependencies": {
-    "monaco-editor": "0.44.0"
+    "monaco-editor": "0.44.0",
+    "vscode-semver": "npm:semver@=5.5.0",
+    "@codingame/monaco-vscode-extensions-service-override": "1.83.10-next.0",
+    "@codingame/monaco-vscode-files-service-override": "1.83.10-next.0",
+    "@codingame/monaco-vscode-layout-service-override": "1.83.10-next.0",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.10-next.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.10-next.0"
   }
 }

package/services.d.ts

@@ -8,6 +8,7 @@ export { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/st
 import { ServiceIdentifier, GetLeadingNonServiceArgs, ServicesAccessor } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 export { IInstantiationService } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 export { IAction } from './vscode/src/vs/base/common/actions.js';
+export { IProductService } from './vscode/src/vs/platform/product/common/productService.js';
 import { IDisposable } from './vscode/src/vs/base/common/lifecycle.js';
 import { IWorkbenchConstructionOptions } from './vscode/src/vs/workbench/browser/web.api.js';
 export { SyncDescriptor } from './vscode/src/vs/platform/instantiation/common/descriptors.js';
@@ -25,7 +26,6 @@ export { DialogType, IBaseDialogOptions, ICheckbox, ICheckboxResult, IConfirmDia
 export { IFileService } from './vscode/src/vs/platform/files/common/files.js';
 export { IMarkerService } from './vscode/src/vs/platform/markers/common/markers.js';
 export { IOpenerService } from './vscode/src/vs/platform/opener/common/opener.js';
-export { IProductService } from './vscode/src/vs/platform/product/common/productService.js';
 export { IQuickInputService } from './vscode/src/vs/platform/quickinput/common/quickInput.js';
 export { ITelemetryService } from './vscode/src/vs/platform/telemetry/common/telemetry.js';
 export { IUriIdentityService } from './vscode/src/vs/platform/uriIdentity/common/uriIdentity.js';
@@ -75,8 +75,6 @@ export { IBannerService } from './vscode/src/vs/workbench/services/banner/browse
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService, IWorkspaceTrustUriInfo } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 
 declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement, configuration?: IWorkbenchConstructionOptions): Promise<void>;
-declare function waitServicesReady(): Promise<void>;
-declare function checkServicesReady(): void;
 declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;
 declare function createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): Promise<R>;
 declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
@@ -85,4 +83,4 @@ declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R
  */
 declare function withReadyServices(callback: (serviceAccessor: ServicesAccessor) => IDisposable): IDisposable;
 
-export { IWorkbenchConstructionOptions, checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };
+export { IWorkbenchConstructionOptions, createInstance, createInstanceSync, getService, initialize, withReadyServices };

package/services.js

@@ -3,15 +3,18 @@ export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.j
 export { StorageScope, StorageTarget } from './vscode/src/vs/platform/storage/common/storage.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 export { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import getServiceOverride from './service-override/layout.js';
-import getServiceOverride$1 from './service-override/environment.js';
-import getServiceOverride$2 from './service-override/extensions.js';
-import getServiceOverride$3 from './service-override/files.js';
-import getServiceOverride$4 from './service-override/quickaccess.js';
-import { startup, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+export { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import getServiceOverride$1 from '@codingame/monaco-vscode-layout-service-override';
+import getServiceOverride$1$1 from '@codingame/monaco-vscode-environment-service-override';
+import getServiceOverride$2 from '@codingame/monaco-vscode-extensions-service-override';
+import getServiceOverride$1$2 from '@codingame/monaco-vscode-files-service-override';
+import getServiceOverride$4 from '@codingame/monaco-vscode-quickaccess-service-override';
+import { checkServicesNotInitialized, startup, waitServicesReady, checkServicesReady, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
 import { initialize as initialize$1 } from './workbench.js';
 export { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
@@ -29,7 +32,6 @@ import './override/vs/platform/dialogs/common/dialogs.js';
 export { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 export { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
 export { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-export { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
 export { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
 export { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 export { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
@@ -77,34 +79,33 @@ export { ITitleService } from './vscode/src/vs/workbench/services/title/common/t
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
 export { IDialogService, IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
-let servicesInitialized = false;
-StandaloneServices.withServices(() => {
-    servicesInitialized = true;
-    return Disposable.None;
-});
 async function initialize(overrides, container = document.body, configuration = {}) {
-    if (servicesInitialized) {
-        throw new Error('The services are already initialized.');
-    }
+    checkServicesNotInitialized();
     initialize$1(container, configuration);
     const instantiationService = StandaloneServices.initialize({
-        ...getServiceOverride(),
+        [( IProductService.toString())]: mixin({
+            version: "1.83.0",
+            quality: 'oss',
+            commit: "e7e037083ff4455cf320e344325dacb480062c3c",
+            nameShort: 'Code - OSS Dev',
+            nameLong: 'Code - OSS Dev',
+            applicationName: 'code-oss',
+            dataFolderName: '.vscode-oss',
+            urlProtocol: 'code-oss',
+            reportIssueUrl: 'https://github.com/microsoft/vscode/issues/new',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt',
+            serverApplicationName: 'code-server-oss'
+        }, configuration.productConfiguration ?? {}),
         ...getServiceOverride$1(),
+        ...getServiceOverride$1$1(),
         ...getServiceOverride$2(),
-        ...getServiceOverride$3(),
+        ...getServiceOverride$1$2(),
         ...getServiceOverride$4(),
         ...overrides
     });
     await startup(instantiationService);
 }
-async function waitServicesReady() {
-    await serviceInitializedBarrier.wait();
-}
-function checkServicesReady() {
-    if (!serviceInitializedBarrier.isOpen()) {
-        throw new Error('Services are not ready yet');
-    }
-}
 async function getService(identifier) {
     await waitServicesReady();
     return StandaloneServices.get(identifier);
@@ -128,4 +129,4 @@ function withReadyServices(callback) {
     }));
     return disposable;
 }
-export { checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };
+export { createInstance, createInstanceSync, getService, initialize, withReadyServices };

package/vscode/src/vs/base/common/uriIpc.js

@@ -1,5 +1,19 @@
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+const DefaultURITransformer = new class {
+    transformIncoming(uri) {
+        return uri;
+    }
+    transformOutgoing(uri) {
+        return uri;
+    }
+    transformOutgoingURI(uri) {
+        return uri;
+    }
+    transformOutgoingScheme(scheme) {
+        return scheme;
+    }
+};
 function _transformIncomingURIs(obj, transformer, revive, depth) {
     if (!obj || depth > 200) {
         return null;
@@ -29,4 +43,11 @@ function transformIncomingURIs(obj, transformer) {
     }
     return result;
 }
-export { transformIncomingURIs };
+function transformAndReviveIncomingURIs(obj, transformer) {
+    const result = _transformIncomingURIs(obj, transformer, true, 0);
+    if (result === null) {
+        return obj;
+    }
+    return result;
+}
+export { DefaultURITransformer, transformAndReviveIncomingURIs, transformIncomingURIs };

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

@@ -1,8 +1,14 @@
 const offlineName = 'Offline';
+function isOfflineError(error) {
+    if (error instanceof OfflineError) {
+        return true;
+    }
+    return error instanceof Error && error.name === offlineName && error.message === offlineName;
+}
 class OfflineError extends Error {
     constructor() {
         super(offlineName);
         this.name = this.message;
     }
 }
-export { OfflineError };
+export { OfflineError, isOfflineError };

package/vscode/src/vs/platform/extensionManagement/common/extensionManagement.js

@@ -1,5 +1,9 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 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 WEB_EXTENSION_TAG = '__web_extension';
+const EXTENSION_INSTALL_SYNC_CONTEXT = 'extensionsSync';
+const EXTENSION_INSTALL_DEP_PACK_CONTEXT = 'dependecyOrPackExtensionInstall';
 function TargetPlatformToString(targetPlatform) {
     switch (targetPlatform) {
         case "win32-x64" : return 'Windows 64 bit';
@@ -18,6 +22,95 @@ function TargetPlatformToString(targetPlatform) {
         case "undefined" : return "undefined" ;
     }
 }
+function toTargetPlatform(targetPlatform) {
+    switch (targetPlatform) {
+        case "win32-x64" : return "win32-x64" ;
+        case "win32-ia32" : return "win32-ia32" ;
+        case "win32-arm64" : return "win32-arm64" ;
+        case "linux-x64" : return "linux-x64" ;
+        case "linux-arm64" : return "linux-arm64" ;
+        case "linux-armhf" : return "linux-armhf" ;
+        case "alpine-x64" : return "alpine-x64" ;
+        case "alpine-arm64" : return "alpine-arm64" ;
+        case "darwin-x64" : return "darwin-x64" ;
+        case "darwin-arm64" : return "darwin-arm64" ;
+        case "web" : return "web" ;
+        case "universal" : return "universal" ;
+        default: return "unknown" ;
+    }
+}
+function getTargetPlatform(platform, arch) {
+    switch (platform) {
+        case 3 :
+            if (arch === 'x64') {
+                return "win32-x64" ;
+            }
+            if (arch === 'ia32') {
+                return "win32-ia32" ;
+            }
+            if (arch === 'arm64') {
+                return "win32-arm64" ;
+            }
+            return "unknown" ;
+        case 2 :
+            if (arch === 'x64') {
+                return "linux-x64" ;
+            }
+            if (arch === 'arm64') {
+                return "linux-arm64" ;
+            }
+            if (arch === 'arm') {
+                return "linux-armhf" ;
+            }
+            return "unknown" ;
+        case 'alpine':
+            if (arch === 'x64') {
+                return "alpine-x64" ;
+            }
+            if (arch === 'arm64') {
+                return "alpine-arm64" ;
+            }
+            return "unknown" ;
+        case 1 :
+            if (arch === 'x64') {
+                return "darwin-x64" ;
+            }
+            if (arch === 'arm64') {
+                return "darwin-arm64" ;
+            }
+            return "unknown" ;
+        case 0 : return "web" ;
+    }
+}
+function isNotWebExtensionInWebTargetPlatform(allTargetPlatforms, productTargetPlatform) {
+    return productTargetPlatform === "web"  && !allTargetPlatforms.includes("web" );
+}
+function isTargetPlatformCompatible(extensionTargetPlatform, allTargetPlatforms, productTargetPlatform) {
+    if (isNotWebExtensionInWebTargetPlatform(allTargetPlatforms, productTargetPlatform)) {
+        return false;
+    }
+    if (extensionTargetPlatform === "undefined" ) {
+        return true;
+    }
+    if (extensionTargetPlatform === "universal" ) {
+        return true;
+    }
+    if (extensionTargetPlatform === "unknown" ) {
+        return false;
+    }
+    if (extensionTargetPlatform === productTargetPlatform) {
+        return true;
+    }
+    const fallbackTargetPlatforms = getFallbackTargetPlarforms(productTargetPlatform);
+    return fallbackTargetPlatforms.includes(extensionTargetPlatform);
+}
+function getFallbackTargetPlarforms(targetPlatform) {
+    switch (targetPlatform) {
+        case "win32-x64" : return ["win32-ia32" ];
+        case "win32-arm64" : return ["win32-ia32" ];
+    }
+    return [];
+}
 const IExtensionGalleryService = ( createDecorator('extensionGalleryService'));
 var ExtensionManagementErrorCode;
 ( (function(ExtensionManagementErrorCode) {
@@ -37,5 +130,27 @@ var ExtensionManagementErrorCode;
     ExtensionManagementErrorCode["Signature"] = "Signature";
     ExtensionManagementErrorCode["Internal"] = "Internal";
 })(ExtensionManagementErrorCode || (ExtensionManagementErrorCode = {})));
+class ExtensionManagementError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = code;
+    }
+}
 const IExtensionManagementService = ( createDecorator('extensionManagementService'));
-export { EXTENSION_IDENTIFIER_PATTERN, ExtensionManagementErrorCode, IExtensionGalleryService, IExtensionManagementService, TargetPlatformToString };
+const DISABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/disabled';
+const ENABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/enabled';
+const IGlobalExtensionEnablementService = ( createDecorator('IGlobalExtensionEnablementService'));
+const IExtensionTipsService = ( createDecorator('IExtensionTipsService'));
+const ExtensionsLabel = ( localizeWithPath(
+    'vs/platform/extensionManagement/common/extensionManagement',
+    'extensions',
+    "Extensions"
+));
+const ExtensionsLocalizedLabel = { value: ExtensionsLabel, original: 'Extensions' };
+const PreferencesLocalizedLabel = { value: ( localizeWithPath(
+    'vs/platform/extensionManagement/common/extensionManagement',
+    'preferences',
+    "Preferences"
+)), original: 'Preferences' };
+export { DISABLED_EXTENSIONS_STORAGE_PATH, ENABLED_EXTENSIONS_STORAGE_PATH, EXTENSION_IDENTIFIER_PATTERN, EXTENSION_INSTALL_DEP_PACK_CONTEXT, EXTENSION_INSTALL_SYNC_CONTEXT, ExtensionManagementError, ExtensionManagementErrorCode, ExtensionsLabel, ExtensionsLocalizedLabel, IExtensionGalleryService, IExtensionManagementService, IExtensionTipsService, IGlobalExtensionEnablementService, PreferencesLocalizedLabel, TargetPlatformToString, WEB_EXTENSION_TAG, getFallbackTargetPlarforms, getTargetPlatform, isNotWebExtensionInWebTargetPlatform, isTargetPlatformCompatible, toTargetPlatform };

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

@@ -1,5 +1,11 @@
 import { compareIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { UNDEFINED_PUBLISHER } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { getTargetPlatform } from './extensionManagement.js';
+import { UNDEFINED_PUBLISHER, ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { isLinux, platform } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { arch } from 'monaco-editor/esm/vs/base/common/process.js';
+import { TelemetryTrustedValue } from '../../telemetry/common/telemetryUtils.js';
 function areSameExtensions(a, b) {
     if (a.uuid && b.uuid) {
         return a.uuid === b.uuid;
@@ -9,6 +15,40 @@ function areSameExtensions(a, b) {
     }
     return compareIgnoreCase(a.id, b.id) === 0;
 }
+const ExtensionKeyRegex = /^([^.]+\..+)-(\d+\.\d+\.\d+)(-(.+))?$/;
+class ExtensionKey {
+    static create(extension) {
+        const version = extension.manifest ? extension.manifest.version : extension.version;
+        const targetPlatform = extension.manifest ? extension.targetPlatform : extension.properties.targetPlatform;
+        return ( new ExtensionKey(extension.identifier, version, targetPlatform));
+    }
+    static parse(key) {
+        const matches = ExtensionKeyRegex.exec(key);
+        return matches && matches[1] && matches[2] ? ( new ExtensionKey({ id: matches[1] }, matches[2], matches[4] || undefined)) : null;
+    }
+    constructor(identifier, version, targetPlatform = "undefined" ) {
+        this.version = version;
+        this.targetPlatform = targetPlatform;
+        this.id = identifier.id;
+    }
+    toString() {
+        return `${this.id}-${this.version}${this.targetPlatform !== "undefined"  ? `-${this.targetPlatform}` : ''}`;
+    }
+    equals(o) {
+        if (!(o instanceof ExtensionKey)) {
+            return false;
+        }
+        return areSameExtensions(this, o) && this.version === o.version && this.targetPlatform === o.targetPlatform;
+    }
+}
+const EXTENSION_IDENTIFIER_WITH_VERSION_REGEX = /^([^.]+\..+)@((prerelease)|(\d+\.\d+\.\d+(-.*)?))$/;
+function getIdAndVersion(id) {
+    const matches = EXTENSION_IDENTIFIER_WITH_VERSION_REGEX.exec(id);
+    if (matches && matches[1]) {
+        return [adoptToGalleryExtensionId(matches[1]), matches[2]];
+    }
+    return [adoptToGalleryExtensionId(id), undefined];
+}
 function getExtensionId(publisher, name) {
     return `${publisher}.${name}`;
 }
@@ -18,6 +58,55 @@ function adoptToGalleryExtensionId(id) {
 function getGalleryExtensionId(publisher, name) {
     return adoptToGalleryExtensionId(getExtensionId(publisher ?? UNDEFINED_PUBLISHER, name));
 }
+function groupByExtension(extensions, getExtensionIdentifier) {
+    const byExtension = [];
+    const findGroup = (extension) => {
+        for (const group of byExtension) {
+            if (( group.some(
+                e => areSameExtensions(getExtensionIdentifier(e), getExtensionIdentifier(extension))
+            ))) {
+                return group;
+            }
+        }
+        return null;
+    };
+    for (const extension of extensions) {
+        const group = findGroup(extension);
+        if (group) {
+            group.push(extension);
+        }
+        else {
+            byExtension.push([extension]);
+        }
+    }
+    return byExtension;
+}
+function getLocalExtensionTelemetryData(extension) {
+    return {
+        id: extension.identifier.id,
+        name: extension.manifest.name,
+        galleryId: null,
+        publisherId: extension.publisherId,
+        publisherName: extension.manifest.publisher,
+        publisherDisplayName: extension.publisherDisplayName,
+        dependencies: extension.manifest.extensionDependencies && extension.manifest.extensionDependencies.length > 0
+    };
+}
+function getGalleryExtensionTelemetryData(extension) {
+    return {
+        id: ( new TelemetryTrustedValue(extension.identifier.id)),
+        name: ( new TelemetryTrustedValue(extension.name)),
+        galleryId: extension.identifier.uuid,
+        publisherId: extension.publisherId,
+        publisherName: extension.publisher,
+        publisherDisplayName: extension.publisherDisplayName,
+        isPreReleaseVersion: extension.properties.isPreReleaseVersion,
+        dependencies: !!(extension.properties.dependencies && extension.properties.dependencies.length > 0),
+        isSigned: extension.isSigned,
+        ...extension.telemetryData
+    };
+}
+const BetterMergeId = ( new ExtensionIdentifier('pprice.better-merge'));
 function getExtensionDependencies(installedExtensions, extension) {
     const dependencies = [];
     const extensions = extension.manifest.extensionDependencies?.slice(0) ?? [];
@@ -33,4 +122,30 @@ function getExtensionDependencies(installedExtensions, extension) {
     }
     return dependencies;
 }
-export { adoptToGalleryExtensionId, areSameExtensions, getExtensionDependencies, getExtensionId, getGalleryExtensionId };
+async function isAlpineLinux(fileService, logService) {
+    if (!isLinux) {
+        return false;
+    }
+    let content;
+    try {
+        const fileContent = await fileService.readFile(URI.file('/etc/os-release'));
+        content = ( fileContent.value.toString());
+    }
+    catch (error) {
+        try {
+            const fileContent = await fileService.readFile(URI.file('/usr/lib/os-release'));
+            content = ( fileContent.value.toString());
+        }
+        catch (error) {
+            logService.debug(`Error while getting the os-release file.`, getErrorMessage(error));
+        }
+    }
+    return !!content && (content.match(/^ID=([^\u001b\r\n]*)/m) || [])[1] === 'alpine';
+}
+async function computeTargetPlatform(fileService, logService) {
+    const alpineLinux = await isAlpineLinux(fileService, logService);
+    const targetPlatform = getTargetPlatform(alpineLinux ? 'alpine' : platform, arch);
+    logService.debug('ComputeTargetPlatform:', targetPlatform);
+    return targetPlatform;
+}
+export { BetterMergeId, ExtensionKey, adoptToGalleryExtensionId, areSameExtensions, computeTargetPlatform, getExtensionDependencies, getExtensionId, getGalleryExtensionId, getGalleryExtensionTelemetryData, getIdAndVersion, getLocalExtensionTelemetryData, groupByExtension };