@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common 18.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common",
+  "version": "18.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (base, chat, extension-gallery, interactive, localization, mcp, notebook, remote-agent, search, telemetry, terminal, textmate, theme, treesitter, view-common, walkthrough)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "18.0.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/base/parts/request/common/request.d.ts

@@ -0,0 +1,34 @@
+import { VSBufferReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+export declare function isOfflineError(error: unknown): boolean;
+export declare class OfflineError extends Error {
+    constructor();
+}
+export interface IHeaders {
+    "Proxy-Authorization"?: string;
+    "x-operation-id"?: string;
+    "retry-after"?: string;
+    etag?: string;
+    "Content-Length"?: string;
+    "activityid"?: string;
+    "X-Market-User-Id"?: string;
+    [header: string]: string | string[] | undefined;
+}
+export interface IRequestOptions {
+    type?: string;
+    url?: string;
+    user?: string;
+    password?: string;
+    headers?: IHeaders;
+    timeout?: number;
+    data?: string;
+    followRedirects?: number;
+    proxyAuthorization?: string;
+    disableCache?: boolean;
+}
+export interface IRequestContext {
+    res: {
+        headers: IHeaders;
+        statusCode?: number;
+    };
+    stream: VSBufferReadableStream;
+}

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

@@ -0,0 +1,17 @@
+
+
+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, isOfflineError };

package/vscode/src/vs/platform/languagePacks/common/languagePacks.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IQuickPickItem } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput";
+import { IGalleryExtension } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement";
+import { IExtensionGalleryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { ILanguagePackService } from "@codingame/monaco-vscode-api/vscode/vs/platform/languagePacks/common/languagePacks.service";
+export declare function getLocale(extension: IGalleryExtension): string | undefined;
+export interface ILanguagePackItem extends IQuickPickItem {
+    readonly extensionId?: string;
+    readonly galleryExtension?: IGalleryExtension;
+}
+export declare abstract class LanguagePackBaseService extends Disposable implements ILanguagePackService {
+    protected readonly extensionGalleryService: IExtensionGalleryService;
+    readonly _serviceBrand: undefined;
+    constructor(extensionGalleryService: IExtensionGalleryService);
+    abstract getBuiltInExtensionTranslationsUri(id: string, language: string): Promise<URI | undefined>;
+    abstract getInstalledLanguages(): Promise<Array<ILanguagePackItem>>;
+    getAvailableLanguages(): Promise<ILanguagePackItem[]>;
+    protected createQuickPickItem(locale: string, languageName?: string, languagePack?: IGalleryExtension): IQuickPickItem;
+}

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

@@ -0,0 +1,80 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { language } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IExtensionGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
+
+function getLocale(extension) {
+    return extension.tags.find(t => t.startsWith('lp-'))?.split('lp-')[1];
+}
+let LanguagePackBaseService = class LanguagePackBaseService extends Disposable {
+    constructor(extensionGalleryService) {
+        super();
+        this.extensionGalleryService = extensionGalleryService;
+    }
+    async getAvailableLanguages() {
+        const timeout = ( new CancellationTokenSource());
+        setTimeout(() => timeout.cancel(), 1000);
+        let result;
+        try {
+            result = await this.extensionGalleryService.query({
+                text: 'category:"language packs"',
+                pageSize: 20
+            }, timeout.token);
+        }
+        catch (_) {
+            return [];
+        }
+        const languagePackExtensions = result.firstPage.filter(e => e.properties.localizedLanguages?.length && ( e.tags.some(t => t.startsWith('lp-'))));
+        const allFromMarketplace = ( languagePackExtensions.map(lp => {
+            const languageName = lp.properties.localizedLanguages?.[0];
+            const locale = getLocale(lp);
+            const baseQuickPick = this.createQuickPickItem(locale, languageName, lp);
+            return {
+                ...baseQuickPick,
+                extensionId: lp.identifier.id,
+                galleryExtension: lp
+            };
+        }));
+        allFromMarketplace.push(this.createQuickPickItem('en', 'English'));
+        return allFromMarketplace;
+    }
+    createQuickPickItem(locale, languageName, languagePack) {
+        const label = languageName ?? locale;
+        let description;
+        if (label !== locale) {
+            description = `(${locale})`;
+        }
+        if (locale.toLowerCase() === language.toLowerCase()) {
+            description ??= '';
+            description += ( localize(1897, " (Current)"));
+        }
+        if (languagePack?.installCount) {
+            description ??= '';
+            const count = languagePack.installCount;
+            let countLabel;
+            if (count > 1000000) {
+                countLabel = `${Math.floor(count / 100000) / 10}M`;
+            }
+            else if (count > 1000) {
+                countLabel = `${Math.floor(count / 1000)}K`;
+            }
+            else {
+                countLabel = String(count);
+            }
+            description += ` $(cloud-download) ${countLabel}`;
+        }
+        return {
+            id: locale,
+            label,
+            description
+        };
+    }
+};
+LanguagePackBaseService = ( __decorate([
+    ( __param(0, IExtensionGalleryService))
+], LanguagePackBaseService));
+
+export { LanguagePackBaseService, getLocale };

package/vscode/src/vs/platform/theme/common/tokenClassificationRegistry.d.ts

@@ -0,0 +1,100 @@
+import { Color } from "@codingame/monaco-vscode-api/vscode/vs/base/common/color";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IJSONSchema } from "@codingame/monaco-vscode-api/vscode/vs/base/common/jsonSchema";
+import { IColorTheme } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService";
+type TokenClassificationString = string;
+export declare const typeAndModifierIdPattern = "^\\w+[-_\\w+]*$";
+export interface TokenSelector {
+    match(type: string, modifiers: string[], language: string): number;
+    readonly id: string;
+}
+export interface TokenTypeOrModifierContribution {
+    readonly num: number;
+    readonly id: string;
+    readonly superType?: string;
+    readonly description: string;
+    readonly deprecationMessage?: string;
+}
+export interface TokenStyleData {
+    foreground: Color | undefined;
+    bold: boolean | undefined;
+    underline: boolean | undefined;
+    strikethrough: boolean | undefined;
+    italic: boolean | undefined;
+}
+export declare class TokenStyle implements Readonly<TokenStyleData> {
+    readonly foreground: Color | undefined;
+    readonly bold: boolean | undefined;
+    readonly underline: boolean | undefined;
+    readonly strikethrough: boolean | undefined;
+    readonly italic: boolean | undefined;
+    constructor(foreground: Color | undefined, bold: boolean | undefined, underline: boolean | undefined, strikethrough: boolean | undefined, italic: boolean | undefined);
+}
+export declare namespace TokenStyle {
+    function toJSONObject(style: TokenStyle): any;
+    function fromJSONObject(obj: any): TokenStyle | undefined;
+    function equals(s1: any, s2: any): boolean;
+    function is(s: any): s is TokenStyle;
+    function fromData(data: {
+        foreground: Color | undefined;
+        bold: boolean | undefined;
+        underline: boolean | undefined;
+        strikethrough: boolean | undefined;
+        italic: boolean | undefined;
+    }): TokenStyle;
+    function fromSettings(foreground: string | undefined, fontStyle: string | undefined): TokenStyle;
+    function fromSettings(foreground: string | undefined, fontStyle: string | undefined, bold: boolean | undefined, underline: boolean | undefined, strikethrough: boolean | undefined, italic: boolean | undefined): TokenStyle;
+}
+export type ProbeScope = string[];
+export interface TokenStyleFunction {
+    (theme: IColorTheme): TokenStyle | undefined;
+}
+export interface TokenStyleDefaults {
+    scopesToProbe?: ProbeScope[];
+    light?: TokenStyleValue;
+    dark?: TokenStyleValue;
+    hcDark?: TokenStyleValue;
+    hcLight?: TokenStyleValue;
+}
+export interface SemanticTokenDefaultRule {
+    selector: TokenSelector;
+    defaults: TokenStyleDefaults;
+}
+export interface SemanticTokenRule {
+    style: TokenStyle;
+    selector: TokenSelector;
+}
+export declare namespace SemanticTokenRule {
+    function fromJSONObject(registry: ITokenClassificationRegistry, o: any): SemanticTokenRule | undefined;
+    function toJSONObject(rule: SemanticTokenRule): any;
+    function equals(r1: SemanticTokenRule | undefined, r2: SemanticTokenRule | undefined): boolean;
+    function is(r: any): r is SemanticTokenRule;
+}
+export type TokenStyleValue = TokenStyle | TokenClassificationString;
+export interface ITokenClassificationRegistry {
+    readonly onDidChangeSchema: Event<void>;
+    registerTokenType(id: string, description: string, superType?: string, deprecationMessage?: string): void;
+    registerTokenModifier(id: string, description: string): void;
+    parseTokenSelector(selectorString: string, language?: string): TokenSelector;
+    registerTokenStyleDefault(selector: TokenSelector, defaults: TokenStyleDefaults): void;
+    deregisterTokenStyleDefault(selector: TokenSelector): void;
+    deregisterTokenType(id: string): void;
+    deregisterTokenModifier(id: string): void;
+    getTokenTypes(): TokenTypeOrModifierContribution[];
+    getTokenModifiers(): TokenTypeOrModifierContribution[];
+    getTokenStylingDefaultRules(): SemanticTokenDefaultRule[];
+    getTokenStylingSchema(): IJSONSchema;
+}
+export declare function parseClassifierString(s: string, defaultLanguage: string): {
+    type: string;
+    modifiers: string[];
+    language: string;
+};
+export declare function parseClassifierString(s: string, defaultLanguage?: string): {
+    type: string;
+    modifiers: string[];
+    language: string | undefined;
+};
+export declare function getTokenClassificationRegistry(): ITokenClassificationRegistry;
+export declare const tokenStylingSchemaId = "vscode://schemas/token-styling";
+export {};

package/vscode/src/vs/platform/theme/common/tokenClassificationRegistry.js

@@ -0,0 +1,472 @@
+
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Color } from '@codingame/monaco-vscode-api/vscode/vs/base/common/color';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions as Extensions$1 } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+
+const TOKEN_TYPE_WILDCARD = '*';
+const TOKEN_CLASSIFIER_LANGUAGE_SEPARATOR = ':';
+const CLASSIFIER_MODIFIER_SEPARATOR = '.';
+const idPattern = '\\w+[-_\\w+]*';
+const typeAndModifierIdPattern = `^${idPattern}$`;
+const selectorPattern = `^(${idPattern}|\\*)(\\${CLASSIFIER_MODIFIER_SEPARATOR}${idPattern})*(${TOKEN_CLASSIFIER_LANGUAGE_SEPARATOR}${idPattern})?$`;
+const fontStylePattern = '^(\\s*(italic|bold|underline|strikethrough))*\\s*$';
+class TokenStyle {
+    constructor(foreground, bold, underline, strikethrough, italic) {
+        this.foreground = foreground;
+        this.bold = bold;
+        this.underline = underline;
+        this.strikethrough = strikethrough;
+        this.italic = italic;
+    }
+}
+(function (TokenStyle) {
+    function toJSONObject(style) {
+        return {
+            _foreground: style.foreground === undefined ? null : Color.Format.CSS.formatHexA(style.foreground, true),
+            _bold: style.bold === undefined ? null : style.bold,
+            _underline: style.underline === undefined ? null : style.underline,
+            _italic: style.italic === undefined ? null : style.italic,
+            _strikethrough: style.strikethrough === undefined ? null : style.strikethrough,
+        };
+    }
+    TokenStyle.toJSONObject = toJSONObject;
+    function fromJSONObject(obj) {
+        if (obj) {
+            const boolOrUndef = (b) => (typeof b === 'boolean') ? b : undefined;
+            const colorOrUndef = (s) => (typeof s === 'string') ? ( Color.fromHex(s)) : undefined;
+            return ( new TokenStyle(
+                colorOrUndef(obj._foreground),
+                boolOrUndef(obj._bold),
+                boolOrUndef(obj._underline),
+                boolOrUndef(obj._strikethrough),
+                boolOrUndef(obj._italic)
+            ));
+        }
+        return undefined;
+    }
+    TokenStyle.fromJSONObject = fromJSONObject;
+    function equals(s1, s2) {
+        if (s1 === s2) {
+            return true;
+        }
+        return s1 !== undefined && s2 !== undefined
+            && (s1.foreground instanceof Color ? s1.foreground.equals(s2.foreground) : s2.foreground === undefined)
+            && s1.bold === s2.bold
+            && s1.underline === s2.underline
+            && s1.strikethrough === s2.strikethrough
+            && s1.italic === s2.italic;
+    }
+    TokenStyle.equals = equals;
+    function is(s) {
+        return s instanceof TokenStyle;
+    }
+    TokenStyle.is = is;
+    function fromData(data) {
+        return ( new TokenStyle(
+            data.foreground,
+            data.bold,
+            data.underline,
+            data.strikethrough,
+            data.italic
+        ));
+    }
+    TokenStyle.fromData = fromData;
+    function fromSettings(foreground, fontStyle, bold, underline, strikethrough, italic) {
+        let foregroundColor = undefined;
+        if (foreground !== undefined) {
+            foregroundColor = ( Color.fromHex(foreground));
+        }
+        if (fontStyle !== undefined) {
+            bold = italic = underline = strikethrough = false;
+            const expression = /italic|bold|underline|strikethrough/g;
+            let match;
+            while ((match = expression.exec(fontStyle))) {
+                switch (match[0]) {
+                    case 'bold':
+                        bold = true;
+                        break;
+                    case 'italic':
+                        italic = true;
+                        break;
+                    case 'underline':
+                        underline = true;
+                        break;
+                    case 'strikethrough':
+                        strikethrough = true;
+                        break;
+                }
+            }
+        }
+        return ( new TokenStyle(foregroundColor, bold, underline, strikethrough, italic));
+    }
+    TokenStyle.fromSettings = fromSettings;
+})(TokenStyle || (TokenStyle = {}));
+var SemanticTokenRule;
+(function (SemanticTokenRule) {
+    function fromJSONObject(registry, o) {
+        if (o && typeof o._selector === 'string' && o._style) {
+            const style = TokenStyle.fromJSONObject(o._style);
+            if (style) {
+                try {
+                    return { selector: registry.parseTokenSelector(o._selector), style };
+                }
+                catch (_ignore) {
+                }
+            }
+        }
+        return undefined;
+    }
+    SemanticTokenRule.fromJSONObject = fromJSONObject;
+    function toJSONObject(rule) {
+        return {
+            _selector: rule.selector.id,
+            _style: TokenStyle.toJSONObject(rule.style)
+        };
+    }
+    SemanticTokenRule.toJSONObject = toJSONObject;
+    function equals(r1, r2) {
+        if (r1 === r2) {
+            return true;
+        }
+        return r1 !== undefined && r2 !== undefined
+            && r1.selector && r2.selector && r1.selector.id === r2.selector.id
+            && TokenStyle.equals(r1.style, r2.style);
+    }
+    SemanticTokenRule.equals = equals;
+    function is(r) {
+        return r && r.selector && typeof r.selector.id === 'string' && TokenStyle.is(r.style);
+    }
+    SemanticTokenRule.is = is;
+})(SemanticTokenRule || (SemanticTokenRule = {}));
+const Extensions = {
+    TokenClassificationContribution: 'base.contributions.tokenClassification'
+};
+class TokenClassificationRegistry extends Disposable {
+    constructor() {
+        super();
+        this._onDidChangeSchema = this._register(( new Emitter()));
+        this.onDidChangeSchema = this._onDidChangeSchema.event;
+        this.currentTypeNumber = 0;
+        this.currentModifierBit = 1;
+        this.tokenStylingDefaultRules = [];
+        this.tokenStylingSchema = {
+            type: 'object',
+            properties: {},
+            patternProperties: {
+                [selectorPattern]: getStylingSchemeEntry()
+            },
+            additionalProperties: false,
+            definitions: {
+                style: {
+                    type: 'object',
+                    description: ( localize(2298, 'Colors and styles for the token.')),
+                    properties: {
+                        foreground: {
+                            type: 'string',
+                            description: ( localize(2299, 'Foreground color for the token.')),
+                            format: 'color-hex',
+                            default: '#ff0000'
+                        },
+                        background: {
+                            type: 'string',
+                            deprecationMessage: ( localize(2300, 'Token background colors are currently not supported.'))
+                        },
+                        fontStyle: {
+                            type: 'string',
+                            description: ( localize(
+                                2301,
+                                'Sets the all font styles of the rule: \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. All styles that are not listed are unset. The empty string unsets all styles.'
+                            )),
+                            pattern: fontStylePattern,
+                            patternErrorMessage: ( localize(
+                                2302,
+                                'Font style must be \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. The empty string unsets all styles.'
+                            )),
+                            defaultSnippets: [
+                                { label: ( localize(2303, 'None (clear inherited style)')), bodyText: '""' },
+                                { body: 'italic' },
+                                { body: 'bold' },
+                                { body: 'underline' },
+                                { body: 'strikethrough' },
+                                { body: 'italic bold' },
+                                { body: 'italic underline' },
+                                { body: 'italic strikethrough' },
+                                { body: 'bold underline' },
+                                { body: 'bold strikethrough' },
+                                { body: 'underline strikethrough' },
+                                { body: 'italic bold underline' },
+                                { body: 'italic bold strikethrough' },
+                                { body: 'italic underline strikethrough' },
+                                { body: 'bold underline strikethrough' },
+                                { body: 'italic bold underline strikethrough' }
+                            ]
+                        },
+                        bold: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2304,
+                                'Sets or unsets the font style to bold. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        },
+                        italic: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2305,
+                                'Sets or unsets the font style to italic. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        },
+                        underline: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2306,
+                                'Sets or unsets the font style to underline. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        },
+                        strikethrough: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2307,
+                                'Sets or unsets the font style to strikethrough. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        }
+                    },
+                    defaultSnippets: [{ body: { foreground: '${1:#FF0000}', fontStyle: '${2:bold}' } }]
+                }
+            }
+        };
+        this.tokenTypeById = Object.create(null);
+        this.tokenModifierById = Object.create(null);
+        this.typeHierarchy = Object.create(null);
+    }
+    registerTokenType(id, description, superType, deprecationMessage) {
+        if (!id.match(typeAndModifierIdPattern)) {
+            throw ( new Error('Invalid token type id.'));
+        }
+        if (superType && !superType.match(typeAndModifierIdPattern)) {
+            throw ( new Error('Invalid token super type id.'));
+        }
+        const num = this.currentTypeNumber++;
+        const tokenStyleContribution = { num, id, superType, description, deprecationMessage };
+        this.tokenTypeById[id] = tokenStyleContribution;
+        const stylingSchemeEntry = getStylingSchemeEntry(description, deprecationMessage);
+        this.tokenStylingSchema.properties[id] = stylingSchemeEntry;
+        this.typeHierarchy = Object.create(null);
+    }
+    registerTokenModifier(id, description, deprecationMessage) {
+        if (!id.match(typeAndModifierIdPattern)) {
+            throw ( new Error('Invalid token modifier id.'));
+        }
+        const num = this.currentModifierBit;
+        this.currentModifierBit = this.currentModifierBit * 2;
+        const tokenStyleContribution = { num, id, description, deprecationMessage };
+        this.tokenModifierById[id] = tokenStyleContribution;
+        this.tokenStylingSchema.properties[`*.${id}`] = getStylingSchemeEntry(description, deprecationMessage);
+    }
+    parseTokenSelector(selectorString, language) {
+        const selector = parseClassifierString(selectorString, language);
+        if (!selector.type) {
+            return {
+                match: () => -1,
+                id: '$invalid'
+            };
+        }
+        return {
+            match: (type, modifiers, language) => {
+                let score = 0;
+                if (selector.language !== undefined) {
+                    if (selector.language !== language) {
+                        return -1;
+                    }
+                    score += 10;
+                }
+                if (selector.type !== TOKEN_TYPE_WILDCARD) {
+                    const hierarchy = this.getTypeHierarchy(type);
+                    const level = hierarchy.indexOf(selector.type);
+                    if (level === -1) {
+                        return -1;
+                    }
+                    score += (100 - level);
+                }
+                for (const selectorModifier of selector.modifiers) {
+                    if (modifiers.indexOf(selectorModifier) === -1) {
+                        return -1;
+                    }
+                }
+                return score + selector.modifiers.length * 100;
+            },
+            id: `${[selector.type, ...selector.modifiers.sort()].join('.')}${selector.language !== undefined ? ':' + selector.language : ''}`
+        };
+    }
+    registerTokenStyleDefault(selector, defaults) {
+        this.tokenStylingDefaultRules.push({ selector, defaults });
+    }
+    deregisterTokenStyleDefault(selector) {
+        const selectorString = selector.id;
+        this.tokenStylingDefaultRules = this.tokenStylingDefaultRules.filter(r => r.selector.id !== selectorString);
+    }
+    deregisterTokenType(id) {
+        delete this.tokenTypeById[id];
+        delete this.tokenStylingSchema.properties[id];
+        this.typeHierarchy = Object.create(null);
+    }
+    deregisterTokenModifier(id) {
+        delete this.tokenModifierById[id];
+        delete this.tokenStylingSchema.properties[`*.${id}`];
+    }
+    getTokenTypes() {
+        return ( ( Object.keys(this.tokenTypeById)).map(id => this.tokenTypeById[id]));
+    }
+    getTokenModifiers() {
+        return ( ( Object.keys(this.tokenModifierById)).map(id => this.tokenModifierById[id]));
+    }
+    getTokenStylingSchema() {
+        return this.tokenStylingSchema;
+    }
+    getTokenStylingDefaultRules() {
+        return this.tokenStylingDefaultRules;
+    }
+    getTypeHierarchy(typeId) {
+        let hierarchy = this.typeHierarchy[typeId];
+        if (!hierarchy) {
+            this.typeHierarchy[typeId] = hierarchy = [typeId];
+            let type = this.tokenTypeById[typeId];
+            while (type && type.superType) {
+                hierarchy.push(type.superType);
+                type = this.tokenTypeById[type.superType];
+            }
+        }
+        return hierarchy;
+    }
+    toString() {
+        const sorter = (a, b) => {
+            const cat1 = a.indexOf('.') === -1 ? 0 : 1;
+            const cat2 = b.indexOf('.') === -1 ? 0 : 1;
+            if (cat1 !== cat2) {
+                return cat1 - cat2;
+            }
+            return a.localeCompare(b);
+        };
+        return ( ( Object.keys(this.tokenTypeById)).sort(sorter).map(k => `- \`${k}\`: ${this.tokenTypeById[k].description}`)).join('\n');
+    }
+}
+const CHAR_LANGUAGE = TOKEN_CLASSIFIER_LANGUAGE_SEPARATOR.charCodeAt(0);
+const CHAR_MODIFIER = CLASSIFIER_MODIFIER_SEPARATOR.charCodeAt(0);
+function parseClassifierString(s, defaultLanguage) {
+    let k = s.length;
+    let language = defaultLanguage;
+    const modifiers = [];
+    for (let i = k - 1; i >= 0; i--) {
+        const ch = s.charCodeAt(i);
+        if (ch === CHAR_LANGUAGE || ch === CHAR_MODIFIER) {
+            const segment = s.substring(i + 1, k);
+            k = i;
+            if (ch === CHAR_LANGUAGE) {
+                language = segment;
+            }
+            else {
+                modifiers.push(segment);
+            }
+        }
+    }
+    const type = s.substring(0, k);
+    return { type, modifiers, language };
+}
+const tokenClassificationRegistry = createDefaultTokenClassificationRegistry();
+Registry.add(Extensions.TokenClassificationContribution, tokenClassificationRegistry);
+function createDefaultTokenClassificationRegistry() {
+    const registry = ( new TokenClassificationRegistry());
+    function registerTokenType(id, description, scopesToProbe = [], superType, deprecationMessage) {
+        registry.registerTokenType(id, description, superType, deprecationMessage);
+        if (scopesToProbe) {
+            registerTokenStyleDefault(id, scopesToProbe);
+        }
+        return id;
+    }
+    function registerTokenStyleDefault(selectorString, scopesToProbe) {
+        try {
+            const selector = registry.parseTokenSelector(selectorString);
+            registry.registerTokenStyleDefault(selector, { scopesToProbe });
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    registerTokenType('comment', ( localize(2308, "Style for comments.")), [['comment']]);
+    registerTokenType('string', ( localize(2309, "Style for strings.")), [['string']]);
+    registerTokenType('keyword', ( localize(2310, "Style for keywords.")), [['keyword.control']]);
+    registerTokenType('number', ( localize(2311, "Style for numbers.")), [['constant.numeric']]);
+    registerTokenType('regexp', ( localize(2312, "Style for expressions.")), [['constant.regexp']]);
+    registerTokenType('operator', ( localize(2313, "Style for operators.")), [['keyword.operator']]);
+    registerTokenType('namespace', ( localize(2314, "Style for namespaces.")), [['entity.name.namespace']]);
+    registerTokenType('type', ( localize(2315, "Style for types.")), [['entity.name.type'], ['support.type']]);
+    registerTokenType('struct', ( localize(2316, "Style for structs.")), [['entity.name.type.struct']]);
+    registerTokenType('class', ( localize(2317, "Style for classes.")), [['entity.name.type.class'], ['support.class']]);
+    registerTokenType('interface', ( localize(2318, "Style for interfaces.")), [['entity.name.type.interface']]);
+    registerTokenType('enum', ( localize(2319, "Style for enums.")), [['entity.name.type.enum']]);
+    registerTokenType('typeParameter', ( localize(2320, "Style for type parameters.")), [['entity.name.type.parameter']]);
+    registerTokenType('function', ( localize(2321, "Style for functions")), [['entity.name.function'], ['support.function']]);
+    registerTokenType('member', ( localize(2322, "Style for member functions")), [], 'method', 'Deprecated use `method` instead');
+    registerTokenType('method', ( localize(2323, "Style for method (member functions)")), [['entity.name.function.member'], ['support.function']]);
+    registerTokenType('macro', ( localize(2324, "Style for macros.")), [['entity.name.function.preprocessor']]);
+    registerTokenType('variable', ( localize(2325, "Style for variables.")), [['variable.other.readwrite'], ['entity.name.variable']]);
+    registerTokenType('parameter', ( localize(2326, "Style for parameters.")), [['variable.parameter']]);
+    registerTokenType('property', ( localize(2327, "Style for properties.")), [['variable.other.property']]);
+    registerTokenType('enumMember', ( localize(2328, "Style for enum members.")), [['variable.other.enummember']]);
+    registerTokenType('event', ( localize(2329, "Style for events.")), [['variable.other.event']]);
+    registerTokenType('decorator', ( localize(2330, "Style for decorators & annotations.")), [['entity.name.decorator'], ['entity.name.function']]);
+    registerTokenType('label', ( localize(2331, "Style for labels. ")), undefined);
+    registry.registerTokenModifier('declaration', ( localize(2332, "Style for all symbol declarations.")), undefined);
+    registry.registerTokenModifier('documentation', ( localize(2333, "Style to use for references in documentation.")), undefined);
+    registry.registerTokenModifier('static', ( localize(2334, "Style to use for symbols that are static.")), undefined);
+    registry.registerTokenModifier('abstract', ( localize(2335, "Style to use for symbols that are abstract.")), undefined);
+    registry.registerTokenModifier('deprecated', ( localize(2336, "Style to use for symbols that are deprecated.")), undefined);
+    registry.registerTokenModifier('modification', ( localize(2337, "Style to use for write accesses.")), undefined);
+    registry.registerTokenModifier('async', ( localize(2338, "Style to use for symbols that are async.")), undefined);
+    registry.registerTokenModifier('readonly', ( localize(2339, "Style to use for symbols that are read-only.")), undefined);
+    registerTokenStyleDefault('variable.readonly', [['variable.other.constant']]);
+    registerTokenStyleDefault('property.readonly', [['variable.other.constant.property']]);
+    registerTokenStyleDefault('type.defaultLibrary', [['support.type']]);
+    registerTokenStyleDefault('class.defaultLibrary', [['support.class']]);
+    registerTokenStyleDefault('interface.defaultLibrary', [['support.class']]);
+    registerTokenStyleDefault('variable.defaultLibrary', [['support.variable'], ['support.other.variable']]);
+    registerTokenStyleDefault('variable.defaultLibrary.readonly', [['support.constant']]);
+    registerTokenStyleDefault('property.defaultLibrary', [['support.variable.property']]);
+    registerTokenStyleDefault('property.defaultLibrary.readonly', [['support.constant.property']]);
+    registerTokenStyleDefault('function.defaultLibrary', [['support.function']]);
+    registerTokenStyleDefault('member.defaultLibrary', [['support.function']]);
+    return registry;
+}
+function getTokenClassificationRegistry() {
+    return tokenClassificationRegistry;
+}
+function getStylingSchemeEntry(description, deprecationMessage) {
+    return {
+        description,
+        deprecationMessage,
+        defaultSnippets: [{ body: '${1:#ff0000}' }],
+        anyOf: [
+            {
+                type: 'string',
+                format: 'color-hex'
+            },
+            {
+                $ref: '#/definitions/style'
+            }
+        ]
+    };
+}
+const tokenStylingSchemaId = 'vscode://schemas/token-styling';
+const schemaRegistry = Registry.as(Extensions$1.JSONContribution);
+schemaRegistry.registerSchema(tokenStylingSchemaId, tokenClassificationRegistry.getTokenStylingSchema());
+const delayer = ( new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(tokenStylingSchemaId), 200));
+tokenClassificationRegistry.onDidChangeSchema(() => {
+    if (!delayer.isScheduled()) {
+        delayer.schedule();
+    }
+});
+
+export { SemanticTokenRule, TokenStyle, getTokenClassificationRegistry, parseClassifierString, tokenStylingSchemaId, typeAndModifierIdPattern };

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsIcons.d.ts

@@ -0,0 +1,24 @@
+export declare const extensionsViewIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const manageExtensionIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const clearSearchResultsIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const refreshIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const filterIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const installLocalInRemoteIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const installWorkspaceRecommendedIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const configureRecommendedIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const syncEnabledIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const syncIgnoredIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const remoteIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const installCountIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const privateExtensionIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const ratingIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const preReleaseIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const sponsorIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const starFullIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const starHalfIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const starEmptyIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const errorIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const warningIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const infoIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const trustIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const activationTimeIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;

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

@@ -0,0 +1,61 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+
+const extensionsViewIcon = registerIcon('extensions-view-icon', Codicon.extensions, ( localize(6730, 'View icon of the extensions view.')));
+const manageExtensionIcon = registerIcon('extensions-manage', Codicon.gear, ( localize(6731, 'Icon for the \'Manage\' action in the extensions view.')));
+const clearSearchResultsIcon = registerIcon('extensions-clear-search-results', Codicon.clearAll, ( localize(
+ 6732,
+ 'Icon for the \'Clear Search Result\' action in the extensions view.'
+)));
+const refreshIcon = registerIcon('extensions-refresh', Codicon.refresh, ( localize(6733, 'Icon for the \'Refresh\' action in the extensions view.')));
+const filterIcon = registerIcon('extensions-filter', Codicon.filter, ( localize(6734, 'Icon for the \'Filter\' action in the extensions view.')));
+const installLocalInRemoteIcon = registerIcon('extensions-install-local-in-remote', Codicon.cloudDownload, ( localize(
+ 6735,
+ 'Icon for the \'Install Local Extension in Remote\' action in the extensions view.'
+)));
+const installWorkspaceRecommendedIcon = registerIcon('extensions-install-workspace-recommended', Codicon.cloudDownload, ( localize(
+ 6736,
+ 'Icon for the \'Install Workspace Recommended Extensions\' action in the extensions view.'
+)));
+const configureRecommendedIcon = registerIcon('extensions-configure-recommended', Codicon.pencil, ( localize(
+ 6737,
+ 'Icon for the \'Configure Recommended Extensions\' action in the extensions view.'
+)));
+const syncEnabledIcon = registerIcon('extensions-sync-enabled', Codicon.sync, ( localize(6738, 'Icon to indicate that an extension is synced.')));
+const syncIgnoredIcon = registerIcon('extensions-sync-ignored', Codicon.syncIgnored, ( localize(6739, 'Icon to indicate that an extension is ignored when syncing.')));
+const remoteIcon = registerIcon('extensions-remote', Codicon.remote, ( localize(
+ 6740,
+ 'Icon to indicate that an extension is remote in the extensions view and editor.'
+)));
+const installCountIcon = registerIcon('extensions-install-count', Codicon.cloudDownload, ( localize(
+ 6741,
+ 'Icon shown along with the install count in the extensions view and editor.'
+)));
+const privateExtensionIcon = registerIcon('extensions-private', Codicon.lock, ( localize(
+ 6742,
+ 'Icon shown for private extensions in the extensions view and editor.'
+)));
+const ratingIcon = registerIcon('extensions-rating', Codicon.star, ( localize(
+ 6743,
+ 'Icon shown along with the rating in the extensions view and editor.'
+)));
+const preReleaseIcon = registerIcon('extensions-pre-release', Codicon.versions, ( localize(
+ 6744,
+ 'Icon shown for extensions having pre-release versions in extensions view and editor.'
+)));
+const sponsorIcon = registerIcon('extensions-sponsor', Codicon.heartFilled, ( localize(
+ 6745,
+ 'Icon used for sponsoring extensions in the extensions view and editor.'
+)));
+const starFullIcon = registerIcon('extensions-star-full', Codicon.starFull, ( localize(6746, 'Full star icon used for the rating in the extensions editor.')));
+const starHalfIcon = registerIcon('extensions-star-half', Codicon.starHalf, ( localize(6747, 'Half star icon used for the rating in the extensions editor.')));
+const starEmptyIcon = registerIcon('extensions-star-empty', Codicon.starEmpty, ( localize(6748, 'Empty star icon used for the rating in the extensions editor.')));
+const errorIcon = registerIcon('extensions-error-message', Codicon.error, ( localize(6749, 'Icon shown with a error message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(6750, 'Icon shown with a warning message in the extensions editor.')));
+const infoIcon = registerIcon('extensions-info-message', Codicon.info, ( localize(6751, 'Icon shown with an info message in the extensions editor.')));
+const trustIcon = registerIcon('extension-workspace-trust', Codicon.shield, ( localize(6752, 'Icon shown with a workspace trust message in the extension editor.')));
+const activationTimeIcon = registerIcon('extension-activation-time', Codicon.history, ( localize(6753, 'Icon shown with a activation time message in the extension editor.')));
+
+export { activationTimeIcon, clearSearchResultsIcon, configureRecommendedIcon, errorIcon, extensionsViewIcon, filterIcon, infoIcon, installCountIcon, installLocalInRemoteIcon, installWorkspaceRecommendedIcon, manageExtensionIcon, preReleaseIcon, privateExtensionIcon, ratingIcon, refreshIcon, remoteIcon, sponsorIcon, starEmptyIcon, starFullIcon, starHalfIcon, syncEnabledIcon, syncIgnoredIcon, trustIcon, warningIcon };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionsIcons.d.ts

@@ -0,0 +1,3 @@
+export declare const extensionDefaultIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const verifiedPublisherIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const extensionVerifiedPublisherIconColor: string;

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionsIcons.js

@@ -0,0 +1,27 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerColor } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { textLinkForeground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+
+const extensionDefaultIcon = registerIcon('extension-default-icon', Codicon.extensionsLarge, ( localize(
+ 12557,
+ 'Icon used for the default extension in the extensions view and editor.'
+)));
+const verifiedPublisherIcon = registerIcon('extensions-verified-publisher', Codicon.verifiedFilled, ( localize(
+ 12558,
+ 'Icon used for the verified extension publisher in the extensions view and editor.'
+)));
+const extensionVerifiedPublisherIconColor = registerColor('extensionIcon.verifiedForeground', textLinkForeground, ( localize(12559, "The icon color for extension verified publisher.")), false);
+
+export { extensionDefaultIcon, extensionVerifiedPublisherIconColor, verifiedPublisherIcon };

package/vscode/src/vs/workbench/services/themes/common/workbenchThemeService.service.d.ts

@@ -0,0 +1,24 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { ColorScheme } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/theme";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IWorkbenchColorTheme, ThemeSettingTarget, IWorkbenchFileIconTheme, IWorkbenchProductIconTheme } from "@codingame/monaco-vscode-9d0168a3-519b-57f3-9bcc-89efc41f951a-common/vscode/vs/workbench/services/themes/common/workbenchThemeService";
+export declare const IWorkbenchThemeService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IWorkbenchThemeService>;
+export interface IWorkbenchThemeService extends IThemeService {
+    readonly _serviceBrand: undefined;
+    setColorTheme(themeId: string | undefined | IWorkbenchColorTheme, settingsTarget: ThemeSettingTarget): Promise<IWorkbenchColorTheme | null>;
+    getColorTheme(): IWorkbenchColorTheme;
+    getColorThemes(): Promise<IWorkbenchColorTheme[]>;
+    getMarketplaceColorThemes(publisher: string, name: string, version: string): Promise<IWorkbenchColorTheme[]>;
+    onDidColorThemeChange: Event<IWorkbenchColorTheme>;
+    getPreferredColorScheme(): ColorScheme | undefined;
+    setFileIconTheme(iconThemeId: string | undefined | IWorkbenchFileIconTheme, settingsTarget: ThemeSettingTarget): Promise<IWorkbenchFileIconTheme>;
+    getFileIconTheme(): IWorkbenchFileIconTheme;
+    getFileIconThemes(): Promise<IWorkbenchFileIconTheme[]>;
+    getMarketplaceFileIconThemes(publisher: string, name: string, version: string): Promise<IWorkbenchFileIconTheme[]>;
+    onDidFileIconThemeChange: Event<IWorkbenchFileIconTheme>;
+    setProductIconTheme(iconThemeId: string | undefined | IWorkbenchProductIconTheme, settingsTarget: ThemeSettingTarget): Promise<IWorkbenchProductIconTheme>;
+    getProductIconTheme(): IWorkbenchProductIconTheme;
+    getProductIconThemes(): Promise<IWorkbenchProductIconTheme[]>;
+    getMarketplaceProductIconThemes(publisher: string, name: string, version: string): Promise<IWorkbenchProductIconTheme[]>;
+    onDidProductIconThemeChange: Event<IWorkbenchProductIconTheme>;
+}

package/vscode/src/vs/workbench/services/themes/common/workbenchThemeService.service.js

@@ -0,0 +1,7 @@
+
+import { refineServiceDecorator } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+
+const IWorkbenchThemeService = refineServiceDecorator(IThemeService);
+
+export { IWorkbenchThemeService };