@codingame/monaco-vscode-api 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/themes/common/colorThemeData.js

@@ -33,16 +33,18 @@ import { toStandardTokenType } from '../../../../editor/common/languages/support
 const colorRegistry = ( Registry.as(Extensions.ColorContribution));
 const tokenClassificationRegistry = getTokenClassificationRegistry();
 const tokenGroupToScopesMap = {
-    comments: ['comment', 'punctuation.definition.comment'],
-    strings: ['string', 'meta.embedded.assembly'],
-    keywords: ['keyword - keyword.operator', 'keyword.control', 'storage', 'storage.type'],
-    numbers: ['constant.numeric'],
-    types: ['entity.name.type', 'entity.name.class', 'support.type', 'support.class'],
-    functions: ['entity.name.function', 'support.function'],
-    variables: ['variable', 'entity.name.variable']
+    comments: ["comment", "punctuation.definition.comment"],
+    strings: ["string", "meta.embedded.assembly"],
+    keywords: ["keyword - keyword.operator", "keyword.control", "storage", "storage.type"],
+    numbers: ["constant.numeric"],
+    types: ["entity.name.type", "entity.name.class", "support.type", "support.class"],
+    functions: ["entity.name.function", "support.function"],
+    variables: ["variable", "entity.name.variable"]
 };
 class ColorThemeData {
-    static { this.STORAGE_KEY = 'colorThemeData'; }
+    static {
+        this.STORAGE_KEY = "colorThemeData";
+    }
     constructor(id, label, settingsId) {
         this.themeTokenColors = [];
         this.customTokenColors = [];
@@ -81,12 +83,13 @@ class ColorThemeData {
             let hasDefaultTokens = false;
             function addRule(rule) {
                 if (rule.scope && rule.settings) {
-                    if (rule.scope === 'token.info-token') {
+                    if (rule.scope === "token.info-token") {
                         hasDefaultTokens = true;
                     }
                     const ruleSettings = rule.settings;
                     result.push({
-                        scope: rule.scope, settings: {
+                        scope: rule.scope,
+                        settings: {
                             foreground: normalizeColor(ruleSettings.foreground),
                             background: normalizeColor(ruleSettings.background),
                             fontStyle: ruleSettings.fontStyle,
@@ -146,7 +149,7 @@ class ColorThemeData {
                 result.foreground = style.foreground;
                 definitions.foreground = definition;
             }
-            for (const p of ['bold', 'underline', 'strikethrough', 'italic']) {
+            for (const p of ["bold", "underline", "strikethrough", "italic"]) {
                 const property = p;
                 const info = style[property];
                 if (info !== undefined) {
@@ -171,8 +174,7 @@ class ColorThemeData {
             const key = k;
             if (score[key] === -1) {
                 hasUndefinedStyleProperty = true;
-            }
-            else {
+            } else {
                 score[key] = Number.MAX_VALUE;
             }
         }
@@ -202,12 +204,14 @@ class ColorThemeData {
     resolveTokenStyleValue(tokenStyleValue) {
         if (tokenStyleValue === undefined) {
             return undefined;
-        }
-        else if (typeof tokenStyleValue === 'string') {
-            const { type, modifiers, language } = parseClassifierString(tokenStyleValue, '');
+        } else if (typeof tokenStyleValue === "string") {
+            const {
+                type,
+                modifiers,
+                language
+            } = parseClassifierString(tokenStyleValue, "");
             return this.getTokenStyle(type, modifiers, language);
-        }
-        else if (typeof tokenStyleValue === 'object') {
+        } else if (typeof tokenStyleValue === "object") {
             return tokenStyleValue;
         }
         return undefined;
@@ -222,7 +226,7 @@ class ColorThemeData {
             this.semanticTokenRules.forEach(r => index.add(r.style.foreground));
             tokenClassificationRegistry.getTokenStylingDefaultRules().forEach(r => {
                 const defaultColor = r.defaults[this.type];
-                if (defaultColor && typeof defaultColor === 'object') {
+                if (defaultColor && typeof defaultColor === "object") {
                     index.add(defaultColor.foreground);
                 }
             });
@@ -234,7 +238,9 @@ class ColorThemeData {
     getTokenFontIndex() {
         if (!this.tokenFontIndex) {
             const index = ( new TokenFontIndex());
-            this.tokenColors.forEach(r => index.add(r.settings.fontFamily, r.settings.fontSize, r.settings.lineHeight));
+            this.tokenColors.forEach(
+                r => index.add(r.settings.fontFamily, r.settings.fontSize, r.settings.lineHeight)
+            );
             this.tokenFontIndex = index;
         }
         return this.tokenFontIndex;
@@ -245,8 +251,17 @@ class ColorThemeData {
     get tokenFontMap() {
         return this.getTokenFontIndex().asArray();
     }
-    getTokenStyleMetadata(typeWithLanguage, modifiers, defaultLanguage, useDefault = true, definitions = {}) {
-        const { type, language } = parseClassifierString(typeWithLanguage, defaultLanguage);
+    getTokenStyleMetadata(
+        typeWithLanguage,
+        modifiers,
+        defaultLanguage,
+        useDefault = true,
+        definitions = {}
+    ) {
+        const {
+            type,
+            language
+        } = parseClassifierString(typeWithLanguage, defaultLanguage);
         const style = this.getTokenStyle(type, modifiers, language, useDefault, definitions);
         if (!style) {
             return undefined;
@@ -256,15 +271,15 @@ class ColorThemeData {
             bold: style.bold,
             underline: style.underline,
             strikethrough: style.strikethrough,
-            italic: style.italic,
+            italic: style.italic
         };
     }
     getTokenStylingRuleScope(rule) {
         if (this.customSemanticTokenRules.indexOf(rule) !== -1) {
-            return 'setting';
+            return "setting";
         }
         if (this.semanticTokenRules.indexOf(rule) !== -1) {
-            return 'theme';
+            return "theme";
         }
         return undefined;
     }
@@ -337,6 +352,7 @@ class ColorThemeData {
             this.overwriteCustomColors(themeSpecificColors);
         }
         this.tokenColorIndex = undefined;
+        this.tokenFontIndex = undefined;
         this.textMateThemingRules = undefined;
         this.customTokenScopeMatchers = undefined;
     }
@@ -345,8 +361,7 @@ class ColorThemeData {
             const colorVal = colors[id];
             if (colorVal === DEFAULT_COLOR_CONFIG_VALUE) {
                 this.customColorMap[id] = DEFAULT_COLOR_CONFIG_VALUE;
-            }
-            else if (typeof colorVal === 'string') {
+            } else if (typeof colorVal === "string") {
                 this.customColorMap[id] = ( Color.fromHex(colorVal));
             }
         }
@@ -360,6 +375,7 @@ class ColorThemeData {
             this.addCustomTokenColors(themeSpecificTokenColors);
         }
         this.tokenColorIndex = undefined;
+        this.tokenFontIndex = undefined;
         this.textMateThemingRules = undefined;
         this.customTokenScopeMatchers = undefined;
     }
@@ -382,6 +398,7 @@ class ColorThemeData {
             }
         }
         this.tokenColorIndex = undefined;
+        this.tokenFontIndex = undefined;
         this.textMateThemingRules = undefined;
     }
     isThemeScope(key) {
@@ -393,10 +410,7 @@ class ColorThemeData {
         const themeIdPrefix = themeId.slice(0, -1);
         const themeIdInfix = themeId.slice(1, -1);
         const themeIdSuffix = themeId.slice(1);
-        return themeId === this.settingsId
-            || (this.settingsId.includes(themeIdInfix) && themeIdFirstChar === THEME_SCOPE_WILDCARD && themeIdLastChar === THEME_SCOPE_WILDCARD)
-            || (this.settingsId.startsWith(themeIdPrefix) && themeIdLastChar === THEME_SCOPE_WILDCARD)
-            || (this.settingsId.endsWith(themeIdSuffix) && themeIdFirstChar === THEME_SCOPE_WILDCARD);
+        return themeId === this.settingsId || (this.settingsId.includes(themeIdInfix) && themeIdFirstChar === THEME_SCOPE_WILDCARD && themeIdLastChar === THEME_SCOPE_WILDCARD) || (this.settingsId.startsWith(themeIdPrefix) && themeIdLastChar === THEME_SCOPE_WILDCARD) || (this.settingsId.endsWith(themeIdSuffix) && themeIdFirstChar === THEME_SCOPE_WILDCARD);
     }
     getThemeSpecificColors(colors) {
         let themeSpecificColors;
@@ -416,8 +430,7 @@ class ColorThemeData {
                             const overrideColors = scopedThemeSpecificColors[subkey];
                             if (Array.isArray(originalColors) && Array.isArray(overrideColors)) {
                                 themeSpecificColors[subkey] = originalColors.concat(overrideColors);
-                            }
-                            else if (overrideColors) {
+                            } else if (overrideColors) {
                                 themeSpecificColors[subkey] = overrideColors;
                             }
                         }
@@ -435,9 +448,7 @@ class ColorThemeData {
                     if (rule) {
                         this.customSemanticTokenRules.push(rule);
                     }
-                }
-                catch (e) {
-                }
+                } catch (e) {}
             }
         }
     }
@@ -446,10 +457,15 @@ class ColorThemeData {
             const group = tokenGroup;
             const value = customTokenColors[group];
             if (value) {
-                const settings = typeof value === 'string' ? { foreground: value } : value;
+                const settings = typeof value === "string" ? {
+                    foreground: value
+                } : value;
                 const scopes = tokenGroupToScopesMap[group];
                 for (const scope of scopes) {
-                    this.customTokenColors.push({ scope, settings });
+                    this.customTokenColors.push({
+                        scope,
+                        settings
+                    });
                 }
             }
         }
@@ -492,6 +508,7 @@ class ColorThemeData {
     }
     clearCaches() {
         this.tokenColorIndex = undefined;
+        this.tokenFontIndex = undefined;
         this.textMateThemingRules = undefined;
         this.themeTokenScopeMatchers = undefined;
         this.customTokenScopeMatchers = undefined;
@@ -505,34 +522,46 @@ class ColorThemeData {
             id: this.id,
             label: this.label,
             settingsId: this.settingsId,
-            themeTokenColors: ( this.themeTokenColors.map(tc => ({ settings: tc.settings, scope: tc.scope }))),
+            themeTokenColors: ( this.themeTokenColors.map(tc => ({
+                settings: tc.settings,
+                scope: tc.scope
+            }))),
             semanticTokenRules: ( this.semanticTokenRules.map(SemanticTokenRule.toJSONObject)),
             extensionData: ExtensionData.toJSONObject(this.extensionData),
             themeSemanticHighlighting: this.themeSemanticHighlighting,
             colorMap: colorMapData,
             watch: this.watch
         });
-        storageService.store(ColorThemeData.STORAGE_KEY, value, StorageScope.PROFILE, StorageTarget.USER);
+        storageService.store(
+            ColorThemeData.STORAGE_KEY,
+            value,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
     }
     get themeTypeSelector() {
         return this.classNames[0];
     }
     get classNames() {
-        return this.id.split(' ');
+        return this.id.split(" ");
     }
     get type() {
         switch (this.themeTypeSelector) {
-            case ThemeTypeSelector.VS: return ColorScheme.LIGHT;
-            case ThemeTypeSelector.HC_BLACK: return ColorScheme.HIGH_CONTRAST_DARK;
-            case ThemeTypeSelector.HC_LIGHT: return ColorScheme.HIGH_CONTRAST_LIGHT;
-            default: return ColorScheme.DARK;
+        case ThemeTypeSelector.VS:
+            return ColorScheme.LIGHT;
+        case ThemeTypeSelector.HC_BLACK:
+            return ColorScheme.HIGH_CONTRAST_DARK;
+        case ThemeTypeSelector.HC_LIGHT:
+            return ColorScheme.HIGH_CONTRAST_LIGHT;
+        default:
+            return ColorScheme.DARK;
         }
     }
     static createUnloadedThemeForThemeType(themeType, colorMap) {
         return ColorThemeData.createUnloadedTheme(getThemeTypeSelector(themeType), colorMap);
     }
     static createUnloadedTheme(id, colorMap) {
-        const themeData = ( new ColorThemeData(id, '', '__' + id));
+        const themeData = ( new ColorThemeData(id, "", "__" + id));
         themeData.isLoaded = false;
         themeData.themeTokenColors = [];
         themeData.watch = false;
@@ -544,7 +573,7 @@ class ColorThemeData {
         return themeData;
     }
     static createLoadedEmptyTheme(id, settingsId) {
-        const themeData = ( new ColorThemeData(id, '', settingsId));
+        const themeData = ( new ColorThemeData(id, "", settingsId));
         themeData.isLoaded = true;
         themeData.themeTokenColors = [];
         themeData.watch = false;
@@ -557,25 +586,27 @@ class ColorThemeData {
         }
         try {
             const data = JSON.parse(input);
-            const theme = ( new ColorThemeData('', '', ''));
+            const theme = ( new ColorThemeData("", "", ""));
             for (const key in data) {
                 switch (key) {
-                    case 'colorMap': {
+                case "colorMap":
+                    {
                         const colorMapData = data[key];
                         for (const id in colorMapData) {
                             theme.colorMap[id] = ( Color.fromHex(colorMapData[id]));
                         }
                         break;
                     }
-                    case 'themeTokenColors':
-                    case 'id':
-                    case 'label':
-                    case 'settingsId':
-                    case 'watch':
-                    case 'themeSemanticHighlighting':
-                        theme[key] = data[key];
-                        break;
-                    case 'semanticTokenRules': {
+                case "themeTokenColors":
+                case "id":
+                case "label":
+                case "settingsId":
+                case "watch":
+                case "themeSemanticHighlighting":
+                    theme[key] = data[key];
+                    break;
+                case "semanticTokenRules":
+                    {
                         const rulesData = data[key];
                         if (Array.isArray(rulesData)) {
                             for (const d of rulesData) {
@@ -587,24 +618,23 @@ class ColorThemeData {
                         }
                         break;
                     }
-                    case 'location':
-                        break;
-                    case 'extensionData':
-                        theme.extensionData = ExtensionData.fromJSONObject(data.extensionData);
-                        break;
+                case "location":
+                    break;
+                case "extensionData":
+                    theme.extensionData = ExtensionData.fromJSONObject(data.extensionData);
+                    break;
                 }
             }
             if (!theme.id || !theme.settingsId) {
                 return undefined;
             }
             return theme;
-        }
-        catch (e) {
+        } catch (e) {
             return undefined;
         }
     }
     static fromExtensionTheme(theme, colorThemeLocation, extensionData) {
-        const baseTheme = theme['uiTheme'] || 'vs-dark';
+        const baseTheme = theme["uiTheme"] || "vs-dark";
         const themeSelector = toCSSSelector(extensionData.extensionId, theme.path);
         const id = `${baseTheme} ${themeSelector}`;
         const label = theme.label || basename(theme.path);
@@ -619,33 +649,36 @@ class ColorThemeData {
     }
 }
 function toCSSSelector(extensionId, path) {
-    if (path.startsWith('./')) {
+    if (path.startsWith("./")) {
         path = path.substr(2);
     }
     let str = `${extensionId}-${path}`;
-    str = str.replace(/[^_a-zA-Z0-9-]/g, '-');
+    str = str.replace(/[^_a-zA-Z0-9-]/g, "-");
     if (str.charAt(0).match(/[0-9-]/)) {
-        str = '_' + str;
+        str = "_" + str;
     }
     return str;
 }
 async function _loadColorTheme(extensionResourceLoaderService, themeLocation, result) {
-    if (extname(themeLocation) === '.json') {
+    if (extname(themeLocation) === ".json") {
         const content = await extensionResourceLoaderService.readExtensionResource(themeLocation);
         const errors = [];
         const contentValue = parse(content, errors);
         if (errors.length > 0) {
             return Promise.reject(( new Error(( localize(
-                14353,
+                14750,
                 "Problems parsing JSON theme file: {0}",
-                ( errors.map(e => getParseErrorMessage(e.error))).join(', ')
+                ( errors.map(e => getParseErrorMessage(e.error))).join(", ")
             )))));
-        }
-        else if (getNodeType(contentValue) !== 'object') {
-            return Promise.reject(( new Error(( localize(14354, "Invalid format for JSON theme file: Object expected.")))));
+        } else if (getNodeType(contentValue) !== "object") {
+            return Promise.reject(( new Error(( localize(14751, "Invalid format for JSON theme file: Object expected.")))));
         }
         if (contentValue.include) {
-            await _loadColorTheme(extensionResourceLoaderService, joinPath(dirname(themeLocation), contentValue.include), result);
+            await _loadColorTheme(
+                extensionResourceLoaderService,
+                joinPath(dirname(themeLocation), contentValue.include),
+                result
+            );
         }
         if (Array.isArray(contentValue.settings)) {
             convertSettings(contentValue.settings, result);
@@ -654,9 +687,9 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
         result.semanticHighlighting = result.semanticHighlighting || contentValue.semanticHighlighting;
         const colors = contentValue.colors;
         if (colors) {
-            if (typeof colors !== 'object') {
+            if (typeof colors !== "object") {
                 return Promise.reject(( new Error(( localize(
-                    14355,
+                    14752,
                     "Problem parsing color theme file: {0}. Property 'colors' is not of type 'object'.",
                     (themeLocation.toString())
                 )))));
@@ -665,8 +698,7 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
                 const colorVal = colors[colorId];
                 if (colorVal === DEFAULT_COLOR_CONFIG_VALUE) {
                     delete result.colors[colorId];
-                }
-                else if (typeof colorVal === 'string') {
+                } else if (typeof colorVal === "string") {
                     result.colors[colorId] = ( Color.fromHex(colors[colorId]));
                 }
             }
@@ -675,38 +707,38 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
         if (tokenColors) {
             if (Array.isArray(tokenColors)) {
                 result.textMateRules.push(...tokenColors);
-            }
-            else if (typeof tokenColors === 'string') {
-                await _loadSyntaxTokens(extensionResourceLoaderService, joinPath(dirname(themeLocation), tokenColors), result);
-            }
-            else {
+            } else if (typeof tokenColors === "string") {
+                await _loadSyntaxTokens(
+                    extensionResourceLoaderService,
+                    joinPath(dirname(themeLocation), tokenColors),
+                    result
+                );
+            } else {
                 return Promise.reject(( new Error(( localize(
-                    14356,
+                    14753,
                     "Problem parsing color theme file: {0}. Property 'tokenColors' should be either an array specifying colors or a path to a TextMate theme file",
                     (themeLocation.toString())
                 )))));
             }
         }
         const semanticTokenColors = contentValue.semanticTokenColors;
-        if (semanticTokenColors && typeof semanticTokenColors === 'object') {
+        if (semanticTokenColors && typeof semanticTokenColors === "object") {
             for (const key in semanticTokenColors) {
                 try {
                     const rule = readSemanticTokenRule(key, semanticTokenColors[key]);
                     if (rule) {
                         result.semanticTokenRules.push(rule);
                     }
-                }
-                catch (e) {
+                } catch (e) {
                     return Promise.reject(( new Error(( localize(
-                        14357,
+                        14754,
                         "Problem parsing color theme file: {0}. Property 'semanticTokenColors' contains a invalid selector",
                         (themeLocation.toString())
                     )))));
                 }
             }
         }
-    }
-    else {
+    } else {
         return _loadSyntaxTokens(extensionResourceLoaderService, themeLocation, result);
     }
 }
@@ -716,17 +748,16 @@ function _loadSyntaxTokens(extensionResourceLoaderService, themeLocation, result
             const contentValue = parse$1(content);
             const settings = contentValue.settings;
             if (!Array.isArray(settings)) {
-                return Promise.reject(( new Error(( localize(14358, "Problem parsing tmTheme file: {0}. 'settings' is not array.")))));
+                return Promise.reject(( new Error(( localize(14755, "Problem parsing tmTheme file: {0}. 'settings' is not array.")))));
             }
             convertSettings(settings, result);
             return Promise.resolve(null);
-        }
-        catch (e) {
-            return Promise.reject(( new Error(( localize(14359, "Problems parsing tmTheme file: {0}", e.message)))));
+        } catch (e) {
+            return Promise.reject(( new Error(( localize(14756, "Problems parsing tmTheme file: {0}", e.message)))));
         }
     }, error => {
         return Promise.reject(( new Error(( localize(
-            14360,
+            14757,
             "Problems loading tmTheme file {0}: {1}",
             (themeLocation.toString()),
             error.message
@@ -734,38 +765,98 @@ function _loadSyntaxTokens(extensionResourceLoaderService, themeLocation, result
     });
 }
 const defaultThemeColors = {
-    'light': [
-        { scope: 'token.info-token', settings: { foreground: '#316bcd' } },
-        { scope: 'token.warn-token', settings: { foreground: '#cd9731' } },
-        { scope: 'token.error-token', settings: { foreground: '#cd3131' } },
-        { scope: 'token.debug-token', settings: { foreground: '#800080' } }
-    ],
-    'dark': [
-        { scope: 'token.info-token', settings: { foreground: '#6796e6' } },
-        { scope: 'token.warn-token', settings: { foreground: '#cd9731' } },
-        { scope: 'token.error-token', settings: { foreground: '#f44747' } },
-        { scope: 'token.debug-token', settings: { foreground: '#b267e6' } }
-    ],
-    'hcLight': [
-        { scope: 'token.info-token', settings: { foreground: '#316bcd' } },
-        { scope: 'token.warn-token', settings: { foreground: '#cd9731' } },
-        { scope: 'token.error-token', settings: { foreground: '#cd3131' } },
-        { scope: 'token.debug-token', settings: { foreground: '#800080' } }
-    ],
-    'hcDark': [
-        { scope: 'token.info-token', settings: { foreground: '#6796e6' } },
-        { scope: 'token.warn-token', settings: { foreground: '#008000' } },
-        { scope: 'token.error-token', settings: { foreground: '#FF0000' } },
-        { scope: 'token.debug-token', settings: { foreground: '#b267e6' } }
-    ]
+    "light": [{
+        scope: "token.info-token",
+        settings: {
+            foreground: "#316bcd"
+        }
+    }, {
+        scope: "token.warn-token",
+        settings: {
+            foreground: "#cd9731"
+        }
+    }, {
+        scope: "token.error-token",
+        settings: {
+            foreground: "#cd3131"
+        }
+    }, {
+        scope: "token.debug-token",
+        settings: {
+            foreground: "#800080"
+        }
+    }],
+    "dark": [{
+        scope: "token.info-token",
+        settings: {
+            foreground: "#6796e6"
+        }
+    }, {
+        scope: "token.warn-token",
+        settings: {
+            foreground: "#cd9731"
+        }
+    }, {
+        scope: "token.error-token",
+        settings: {
+            foreground: "#f44747"
+        }
+    }, {
+        scope: "token.debug-token",
+        settings: {
+            foreground: "#b267e6"
+        }
+    }],
+    "hcLight": [{
+        scope: "token.info-token",
+        settings: {
+            foreground: "#316bcd"
+        }
+    }, {
+        scope: "token.warn-token",
+        settings: {
+            foreground: "#cd9731"
+        }
+    }, {
+        scope: "token.error-token",
+        settings: {
+            foreground: "#cd3131"
+        }
+    }, {
+        scope: "token.debug-token",
+        settings: {
+            foreground: "#800080"
+        }
+    }],
+    "hcDark": [{
+        scope: "token.info-token",
+        settings: {
+            foreground: "#6796e6"
+        }
+    }, {
+        scope: "token.warn-token",
+        settings: {
+            foreground: "#008000"
+        }
+    }, {
+        scope: "token.error-token",
+        settings: {
+            foreground: "#FF0000"
+        }
+    }, {
+        scope: "token.debug-token",
+        settings: {
+            foreground: "#b267e6"
+        }
+    }]
 };
-const noMatch = (_scope) => -1;
+const noMatch = _scope => -1;
 function nameMatcher(identifiers, scopes) {
     if (scopes.length < identifiers.length) {
         return -1;
     }
     let score = undefined;
-    const every = identifiers.every((identifier) => {
+    const every = identifiers.every(identifier => {
         for (let i = scopes.length - 1; i >= 0; i--) {
             if (scopesAreMatching(scopes[i], identifier)) {
                 score = (i + 1) * 0x10000 + identifier.length;
@@ -784,7 +875,7 @@ function scopesAreMatching(thisScopeName, scopeName) {
         return true;
     }
     const len = scopeName.length;
-    return thisScopeName.length > len && thisScopeName.substr(0, len) === scopeName && thisScopeName[len] === '.';
+    return thisScopeName.length > len && thisScopeName.substr(0, len) === scopeName && thisScopeName[len] === ".";
 }
 function getScopeMatcher(rule) {
     const ruleScope = rule.scope;
@@ -796,14 +887,13 @@ function getScopeMatcher(rule) {
         for (const rs of ruleScope) {
             createMatchers(rs, nameMatcher, matchers);
         }
-    }
-    else {
+    } else {
         createMatchers(ruleScope, nameMatcher, matchers);
     }
     if (matchers.length === 0) {
         return noMatch;
     }
-    return (scope) => {
+    return scope => {
         let max = matchers[0].matcher(scope);
         for (let i = 1; i < matchers.length; i++) {
             max = Math.max(max, matchers[i].matcher(scope));
@@ -814,20 +904,28 @@ function getScopeMatcher(rule) {
 function readSemanticTokenRule(selectorString, settings) {
     const selector = tokenClassificationRegistry.parseTokenSelector(selectorString);
     let style;
-    if (typeof settings === 'string') {
+    if (typeof settings === "string") {
         style = TokenStyle.fromSettings(settings, undefined);
-    }
-    else if (isSemanticTokenColorizationSetting(settings)) {
-        style = TokenStyle.fromSettings(settings.foreground, settings.fontStyle, settings.bold, settings.underline, settings.strikethrough, settings.italic);
+    } else if (isSemanticTokenColorizationSetting(settings)) {
+        style = TokenStyle.fromSettings(
+            settings.foreground,
+            settings.fontStyle,
+            settings.bold,
+            settings.underline,
+            settings.strikethrough,
+            settings.italic
+        );
     }
     if (style) {
-        return { selector, style };
+        return {
+            selector,
+            style
+        };
     }
     return undefined;
 }
 function isSemanticTokenColorizationSetting(style) {
-    return style && (isString(style.foreground) || isString(style.fontStyle) || isBoolean(style.italic)
-        || isBoolean(style.underline) || isBoolean(style.strikethrough) || isBoolean(style.bold));
+    return style && (isString(style.foreground) || isString(style.fontStyle) || isBoolean(style.italic) || isBoolean(style.underline) || isBoolean(style.strikethrough) || isBoolean(style.bold));
 }
 function findMetadata(colorThemeData, captureNames, languageId, bracket) {
     let metadata = 0;
@@ -839,16 +937,16 @@ function findMetadata(colorThemeData, captureNames, languageId, bracket) {
         metadata |= (standardToken << MetadataConsts.TOKEN_TYPE_OFFSET);
     }
     const fontStyle = definitions.foreground?.settings.fontStyle || definitions.bold?.settings.fontStyle;
-    if (fontStyle?.includes('italic')) {
+    if (fontStyle?.includes("italic")) {
         metadata |= FontStyle.Italic | MetadataConsts.ITALIC_MASK;
     }
-    if (fontStyle?.includes('bold')) {
+    if (fontStyle?.includes("bold")) {
         metadata |= FontStyle.Bold | MetadataConsts.BOLD_MASK;
     }
-    if (fontStyle?.includes('underline')) {
+    if (fontStyle?.includes("underline")) {
         metadata |= FontStyle.Underline | MetadataConsts.UNDERLINE_MASK;
     }
-    if (fontStyle?.includes('strikethrough')) {
+    if (fontStyle?.includes("strikethrough")) {
         metadata |= FontStyle.Strikethrough | MetadataConsts.STRIKETHROUGH_MASK;
     }
     const foreground = tokenStyle?.foreground;
@@ -901,8 +999,12 @@ class TokenFontIndex {
         this._id2font = [];
         this._font2id = ( new Map());
     }
-    add(fontFamily, fontSize, lineHeight) {
-        const font = { fontFamily, fontSize, lineHeight };
+    add(fontFamily, fontSizeMultiplier, lineHeightMultiplier) {
+        const font = {
+            fontFamily,
+            fontSizeMultiplier,
+            lineHeightMultiplier
+        };
         let value = this._font2id.get(font);
         if (value) {
             return value;
@@ -927,7 +1029,7 @@ function normalizeColor(color) {
     if (!color) {
         return undefined;
     }
-    if (typeof color !== 'string') {
+    if (typeof color !== "string") {
         color = Color.Format.CSS.formatHexA(color, true);
     }
     const len = color.length;
@@ -953,8 +1055,7 @@ function normalizeColor(color) {
 function hexUpper(charCode) {
     if (charCode >= CharCode.Digit0 && charCode <= CharCode.Digit9 || charCode >= CharCode.A && charCode <= CharCode.F) {
         return charCode;
-    }
-    else if (charCode >= CharCode.a && charCode <= CharCode.f) {
+    } else if (charCode >= CharCode.a && charCode <= CharCode.f) {
         return charCode - CharCode.a + CharCode.A;
     }
     return 0;