@codingame/monaco-vscode-base-service-override 4.1.0 → 4.1.2

package/base.js

@@ -7,16 +7,16 @@ import { ITreeViewsDnDService } from 'vscode/vscode/vs/editor/common/services/tr
 import { ITreeViewsService } from 'vscode/vscode/vs/workbench/services/views/browser/treeViewsService';
 import { TreeViewsDnDService } from 'vscode/vscode/vs/editor/common/services/treeViewsDnd';
 import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
-import { JSONEditingService } from 'vscode/vscode/vs/workbench/services/configuration/common/jsonEditingService';
-import { DecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/browser/decorationsService';
-import { BrowserRequestService } from 'vscode/vscode/vs/workbench/services/request/browser/requestService';
-import { BrowserURLService } from 'vscode/vscode/vs/workbench/services/url/browser/urlService';
+import { JSONEditingService } from './vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js';
+import { DecorationsService } from './vscode/src/vs/workbench/services/decorations/browser/decorationsService.js';
+import { BrowserRequestService } from './vscode/src/vs/workbench/services/request/browser/requestService.js';
+import { BrowserURLService } from './vscode/src/vs/workbench/services/url/browser/urlService.js';
 import { TreeviewsService } from './vscode/src/vs/workbench/services/views/common/treeViewsService.js';
 import { CanonicalUriService } from './vscode/src/vs/workbench/services/workspaces/common/canonicalUriService.js';
 import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri';
 import { IUserActivityService, UserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
 import { IDownloadService } from 'vscode/vscode/vs/platform/download/common/download';
-import { DownloadService } from 'vscode/vscode/vs/platform/download/common/downloadService';
+import { DownloadService } from './vscode/src/vs/platform/download/common/downloadService.js';
 import { IPathService, AbstractPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
 import { IWorkingCopyFileService, WorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-base-service-override",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.2"
   }
 }

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

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

package/vscode/src/vs/platform/download/common/downloadService.js

@@ -0,0 +1,33 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { asTextOrError, IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
+
+let DownloadService = class DownloadService {
+    constructor(requestService, fileService) {
+        this.requestService = requestService;
+        this.fileService = fileService;
+    }
+    async download(resource, target, cancellationToken = CancellationToken.None) {
+        if (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeRemote) {
+            await this.fileService.copy(resource, target);
+            return;
+        }
+        const options = { type: 'GET', url: ( resource.toString(true)) };
+        const context = await this.requestService.request(options, cancellationToken);
+        if (context.res.statusCode === 200) {
+            await this.fileService.writeFile(target, context.stream);
+        }
+        else {
+            const message = await asTextOrError(context);
+            throw new Error(`Expected 200, got back ${context.res.statusCode} instead.\n\n${message}`);
+        }
+    }
+};
+DownloadService = ( __decorate([
+    ( __param(0, IRequestService)),
+    ( __param(1, IFileService))
+], DownloadService));
+
+export { DownloadService };

package/vscode/src/vs/platform/request/browser/requestService.js

@@ -0,0 +1,30 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { request } from '../../../base/parts/request/browser/request.js';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
+import { AbstractRequestService } from 'vscode/vscode/vs/platform/request/common/request';
+
+let RequestService = class RequestService extends AbstractRequestService {
+    constructor(configurationService, loggerService) {
+        super(loggerService);
+        this.configurationService = configurationService;
+    }
+    async request(options, token) {
+        if (!options.proxyAuthorization) {
+            options.proxyAuthorization = this.configurationService.getValue('http.proxyAuthorization');
+        }
+        return this.logAndRequest('browser', options, () => request(options, token));
+    }
+    async resolveProxy(url) {
+        return undefined;
+    }
+    async loadCertificates() {
+        return [];
+    }
+};
+RequestService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ILoggerService))
+], RequestService));
+
+export { RequestService };

package/vscode/src/vs/platform/request/common/requestIpc.js

@@ -0,0 +1,20 @@
+import { bufferToStream } from 'vscode/vscode/vs/base/common/buffer';
+import 'vscode/vscode/vs/base/common/cancellation';
+
+class RequestChannelClient {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async request(options, token) {
+        const [res, buffer] = await this.channel.call('request', [options], token);
+        return { res, stream: bufferToStream(buffer) };
+    }
+    async resolveProxy(url) {
+        return this.channel.call('resolveProxy', [url]);
+    }
+    async loadCertificates() {
+        return this.channel.call('loadCertificates');
+    }
+}
+
+export { RequestChannelClient };

package/vscode/src/vs/platform/url/common/urlService.js

@@ -0,0 +1,22 @@
+import { first } from 'vscode/vscode/vs/base/common/async';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import 'vscode/vscode/vs/base/common/path';
+import 'vscode/vscode/vs/base/common/platform';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+class AbstractURLService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.handlers = ( new Set());
+    }
+    open(uri, options) {
+        const handlers = [...( this.handlers.values())];
+        return first(( handlers.map(h => () => h.handleURL(uri, options))), undefined, false).then(val => val || false);
+    }
+    registerHandler(handler) {
+        this.handlers.add(handler);
+        return toDisposable(() => this.handlers.delete(handler));
+    }
+}
+
+export { AbstractURLService };

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -0,0 +1,122 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { parse } from 'vscode/vscode/vs/base/common/json';
+import { setProperty } from 'vscode/vscode/vs/base/common/jsonEdit';
+import { Queue } from 'vscode/vscode/vs/base/common/async';
+import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { Selection } from 'vscode/vscode/vs/editor/common/core/selection';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { JSONEditingError } from 'vscode/vscode/vs/workbench/services/configuration/common/jsonEditing';
+
+let JSONEditingService = class JSONEditingService {
+    constructor(fileService, textModelResolverService, textFileService) {
+        this.fileService = fileService;
+        this.textModelResolverService = textModelResolverService;
+        this.textFileService = textFileService;
+        this.queue = ( new Queue());
+    }
+    write(resource, values) {
+        return Promise.resolve(this.queue.queue(() => this.doWriteConfiguration(resource, values)));
+    }
+    async doWriteConfiguration(resource, values) {
+        const reference = await this.resolveAndValidate(resource, true);
+        try {
+            await this.writeToBuffer(reference.object.textEditorModel, values);
+        }
+        finally {
+            reference.dispose();
+        }
+    }
+    async writeToBuffer(model, values) {
+        let hasEdits = false;
+        for (const value of values) {
+            const edit = this.getEdits(model, value)[0];
+            hasEdits = !!edit && this.applyEditsToBuffer(edit, model);
+        }
+        if (hasEdits) {
+            return this.textFileService.save(model.uri);
+        }
+    }
+    applyEditsToBuffer(edit, model) {
+        const startPosition = model.getPositionAt(edit.offset);
+        const endPosition = model.getPositionAt(edit.offset + edit.length);
+        const range = ( new Range(
+            startPosition.lineNumber,
+            startPosition.column,
+            endPosition.lineNumber,
+            endPosition.column
+        ));
+        const currentText = model.getValueInRange(range);
+        if (edit.content !== currentText) {
+            const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
+            model.pushEditOperations([( new Selection(
+                startPosition.lineNumber,
+                startPosition.column,
+                startPosition.lineNumber,
+                startPosition.column
+            ))], [editOperation], () => []);
+            return true;
+        }
+        return false;
+    }
+    getEdits(model, configurationValue) {
+        const { tabSize, insertSpaces } = model.getOptions();
+        const eol = model.getEOL();
+        const { path, value } = configurationValue;
+        if (!path.length) {
+            const content = JSON.stringify(value, null, insertSpaces ? ' '.repeat(tabSize) : '\t');
+            return [{
+                    content,
+                    length: content.length,
+                    offset: 0
+                }];
+        }
+        return setProperty(model.getValue(), path, value, { tabSize, insertSpaces, eol });
+    }
+    async resolveModelReference(resource) {
+        const exists = await this.fileService.exists(resource);
+        if (!exists) {
+            await this.textFileService.write(resource, '{}', { encoding: 'utf8' });
+        }
+        return this.textModelResolverService.createModelReference(resource);
+    }
+    hasParseErrors(model) {
+        const parseErrors = [];
+        parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+        return parseErrors.length > 0;
+    }
+    async resolveAndValidate(resource, checkDirty) {
+        const reference = await this.resolveModelReference(resource);
+        const model = reference.object.textEditorModel;
+        if (this.hasParseErrors(model)) {
+            reference.dispose();
+            return this.reject(0 );
+        }
+        return reference;
+    }
+    reject(code) {
+        const message = this.toErrorMessage(code);
+        return Promise.reject(( new JSONEditingError(message, code)));
+    }
+    toErrorMessage(error) {
+        switch (error) {
+            case 0 : {
+                return ( localizeWithPath(
+                    'vs/workbench/services/configuration/common/jsonEditingService',
+                    'errorInvalidFile',
+                    "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
+                ));
+            }
+        }
+    }
+};
+JSONEditingService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, ITextFileService))
+], JSONEditingService));
+
+export { JSONEditingService };

package/vscode/src/vs/workbench/services/decorations/browser/decorationsService.js

@@ -0,0 +1,332 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DebounceEmitter, Emitter } from 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { TernarySearchTree } from 'vscode/vscode/vs/base/common/ternarySearchTree';
+import { toDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isThenable } from 'vscode/vscode/vs/base/common/async';
+import { LinkedList } from 'vscode/vscode/vs/base/common/linkedList';
+import { createCSSRule, asCSSPropertyValue, removeCSSRulesContainingSelector, createStyleSheet } from 'vscode/vscode/vs/base/browser/dom';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { isFalsyOrWhitespace } from 'vscode/vscode/vs/base/common/strings';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { hash } from 'vscode/vscode/vs/base/common/hash';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { distinct, asArray } from 'vscode/vscode/vs/base/common/arrays';
+import { asCssVariable } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { getIconRegistry } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
+
+class DecorationRule {
+    static keyOf(data) {
+        if (Array.isArray(data)) {
+            return ( data.map(DecorationRule.keyOf)).join(',');
+        }
+        else {
+            const { color, letter } = data;
+            if (ThemeIcon.isThemeIcon(letter)) {
+                return `${color}+${letter.id}`;
+            }
+            else {
+                return `${color}/${letter}`;
+            }
+        }
+    }
+    static { this._classNamesPrefix = 'monaco-decoration'; }
+    constructor(themeService, data, key) {
+        this.themeService = themeService;
+        this._refCounter = 0;
+        this.data = data;
+        const suffix = ( hash(key).toString(36));
+        this.itemColorClassName = `${DecorationRule._classNamesPrefix}-itemColor-${suffix}`;
+        this.itemBadgeClassName = `${DecorationRule._classNamesPrefix}-itemBadge-${suffix}`;
+        this.bubbleBadgeClassName = `${DecorationRule._classNamesPrefix}-bubbleBadge-${suffix}`;
+        this.iconBadgeClassName = `${DecorationRule._classNamesPrefix}-iconBadge-${suffix}`;
+    }
+    acquire() {
+        this._refCounter += 1;
+    }
+    release() {
+        return --this._refCounter === 0;
+    }
+    appendCSSRules(element) {
+        if (!Array.isArray(this.data)) {
+            this._appendForOne(this.data, element);
+        }
+        else {
+            this._appendForMany(this.data, element);
+        }
+    }
+    _appendForOne(data, element) {
+        const { color, letter } = data;
+        createCSSRule(`.${this.itemColorClassName}`, `color: ${getColor(color)};`, element);
+        if (ThemeIcon.isThemeIcon(letter)) {
+            this._createIconCSSRule(letter, color, element);
+        }
+        else if (letter) {
+            createCSSRule(`.${this.itemBadgeClassName}::after`, `content: "${letter}"; color: ${getColor(color)};`, element);
+        }
+    }
+    _appendForMany(data, element) {
+        const { color } = data.find(d => !!d.color) ?? data[0];
+        createCSSRule(`.${this.itemColorClassName}`, `color: ${getColor(color)};`, element);
+        const letters = [];
+        let icon;
+        for (const d of data) {
+            if (ThemeIcon.isThemeIcon(d.letter)) {
+                icon = d.letter;
+                break;
+            }
+            else if (d.letter) {
+                letters.push(d.letter);
+            }
+        }
+        if (icon) {
+            this._createIconCSSRule(icon, color, element);
+        }
+        else {
+            if (letters.length) {
+                createCSSRule(`.${this.itemBadgeClassName}::after`, `content: "${letters.join(', ')}"; color: ${getColor(color)};`, element);
+            }
+            createCSSRule(`.${this.bubbleBadgeClassName}::after`, `content: "\uea71"; color: ${getColor(color)}; font-family: codicon; font-size: 14px; margin-right: 14px; opacity: 0.4;`, element);
+        }
+    }
+    _createIconCSSRule(icon, color, element) {
+        const modifier = ThemeIcon.getModifier(icon);
+        if (modifier) {
+            icon = ThemeIcon.modify(icon, undefined);
+        }
+        const iconContribution = getIconRegistry().getIcon(icon.id);
+        if (!iconContribution) {
+            return;
+        }
+        const definition = this.themeService.getProductIconTheme().getIcon(iconContribution);
+        if (!definition) {
+            return;
+        }
+        createCSSRule(`.${this.iconBadgeClassName}::after`, `content: '${definition.fontCharacter}';
+			color: ${icon.color ? getColor(icon.color.id) : getColor(color)};
+			font-family: ${asCSSPropertyValue(definition.font?.id ?? 'codicon')};
+			font-size: 16px;
+			margin-right: 14px;
+			font-weight: normal;
+			${modifier === 'spin' ? 'animation: codicon-spin 1.5s steps(30) infinite' : ''};
+			`, element);
+    }
+    removeCSSRules(element) {
+        removeCSSRulesContainingSelector(this.itemColorClassName, element);
+        removeCSSRulesContainingSelector(this.itemBadgeClassName, element);
+        removeCSSRulesContainingSelector(this.bubbleBadgeClassName, element);
+        removeCSSRulesContainingSelector(this.iconBadgeClassName, element);
+    }
+}
+class DecorationStyles {
+    constructor(_themeService) {
+        this._themeService = _themeService;
+        this._dispoables = ( new DisposableStore());
+        this._styleElement = createStyleSheet(undefined, undefined, this._dispoables);
+        this._decorationRules = ( new Map());
+    }
+    dispose() {
+        this._dispoables.dispose();
+    }
+    asDecoration(data, onlyChildren) {
+        data.sort((a, b) => (b.weight || 0) - (a.weight || 0));
+        const key = DecorationRule.keyOf(data);
+        let rule = this._decorationRules.get(key);
+        if (!rule) {
+            rule = ( new DecorationRule(this._themeService, data, key));
+            this._decorationRules.set(key, rule);
+            rule.appendCSSRules(this._styleElement);
+        }
+        rule.acquire();
+        const labelClassName = rule.itemColorClassName;
+        let badgeClassName = rule.itemBadgeClassName;
+        const iconClassName = rule.iconBadgeClassName;
+        let tooltip = distinct(( data.filter(d => !isFalsyOrWhitespace(d.tooltip)).map(d => d.tooltip))).join(' • ');
+        const strikethrough = ( data.some(d => d.strikethrough));
+        if (onlyChildren) {
+            badgeClassName = rule.bubbleBadgeClassName;
+            tooltip = ( localizeWithPath(
+                'vs/workbench/services/decorations/browser/decorationsService',
+                'bubbleTitle',
+                "Contains emphasized items"
+            ));
+        }
+        return {
+            labelClassName,
+            badgeClassName,
+            iconClassName,
+            strikethrough,
+            tooltip,
+            dispose: () => {
+                if (rule?.release()) {
+                    this._decorationRules.delete(key);
+                    rule.removeCSSRules(this._styleElement);
+                    rule = undefined;
+                }
+            }
+        };
+    }
+}
+class FileDecorationChangeEvent {
+    constructor(all) {
+        this._data = TernarySearchTree.forUris(_uri => true);
+        this._data.fill(true, asArray(all));
+    }
+    affectsResource(uri) {
+        return this._data.hasElementOrSubtree(uri);
+    }
+}
+class DecorationDataRequest {
+    constructor(source, thenable) {
+        this.source = source;
+        this.thenable = thenable;
+    }
+}
+function getColor(color) {
+    return color ? asCssVariable(color) : 'inherit';
+}
+let DecorationsService = class DecorationsService {
+    constructor(uriIdentityService, themeService) {
+        this._onDidChangeDecorationsDelayed = ( new DebounceEmitter({ merge: all => all.flat() }));
+        this._onDidChangeDecorations = ( new Emitter());
+        this.onDidChangeDecorations = this._onDidChangeDecorations.event;
+        this._provider = ( new LinkedList());
+        this._decorationStyles = ( new DecorationStyles(themeService));
+        this._data = TernarySearchTree.forUris(key => uriIdentityService.extUri.ignorePathCasing(key));
+        this._onDidChangeDecorationsDelayed.event(event => { this._onDidChangeDecorations.fire(( new FileDecorationChangeEvent(event))); });
+    }
+    dispose() {
+        this._onDidChangeDecorations.dispose();
+        this._onDidChangeDecorationsDelayed.dispose();
+        this._data.clear();
+    }
+    registerDecorationsProvider(provider) {
+        const rm = this._provider.unshift(provider);
+        this._onDidChangeDecorations.fire({
+            affectsResource() { return true; }
+        });
+        const removeAll = () => {
+            const uris = [];
+            for (const [uri, map] of this._data) {
+                if (map.delete(provider)) {
+                    uris.push(uri);
+                }
+            }
+            if (uris.length > 0) {
+                this._onDidChangeDecorationsDelayed.fire(uris);
+            }
+        };
+        const listener = provider.onDidChange(uris => {
+            if (!uris) {
+                removeAll();
+            }
+            else {
+                for (const uri of uris) {
+                    const map = this._ensureEntry(uri);
+                    this._fetchData(map, uri, provider);
+                }
+            }
+        });
+        return toDisposable(() => {
+            rm();
+            listener.dispose();
+            removeAll();
+        });
+    }
+    _ensureEntry(uri) {
+        let map = this._data.get(uri);
+        if (!map) {
+            map = ( new Map());
+            this._data.set(uri, map);
+        }
+        return map;
+    }
+    getDecoration(uri, includeChildren) {
+        const all = [];
+        let containsChildren = false;
+        const map = this._ensureEntry(uri);
+        for (const provider of this._provider) {
+            let data = map.get(provider);
+            if (data === undefined) {
+                data = this._fetchData(map, uri, provider);
+            }
+            if (data && !(data instanceof DecorationDataRequest)) {
+                all.push(data);
+            }
+        }
+        if (includeChildren) {
+            const iter = this._data.findSuperstr(uri);
+            if (iter) {
+                for (const tuple of iter) {
+                    for (const data of ( tuple[1].values())) {
+                        if (data && !(data instanceof DecorationDataRequest)) {
+                            if (data.bubble) {
+                                all.push(data);
+                                containsChildren = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return all.length === 0
+            ? undefined
+            : this._decorationStyles.asDecoration(all, containsChildren);
+    }
+    _fetchData(map, uri, provider) {
+        const pendingRequest = map.get(provider);
+        if (pendingRequest instanceof DecorationDataRequest) {
+            pendingRequest.source.cancel();
+            map.delete(provider);
+        }
+        const cts = ( new CancellationTokenSource());
+        const dataOrThenable = provider.provideDecorations(uri, cts.token);
+        if (!isThenable(dataOrThenable)) {
+            cts.dispose();
+            return this._keepItem(map, provider, uri, dataOrThenable);
+        }
+        else {
+            const request = ( new DecorationDataRequest(cts, Promise.resolve(dataOrThenable).then(data => {
+                if (map.get(provider) === request) {
+                    this._keepItem(map, provider, uri, data);
+                }
+            }).catch(err => {
+                if (!isCancellationError(err) && map.get(provider) === request) {
+                    map.delete(provider);
+                }
+            }).finally(() => {
+                cts.dispose();
+            })));
+            map.set(provider, request);
+            return null;
+        }
+    }
+    _keepItem(map, provider, uri, data) {
+        const deco = data ? data : null;
+        const old = map.get(provider);
+        map.set(provider, deco);
+        if (deco || old) {
+            this._onDidChangeDecorationsDelayed.fire(uri);
+        }
+        return deco;
+    }
+};
+DecorationsService = ( __decorate([
+    ( __param(0, IUriIdentityService)),
+    ( __param(1, IThemeService))
+], DecorationsService));
+
+export { DecorationsService };

package/vscode/src/vs/workbench/services/request/browser/requestService.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
+import { RequestChannelClient } from '../../../../platform/request/common/requestIpc.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { RequestService } from '../../../../platform/request/browser/requestService.js';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+
+let BrowserRequestService = class BrowserRequestService extends RequestService {
+    constructor(remoteAgentService, configurationService, loggerService) {
+        super(configurationService, loggerService);
+        this.remoteAgentService = remoteAgentService;
+    }
+    async request(options, token) {
+        try {
+            const context = await super.request(options, token);
+            const connection = this.remoteAgentService.getConnection();
+            if (connection && context.res.statusCode === 405) {
+                return this._makeRemoteRequest(connection, options, token);
+            }
+            return context;
+        }
+        catch (error) {
+            const connection = this.remoteAgentService.getConnection();
+            if (connection) {
+                return this._makeRemoteRequest(connection, options, token);
+            }
+            throw error;
+        }
+    }
+    _makeRemoteRequest(connection, options, token) {
+        return connection.withChannel('request', channel => ( new RequestChannelClient(channel)).request(options, token));
+    }
+};
+BrowserRequestService = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ILoggerService))
+], BrowserRequestService));
+CommandsRegistry.registerCommand('_workbench.fetchJSON', async function (accessor, url, method) {
+    const result = await fetch(url, { method, headers: { Accept: 'application/json' } });
+    if (result.ok) {
+        return result.json();
+    }
+    else {
+        throw new Error(result.statusText);
+    }
+});
+
+export { BrowserRequestService };

package/vscode/src/vs/workbench/services/url/browser/urlService.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { AbstractURLService } from '../../../../platform/url/common/urlService.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { matchesScheme } from 'vscode/vscode/vs/base/common/network';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+
+class BrowserURLOpener {
+    constructor(urlService, productService) {
+        this.urlService = urlService;
+        this.productService = productService;
+    }
+    async open(resource, options) {
+        if (options?.openExternal) {
+            return false;
+        }
+        if (!matchesScheme(resource, this.productService.urlProtocol)) {
+            return false;
+        }
+        if (typeof resource === 'string') {
+            resource = ( URI.parse(resource));
+        }
+        return this.urlService.open(resource, { trusted: true });
+    }
+}
+let BrowserURLService = class BrowserURLService extends AbstractURLService {
+    constructor(environmentService, openerService, productService) {
+        super();
+        this.provider = environmentService.options?.urlCallbackProvider;
+        if (this.provider) {
+            this._register(this.provider.onCallback(uri => this.open(uri, { trusted: true })));
+        }
+        this._register(openerService.registerOpener(( new BrowserURLOpener(this, productService))));
+    }
+    create(options) {
+        if (this.provider) {
+            return this.provider.create(options);
+        }
+        return ( URI.parse('unsupported://'));
+    }
+};
+BrowserURLService = ( __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, IOpenerService)),
+    ( __param(2, IProductService))
+], BrowserURLService));
+
+export { BrowserURLService };