monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/iconLabel.js

@@ -0,0 +1,291 @@
+import './iconlabel.css';
+import { append, $, isHTMLElement, isAncestor, after } from '../../dom.js';
+import { asCSSUrl } from '../../cssValue.js';
+import { HighlightedLabel } from '../highlightedlabel/highlightedLabel.js';
+import { Disposable } from '../../../common/lifecycle.js';
+import { equals } from '../../../common/objects.js';
+import { Range } from '../../../common/range.js';
+import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
+import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
+import { ThemeIcon } from '../../../common/themables.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class FastLabelNode {
+    constructor(_element) {
+        this._element = _element;
+    }
+    get element() {
+        return this._element;
+    }
+    set textContent(content) {
+        if (this.disposed || content === this._textContent) {
+            return;
+        }
+        this._textContent = content;
+        this._element.textContent = content;
+    }
+    set classNames(classNames) {
+        if (this.disposed || equals(classNames, this._classNames)) {
+            return;
+        }
+        this._classNames = classNames;
+        this._element.classList.value = '';
+        this._element.classList.add(...classNames);
+    }
+    set empty(empty) {
+        if (this.disposed || empty === this._empty) {
+            return;
+        }
+        this._empty = empty;
+        this._element.style.marginLeft = empty ? '0' : '';
+    }
+    dispose() {
+        this.disposed = true;
+    }
+}
+class IconLabel extends Disposable {
+    constructor(container, options) {
+        super();
+        this.customHovers = new Map();
+        this.creationOptions = options;
+        this.domNode = this._register(new FastLabelNode(append(container, $('.monaco-icon-label'))));
+        this.labelContainer = append(this.domNode.element, $('.monaco-icon-label-container'));
+        this.nameContainer = append(this.labelContainer, $('span.monaco-icon-name-container'));
+        if (options?.supportHighlights || options?.supportIcons) {
+            this.nameNode = this._register(new LabelWithHighlights(this.nameContainer, !!options.supportIcons));
+        }
+        else {
+            this.nameNode = new Label(this.nameContainer);
+        }
+        this.hoverDelegate = options?.hoverDelegate ?? getDefaultHoverDelegate('mouse');
+    }
+    get element() {
+        return this.domNode.element;
+    }
+    setLabel(label, description, options) {
+        const labelClasses = ['monaco-icon-label'];
+        const containerClasses = ['monaco-icon-label-container'];
+        let ariaLabel = '';
+        if (options) {
+            if (options.extraClasses) {
+                labelClasses.push(...options.extraClasses);
+            }
+            if (options.bold) {
+                labelClasses.push('bold');
+            }
+            if (options.italic) {
+                labelClasses.push('italic');
+            }
+            if (options.strikethrough) {
+                labelClasses.push('strikethrough');
+            }
+            if (options.disabledCommand) {
+                containerClasses.push('disabled');
+            }
+            if (options.title) {
+                if (typeof options.title === 'string') {
+                    ariaLabel += options.title;
+                }
+                else {
+                    ariaLabel += label;
+                }
+            }
+        }
+        // eslint-disable-next-line no-restricted-syntax
+        const existingIconNode = this.domNode.element.querySelector('.monaco-icon-label-iconpath');
+        if (options?.iconPath) {
+            let iconNode;
+            if (!existingIconNode || !(isHTMLElement(existingIconNode))) {
+                iconNode = $('.monaco-icon-label-iconpath');
+                this.domNode.element.prepend(iconNode);
+            }
+            else {
+                iconNode = existingIconNode;
+            }
+            if (ThemeIcon.isThemeIcon(options.iconPath)) {
+                const iconClass = ThemeIcon.asClassName(options.iconPath);
+                iconNode.className = `monaco-icon-label-iconpath ${iconClass}`;
+                iconNode.style.backgroundImage = '';
+            }
+            else {
+                iconNode.style.backgroundImage = asCSSUrl(options?.iconPath);
+            }
+            iconNode.style.backgroundRepeat = 'no-repeat';
+            iconNode.style.backgroundPosition = 'center';
+            iconNode.style.backgroundSize = 'contain';
+        }
+        else if (existingIconNode) {
+            existingIconNode.remove();
+        }
+        this.domNode.classNames = labelClasses;
+        this.domNode.element.setAttribute('aria-label', ariaLabel);
+        this.labelContainer.classList.value = '';
+        this.labelContainer.classList.add(...containerClasses);
+        this.setupHover(options?.descriptionTitle ? this.labelContainer : this.element, options?.title);
+        this.nameNode.setLabel(label, options);
+        if (description || this.descriptionNode) {
+            const descriptionNode = this.getOrCreateDescriptionNode();
+            if (descriptionNode instanceof HighlightedLabel) {
+                const supportIcons = options?.supportIcons ?? this.creationOptions?.supportIcons;
+                descriptionNode.set(description || '', options ? options.descriptionMatches : undefined, undefined, options?.labelEscapeNewLines, supportIcons);
+                this.setupHover(descriptionNode.element, options?.descriptionTitle);
+            }
+            else {
+                descriptionNode.textContent = description && options?.labelEscapeNewLines ? HighlightedLabel.escapeNewLines(description, []) : (description || '');
+                this.setupHover(descriptionNode.element, options?.descriptionTitle || '');
+                descriptionNode.empty = !description;
+            }
+        }
+        if (options?.suffix || this.suffixNode) {
+            const suffixNode = this.getOrCreateSuffixNode();
+            suffixNode.textContent = options?.suffix ?? '';
+        }
+    }
+    setupHover(htmlElement, tooltip) {
+        const previousCustomHover = this.customHovers.get(htmlElement);
+        if (previousCustomHover) {
+            previousCustomHover.dispose();
+            this.customHovers.delete(htmlElement);
+        }
+        if (!tooltip) {
+            htmlElement.removeAttribute('title');
+            return;
+        }
+        let hoverTarget = htmlElement;
+        if (this.creationOptions?.hoverTargetOverride) {
+            if (!isAncestor(htmlElement, this.creationOptions.hoverTargetOverride)) {
+                throw new Error('hoverTargetOverrride must be an ancestor of the htmlElement');
+            }
+            hoverTarget = this.creationOptions.hoverTargetOverride;
+        }
+        const hoverDisposable = getBaseLayerHoverDelegate().setupManagedHover(this.hoverDelegate, hoverTarget, tooltip);
+        if (hoverDisposable) {
+            this.customHovers.set(htmlElement, hoverDisposable);
+        }
+    }
+    dispose() {
+        super.dispose();
+        for (const disposable of this.customHovers.values()) {
+            disposable.dispose();
+        }
+        this.customHovers.clear();
+    }
+    getOrCreateSuffixNode() {
+        if (!this.suffixNode) {
+            const suffixContainer = this._register(new FastLabelNode(after(this.nameContainer, $('span.monaco-icon-suffix-container'))));
+            this.suffixNode = this._register(new FastLabelNode(append(suffixContainer.element, $('span.label-suffix'))));
+        }
+        return this.suffixNode;
+    }
+    getOrCreateDescriptionNode() {
+        if (!this.descriptionNode) {
+            const descriptionContainer = this._register(new FastLabelNode(append(this.labelContainer, $('span.monaco-icon-description-container'))));
+            if (this.creationOptions?.supportDescriptionHighlights) {
+                this.descriptionNode = this._register(new HighlightedLabel(append(descriptionContainer.element, $('span.label-description'))));
+            }
+            else {
+                this.descriptionNode = this._register(new FastLabelNode(append(descriptionContainer.element, $('span.label-description'))));
+            }
+        }
+        return this.descriptionNode;
+    }
+}
+class Label {
+    constructor(container) {
+        this.container = container;
+        this.label = undefined;
+        this.singleLabel = undefined;
+    }
+    setLabel(label, options) {
+        if (this.label === label && equals(this.options, options)) {
+            return;
+        }
+        this.label = label;
+        this.options = options;
+        if (typeof label === 'string') {
+            if (!this.singleLabel) {
+                this.container.textContent = '';
+                this.container.classList.remove('multiple');
+                this.singleLabel = append(this.container, $('a.label-name', { id: options?.domId }));
+            }
+            this.singleLabel.textContent = label;
+        }
+        else {
+            this.container.textContent = '';
+            this.container.classList.add('multiple');
+            this.singleLabel = undefined;
+            for (let i = 0; i < label.length; i++) {
+                const l = label[i];
+                const id = options?.domId && `${options?.domId}_${i}`;
+                append(this.container, $('a.label-name', { id, 'data-icon-label-count': label.length, 'data-icon-label-index': i, 'role': 'treeitem' }, l));
+                if (i < label.length - 1) {
+                    append(this.container, $('span.label-separator', undefined, options?.separator || '/'));
+                }
+            }
+        }
+    }
+}
+function splitMatches(labels, separator, matches) {
+    if (!matches) {
+        return undefined;
+    }
+    let labelStart = 0;
+    return labels.map(label => {
+        const labelRange = { start: labelStart, end: labelStart + label.length };
+        const result = matches
+            .map(match => Range.intersect(labelRange, match))
+            .filter(range => !Range.isEmpty(range))
+            .map(({ start, end }) => ({ start: start - labelStart, end: end - labelStart }));
+        labelStart = labelRange.end + separator.length;
+        return result;
+    });
+}
+class LabelWithHighlights extends Disposable {
+    constructor(container, supportIcons) {
+        super();
+        this.container = container;
+        this.supportIcons = supportIcons;
+        this.label = undefined;
+        this.singleLabel = undefined;
+    }
+    setLabel(label, options) {
+        if (this.label === label && equals(this.options, options)) {
+            return;
+        }
+        this.label = label;
+        this.options = options;
+        // Determine supportIcons: use option if provided, otherwise use constructor value
+        const supportIcons = options?.supportIcons ?? this.supportIcons;
+        if (typeof label === 'string') {
+            if (!this.singleLabel) {
+                this.container.textContent = '';
+                this.container.classList.remove('multiple');
+                this.singleLabel = this._register(new HighlightedLabel(append(this.container, $('a.label-name', { id: options?.domId }))));
+            }
+            this.singleLabel.set(label, options?.matches, undefined, options?.labelEscapeNewLines, supportIcons);
+        }
+        else {
+            this.container.textContent = '';
+            this.container.classList.add('multiple');
+            this.singleLabel = undefined;
+            const separator = options?.separator || '/';
+            const matches = splitMatches(label, separator, options?.matches);
+            for (let i = 0; i < label.length; i++) {
+                const l = label[i];
+                const m = matches ? matches[i] : undefined;
+                const id = options?.domId && `${options?.domId}_${i}`;
+                const name = $('a.label-name', { id, 'data-icon-label-count': label.length, 'data-icon-label-index': i, 'role': 'treeitem' });
+                const highlightedLabel = this._register(new HighlightedLabel(append(this.container, name)));
+                highlightedLabel.set(l, m, undefined, options?.labelEscapeNewLines, supportIcons);
+                if (i < label.length - 1) {
+                    append(name, $('span.label-separator', undefined, separator));
+                }
+            }
+        }
+    }
+}
+
+export { IconLabel };

package/dist/workers/iconLabels.js

@@ -0,0 +1,33 @@
+import { $ } from '../../dom.js';
+import { ThemeIcon } from '../../../common/themables.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const labelWithIconsRegex = new RegExp(`(\\\\)?\\$\\((${ThemeIcon.iconNameExpression}(?:${ThemeIcon.iconModifierExpression})?)\\)`, 'g');
+function renderLabelWithIcons(text) {
+    const elements = new Array();
+    let match;
+    let textStart = 0, textStop = 0;
+    while ((match = labelWithIconsRegex.exec(text)) !== null) {
+        textStop = match.index || 0;
+        if (textStart < textStop) {
+            elements.push(text.substring(textStart, textStop));
+        }
+        textStart = (match.index || 0) + match[0].length;
+        const [, escaped, codicon] = match;
+        elements.push(escaped ? `$(${codicon})` : renderIcon({ id: codicon }));
+    }
+    if (textStart < text.length) {
+        elements.push(text.substring(textStart));
+    }
+    return elements;
+}
+function renderIcon(icon) {
+    const node = $(`span`);
+    node.classList.add(...ThemeIcon.asClassNameArray(icon));
+    return node;
+}
+
+export { renderIcon, renderLabelWithIcons };

package/dist/workers/iconRegistry.js

@@ -0,0 +1,183 @@
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { Codicon } from '../../../base/common/codicons.js';
+import { getCodiconFontCharacters } from '../../../base/common/codiconsUtil.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
+import { Emitter } from '../../../base/common/event.js';
+import { isString } from '../../../base/common/types.js';
+import { URI } from '../../../base/common/uri.js';
+import { localize } from '../../../nls.js';
+import { Extensions as Extensions$1 } from '../../jsonschemas/common/jsonContributionRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+//  ------ API types
+// icon registry
+const Extensions = {
+    IconContribution: 'base.contributions.icons'
+};
+var IconContribution;
+(function (IconContribution) {
+    function getDefinition(contribution, registry) {
+        let definition = contribution.defaults;
+        while (ThemeIcon.isThemeIcon(definition)) {
+            const c = iconRegistry.getIcon(definition.id);
+            if (!c) {
+                return undefined;
+            }
+            definition = c.defaults;
+        }
+        return definition;
+    }
+    IconContribution.getDefinition = getDefinition;
+})(IconContribution || (IconContribution = {}));
+var IconFontDefinition;
+(function (IconFontDefinition) {
+    function toJSONObject(iconFont) {
+        return {
+            weight: iconFont.weight,
+            style: iconFont.style,
+            src: iconFont.src.map(s => ({ format: s.format, location: s.location.toString() }))
+        };
+    }
+    IconFontDefinition.toJSONObject = toJSONObject;
+    function fromJSONObject(json) {
+        const stringOrUndef = (s) => isString(s) ? s : undefined;
+        if (json && Array.isArray(json.src) && json.src.every((s) => isString(s.format) && isString(s.location))) {
+            return {
+                weight: stringOrUndef(json.weight),
+                style: stringOrUndef(json.style),
+                src: json.src.map((s) => ({ format: s.format, location: URI.parse(s.location) }))
+            };
+        }
+        return undefined;
+    }
+    IconFontDefinition.fromJSONObject = fromJSONObject;
+})(IconFontDefinition || (IconFontDefinition = {}));
+// regexes for validation of font properties
+const fontIdRegex = /^([\w_-]+)$/;
+const fontIdErrorMessage = localize(2024, 'The font ID must only contain letters, numbers, underscores and dashes.');
+class IconRegistry extends Disposable {
+    constructor() {
+        super();
+        this._onDidChange = this._register(new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.iconSchema = {
+            definitions: {
+                icons: {
+                    type: 'object',
+                    properties: {
+                        fontId: { type: 'string', description: localize(2025, 'The id of the font to use. If not set, the font that is defined first is used.'), pattern: fontIdRegex.source, patternErrorMessage: fontIdErrorMessage },
+                        fontCharacter: { type: 'string', description: localize(2026, 'The font character associated with the icon definition.') }
+                    },
+                    additionalProperties: false,
+                    defaultSnippets: [{ body: { fontCharacter: '\\\\e030' } }]
+                }
+            },
+            type: 'object',
+            properties: {}
+        };
+        this.iconReferenceSchema = { type: 'string', pattern: `^${ThemeIcon.iconNameExpression}$`, enum: [], enumDescriptions: [] };
+        this.iconsById = {};
+        this.iconFontsById = {};
+    }
+    registerIcon(id, defaults, description, deprecationMessage) {
+        const existing = this.iconsById[id];
+        if (existing) {
+            if (description && !existing.description) {
+                existing.description = description;
+                this.iconSchema.properties[id].markdownDescription = `${description} $(${id})`;
+                const enumIndex = this.iconReferenceSchema.enum.indexOf(id);
+                if (enumIndex !== -1) {
+                    this.iconReferenceSchema.enumDescriptions[enumIndex] = description;
+                }
+                this._onDidChange.fire();
+            }
+            return existing;
+        }
+        const iconContribution = { id, description, defaults, deprecationMessage };
+        this.iconsById[id] = iconContribution;
+        const propertySchema = { $ref: '#/definitions/icons' };
+        if (deprecationMessage) {
+            propertySchema.deprecationMessage = deprecationMessage;
+        }
+        if (description) {
+            propertySchema.markdownDescription = `${description}: $(${id})`;
+        }
+        this.iconSchema.properties[id] = propertySchema;
+        this.iconReferenceSchema.enum.push(id);
+        this.iconReferenceSchema.enumDescriptions.push(description || '');
+        this._onDidChange.fire();
+        return { id };
+    }
+    getIcons() {
+        return Object.keys(this.iconsById).map(id => this.iconsById[id]);
+    }
+    getIcon(id) {
+        return this.iconsById[id];
+    }
+    getIconSchema() {
+        return this.iconSchema;
+    }
+    toString() {
+        const sorter = (i1, i2) => {
+            return i1.id.localeCompare(i2.id);
+        };
+        const classNames = (i) => {
+            while (ThemeIcon.isThemeIcon(i.defaults)) {
+                i = this.iconsById[i.defaults.id];
+            }
+            return `codicon codicon-${i ? i.id : ''}`;
+        };
+        const reference = [];
+        reference.push(`| preview     | identifier                        | default codicon ID                | description`);
+        reference.push(`| ----------- | --------------------------------- | --------------------------------- | --------------------------------- |`);
+        const contributions = Object.keys(this.iconsById).map(key => this.iconsById[key]);
+        for (const i of contributions.filter(i => !!i.description).sort(sorter)) {
+            reference.push(`|<i class="${classNames(i)}"></i>|${i.id}|${ThemeIcon.isThemeIcon(i.defaults) ? i.defaults.id : i.id}|${i.description || ''}|`);
+        }
+        reference.push(`| preview     | identifier                        `);
+        reference.push(`| ----------- | --------------------------------- |`);
+        for (const i of contributions.filter(i => !ThemeIcon.isThemeIcon(i.defaults)).sort(sorter)) {
+            reference.push(`|<i class="${classNames(i)}"></i>|${i.id}|`);
+        }
+        return reference.join('\n');
+    }
+}
+const iconRegistry = new IconRegistry();
+Registry.add(Extensions.IconContribution, iconRegistry);
+function registerIcon(id, defaults, description, deprecationMessage) {
+    return iconRegistry.registerIcon(id, defaults, description, deprecationMessage);
+}
+function getIconRegistry() {
+    return iconRegistry;
+}
+function initialize() {
+    const codiconFontCharacters = getCodiconFontCharacters();
+    for (const icon in codiconFontCharacters) {
+        const fontCharacter = '\\' + codiconFontCharacters[icon].toString(16);
+        iconRegistry.registerIcon(icon, { fontCharacter });
+    }
+}
+initialize();
+const iconsSchemaId = 'vscode://schemas/icons';
+const schemaRegistry = Registry.as(Extensions$1.JSONContribution);
+schemaRegistry.registerSchema(iconsSchemaId, iconRegistry.getIconSchema());
+const delayer = new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(iconsSchemaId), 200);
+iconRegistry.onDidChange(() => {
+    if (!delayer.isScheduled()) {
+        delayer.schedule();
+    }
+});
+//setTimeout(_ => console.log(iconRegistry.toString()), 5000);
+// common icons
+const widgetClose = registerIcon('widget-close', Codicon.close, localize(2027, 'Icon for the close action in widgets.'));
+registerIcon('goto-previous-location', Codicon.arrowUp, localize(2028, 'Icon for goto previous editor location.'));
+registerIcon('goto-next-location', Codicon.arrowDown, localize(2029, 'Icon for goto next editor location.'));
+ThemeIcon.modify(Codicon.sync, 'spin');
+ThemeIcon.modify(Codicon.loading, 'spin');
+
+export { Extensions, IconContribution, IconFontDefinition, fontIdErrorMessage, fontIdRegex, getIconRegistry, iconsSchemaId, registerIcon, widgetClose };

package/dist/workers/iconsStyleSheet.js

@@ -0,0 +1,75 @@
+import { className, inline, Builder, stringValue, identValue, asCSSUrl } from '../../../base/browser/cssValue.js';
+import { Emitter } from '../../../base/common/event.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
+import { getIconRegistry } from '../common/iconRegistry.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function getIconsStyleSheet(themeService) {
+    const disposable = new DisposableStore();
+    const onDidChangeEmmiter = disposable.add(new Emitter());
+    const iconRegistry = getIconRegistry();
+    disposable.add(iconRegistry.onDidChange(() => onDidChangeEmmiter.fire()));
+    if (themeService) {
+        disposable.add(themeService.onDidProductIconThemeChange(() => onDidChangeEmmiter.fire()));
+    }
+    return {
+        dispose: () => disposable.dispose(),
+        onDidChange: onDidChangeEmmiter.event,
+        getCSS() {
+            const productIconTheme = themeService ? themeService.getProductIconTheme() : new UnthemedProductIconTheme();
+            const usedFontIds = {};
+            const rules = new Builder();
+            const rootAttribs = new Builder();
+            for (const contribution of iconRegistry.getIcons()) {
+                const definition = productIconTheme.getIcon(contribution);
+                if (!definition) {
+                    continue;
+                }
+                const fontContribution = definition.font;
+                const fontFamilyVar = inline `--vscode-icon-${className(contribution.id)}-font-family`;
+                const contentVar = inline `--vscode-icon-${className(contribution.id)}-content`;
+                if (fontContribution) {
+                    usedFontIds[fontContribution.id] = fontContribution.definition;
+                    rootAttribs.push(inline `${fontFamilyVar}: ${stringValue(fontContribution.id)};`, inline `${contentVar}: ${stringValue(definition.fontCharacter)};`);
+                    rules.push(inline `.codicon-${className(contribution.id)}:before { content: ${stringValue(definition.fontCharacter)}; font-family: ${stringValue(fontContribution.id)}; }`);
+                }
+                else {
+                    rootAttribs.push(inline `${contentVar}: ${stringValue(definition.fontCharacter)}; ${fontFamilyVar}: 'codicon';`);
+                    rules.push(inline `.codicon-${className(contribution.id)}:before { content: ${stringValue(definition.fontCharacter)}; }`);
+                }
+            }
+            for (const id in usedFontIds) {
+                const definition = usedFontIds[id];
+                const fontWeight = definition.weight ? inline `font-weight: ${identValue(definition.weight)};` : inline ``;
+                const fontStyle = definition.style ? inline `font-style: ${identValue(definition.style)};` : inline ``;
+                const src = new Builder();
+                for (const l of definition.src) {
+                    src.push(inline `${asCSSUrl(l.location)} format(${stringValue(l.format)})`);
+                }
+                rules.push(inline `@font-face { src: ${src.join(', ')}; font-family: ${stringValue(id)};${fontWeight}${fontStyle} font-display: block; }`);
+            }
+            rules.push(inline `:root { ${rootAttribs.join(' ')} }`);
+            return rules.join('\n');
+        }
+    };
+}
+class UnthemedProductIconTheme {
+    getIcon(contribution) {
+        const iconRegistry = getIconRegistry();
+        let definition = contribution.defaults;
+        while (ThemeIcon.isThemeIcon(definition)) {
+            const c = iconRegistry.getIcon(definition.id);
+            if (!c) {
+                return undefined;
+            }
+            definition = c.defaults;
+        }
+        return definition;
+    }
+}
+
+export { UnthemedProductIconTheme, getIconsStyleSheet };

package/dist/workers/idGenerator.js

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class IdGenerator {
+    constructor(prefix) {
+        this._prefix = prefix;
+        this._lastId = 0;
+    }
+    nextId() {
+        return this._prefix + (++this._lastId);
+    }
+}
+const defaultGenerator = new IdGenerator('id#');
+
+export { IdGenerator, defaultGenerator };