@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,353 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import * as json from 'monaco-editor/esm/vs/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 {
-    static { this.STORAGE_KEY = 'iconThemeData'; }
-    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 || path.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 { this._noIconTheme = null; }
-    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 );
-    }
-}
-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 = json.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 (json.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/vscode/src/vs/workbench/services/themes/browser/productIconThemeData.js

@@ -1,290 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import * as json from 'monaco-editor/esm/vs/base/common/json.js';
-import { ThemeSettingDefaults, ExtensionData } from '../common/workbenchThemeService.js';
-import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
-import { fontIdRegex, fontWeightRegex, fontStyleRegex, fontFormatRegex } from '../common/productIconThemeSchema.js';
-import { isObject, isString } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IconFontDefinition, getIconRegistry } 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 {
-    static { this.STORAGE_KEY = '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 || path.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 { this._defaultProductIconTheme = null; }
-    static get defaultTheme() {
-        let themeData = ProductIconThemeData._defaultProductIconTheme;
-        if (!themeData) {
-            themeData = ProductIconThemeData._defaultProductIconTheme = ( new ProductIconThemeData(DEFAULT_PRODUCT_ICON_THEME_ID, ( nls.localize('defaultTheme', 'Default')), ThemeSettingDefaults.PRODUCT_ICON_THEME));
-            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 );
-    }
-}
-function _loadProductIconThemeDocument(fileService, location, warnings) {
-    return fileService.readExtensionResource(location).then((content) => {
-        const parseErrors = [];
-        const contentValue = json.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 (json.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 };