@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

package/vscode/src/vs/workbench/contrib/extensions/browser/workspaceRecommendations.js

@@ -0,0 +1,88 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { EXTENSION_IDENTIFIER_PATTERN } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { distinct, flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ExtensionRecommendations } from './extensionRecommendations.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IWorkspaceExtensionsConfigService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig';
+
+let WorkspaceRecommendations = class WorkspaceRecommendations extends ExtensionRecommendations {
+    get recommendations() { return this._recommendations; }
+    get ignoredRecommendations() { return this._ignoredRecommendations; }
+    constructor(workspaceExtensionsConfigService, notificationService) {
+        super();
+        this.workspaceExtensionsConfigService = workspaceExtensionsConfigService;
+        this.notificationService = notificationService;
+        this._recommendations = [];
+        this._onDidChangeRecommendations = this._register(( new Emitter()));
+        this.onDidChangeRecommendations = this._onDidChangeRecommendations.event;
+        this._ignoredRecommendations = [];
+    }
+    async doActivate() {
+        await this.fetch();
+        this._register(this.workspaceExtensionsConfigService.onDidChangeExtensionsConfigs(() => this.onDidChangeExtensionsConfigs()));
+    }
+    async fetch() {
+        const extensionsConfigs = await this.workspaceExtensionsConfigService.getExtensionsConfigs();
+        const { invalidRecommendations, message } = await this.validateExtensions(extensionsConfigs);
+        if (invalidRecommendations.length) {
+            this.notificationService.warn(`The ${invalidRecommendations.length} extension(s) below, in workspace recommendations have issues:\n${message}`);
+        }
+        this._recommendations = [];
+        this._ignoredRecommendations = [];
+        for (const extensionsConfig of extensionsConfigs) {
+            if (extensionsConfig.unwantedRecommendations) {
+                for (const unwantedRecommendation of extensionsConfig.unwantedRecommendations) {
+                    if (invalidRecommendations.indexOf(unwantedRecommendation) === -1) {
+                        this._ignoredRecommendations.push(unwantedRecommendation);
+                    }
+                }
+            }
+            if (extensionsConfig.recommendations) {
+                for (const extensionId of extensionsConfig.recommendations) {
+                    if (invalidRecommendations.indexOf(extensionId) === -1) {
+                        this._recommendations.push({
+                            extensionId,
+                            reason: {
+                                reasonId: 0 ,
+                                reasonText: ( localizeWithPath(
+                                    'vs/workbench/contrib/extensions/browser/workspaceRecommendations',
+                                    'workspaceRecommendation',
+                                    "This extension is recommended by users of the current workspace."
+                                ))
+                            }
+                        });
+                    }
+                }
+            }
+        }
+    }
+    async validateExtensions(contents) {
+        const validExtensions = [];
+        const invalidExtensions = [];
+        let message = '';
+        const allRecommendations = distinct(flatten(( contents.map(({ recommendations }) => recommendations || []))));
+        const regEx = ( new RegExp(EXTENSION_IDENTIFIER_PATTERN));
+        for (const extensionId of allRecommendations) {
+            if (regEx.test(extensionId)) {
+                validExtensions.push(extensionId);
+            }
+            else {
+                invalidExtensions.push(extensionId);
+                message += `${extensionId} (bad format) Expected: <provider>.<name>\n`;
+            }
+        }
+        return { validRecommendations: validExtensions, invalidRecommendations: invalidExtensions, message };
+    }
+    async onDidChangeExtensionsConfigs() {
+        await this.fetch();
+        this._onDidChangeRecommendations.fire();
+    }
+};
+WorkspaceRecommendations = ( __decorate([
+    ( __param(0, IWorkspaceExtensionsConfigService)),
+    ( __param(1, INotificationService))
+], WorkspaceRecommendations));
+
+export { WorkspaceRecommendations };

package/vscode/src/vs/workbench/contrib/extensions/common/extensionQuery.js

@@ -0,0 +1,67 @@
+import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { EXTENSION_CATEGORIES } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+
+class Query {
+    constructor(value, sortBy, groupBy) {
+        this.value = value;
+        this.sortBy = sortBy;
+        this.groupBy = groupBy;
+        this.value = value.trim();
+    }
+    static suggestions(query) {
+        const commands = ['installed', 'updates', 'enabled', 'disabled', 'builtin', 'featured', 'popular', 'recommended', 'recentlyPublished', 'workspaceUnsupported', 'deprecated', 'sort', 'category', 'tag', 'ext', 'id'];
+        const subcommands = {
+            'sort': ['installs', 'rating', 'name', 'publishedDate', 'updateDate'],
+            'category': ( EXTENSION_CATEGORIES.map(c => `"${c.toLowerCase()}"`)),
+            'tag': [''],
+            'ext': [''],
+            'id': ['']
+        };
+        const queryContains = (substr) => query.indexOf(substr) > -1;
+        const hasSort = ( subcommands.sort.some(subcommand => queryContains(`@sort:${subcommand}`)));
+        const hasCategory = ( subcommands.category.some(subcommand => queryContains(`@category:${subcommand}`)));
+        return flatten(( commands.map(command => {
+            if (hasSort && command === 'sort' || hasCategory && command === 'category') {
+                return [];
+            }
+            if (command in subcommands) {
+                return ( subcommands[command]
+                    .map(subcommand => `@${command}:${subcommand}${subcommand === '' ? '' : ' '}`));
+            }
+            else {
+                return queryContains(`@${command}`) ? [] : [`@${command} `];
+            }
+        })));
+    }
+    static parse(value) {
+        let sortBy = '';
+        value = value.replace(/@sort:(\w+)(-\w*)?/g, (match, by, order) => {
+            sortBy = by;
+            return '';
+        });
+        let groupBy = '';
+        value = value.replace(/@group:(\w+)(-\w*)?/g, (match, by, order) => {
+            groupBy = by;
+            return '';
+        });
+        return ( new Query(value, sortBy, groupBy));
+    }
+    toString() {
+        let result = this.value;
+        if (this.sortBy) {
+            result = `${result}${result ? ' ' : ''}@sort:${this.sortBy}`;
+        }
+        if (this.groupBy) {
+            result = `${result}${result ? ' ' : ''}@group:${this.groupBy}`;
+        }
+        return result;
+    }
+    isValid() {
+        return !/@outdated/.test(this.value);
+    }
+    equals(other) {
+        return this.value === other.value && this.sortBy === other.sortBy;
+    }
+}
+
+export { Query };

package/vscode/src/vs/workbench/contrib/extensions/common/extensionsInput.js

@@ -0,0 +1,43 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { join } from 'monaco-editor/esm/vs/base/common/path.js';
+
+class ExtensionsInput extends EditorInput {
+    static { this.ID = 'workbench.extensions.input2'; }
+    get typeId() {
+        return ExtensionsInput.ID;
+    }
+    get capabilities() {
+        return 2  | 8 ;
+    }
+    get resource() {
+        return ( URI.from({
+            scheme: Schemas.extension,
+            path: join(this._extension.identifier.id, 'extension')
+        }));
+    }
+    constructor(_extension) {
+        super();
+        this._extension = _extension;
+    }
+    get extension() { return this._extension; }
+    getName() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/extensions/common/extensionsInput',
+            'extensionsInputName',
+            "Extension: {0}",
+            this._extension.displayName
+        ));
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return other instanceof ExtensionsInput && areSameExtensions(this._extension.identifier, other._extension.identifier);
+    }
+}
+
+export { ExtensionsInput };

package/vscode/src/vs/workbench/contrib/extensions/common/extensionsUtils.js

@@ -0,0 +1,104 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IExtensionRecommendationsService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/extensionRecommendations';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+
+let KeymapExtensions = class KeymapExtensions extends Disposable {
+    constructor(instantiationService, extensionEnablementService, tipsService, lifecycleService, notificationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.tipsService = tipsService;
+        this.notificationService = notificationService;
+        this._register(lifecycleService.onDidShutdown(() => this.dispose()));
+        this._register(instantiationService.invokeFunction(onExtensionChanged)((identifiers => {
+            Promise.all(( identifiers.map(identifier => this.checkForOtherKeymaps(identifier))))
+                .then(undefined, onUnexpectedError);
+        })));
+    }
+    checkForOtherKeymaps(extensionIdentifier) {
+        return this.instantiationService.invokeFunction(getInstalledExtensions).then(extensions => {
+            const keymaps = extensions.filter(extension => isKeymapExtension(this.tipsService, extension));
+            const extension = keymaps.find(extension => areSameExtensions(extension.identifier, extensionIdentifier));
+            if (extension && extension.globallyEnabled) {
+                const otherKeymaps = keymaps.filter(extension => !areSameExtensions(extension.identifier, extensionIdentifier) && extension.globallyEnabled);
+                if (otherKeymaps.length) {
+                    return this.promptForDisablingOtherKeymaps(extension, otherKeymaps);
+                }
+            }
+            return undefined;
+        });
+    }
+    promptForDisablingOtherKeymaps(newKeymap, oldKeymaps) {
+        const onPrompt = (confirmed) => {
+            if (confirmed) {
+                this.extensionEnablementService.setEnablement(( oldKeymaps.map(keymap => keymap.local)), 6 );
+            }
+        };
+        this.notificationService.prompt(Severity.Info, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/common/extensionsUtils',
+            'disableOtherKeymapsConfirmation',
+            "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
+            ( oldKeymaps.map(k => `'${k.local.manifest.displayName}'`)).join(', ')
+        )), [{
+                label: ( localizeWithPath('vs/workbench/contrib/extensions/common/extensionsUtils', 'yes', "Yes")),
+                run: () => onPrompt(true)
+            }, {
+                label: ( localizeWithPath('vs/workbench/contrib/extensions/common/extensionsUtils', 'no', "No")),
+                run: () => onPrompt(false)
+            }]);
+    }
+};
+KeymapExtensions = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkbenchExtensionEnablementService)),
+    ( __param(2, IExtensionRecommendationsService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, INotificationService))
+], KeymapExtensions));
+function onExtensionChanged(accessor) {
+    const extensionService = accessor.get(IExtensionManagementService);
+    const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
+    const onDidInstallExtensions = Event.chain(extensionService.onDidInstallExtensions, $ => ( $.filter(e => ( e.some(({ operation }) => operation === 2 )))
+        .map(e => ( e.map(({ identifier }) => identifier)))));
+    return Event.debounce(Event.any(Event.any(onDidInstallExtensions, ( Event.map(extensionService.onDidUninstallExtension, e => [e.identifier]))), ( Event.map(
+        extensionEnablementService.onEnablementChanged,
+        extensions => ( extensions.map(e => e.identifier))
+    ))), (result, identifiers) => {
+        result = result || [];
+        for (const identifier of identifiers) {
+            if (( result.some(l => !areSameExtensions(l, identifier)))) {
+                result.push(identifier);
+            }
+        }
+        return result;
+    });
+}
+async function getInstalledExtensions(accessor) {
+    const extensionService = accessor.get(IExtensionManagementService);
+    const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
+    const extensions = await extensionService.getInstalled();
+    return ( extensions.map(extension => {
+        return {
+            identifier: extension.identifier,
+            local: extension,
+            globallyEnabled: extensionEnablementService.isEnabled(extension)
+        };
+    }));
+}
+function isKeymapExtension(tipsService, extension) {
+    const cats = extension.local.manifest.categories;
+    return cats && cats.indexOf('Keymaps') !== -1 || ( tipsService.getKeymapRecommendations().some(
+        extensionId => areSameExtensions({ id: extensionId }, extension.local.identifier)
+    ));
+}
+
+export { KeymapExtensions, getInstalledExtensions };

package/vscode/src/vs/workbench/contrib/extensions/common/reportExtensionIssueAction.js

@@ -0,0 +1,31 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IWorkbenchIssueService } from 'vscode/vscode/vs/workbench/services/issue/common/issue';
+
+var ReportExtensionIssueAction_1;
+let ReportExtensionIssueAction = class ReportExtensionIssueAction extends Action {
+    static { ReportExtensionIssueAction_1 = this; }
+    static { this._id = 'workbench.extensions.action.reportExtensionIssue'; }
+    static { this._label = ( nls.localizeWithPath(
+        'vs/workbench/contrib/extensions/common/reportExtensionIssueAction',
+        'reportExtensionIssue',
+        "Report Issue"
+    )); }
+    constructor(extension, issueService) {
+        super(ReportExtensionIssueAction_1._id, ReportExtensionIssueAction_1._label, 'extension-action report-issue');
+        this.extension = extension;
+        this.issueService = issueService;
+        this.enabled = extension.isBuiltin || (!!extension.repository && !!extension.repository.url);
+    }
+    async run() {
+        await this.issueService.openReporter({
+            extensionId: this.extension.identifier.value,
+        });
+    }
+};
+ReportExtensionIssueAction = ReportExtensionIssueAction_1 = ( __decorate([
+    ( __param(1, IWorkbenchIssueService))
+], ReportExtensionIssueAction));
+
+export { ReportExtensionIssueAction };

package/vscode/src/vs/workbench/contrib/extensions/common/runtimeExtensionsInput.js

@@ -0,0 +1,41 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+
+class RuntimeExtensionsInput extends EditorInput {
+    constructor() {
+        super(...arguments);
+        this.resource = ( URI.from({
+            scheme: 'runtime-extensions',
+            path: 'default'
+        }));
+    }
+    static { this.ID = 'workbench.runtimeExtensions.input'; }
+    get typeId() {
+        return RuntimeExtensionsInput.ID;
+    }
+    get capabilities() {
+        return 2  | 8 ;
+    }
+    static get instance() {
+        if (!RuntimeExtensionsInput._instance || RuntimeExtensionsInput._instance.isDisposed()) {
+            RuntimeExtensionsInput._instance = ( new RuntimeExtensionsInput());
+        }
+        return RuntimeExtensionsInput._instance;
+    }
+    getName() {
+        return ( nls.localizeWithPath(
+            'vs/workbench/contrib/extensions/common/runtimeExtensionsInput',
+            'extensionsInputName',
+            "Running Extensions"
+        ));
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return other instanceof RuntimeExtensionsInput;
+    }
+}
+
+export { RuntimeExtensionsInput };

package/vscode/src/vs/workbench/contrib/markdown/browser/markdownDocumentRenderer.js

@@ -0,0 +1,207 @@
+import { hookDomPurifyHrefAndSrcSanitizer, basicMarkupHtmlTags } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as dompurify from 'monaco-editor/esm/vs/base/browser/dompurify/dompurify.js';
+import { allowedMarkdownAttr } from 'monaco-editor/esm/vs/base/browser/markdownRenderer.js';
+import { marked } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { tokenizeToString } from 'monaco-editor/esm/vs/editor/common/languages/textToHtmlTokenizer.js';
+import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
+
+const DEFAULT_MARKDOWN_STYLES = `
+body {
+	padding: 10px 20px;
+	line-height: 22px;
+	max-width: 882px;
+	margin: 0 auto;
+}
+
+body *:last-child {
+	margin-bottom: 0;
+}
+
+img {
+	max-width: 100%;
+	max-height: 100%;
+}
+
+a {
+	text-decoration: none;
+}
+
+a:hover {
+	text-decoration: underline;
+}
+
+a:focus,
+input:focus,
+select:focus,
+textarea:focus {
+	outline: 1px solid -webkit-focus-ring-color;
+	outline-offset: -1px;
+}
+
+hr {
+	border: 0;
+	height: 2px;
+	border-bottom: 2px solid;
+}
+
+h1 {
+	padding-bottom: 0.3em;
+	line-height: 1.2;
+	border-bottom-width: 1px;
+	border-bottom-style: solid;
+}
+
+h1, h2, h3 {
+	font-weight: normal;
+}
+
+table {
+	border-collapse: collapse;
+}
+
+th {
+	text-align: left;
+	border-bottom: 1px solid;
+}
+
+th,
+td {
+	padding: 5px 10px;
+}
+
+table > tbody > tr + tr > td {
+	border-top-width: 1px;
+	border-top-style: solid;
+}
+
+blockquote {
+	margin: 0 7px 0 5px;
+	padding: 0 16px 0 10px;
+	border-left-width: 5px;
+	border-left-style: solid;
+}
+
+code {
+	font-family: "SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace;
+}
+
+pre {
+	padding: 16px;
+	border-radius: 3px;
+	overflow: auto;
+}
+
+pre code {
+	font-family: var(--vscode-editor-font-family);
+	font-weight: var(--vscode-editor-font-weight);
+	font-size: var(--vscode-editor-font-size);
+	line-height: 1.5;
+	color: var(--vscode-editor-foreground);
+	tab-size: 4;
+}
+
+.monaco-tokenized-source {
+	white-space: pre;
+}
+
+/** Theming */
+
+.pre {
+	background-color: var(--vscode-textCodeBlock-background);
+}
+
+.vscode-high-contrast h1 {
+	border-color: rgb(0, 0, 0);
+}
+
+.vscode-light th {
+	border-color: rgba(0, 0, 0, 0.69);
+}
+
+.vscode-dark th {
+	border-color: rgba(255, 255, 255, 0.69);
+}
+
+.vscode-light h1,
+.vscode-light hr,
+.vscode-light td {
+	border-color: rgba(0, 0, 0, 0.18);
+}
+
+.vscode-dark h1,
+.vscode-dark hr,
+.vscode-dark td {
+	border-color: rgba(255, 255, 255, 0.18);
+}
+
+@media (forced-colors: active) and (prefers-color-scheme: light){
+	body {
+		forced-color-adjust: none;
+	}
+}
+
+@media (forced-colors: active) and (prefers-color-scheme: dark){
+	body {
+		forced-color-adjust: none;
+	}
+}
+`;
+const allowedProtocols = [Schemas.http, Schemas.https, Schemas.command];
+function sanitize(documentContent, allowUnknownProtocols) {
+    const hook = hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, true);
+    try {
+        return dompurify.sanitize(documentContent, {
+            ...{
+                ALLOWED_TAGS: [
+                    ...basicMarkupHtmlTags,
+                    'checkbox',
+                    'checklist',
+                ],
+                ALLOWED_ATTR: [
+                    ...allowedMarkdownAttr,
+                    'data-command', 'name', 'id', 'role', 'tabindex',
+                    'x-dispatch',
+                    'required', 'checked', 'placeholder', 'when-checked', 'checked-on',
+                ],
+            },
+            ...(allowUnknownProtocols ? { ALLOW_UNKNOWN_PROTOCOLS: true } : {}),
+        });
+    }
+    finally {
+        hook.dispose();
+    }
+}
+async function renderMarkdownDocument(text, extensionService, languageService, shouldSanitize = true, allowUnknownProtocols = false, token) {
+    const highlight = (code, lang, callback) => {
+        if (!callback) {
+            return code;
+        }
+        if (typeof lang !== 'string') {
+            callback(null, `<code>${escape(code)}</code>`);
+            return '';
+        }
+        extensionService.whenInstalledExtensionsRegistered().then(async () => {
+            if (token?.isCancellationRequested) {
+                callback(null, '');
+                return;
+            }
+            const languageId = languageService.getLanguageIdByLanguageName(lang);
+            const html = await tokenizeToString(languageService, code, languageId);
+            callback(null, `<code>${html}</code>`);
+        });
+        return '';
+    };
+    return ( new Promise((resolve, reject) => {
+        marked(text, { highlight }, (err, value) => err ? reject(err) : resolve(value));
+    })).then(raw => {
+        if (shouldSanitize) {
+            return sanitize(raw, allowUnknownProtocols);
+        }
+        else {
+            return raw;
+        }
+    });
+}
+
+export { DEFAULT_MARKDOWN_STYLES, renderMarkdownDocument };

package/vscode/src/vs/workbench/contrib/update/common/update.js

@@ -0,0 +1,3 @@
+const ShowCurrentReleaseNotesActionId = 'update.showCurrentReleaseNotes';
+
+export { ShowCurrentReleaseNotesActionId };

package/vscode/src/vs/workbench/services/extensionManagement/browser/builtinExtensionsScannerService.js

@@ -0,0 +1,84 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isWeb, Language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { getGalleryExtensionId } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { FileAccess, builtinExtensionsPath } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IExtensionResourceLoaderService } from 'vscode/vscode/vs/platform/extensionResourceLoader/common/extensionResourceLoader';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { localizeManifest } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionNls';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+
+let BuiltinExtensionsScannerService = class BuiltinExtensionsScannerService {
+    constructor(environmentService, uriIdentityService, extensionResourceLoaderService, productService, logService) {
+        this.extensionResourceLoaderService = extensionResourceLoaderService;
+        this.logService = logService;
+        this.builtinExtensionsPromises = [];
+        if (isWeb) {
+            const nlsBaseUrl = productService.extensionsGallery?.nlsBaseUrl;
+            if (nlsBaseUrl && productService.commit && !Language.isDefaultVariant()) {
+                this.nlsUrl = URI.joinPath(( URI.parse(nlsBaseUrl)), productService.commit, productService.version, Language.value());
+            }
+            const builtinExtensionsServiceUrl = ( FileAccess.asBrowserUri(builtinExtensionsPath));
+            if (builtinExtensionsServiceUrl) {
+                let bundledExtensions = [];
+                if (environmentService.isBuilt) {
+                    bundledExtensions = [ ];
+                }
+                else {
+                    const builtinExtensionsElement = document.getElementById('vscode-workbench-builtin-extensions');
+                    const builtinExtensionsElementAttribute = builtinExtensionsElement ? builtinExtensionsElement.getAttribute('data-settings') : undefined;
+                    if (builtinExtensionsElementAttribute) {
+                        try {
+                            bundledExtensions = JSON.parse(builtinExtensionsElementAttribute);
+                        }
+                        catch (error) {  }
+                    }
+                }
+                this.builtinExtensionsPromises = ( bundledExtensions.map(async (e) => {
+                    const id = getGalleryExtensionId(e.packageJSON.publisher, e.packageJSON.name);
+                    return {
+                        identifier: { id },
+                        location: uriIdentityService.extUri.joinPath(builtinExtensionsServiceUrl, e.extensionPath),
+                        type: 0 ,
+                        isBuiltin: true,
+                        manifest: e.packageNLS ? await this.localizeManifest(id, e.packageJSON, e.packageNLS) : e.packageJSON,
+                        readmeUrl: e.readmePath ? uriIdentityService.extUri.joinPath(builtinExtensionsServiceUrl, e.readmePath) : undefined,
+                        changelogUrl: e.changelogPath ? uriIdentityService.extUri.joinPath(builtinExtensionsServiceUrl, e.changelogPath) : undefined,
+                        targetPlatform: "web" ,
+                        validations: [],
+                        isValid: true
+                    };
+                }));
+            }
+        }
+    }
+    async scanBuiltinExtensions() {
+        return [...(await Promise.all(this.builtinExtensionsPromises))];
+    }
+    async localizeManifest(extensionId, manifest, fallbackTranslations) {
+        if (!this.nlsUrl) {
+            return localizeManifest(this.logService, manifest, fallbackTranslations);
+        }
+        const uri = URI.joinPath(this.nlsUrl, extensionId, 'package');
+        try {
+            const res = await this.extensionResourceLoaderService.readExtensionResource(uri);
+            const json = JSON.parse(( res.toString()));
+            return localizeManifest(this.logService, manifest, json, fallbackTranslations);
+        }
+        catch (e) {
+            this.logService.error(e);
+            return localizeManifest(this.logService, manifest, fallbackTranslations);
+        }
+    }
+};
+BuiltinExtensionsScannerService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, IExtensionResourceLoaderService)),
+    ( __param(3, IProductService)),
+    ( __param(4, ILogService))
+], BuiltinExtensionsScannerService));
+
+export { BuiltinExtensionsScannerService };