@codingame/monaco-vscode-api 1.83.7 → 1.83.9

package/monaco.d.ts

@@ -18,12 +18,17 @@ export { ContextKeyExpr, RawContextKey } from './vscode/src/vs/platform/contextk
 import { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
 import { KeybindingResolver } from './vscode/src/vs/platform/keybinding/common/keybindingResolver.js';
 import { ResolvedKeybindingItem } from './vscode/src/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+import { Event } from './vscode/src/vs/base/common/event.js';
 
 declare function writeFile(uri: URI, content: string): Promise<void>;
 declare function deleteFile(uri: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
 declare function createModelReference(resource: URI, content?: string): Promise<IReference<ITextFileEditorModel>>;
+interface KeybindingProvider {
+    provideKeybindings(): ResolvedKeybindingItem[];
+    onDidChangeKeybindings: Event<void>;
+}
 interface DynamicKeybindingService extends IKeybindingService {
-    registerKeybindingProvider(provider: () => ResolvedKeybindingItem[]): IDisposable;
+    registerKeybindingProvider(provider: KeybindingProvider): IDisposable;
     _getResolver(): KeybindingResolver;
 }
 declare const createConfiguredEditor: typeof create;
@@ -33,4 +38,4 @@ declare const Extensions: {
     JSONContribution: string;
 };
 
-export { type DynamicKeybindingService, Extensions, IReference, ITextFileEditorModel, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };
+export { type DynamicKeybindingService, Extensions, IReference, ITextFileEditorModel, type KeybindingProvider, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };

package/monaco.js

@@ -36,6 +36,7 @@ import { INotificationService } from 'monaco-editor/esm/vs/platform/notification
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Emitter } from 'monaco-editor';
 import { createInjectedClass } from './tools/injection.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/workbenchReferenceSearch.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/menuPreventer.js';
@@ -144,11 +145,21 @@ let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingServ
     constructor(delegate, contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
         super(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService);
         this.delegate = delegate;
-        this._register(delegate.registerKeybindingProvider(() => this.getUserKeybindingItems()));
+        this._onDidChangeKeybindings = new Emitter();
+        this._register(delegate.registerKeybindingProvider({
+            provideKeybindings: () => {
+                return this.getUserKeybindingItems();
+            },
+            onDidChangeKeybindings: this._onDidChangeKeybindings.event
+        }));
     }
     _getResolver() {
         return this.delegate._getResolver();
     }
+    updateResolver() {
+        super.updateResolver();
+        this._onDidChangeKeybindings.fire();
+    }
     resolveKeyboardEvent(keyboardEvent) {
         return this.delegate.resolveKeyboardEvent(keyboardEvent);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.7",
+  "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,10 +33,16 @@
       "types": "./assets.d.ts",
       "default": "./assets.js"
     },
+    "./missing-services": {
+      "default": "./missing-services.js"
+    },
     "./lifecycle": {
       "types": "./lifecycle.d.ts",
       "default": "./lifecycle.js"
     },
+    "./workbench": {
+      "default": "./workbench.js"
+    },
     "./service-override/*": {
       "types": "./service-override/*.d.ts",
       "default": "./service-override/*.js"
@@ -87,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/service-override/tools/editor.d.ts

@@ -8,12 +8,12 @@ import { IWorkspaceContextService } from '../../vscode/src/vs/platform/workspace
 import { IUriIdentityService } from '../../vscode/src/vs/platform/uriIdentity/common/uriIdentity.js';
 import { ICodeEditor, IDiffEditor } from '../../vscode/src/vs/editor/browser/editorBrowser.js';
 import { IEditorOptions, IResourceEditorInput, ITextResourceEditorInput } from '../../vscode/src/vs/platform/editor/common/editor.js';
+import { IHostService } from '../../vscode/src/vs/workbench/services/host/browser/host.js';
 import { IEditorGroupsService } from '../../vscode/src/vs/workbench/services/editor/common/editorGroupsService.js';
 import { EditorInput } from '../../vscode/src/vs/workbench/common/editor/editorInput.js';
 import { PreferredGroup } from '../../vscode/src/vs/workbench/services/editor/common/editorService.js';
 import { IEditorResolverService } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
 import { ITextEditorService } from '../../vscode/src/vs/workbench/services/textfile/common/textEditorService.js';
-import { IHostService } from '../../vscode/src/vs/workbench/services/host/browser/host.js';
 import { IWorkspaceTrustRequestService } from '../../vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 import { EditorService } from '../../vscode/src/vs/workbench/services/editor/browser/editorService.js';
 

package/services.d.ts

@@ -8,7 +8,9 @@ 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';
 export { ICommandService } from './vscode/src/vs/platform/commands/common/commands.js';
 export { INeverShowAgainOptions, INotification, INotificationActions, INotificationHandle, INotificationProgress, INotificationProgressProperties, INotificationProperties, INotificationService, IPromptChoice, IPromptChoiceWithMenu, IPromptOptions, IStatusMessageOptions, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationMessage, NotificationPriority, NotificationsFilter } from './vscode/src/vs/platform/notification/common/notification.js';
@@ -24,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';
@@ -73,9 +74,7 @@ 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, IWorkspaceTrustUriInfo } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 
-declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement): Promise<void>;
-declare function waitServicesReady(): Promise<void>;
-declare function checkServicesReady(): void;
+declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement, configuration?: IWorkbenchConstructionOptions): Promise<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;
@@ -84,4 +83,4 @@ declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R
  */
 declare function withReadyServices(callback: (serviceAccessor: ServicesAccessor) => IDisposable): IDisposable;
 
-export { checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };
+export { IWorkbenchConstructionOptions, createInstance, createInstanceSync, getService, initialize, withReadyServices };

package/services.js

@@ -3,15 +3,19 @@ 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';
 export { INotificationService, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationPriority, NotificationsFilter } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -28,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';
@@ -76,33 +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) {
-    if (servicesInitialized) {
-        throw new Error('The services are already initialized.');
-    }
+async function initialize(overrides, container = document.body, configuration = {}) {
+    checkServicesNotInitialized();
+    initialize$1(container, configuration);
     const instantiationService = StandaloneServices.initialize({
-        ...getServiceOverride(container),
+        [( 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);
@@ -126,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 };