@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/services/themes/browser/browserHostColorSchemeService.js

@@ -0,0 +1,37 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { addMatchMediaChangeListener } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class BrowserHostColorSchemeService extends Disposable {
+    constructor() {
+        super();
+        this._onDidSchemeChangeEvent = this._register(( new Emitter()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        addMatchMediaChangeListener('(prefers-color-scheme: dark)', () => {
+            this._onDidSchemeChangeEvent.fire();
+        });
+        addMatchMediaChangeListener('(forced-colors: active)', () => {
+            this._onDidSchemeChangeEvent.fire();
+        });
+    }
+    get onDidChangeColorScheme() {
+        return this._onDidSchemeChangeEvent.event;
+    }
+    get dark() {
+        if (window.matchMedia(`(prefers-color-scheme: light)`).matches) {
+            return false;
+        }
+        else if (window.matchMedia(`(prefers-color-scheme: dark)`).matches) {
+            return true;
+        }
+        return false;
+    }
+    get highContrast() {
+        if (window.matchMedia(`(forced-colors: active)`).matches) {
+            return true;
+        }
+        return false;
+    }
+}
+export { BrowserHostColorSchemeService };

package/dist/vscode/vs/workbench/services/themes/browser/fileIconThemeData.js

@@ -0,0 +1,353 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { parse, getNodeType } from '../../../../base/common/json.js';
+import { ExtensionData } from '../common/workbenchThemeService.js';
+import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
+import { asCSSUrl } from 'monaco-editor/esm/vs/base/browser/dom.js';
+class FileIconThemeData {
+    constructor(id, label, settingsId) {
+        this.id = id;
+        this.label = label;
+        this.settingsId = settingsId;
+        this.isLoaded = false;
+        this.hasFileIcons = false;
+        this.hasFolderIcons = false;
+        this.hidesExplorerArrows = false;
+    }
+    ensureLoaded(themeLoader) {
+        return !this.isLoaded ? this.load(themeLoader) : Promise.resolve(this.styleSheetContent);
+    }
+    reload(themeLoader) {
+        return this.load(themeLoader);
+    }
+    load(themeLoader) {
+        return themeLoader.load(this);
+    }
+    static fromExtensionTheme(iconTheme, iconThemeLocation, extensionData) {
+        const id = extensionData.extensionId + '-' + iconTheme.id;
+        const label = iconTheme.label || paths.basename(iconTheme.path);
+        const settingsId = iconTheme.id;
+        const themeData = ( new FileIconThemeData(id, label, settingsId));
+        themeData.description = iconTheme.description;
+        themeData.location = iconThemeLocation;
+        themeData.extensionData = extensionData;
+        themeData.watch = iconTheme._watch;
+        themeData.isLoaded = false;
+        return themeData;
+    }
+    static get noIconTheme() {
+        let themeData = FileIconThemeData._noIconTheme;
+        if (!themeData) {
+            themeData = FileIconThemeData._noIconTheme = ( new FileIconThemeData('', '', null));
+            themeData.hasFileIcons = false;
+            themeData.hasFolderIcons = false;
+            themeData.hidesExplorerArrows = false;
+            themeData.isLoaded = true;
+            themeData.extensionData = undefined;
+            themeData.watch = false;
+        }
+        return themeData;
+    }
+    static createUnloadedTheme(id) {
+        const themeData = ( new FileIconThemeData(id, '', '__' + id));
+        themeData.isLoaded = false;
+        themeData.hasFileIcons = false;
+        themeData.hasFolderIcons = false;
+        themeData.hidesExplorerArrows = false;
+        themeData.extensionData = undefined;
+        themeData.watch = false;
+        return themeData;
+    }
+    static fromStorageData(storageService) {
+        const input = storageService.get(FileIconThemeData.STORAGE_KEY, 0 );
+        if (!input) {
+            return undefined;
+        }
+        try {
+            const data = JSON.parse(input);
+            const theme = ( new FileIconThemeData('', '', null));
+            for (const key in data) {
+                switch (key) {
+                    case 'id':
+                    case 'label':
+                    case 'description':
+                    case 'settingsId':
+                    case 'styleSheetContent':
+                    case 'hasFileIcons':
+                    case 'hidesExplorerArrows':
+                    case 'hasFolderIcons':
+                    case 'watch':
+                        theme[key] = data[key];
+                        break;
+                    case 'location':
+                        break;
+                    case 'extensionData':
+                        theme.extensionData = ExtensionData.fromJSONObject(data.extensionData);
+                        break;
+                }
+            }
+            return theme;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    toStorage(storageService) {
+        const data = JSON.stringify({
+            id: this.id,
+            label: this.label,
+            description: this.description,
+            settingsId: this.settingsId,
+            styleSheetContent: this.styleSheetContent,
+            hasFileIcons: this.hasFileIcons,
+            hasFolderIcons: this.hasFolderIcons,
+            hidesExplorerArrows: this.hidesExplorerArrows,
+            extensionData: ExtensionData.toJSONObject(this.extensionData),
+            watch: this.watch
+        });
+        storageService.store(FileIconThemeData.STORAGE_KEY, data, 0 , 1 );
+    }
+}
+FileIconThemeData.STORAGE_KEY = 'iconThemeData';
+FileIconThemeData._noIconTheme = null;
+class FileIconThemeLoader {
+    constructor(fileService, languageService) {
+        this.fileService = fileService;
+        this.languageService = languageService;
+    }
+    load(data) {
+        if (!data.location) {
+            return Promise.resolve(data.styleSheetContent);
+        }
+        return this.loadIconThemeDocument(data.location).then(iconThemeDocument => {
+            const result = this.processIconThemeDocument(data.id, data.location, iconThemeDocument);
+            data.styleSheetContent = result.content;
+            data.hasFileIcons = result.hasFileIcons;
+            data.hasFolderIcons = result.hasFolderIcons;
+            data.hidesExplorerArrows = result.hidesExplorerArrows;
+            data.isLoaded = true;
+            return data.styleSheetContent;
+        });
+    }
+    loadIconThemeDocument(location) {
+        return this.fileService.readExtensionResource(location).then((content) => {
+            const errors = [];
+            const contentValue = parse(content, errors);
+            if (errors.length > 0) {
+                return Promise.reject(( new Error(( nls.localize(
+                    'error.cannotparseicontheme',
+                    "Problems parsing file icons file: {0}",
+                    ( errors.map(e => getParseErrorMessage(e.error))).join(', ')
+                )))));
+            }
+            else if (getNodeType(contentValue) !== 'object') {
+                return Promise.reject(( new Error(( nls.localize(
+                    'error.invalidformat',
+                    "Invalid format for file icons theme file: Object expected."
+                )))));
+            }
+            return Promise.resolve(contentValue);
+        });
+    }
+    processIconThemeDocument(id, iconThemeDocumentLocation, iconThemeDocument) {
+        const result = { content: '', hasFileIcons: false, hasFolderIcons: false, hidesExplorerArrows: !!iconThemeDocument.hidesExplorerArrows };
+        let hasSpecificFileIcons = false;
+        if (!iconThemeDocument.iconDefinitions) {
+            return result;
+        }
+        const selectorByDefinitionId = {};
+        const coveredLanguages = {};
+        const iconThemeDocumentLocationDirname = resources.dirname(iconThemeDocumentLocation);
+        function resolvePath(path) {
+            return resources.joinPath(iconThemeDocumentLocationDirname, path);
+        }
+        function collectSelectors(associations, baseThemeClassName) {
+            function addSelector(selector, defId) {
+                if (defId) {
+                    let list = selectorByDefinitionId[defId];
+                    if (!list) {
+                        list = selectorByDefinitionId[defId] = [];
+                    }
+                    list.push(selector);
+                }
+            }
+            if (associations) {
+                let qualifier = '.show-file-icons';
+                if (baseThemeClassName) {
+                    qualifier = baseThemeClassName + ' ' + qualifier;
+                }
+                const expanded = '.monaco-tl-twistie.collapsible:not(.collapsed) + .monaco-tl-contents';
+                if (associations.folder) {
+                    addSelector(`${qualifier} .folder-icon::before`, associations.folder);
+                    result.hasFolderIcons = true;
+                }
+                if (associations.folderExpanded) {
+                    addSelector(`${qualifier} ${expanded} .folder-icon::before`, associations.folderExpanded);
+                    result.hasFolderIcons = true;
+                }
+                const rootFolder = associations.rootFolder || associations.folder;
+                const rootFolderExpanded = associations.rootFolderExpanded || associations.folderExpanded;
+                if (rootFolder) {
+                    addSelector(`${qualifier} .rootfolder-icon::before`, rootFolder);
+                    result.hasFolderIcons = true;
+                }
+                if (rootFolderExpanded) {
+                    addSelector(`${qualifier} ${expanded} .rootfolder-icon::before`, rootFolderExpanded);
+                    result.hasFolderIcons = true;
+                }
+                if (associations.file) {
+                    addSelector(`${qualifier} .file-icon::before`, associations.file);
+                    result.hasFileIcons = true;
+                }
+                const folderNames = associations.folderNames;
+                if (folderNames) {
+                    for (const key in folderNames) {
+                        const selectors = [];
+                        const name = handleParentFolder(key.toLowerCase(), selectors);
+                        selectors.push(`.${escapeCSS(name)}-name-folder-icon`);
+                        addSelector(`${qualifier} ${selectors.join('')}.folder-icon::before`, folderNames[key]);
+                        result.hasFolderIcons = true;
+                    }
+                }
+                const folderNamesExpanded = associations.folderNamesExpanded;
+                if (folderNamesExpanded) {
+                    for (const key in folderNamesExpanded) {
+                        const selectors = [];
+                        const name = handleParentFolder(key.toLowerCase(), selectors);
+                        selectors.push(`.${escapeCSS(name)}-name-folder-icon`);
+                        addSelector(`${qualifier} ${expanded} ${selectors.join('')}.folder-icon::before`, folderNamesExpanded[key]);
+                        result.hasFolderIcons = true;
+                    }
+                }
+                const languageIds = associations.languageIds;
+                if (languageIds) {
+                    if (!languageIds.jsonc && languageIds.json) {
+                        languageIds.jsonc = languageIds.json;
+                    }
+                    for (const languageId in languageIds) {
+                        addSelector(`${qualifier} .${escapeCSS(languageId)}-lang-file-icon.file-icon::before`, languageIds[languageId]);
+                        result.hasFileIcons = true;
+                        hasSpecificFileIcons = true;
+                        coveredLanguages[languageId] = true;
+                    }
+                }
+                const fileExtensions = associations.fileExtensions;
+                if (fileExtensions) {
+                    for (const key in fileExtensions) {
+                        const selectors = [];
+                        const name = handleParentFolder(key.toLowerCase(), selectors);
+                        const segments = name.split('.');
+                        if (segments.length) {
+                            for (let i = 0; i < segments.length; i++) {
+                                selectors.push(`.${escapeCSS(segments.slice(i).join('.'))}-ext-file-icon`);
+                            }
+                            selectors.push('.ext-file-icon');
+                        }
+                        addSelector(`${qualifier} ${selectors.join('')}.file-icon::before`, fileExtensions[key]);
+                        result.hasFileIcons = true;
+                        hasSpecificFileIcons = true;
+                    }
+                }
+                const fileNames = associations.fileNames;
+                if (fileNames) {
+                    for (const key in fileNames) {
+                        const selectors = [];
+                        const fileName = handleParentFolder(key.toLowerCase(), selectors);
+                        selectors.push(`.${escapeCSS(fileName)}-name-file-icon`);
+                        selectors.push('.name-file-icon');
+                        const segments = fileName.split('.');
+                        if (segments.length) {
+                            for (let i = 1; i < segments.length; i++) {
+                                selectors.push(`.${escapeCSS(segments.slice(i).join('.'))}-ext-file-icon`);
+                            }
+                            selectors.push('.ext-file-icon');
+                        }
+                        addSelector(`${qualifier} ${selectors.join('')}.file-icon::before`, fileNames[key]);
+                        result.hasFileIcons = true;
+                        hasSpecificFileIcons = true;
+                    }
+                }
+            }
+        }
+        collectSelectors(iconThemeDocument);
+        collectSelectors(iconThemeDocument.light, '.vs');
+        collectSelectors(iconThemeDocument.highContrast, '.hc-black');
+        collectSelectors(iconThemeDocument.highContrast, '.hc-light');
+        if (!result.hasFileIcons && !result.hasFolderIcons) {
+            return result;
+        }
+        const showLanguageModeIcons = iconThemeDocument.showLanguageModeIcons === true || (hasSpecificFileIcons && iconThemeDocument.showLanguageModeIcons !== false);
+        const cssRules = [];
+        const fonts = iconThemeDocument.fonts;
+        const fontSizes = ( new Map());
+        if (Array.isArray(fonts)) {
+            const defaultFontSize = fonts[0].size || '150%';
+            fonts.forEach(font => {
+                const src = ( font.src.map(l => `${asCSSUrl(resolvePath(l.path))} format('${l.format}')`)).join(', ');
+                cssRules.push(`@font-face { src: ${src}; font-family: '${font.id}'; font-weight: ${font.weight}; font-style: ${font.style}; font-display: block; }`);
+                if (font.size !== undefined && font.size !== defaultFontSize) {
+                    fontSizes.set(font.id, font.size);
+                }
+            });
+            cssRules.push(`.show-file-icons .file-icon::before, .show-file-icons .folder-icon::before, .show-file-icons .rootfolder-icon::before { font-family: '${fonts[0].id}'; font-size: ${defaultFontSize}; }`);
+        }
+        for (const defId in selectorByDefinitionId) {
+            const selectors = selectorByDefinitionId[defId];
+            const definition = iconThemeDocument.iconDefinitions[defId];
+            if (definition) {
+                if (definition.iconPath) {
+                    cssRules.push(`${selectors.join(', ')} { content: ' '; background-image: ${asCSSUrl(resolvePath(definition.iconPath))}; }`);
+                }
+                else if (definition.fontCharacter || definition.fontColor) {
+                    const body = [];
+                    if (definition.fontColor) {
+                        body.push(`color: ${definition.fontColor};`);
+                    }
+                    if (definition.fontCharacter) {
+                        body.push(`content: '${definition.fontCharacter}';`);
+                    }
+                    const fontSize = definition.fontSize ?? (definition.fontId ? fontSizes.get(definition.fontId) : undefined);
+                    if (fontSize) {
+                        body.push(`font-size: ${fontSize};`);
+                    }
+                    if (definition.fontId) {
+                        body.push(`font-family: ${definition.fontId};`);
+                    }
+                    if (showLanguageModeIcons) {
+                        body.push(`background-image: unset;`);
+                    }
+                    cssRules.push(`${selectors.join(', ')} { ${body.join(' ')} }`);
+                }
+            }
+        }
+        if (showLanguageModeIcons) {
+            for (const languageId of this.languageService.getRegisteredLanguageIds()) {
+                if (!coveredLanguages[languageId]) {
+                    const icon = this.languageService.getIcon(languageId);
+                    if (icon) {
+                        const selector = `.show-file-icons .${escapeCSS(languageId)}-lang-file-icon.file-icon::before`;
+                        cssRules.push(`${selector} { content: ' '; background-image: ${asCSSUrl(icon.dark)}; }`);
+                        cssRules.push(`.vs ${selector} { content: ' '; background-image: ${asCSSUrl(icon.light)}; }`);
+                    }
+                }
+            }
+        }
+        result.content = cssRules.join('\n');
+        return result;
+    }
+}
+function handleParentFolder(key, selectors) {
+    const lastIndexOfSlash = key.lastIndexOf('/');
+    if (lastIndexOfSlash >= 0) {
+        const parentFolder = key.substring(0, lastIndexOfSlash);
+        selectors.push(`.${escapeCSS(parentFolder)}-name-dir-icon`);
+        return key.substring(lastIndexOfSlash + 1);
+    }
+    return key;
+}
+function escapeCSS(str) {
+    str = str.replace(/[\11\12\14\15\40]/g, '/');
+    return window.CSS.escape(str);
+}
+export { FileIconThemeData, FileIconThemeLoader };

package/dist/vscode/vs/workbench/services/themes/browser/productIconThemeData.js

@@ -0,0 +1,291 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { parse, getNodeType } from '../../../../base/common/json.js';
+import { ExtensionData } from '../common/workbenchThemeService.js';
+import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
+import { DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE } from '../common/themeConfiguration.js';
+import { fontIdRegex, fontWeightRegex, fontStyleRegex, fontFormatRegex } from '../common/productIconThemeSchema.js';
+import { isObject, isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { getIconRegistry, IconFontDefinition } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+const DEFAULT_PRODUCT_ICON_THEME_ID = '';
+class ProductIconThemeData {
+    constructor(id, label, settingsId) {
+        this.iconThemeDocument = { iconDefinitions: ( new Map()) };
+        this.id = id;
+        this.label = label;
+        this.settingsId = settingsId;
+        this.isLoaded = false;
+    }
+    getIcon(iconContribution) {
+        return _resolveIconDefinition(iconContribution, this.iconThemeDocument);
+    }
+    ensureLoaded(fileService, logService) {
+        return !this.isLoaded ? this.load(fileService, logService) : Promise.resolve(this.styleSheetContent);
+    }
+    reload(fileService, logService) {
+        return this.load(fileService, logService);
+    }
+    async load(fileService, logService) {
+        const location = this.location;
+        if (!location) {
+            return Promise.resolve(this.styleSheetContent);
+        }
+        const warnings = [];
+        this.iconThemeDocument = await _loadProductIconThemeDocument(fileService, location, warnings);
+        this.isLoaded = true;
+        if (warnings.length) {
+            logService.error(( nls.localize(
+                'error.parseicondefs',
+                "Problems processing product icons definitions in {0}:\n{1}",
+                ( location.toString()),
+                warnings.join('\n')
+            )));
+        }
+        return this.styleSheetContent;
+    }
+    static fromExtensionTheme(iconTheme, iconThemeLocation, extensionData) {
+        const id = extensionData.extensionId + '-' + iconTheme.id;
+        const label = iconTheme.label || paths.basename(iconTheme.path);
+        const settingsId = iconTheme.id;
+        const themeData = ( new ProductIconThemeData(id, label, settingsId));
+        themeData.description = iconTheme.description;
+        themeData.location = iconThemeLocation;
+        themeData.extensionData = extensionData;
+        themeData.watch = iconTheme._watch;
+        themeData.isLoaded = false;
+        return themeData;
+    }
+    static createUnloadedTheme(id) {
+        const themeData = ( new ProductIconThemeData(id, '', '__' + id));
+        themeData.isLoaded = false;
+        themeData.extensionData = undefined;
+        themeData.watch = false;
+        return themeData;
+    }
+    static get defaultTheme() {
+        let themeData = ProductIconThemeData._defaultProductIconTheme;
+        if (!themeData) {
+            themeData = ProductIconThemeData._defaultProductIconTheme = ( new ProductIconThemeData(DEFAULT_PRODUCT_ICON_THEME_ID, ( nls.localize('defaultTheme', 'Default')), DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE));
+            themeData.isLoaded = true;
+            themeData.extensionData = undefined;
+            themeData.watch = false;
+        }
+        return themeData;
+    }
+    static fromStorageData(storageService) {
+        const input = storageService.get(ProductIconThemeData.STORAGE_KEY, 0 );
+        if (!input) {
+            return undefined;
+        }
+        try {
+            const data = JSON.parse(input);
+            const theme = ( new ProductIconThemeData('', '', ''));
+            for (const key in data) {
+                switch (key) {
+                    case 'id':
+                    case 'label':
+                    case 'description':
+                    case 'settingsId':
+                    case 'styleSheetContent':
+                    case 'watch':
+                        theme[key] = data[key];
+                        break;
+                    case 'location':
+                        break;
+                    case 'extensionData':
+                        theme.extensionData = ExtensionData.fromJSONObject(data.extensionData);
+                        break;
+                }
+            }
+            const { iconDefinitions, iconFontDefinitions } = data;
+            if (Array.isArray(iconDefinitions) && isObject(iconFontDefinitions)) {
+                const restoredIconDefinitions = ( new Map());
+                for (const entry of iconDefinitions) {
+                    const { id, fontCharacter, fontId } = entry;
+                    if (isString(id) && isString(fontCharacter)) {
+                        if (isString(fontId)) {
+                            const iconFontDefinition = IconFontDefinition.fromJSONObject(iconFontDefinitions[fontId]);
+                            if (iconFontDefinition) {
+                                restoredIconDefinitions.set(id, { fontCharacter, font: { id: fontId, definition: iconFontDefinition } });
+                            }
+                        }
+                        else {
+                            restoredIconDefinitions.set(id, { fontCharacter });
+                        }
+                    }
+                }
+                theme.iconThemeDocument = { iconDefinitions: restoredIconDefinitions };
+            }
+            return theme;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    toStorage(storageService) {
+        const iconDefinitions = [];
+        const iconFontDefinitions = {};
+        for (const entry of this.iconThemeDocument.iconDefinitions.entries()) {
+            const font = entry[1].font;
+            iconDefinitions.push({ id: entry[0], fontCharacter: entry[1].fontCharacter, fontId: font?.id });
+            if (font && iconFontDefinitions[font.id] === undefined) {
+                iconFontDefinitions[font.id] = IconFontDefinition.toJSONObject(font.definition);
+            }
+        }
+        const data = JSON.stringify({
+            id: this.id,
+            label: this.label,
+            description: this.description,
+            settingsId: this.settingsId,
+            styleSheetContent: this.styleSheetContent,
+            watch: this.watch,
+            extensionData: ExtensionData.toJSONObject(this.extensionData),
+            iconDefinitions,
+            iconFontDefinitions
+        });
+        storageService.store(ProductIconThemeData.STORAGE_KEY, data, 0 , 1 );
+    }
+}
+ProductIconThemeData.STORAGE_KEY = 'productIconThemeData';
+ProductIconThemeData._defaultProductIconTheme = null;
+function _loadProductIconThemeDocument(fileService, location, warnings) {
+    return fileService.readExtensionResource(location).then((content) => {
+        const parseErrors = [];
+        const contentValue = parse(content, parseErrors);
+        if (parseErrors.length > 0) {
+            return Promise.reject(( new Error(( nls.localize(
+                'error.cannotparseicontheme',
+                "Problems parsing product icons file: {0}",
+                ( parseErrors.map(e => getParseErrorMessage(e.error))).join(', ')
+            )))));
+        }
+        else if (getNodeType(contentValue) !== 'object') {
+            return Promise.reject(( new Error(( nls.localize(
+                'error.invalidformat',
+                "Invalid format for product icons theme file: Object expected."
+            )))));
+        }
+        else if (!contentValue.iconDefinitions || !Array.isArray(contentValue.fonts) || !contentValue.fonts.length) {
+            return Promise.reject(( new Error(( nls.localize(
+                'error.missingProperties',
+                "Invalid format for product icons theme file: Must contain iconDefinitions and fonts."
+            )))));
+        }
+        const iconThemeDocumentLocationDirname = resources.dirname(location);
+        const sanitizedFonts = ( new Map());
+        for (const font of contentValue.fonts) {
+            if (isString(font.id) && font.id.match(fontIdRegex)) {
+                const fontId = font.id;
+                let fontWeight = undefined;
+                if (isString(font.weight) && font.weight.match(fontWeightRegex)) {
+                    fontWeight = font.weight;
+                }
+                else {
+                    warnings.push(( nls.localize(
+                        'error.fontWeight',
+                        'Invalid font weight in font \'{0}\'. Ignoring setting.',
+                        font.id
+                    )));
+                }
+                let fontStyle = undefined;
+                if (isString(font.style) && font.style.match(fontStyleRegex)) {
+                    fontStyle = font.style;
+                }
+                else {
+                    warnings.push(( nls.localize(
+                        'error.fontStyle',
+                        'Invalid font style in font \'{0}\'. Ignoring setting.',
+                        font.id
+                    )));
+                }
+                const sanitizedSrc = [];
+                if (Array.isArray(font.src)) {
+                    for (const s of font.src) {
+                        if (isString(s.path) && isString(s.format) && s.format.match(fontFormatRegex)) {
+                            const iconFontLocation = resources.joinPath(iconThemeDocumentLocationDirname, s.path);
+                            sanitizedSrc.push({ location: iconFontLocation, format: s.format });
+                        }
+                        else {
+                            warnings.push(( nls.localize(
+                                'error.fontSrc',
+                                'Invalid font source in font \'{0}\'. Ignoring source.',
+                                font.id
+                            )));
+                        }
+                    }
+                }
+                if (sanitizedSrc.length) {
+                    sanitizedFonts.set(fontId, { weight: fontWeight, style: fontStyle, src: sanitizedSrc });
+                }
+                else {
+                    warnings.push(( nls.localize(
+                        'error.noFontSrc',
+                        'No valid font source in font \'{0}\'. Ignoring font definition.',
+                        font.id
+                    )));
+                }
+            }
+            else {
+                warnings.push(( nls.localize(
+                    'error.fontId',
+                    'Missing or invalid font id \'{0}\'. Skipping font definition.',
+                    font.id
+                )));
+            }
+        }
+        const iconDefinitions = ( new Map());
+        const primaryFontId = contentValue.fonts[0].id;
+        for (const iconId in contentValue.iconDefinitions) {
+            const definition = contentValue.iconDefinitions[iconId];
+            if (isString(definition.fontCharacter)) {
+                const fontId = definition.fontId ?? primaryFontId;
+                const fontDefinition = sanitizedFonts.get(fontId);
+                if (fontDefinition) {
+                    const font = { id: `pi-${fontId}`, definition: fontDefinition };
+                    iconDefinitions.set(iconId, { fontCharacter: definition.fontCharacter, font });
+                }
+                else {
+                    warnings.push(( nls.localize(
+                        'error.icon.font',
+                        'Skipping icon definition \'{0}\'. Unknown font.',
+                        iconId
+                    )));
+                }
+            }
+            else {
+                warnings.push(( nls.localize(
+                    'error.icon.fontCharacter',
+                    'Skipping icon definition \'{0}\'. Unknown fontCharacter.',
+                    iconId
+                )));
+            }
+        }
+        return { iconDefinitions };
+    });
+}
+const iconRegistry = getIconRegistry();
+function _resolveIconDefinition(iconContribution, iconThemeDocument) {
+    const iconDefinitions = iconThemeDocument.iconDefinitions;
+    let definition = iconDefinitions.get(iconContribution.id);
+    let defaults = iconContribution.defaults;
+    while (!definition && ThemeIcon.isThemeIcon(defaults)) {
+        const ic = iconRegistry.getIcon(defaults.id);
+        if (ic) {
+            definition = iconDefinitions.get(ic.id);
+            defaults = ic.defaults;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (definition) {
+        return definition;
+    }
+    if (!ThemeIcon.isThemeIcon(defaults)) {
+        return defaults;
+    }
+    return undefined;
+}
+export { DEFAULT_PRODUCT_ICON_THEME_ID, ProductIconThemeData };