@codingame/monaco-vscode-9a934394-0cf8-512d-939b-77e71f69cebb-common 20.0.0

package/empty.js

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

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@codingame/monaco-vscode-9a934394-0cf8-512d-939b-77e71f69cebb-common",
+  "version": "20.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (chat, interactive, notebook, search, textmate, theme, treesitter)",
+  "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": "20.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/amdX.d.ts

@@ -0,0 +1,3 @@
+export declare const canASAR = false;
+export declare function importAMDNodeModule<T>(nodeModuleName: string, pathInsideNodeModule: string, isBuilt?: boolean): Promise<T>;
+export declare function resolveAmdNodeModulePath(nodeModuleName: string, pathInsideNodeModule: string): string;

package/vscode/src/vs/amdX.js

@@ -0,0 +1,196 @@
+
+import { Schemas, VSCODE_AUTHORITY, nodeModulesPath, FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+
+class DefineCall {
+    constructor(id, dependencies, callback) {
+        this.id = id;
+        this.dependencies = dependencies;
+        this.callback = callback;
+    }
+}
+var AMDModuleImporterState;
+(function (AMDModuleImporterState) {
+    AMDModuleImporterState[AMDModuleImporterState["Uninitialized"] = 1] = "Uninitialized";
+    AMDModuleImporterState[AMDModuleImporterState["InitializedInternal"] = 2] = "InitializedInternal";
+    AMDModuleImporterState[AMDModuleImporterState["InitializedExternal"] = 3] = "InitializedExternal";
+})(AMDModuleImporterState || (AMDModuleImporterState = {}));
+class AMDModuleImporter {
+    static { this.INSTANCE = ( new AMDModuleImporter()); }
+    constructor() {
+        this._isWebWorker = (typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope');
+        this._isRenderer = typeof document === 'object';
+        this._defineCalls = [];
+        this._state = AMDModuleImporterState.Uninitialized;
+    }
+    _initialize() {
+        if (this._state === AMDModuleImporterState.Uninitialized) {
+            if (globalThis.define) {
+                this._state = AMDModuleImporterState.InitializedExternal;
+                return;
+            }
+        }
+        else {
+            return;
+        }
+        this._state = AMDModuleImporterState.InitializedInternal;
+        globalThis.define = (id, dependencies, callback) => {
+            if (typeof id !== 'string') {
+                callback = dependencies;
+                dependencies = id;
+                id = null;
+            }
+            if (typeof dependencies !== 'object' || !Array.isArray(dependencies)) {
+                callback = dependencies;
+                dependencies = null;
+            }
+            this._defineCalls.push(( new DefineCall(id, dependencies, callback)));
+        };
+        globalThis.define.amd = true;
+        if (this._isRenderer) {
+            this._amdPolicy = globalThis._VSCODE_WEB_PACKAGE_TTP ?? window.trustedTypes?.createPolicy('amdLoader', {
+                createScriptURL(value) {
+                    if (value.startsWith(window.location.origin)) {
+                        return value;
+                    }
+                    if (value.startsWith(`${Schemas.vscodeFileResource}://${VSCODE_AUTHORITY}`)) {
+                        return value;
+                    }
+                    throw ( new Error(`[trusted_script_src] Invalid script url: ${value}`));
+                }
+            });
+        }
+        else if (this._isWebWorker) {
+            this._amdPolicy = globalThis._VSCODE_WEB_PACKAGE_TTP ?? globalThis.trustedTypes?.createPolicy('amdLoader', {
+                createScriptURL(value) {
+                    return value;
+                }
+            });
+        }
+    }
+    async load(scriptSrc) {
+        this._initialize();
+        if (this._state === AMDModuleImporterState.InitializedExternal) {
+            return ( new Promise(resolve => {
+                const tmpModuleId = generateUuid();
+                globalThis.define(tmpModuleId, [scriptSrc], function (moduleResult) {
+                    resolve(moduleResult);
+                });
+            }));
+        }
+        const defineCall = await (this._isWebWorker ? this._workerLoadScript(scriptSrc) : this._isRenderer ? this._rendererLoadScript(scriptSrc) : this._nodeJSLoadScript(scriptSrc));
+        if (!defineCall) {
+            console.warn(`Did not receive a define call from script ${scriptSrc}`);
+            return undefined;
+        }
+        const exports = {};
+        const dependencyObjs = [];
+        const dependencyModules = [];
+        if (Array.isArray(defineCall.dependencies)) {
+            for (const mod of defineCall.dependencies) {
+                if (mod === 'exports') {
+                    dependencyObjs.push(exports);
+                }
+                else {
+                    dependencyModules.push(mod);
+                }
+            }
+        }
+        if (dependencyModules.length > 0) {
+            throw ( new Error(
+                `Cannot resolve dependencies for script ${scriptSrc}. The dependencies are: ${dependencyModules.join(', ')}`
+            ));
+        }
+        if (typeof defineCall.callback === 'function') {
+            return defineCall.callback(...dependencyObjs) ?? exports;
+        }
+        else {
+            return defineCall.callback;
+        }
+    }
+    _rendererLoadScript(scriptSrc) {
+        return ( new Promise((resolve, reject) => {
+            const scriptElement = document.createElement('script');
+            scriptElement.setAttribute('async', 'async');
+            scriptElement.setAttribute('type', 'text/javascript');
+            const unbind = () => {
+                scriptElement.removeEventListener('load', loadEventListener);
+                scriptElement.removeEventListener('error', errorEventListener);
+            };
+            const loadEventListener = (e) => {
+                unbind();
+                resolve(this._defineCalls.pop());
+            };
+            const errorEventListener = (e) => {
+                unbind();
+                reject(e);
+            };
+            scriptElement.addEventListener('load', loadEventListener);
+            scriptElement.addEventListener('error', errorEventListener);
+            if (this._amdPolicy) {
+                scriptSrc = this._amdPolicy.createScriptURL(scriptSrc);
+            }
+            scriptElement.setAttribute('src', scriptSrc);
+            window.document.getElementsByTagName('head')[0].appendChild(scriptElement);
+        }));
+    }
+    async _workerLoadScript(scriptSrc) {
+        if (this._amdPolicy) {
+            scriptSrc = this._amdPolicy.createScriptURL(scriptSrc);
+        }
+        await import(scriptSrc).then(module => module.default ?? module);
+        return this._defineCalls.pop();
+    }
+    async _nodeJSLoadScript(scriptSrc) {
+        try {
+            const fs = (await import(`${'fs'}`).then(module => module.default ?? module)).default;
+            const vm = (await import(`${'vm'}`).then(module => module.default ?? module)).default;
+            const module = (await import(`${'module'}`).then(module => module.default ?? module)).default;
+            const filePath = ( URI.parse(scriptSrc)).fsPath;
+            const content = ( fs.readFileSync(filePath).toString());
+            const scriptSource = module.wrap(content.replace(/^#!.*/, ''));
+            const script = new vm.Script(scriptSource);
+            const compileWrapper = script.runInThisContext();
+            compileWrapper.apply();
+            return this._defineCalls.pop();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+const cache = ( new Map());
+async function importAMDNodeModule(nodeModuleName, pathInsideNodeModule, isBuilt) {
+    if (isBuilt === undefined) {
+        const product = globalThis._VSCODE_PRODUCT_JSON;
+        isBuilt = Boolean((product ?? globalThis.vscode?.context?.configuration()?.product)?.commit);
+    }
+    const nodeModulePath = pathInsideNodeModule ? `${nodeModuleName}/${pathInsideNodeModule}` : nodeModuleName;
+    if (( cache.has(nodeModulePath))) {
+        return cache.get(nodeModulePath);
+    }
+    let scriptSrc;
+    if (/^\w[\w\d+.-]*:\/\//.test(nodeModulePath)) {
+        scriptSrc = nodeModulePath;
+    }
+    else {
+        const actualNodeModulesPath = (nodeModulesPath);
+        const resourcePath = `${actualNodeModulesPath}/${nodeModulePath}`;
+        scriptSrc = ( ( FileAccess.asBrowserUri(resourcePath)).toString(true));
+    }
+    const result = AMDModuleImporter.INSTANCE.load(scriptSrc);
+    cache.set(nodeModulePath, result);
+    return result;
+}
+function resolveAmdNodeModulePath(nodeModuleName, pathInsideNodeModule) {
+    const product = globalThis._VSCODE_PRODUCT_JSON;
+    Boolean((product ?? globalThis.vscode?.context?.configuration()?.product)?.commit);
+    const nodeModulePath = `${nodeModuleName}/${pathInsideNodeModule}`;
+    const actualNodeModulesPath = (nodeModulesPath);
+    const resourcePath = `${actualNodeModulesPath}/${nodeModulePath}`;
+    return ( ( FileAccess.asBrowserUri(resourcePath)).toString(true));
+}
+
+export { importAMDNodeModule, resolveAmdNodeModulePath };

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(2331, 'Colors and styles for the token.')),
+                    properties: {
+                        foreground: {
+                            type: 'string',
+                            description: ( localize(2332, 'Foreground color for the token.')),
+                            format: 'color-hex',
+                            default: '#ff0000'
+                        },
+                        background: {
+                            type: 'string',
+                            deprecationMessage: ( localize(2333, 'Token background colors are currently not supported.'))
+                        },
+                        fontStyle: {
+                            type: 'string',
+                            description: ( localize(
+                                2334,
+                                '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(
+                                2335,
+                                'Font style must be \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. The empty string unsets all styles.'
+                            )),
+                            defaultSnippets: [
+                                { label: ( localize(2336, '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(
+                                2337,
+                                'Sets or unsets the font style to bold. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        },
+                        italic: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2338,
+                                'Sets or unsets the font style to italic. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        },
+                        underline: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2339,
+                                'Sets or unsets the font style to underline. Note, the presence of \'fontStyle\' overrides this setting.'
+                            )),
+                        },
+                        strikethrough: {
+                            type: 'boolean',
+                            description: ( localize(
+                                2340,
+                                '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(2341, "Style for comments.")), [['comment']]);
+    registerTokenType('string', ( localize(2342, "Style for strings.")), [['string']]);
+    registerTokenType('keyword', ( localize(2343, "Style for keywords.")), [['keyword.control']]);
+    registerTokenType('number', ( localize(2344, "Style for numbers.")), [['constant.numeric']]);
+    registerTokenType('regexp', ( localize(2345, "Style for expressions.")), [['constant.regexp']]);
+    registerTokenType('operator', ( localize(2346, "Style for operators.")), [['keyword.operator']]);
+    registerTokenType('namespace', ( localize(2347, "Style for namespaces.")), [['entity.name.namespace']]);
+    registerTokenType('type', ( localize(2348, "Style for types.")), [['entity.name.type'], ['support.type']]);
+    registerTokenType('struct', ( localize(2349, "Style for structs.")), [['entity.name.type.struct']]);
+    registerTokenType('class', ( localize(2350, "Style for classes.")), [['entity.name.type.class'], ['support.class']]);
+    registerTokenType('interface', ( localize(2351, "Style for interfaces.")), [['entity.name.type.interface']]);
+    registerTokenType('enum', ( localize(2352, "Style for enums.")), [['entity.name.type.enum']]);
+    registerTokenType('typeParameter', ( localize(2353, "Style for type parameters.")), [['entity.name.type.parameter']]);
+    registerTokenType('function', ( localize(2354, "Style for functions")), [['entity.name.function'], ['support.function']]);
+    registerTokenType('member', ( localize(2355, "Style for member functions")), [], 'method', 'Deprecated use `method` instead');
+    registerTokenType('method', ( localize(2356, "Style for method (member functions)")), [['entity.name.function.member'], ['support.function']]);
+    registerTokenType('macro', ( localize(2357, "Style for macros.")), [['entity.name.function.preprocessor']]);
+    registerTokenType('variable', ( localize(2358, "Style for variables.")), [['variable.other.readwrite'], ['entity.name.variable']]);
+    registerTokenType('parameter', ( localize(2359, "Style for parameters.")), [['variable.parameter']]);
+    registerTokenType('property', ( localize(2360, "Style for properties.")), [['variable.other.property']]);
+    registerTokenType('enumMember', ( localize(2361, "Style for enum members.")), [['variable.other.enummember']]);
+    registerTokenType('event', ( localize(2362, "Style for events.")), [['variable.other.event']]);
+    registerTokenType('decorator', ( localize(2363, "Style for decorators & annotations.")), [['entity.name.decorator'], ['entity.name.function']]);
+    registerTokenType('label', ( localize(2364, "Style for labels. ")), undefined);
+    registry.registerTokenModifier('declaration', ( localize(2365, "Style for all symbol declarations.")), undefined);
+    registry.registerTokenModifier('documentation', ( localize(2366, "Style to use for references in documentation.")), undefined);
+    registry.registerTokenModifier('static', ( localize(2367, "Style to use for symbols that are static.")), undefined);
+    registry.registerTokenModifier('abstract', ( localize(2368, "Style to use for symbols that are abstract.")), undefined);
+    registry.registerTokenModifier('deprecated', ( localize(2369, "Style to use for symbols that are deprecated.")), undefined);
+    registry.registerTokenModifier('modification', ( localize(2370, "Style to use for write accesses.")), undefined);
+    registry.registerTokenModifier('async', ( localize(2371, "Style to use for symbols that are async.")), undefined);
+    registry.registerTokenModifier('readonly', ( localize(2372, "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 };