@codingame/monaco-vscode-api 1.83.8 → 1.83.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.8",
+  "version": "1.83.9",
   "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.9",
+    "@codingame/monaco-vscode-files-service-override": "1.83.9",
+    "@codingame/monaco-vscode-layout-service-override": "1.83.9",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.9",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.9"
   }
 }

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

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

@@ -0,0 +1,10 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+function RecommendationSourceToString(source) {
+    switch (source) {
+        case 1 : return 'file';
+        case 2 : return 'workspace';
+        case 3 : return 'exe';
+    }
+}
+const IExtensionRecommendationNotificationService = ( createDecorator('IExtensionRecommendationNotificationService'));
+export { IExtensionRecommendationNotificationService, RecommendationSourceToString };

package/vscode/src/vs/platform/extensionResourceLoader/browser/extensionResourceLoaderService.js

@@ -0,0 +1,42 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { FileAccess, Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { AbstractExtensionResourceLoaderService } from '../common/extensionResourceLoader.js';
+let ExtensionResourceLoaderService = class ExtensionResourceLoaderService extends AbstractExtensionResourceLoaderService {
+    constructor(fileService, storageService, productService, environmentService, configurationService, _logService) {
+        super(fileService, storageService, productService, environmentService, configurationService);
+        this._logService = _logService;
+    }
+    async readExtensionResource(uri) {
+        uri = FileAccess.uriToBrowserUri(uri);
+        if (uri.scheme !== Schemas.http && uri.scheme !== Schemas.https) {
+            const result = await this._fileService.readFile(uri);
+            return ( result.value.toString());
+        }
+        const requestInit = {};
+        if (this.isExtensionGalleryResource(uri)) {
+            requestInit.headers = await this.getExtensionGalleryRequestHeaders();
+            requestInit.mode = 'cors';
+        }
+        const response = await fetch(( uri.toString(true)), requestInit);
+        if (response.status !== 200) {
+            this._logService.info(`Request to '${( uri.toString(true))}' failed with status code ${response.status}`);
+            throw new Error(response.statusText);
+        }
+        return response.text();
+    }
+};
+ExtensionResourceLoaderService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IProductService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ILogService))
+], ExtensionResourceLoaderService));
+export { ExtensionResourceLoaderService };

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

@@ -8,6 +8,17 @@ import { RemoteAuthorities } from 'monaco-editor/esm/vs/base/common/network.js';
 import { getRemoteServerRootPath } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
 const WEB_EXTENSION_RESOURCE_END_POINT = 'web-extension-resource';
 const IExtensionResourceLoaderService = ( createDecorator('extensionResourceLoaderService'));
+function migratePlatformSpecificExtensionGalleryResourceURL(resource, targetPlatform) {
+    if (resource.query !== `target=${targetPlatform}`) {
+        return undefined;
+    }
+    const paths = resource.path.split('/');
+    if (!paths[3]) {
+        return undefined;
+    }
+    paths[3] = `${paths[3]}+${targetPlatform}`;
+    return resource.with({ query: null, path: paths.join('/') });
+}
 class AbstractExtensionResourceLoaderService {
     constructor(_fileService, _storageService, _productService, _environmentService, _configurationService) {
         this._fileService = _fileService;
@@ -74,4 +85,4 @@ class AbstractExtensionResourceLoaderService {
         return uri.path.startsWith(this._webExtensionResourceEndPoint);
     }
 }
-export { AbstractExtensionResourceLoaderService, IExtensionResourceLoaderService };
+export { AbstractExtensionResourceLoaderService, IExtensionResourceLoaderService, migratePlatformSpecificExtensionGalleryResourceURL };