monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/textureAtlasSlabAllocator.js

@@ -0,0 +1,346 @@
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { NKeyMap } from '../../../../base/common/map.js';
+import { ensureNonNullable } from '../gpuUtils.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * The slab allocator is a more complex allocator that places glyphs in square slabs of a fixed
+ * size. Slabs are defined by a small range of glyphs sizes they can house, this places like-sized
+ * glyphs in the same slab which reduces wasted space.
+ *
+ * Slabs also may contain "unused" regions on the left and bottom depending on the size of the
+ * glyphs they include. This space is used to place very thin or short glyphs, which would otherwise
+ * waste a lot of space in their own slab.
+ */
+class TextureAtlasSlabAllocator {
+    constructor(_canvas, _textureIndex, options) {
+        this._canvas = _canvas;
+        this._textureIndex = _textureIndex;
+        this._slabs = [];
+        this._activeSlabsByDims = new NKeyMap();
+        this._unusedRects = [];
+        this._openRegionsByHeight = new Map();
+        this._openRegionsByWidth = new Map();
+        /** A set of all glyphs allocated, this is only tracked to enable debug related functionality */
+        this._allocatedGlyphs = new Set();
+        this._nextIndex = 0;
+        this._ctx = ensureNonNullable(this._canvas.getContext('2d', {
+            willReadFrequently: true
+        }));
+        this._slabW = Math.min(options?.slabW ?? (64 << Math.max(Math.floor(getActiveWindow().devicePixelRatio) - 1, 0)), this._canvas.width);
+        this._slabH = Math.min(options?.slabH ?? this._slabW, this._canvas.height);
+        this._slabsPerRow = Math.floor(this._canvas.width / this._slabW);
+        this._slabsPerColumn = Math.floor(this._canvas.height / this._slabH);
+    }
+    allocate(rasterizedGlyph) {
+        // Find ideal slab, creating it if there is none suitable
+        const glyphWidth = rasterizedGlyph.boundingBox.right - rasterizedGlyph.boundingBox.left + 1;
+        const glyphHeight = rasterizedGlyph.boundingBox.bottom - rasterizedGlyph.boundingBox.top + 1;
+        // The glyph does not fit into the atlas page, glyphs should never be this large in practice
+        if (glyphWidth > this._canvas.width || glyphHeight > this._canvas.height) {
+            throw new BugIndicatingError('Glyph is too large for the atlas page');
+        }
+        // The glyph does not fit into a slab
+        if (glyphWidth > this._slabW || glyphHeight > this._slabH) {
+            // Only if this is the allocator's first glyph, resize the slab size to fit the glyph.
+            if (this._allocatedGlyphs.size > 0) {
+                return undefined;
+            }
+            // Find the largest power of 2 devisor that the glyph fits into, this ensure there is no
+            // wasted space outside the allocated slabs.
+            let sizeCandidate = this._canvas.width;
+            while (glyphWidth < sizeCandidate / 2 && glyphHeight < sizeCandidate / 2) {
+                sizeCandidate /= 2;
+            }
+            this._slabW = sizeCandidate;
+            this._slabH = sizeCandidate;
+            this._slabsPerRow = Math.floor(this._canvas.width / this._slabW);
+            this._slabsPerColumn = Math.floor(this._canvas.height / this._slabH);
+        }
+        // const dpr = getActiveWindow().devicePixelRatio;
+        // TODO: Include font size as well as DPR in nearestXPixels calculation
+        // Round slab glyph dimensions to the nearest x pixels, where x scaled with device pixel ratio
+        // const nearestXPixels = Math.max(1, Math.floor(dpr / 0.5));
+        // const nearestXPixels = Math.max(1, Math.floor(dpr));
+        const desiredSlabSize = {
+            // Nearest square number
+            // TODO: This can probably be optimized
+            // w: 1 << Math.ceil(Math.sqrt(glyphWidth)),
+            // h: 1 << Math.ceil(Math.sqrt(glyphHeight)),
+            // Nearest x px
+            // w: Math.ceil(glyphWidth / nearestXPixels) * nearestXPixels,
+            // h: Math.ceil(glyphHeight / nearestXPixels) * nearestXPixels,
+            // Round odd numbers up
+            // w: glyphWidth % 0 === 1 ? glyphWidth + 1 : glyphWidth,
+            // h: glyphHeight % 0 === 1 ? glyphHeight + 1 : glyphHeight,
+            // Exact number only
+            w: glyphWidth,
+            h: glyphHeight,
+        };
+        // Get any existing slab
+        let slab = this._activeSlabsByDims.get(desiredSlabSize.w, desiredSlabSize.h);
+        // Check if the slab is full
+        if (slab) {
+            const glyphsPerSlab = Math.floor(this._slabW / slab.entryW) * Math.floor(this._slabH / slab.entryH);
+            if (slab.count >= glyphsPerSlab) {
+                slab = undefined;
+            }
+        }
+        let dx;
+        let dy;
+        // Search for suitable space in unused rectangles
+        if (!slab) {
+            // Only check availability for the smallest side
+            if (glyphWidth < glyphHeight) {
+                const openRegions = this._openRegionsByWidth.get(glyphWidth);
+                if (openRegions?.length) {
+                    // TODO: Don't search everything?
+                    // Search from the end so we can typically pop it off the stack
+                    for (let i = openRegions.length - 1; i >= 0; i--) {
+                        const r = openRegions[i];
+                        if (r.w >= glyphWidth && r.h >= glyphHeight) {
+                            dx = r.x;
+                            dy = r.y;
+                            if (glyphWidth < r.w) {
+                                this._unusedRects.push({
+                                    x: r.x + glyphWidth,
+                                    y: r.y,
+                                    w: r.w - glyphWidth,
+                                    h: glyphHeight
+                                });
+                            }
+                            r.y += glyphHeight;
+                            r.h -= glyphHeight;
+                            if (r.h === 0) {
+                                if (i === openRegions.length - 1) {
+                                    openRegions.pop();
+                                }
+                                else {
+                                    this._unusedRects.splice(i, 1);
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                const openRegions = this._openRegionsByHeight.get(glyphHeight);
+                if (openRegions?.length) {
+                    // TODO: Don't search everything?
+                    // Search from the end so we can typically pop it off the stack
+                    for (let i = openRegions.length - 1; i >= 0; i--) {
+                        const r = openRegions[i];
+                        if (r.w >= glyphWidth && r.h >= glyphHeight) {
+                            dx = r.x;
+                            dy = r.y;
+                            if (glyphHeight < r.h) {
+                                this._unusedRects.push({
+                                    x: r.x,
+                                    y: r.y + glyphHeight,
+                                    w: glyphWidth,
+                                    h: r.h - glyphHeight
+                                });
+                            }
+                            r.x += glyphWidth;
+                            r.w -= glyphWidth;
+                            if (r.h === 0) {
+                                if (i === openRegions.length - 1) {
+                                    openRegions.pop();
+                                }
+                                else {
+                                    this._unusedRects.splice(i, 1);
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        // Create a new slab
+        if (dx === undefined || dy === undefined) {
+            if (!slab) {
+                if (this._slabs.length >= this._slabsPerRow * this._slabsPerColumn) {
+                    return undefined;
+                }
+                slab = {
+                    x: Math.floor(this._slabs.length % this._slabsPerRow) * this._slabW,
+                    y: Math.floor(this._slabs.length / this._slabsPerRow) * this._slabH,
+                    entryW: desiredSlabSize.w,
+                    entryH: desiredSlabSize.h,
+                    count: 0
+                };
+                // Track unused regions to use for small glyphs
+                // +-------------+----+
+                // |             |    |
+                // |             |    | <- Unused W region
+                // |             |    |
+                // |-------------+----+
+                // |                  | <- Unused H region
+                // +------------------+
+                const unusedW = this._slabW % slab.entryW;
+                const unusedH = this._slabH % slab.entryH;
+                if (unusedW) {
+                    addEntryToMapArray(this._openRegionsByWidth, unusedW, {
+                        x: slab.x + this._slabW - unusedW,
+                        w: unusedW,
+                        y: slab.y,
+                        h: this._slabH - (unusedH ?? 0)
+                    });
+                }
+                if (unusedH) {
+                    addEntryToMapArray(this._openRegionsByHeight, unusedH, {
+                        x: slab.x,
+                        w: this._slabW,
+                        y: slab.y + this._slabH - unusedH,
+                        h: unusedH
+                    });
+                }
+                this._slabs.push(slab);
+                this._activeSlabsByDims.set(slab, desiredSlabSize.w, desiredSlabSize.h);
+            }
+            const glyphsPerRow = Math.floor(this._slabW / slab.entryW);
+            dx = slab.x + Math.floor(slab.count % glyphsPerRow) * slab.entryW;
+            dy = slab.y + Math.floor(slab.count / glyphsPerRow) * slab.entryH;
+            // Shift current row
+            slab.count++;
+        }
+        // Draw glyph
+        this._ctx.drawImage(rasterizedGlyph.source, 
+        // source
+        rasterizedGlyph.boundingBox.left, rasterizedGlyph.boundingBox.top, glyphWidth, glyphHeight, 
+        // destination
+        dx, dy, glyphWidth, glyphHeight);
+        // Create glyph object
+        const glyph = {
+            pageIndex: this._textureIndex,
+            glyphIndex: this._nextIndex++,
+            x: dx,
+            y: dy,
+            w: glyphWidth,
+            h: glyphHeight,
+            originOffsetX: rasterizedGlyph.originOffset.x,
+            originOffsetY: rasterizedGlyph.originOffset.y,
+            fontBoundingBoxAscent: rasterizedGlyph.fontBoundingBoxAscent,
+            fontBoundingBoxDescent: rasterizedGlyph.fontBoundingBoxDescent,
+        };
+        // Set the glyph
+        this._allocatedGlyphs.add(glyph);
+        return glyph;
+    }
+    getUsagePreview() {
+        const w = this._canvas.width;
+        const h = this._canvas.height;
+        const canvas = new OffscreenCanvas(w, h);
+        const ctx = ensureNonNullable(canvas.getContext('2d'));
+        ctx.fillStyle = "#808080" /* UsagePreviewColors.Unused */;
+        ctx.fillRect(0, 0, w, h);
+        let slabEntryPixels = 0;
+        let usedPixels = 0;
+        let restrictedPixels = 0;
+        const slabW = 64 << (Math.floor(getActiveWindow().devicePixelRatio) - 1);
+        const slabH = slabW;
+        // Draw wasted underneath glyphs first
+        for (const slab of this._slabs) {
+            let x = 0;
+            let y = 0;
+            for (let i = 0; i < slab.count; i++) {
+                if (x + slab.entryW > slabW) {
+                    x = 0;
+                    y += slab.entryH;
+                }
+                ctx.fillStyle = "#FF0000" /* UsagePreviewColors.Wasted */;
+                ctx.fillRect(slab.x + x, slab.y + y, slab.entryW, slab.entryH);
+                slabEntryPixels += slab.entryW * slab.entryH;
+                x += slab.entryW;
+            }
+            const entriesPerRow = Math.floor(slabW / slab.entryW);
+            const entriesPerCol = Math.floor(slabH / slab.entryH);
+            slab.entryW * entriesPerRow * slab.entryH * entriesPerCol;
+        }
+        // Draw glyphs
+        for (const g of this._allocatedGlyphs) {
+            usedPixels += g.w * g.h;
+            ctx.fillStyle = "#4040FF" /* UsagePreviewColors.Used */;
+            ctx.fillRect(g.x, g.y, g.w, g.h);
+        }
+        // Draw unused space on side
+        const unusedRegions = Array.from(this._openRegionsByWidth.values()).flat().concat(Array.from(this._openRegionsByHeight.values()).flat());
+        for (const r of unusedRegions) {
+            ctx.fillStyle = "#FF000088" /* UsagePreviewColors.Restricted */;
+            ctx.fillRect(r.x, r.y, r.w, r.h);
+            restrictedPixels += r.w * r.h;
+        }
+        // Overlay actual glyphs on top
+        ctx.globalAlpha = 0.5;
+        ctx.drawImage(this._canvas, 0, 0);
+        ctx.globalAlpha = 1;
+        return canvas.convertToBlob();
+    }
+    getStats() {
+        const w = this._canvas.width;
+        const h = this._canvas.height;
+        let slabEntryPixels = 0;
+        let usedPixels = 0;
+        let slabEdgePixels = 0;
+        let wastedPixels = 0;
+        let restrictedPixels = 0;
+        const totalPixels = w * h;
+        const slabW = 64 << (Math.floor(getActiveWindow().devicePixelRatio) - 1);
+        const slabH = slabW;
+        // Draw wasted underneath glyphs first
+        for (const slab of this._slabs) {
+            let x = 0;
+            let y = 0;
+            for (let i = 0; i < slab.count; i++) {
+                if (x + slab.entryW > slabW) {
+                    x = 0;
+                    y += slab.entryH;
+                }
+                slabEntryPixels += slab.entryW * slab.entryH;
+                x += slab.entryW;
+            }
+            const entriesPerRow = Math.floor(slabW / slab.entryW);
+            const entriesPerCol = Math.floor(slabH / slab.entryH);
+            const thisSlabPixels = slab.entryW * entriesPerRow * slab.entryH * entriesPerCol;
+            slabEdgePixels += (slabW * slabH) - thisSlabPixels;
+        }
+        // Draw glyphs
+        for (const g of this._allocatedGlyphs) {
+            usedPixels += g.w * g.h;
+        }
+        // Draw unused space on side
+        const unusedRegions = Array.from(this._openRegionsByWidth.values()).flat().concat(Array.from(this._openRegionsByHeight.values()).flat());
+        for (const r of unusedRegions) {
+            restrictedPixels += r.w * r.h;
+        }
+        const edgeUsedPixels = slabEdgePixels - restrictedPixels;
+        wastedPixels = slabEntryPixels - (usedPixels - edgeUsedPixels);
+        // usedPixels += slabEdgePixels - restrictedPixels;
+        const efficiency = usedPixels / (usedPixels + wastedPixels + restrictedPixels);
+        return [
+            `page[${this._textureIndex}]:`,
+            `     Total: ${totalPixels}px (${w}x${h})`,
+            `      Used: ${usedPixels}px (${((usedPixels / totalPixels) * 100).toFixed(2)}%)`,
+            `    Wasted: ${wastedPixels}px (${((wastedPixels / totalPixels) * 100).toFixed(2)}%)`,
+            `Restricted: ${restrictedPixels}px (${((restrictedPixels / totalPixels) * 100).toFixed(2)}%) (hard to allocate)`,
+            `Efficiency: ${efficiency === 1 ? '100' : (efficiency * 100).toFixed(2)}%`,
+            `     Slabs: ${this._slabs.length} of ${Math.floor(this._canvas.width / slabW) * Math.floor(this._canvas.height / slabH)}`
+        ].join('\n');
+    }
+}
+function addEntryToMapArray(map, key, entry) {
+    let list = map.get(key);
+    if (!list) {
+        list = [];
+        map.set(key, list);
+    }
+    list.push(entry);
+}
+
+export { TextureAtlasSlabAllocator };

package/dist/workers/tfIdf.js

@@ -0,0 +1,179 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function countMapFrom(values) {
+    const map = new Map();
+    for (const value of values) {
+        map.set(value, (map.get(value) ?? 0) + 1);
+    }
+    return map;
+}
+/**
+ * Implementation of tf-idf (term frequency-inverse document frequency) for a set of
+ * documents where each document contains one or more chunks of text.
+ * Each document is identified by a key, and the score for each document is computed
+ * by taking the max score over all the chunks in the document.
+ */
+class TfIdfCalculator {
+    constructor() {
+        /**
+         * Total number of chunks
+         */
+        this.chunkCount = 0;
+        this.chunkOccurrences = new Map();
+        this.documents = new Map();
+    }
+    calculateScores(query, token) {
+        const embedding = this.computeEmbedding(query);
+        const idfCache = new Map();
+        const scores = [];
+        // For each document, generate one score
+        for (const [key, doc] of this.documents) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            for (const chunk of doc.chunks) {
+                const score = this.computeSimilarityScore(chunk, embedding, idfCache);
+                if (score > 0) {
+                    scores.push({ key, score });
+                }
+            }
+        }
+        return scores;
+    }
+    /**
+     * Count how many times each term (word) appears in a string.
+     */
+    static termFrequencies(input) {
+        return countMapFrom(TfIdfCalculator.splitTerms(input));
+    }
+    /**
+     * Break a string into terms (words).
+     */
+    static *splitTerms(input) {
+        const normalize = (word) => word.toLowerCase();
+        // Only match on words that are at least 3 characters long and start with a letter
+        for (const [word] of input.matchAll(/\b\p{Letter}[\p{Letter}\d]{2,}\b/gu)) {
+            yield normalize(word);
+            const camelParts = word.replace(/([a-z])([A-Z])/g, '$1 $2').split(/\s+/g);
+            if (camelParts.length > 1) {
+                for (const part of camelParts) {
+                    // Require at least 3 letters in the parts of a camel case word
+                    if (part.length > 2 && /\p{Letter}{3,}/gu.test(part)) {
+                        yield normalize(part);
+                    }
+                }
+            }
+        }
+    }
+    updateDocuments(documents) {
+        for (const { key } of documents) {
+            this.deleteDocument(key);
+        }
+        for (const doc of documents) {
+            const chunks = [];
+            for (const text of doc.textChunks) {
+                // TODO: See if we can compute the tf lazily
+                // The challenge is that we need to also update the `chunkOccurrences`
+                // and all of those updates need to get flushed before the real TF-IDF of
+                // anything is computed.
+                const tf = TfIdfCalculator.termFrequencies(text);
+                // Update occurrences list
+                for (const term of tf.keys()) {
+                    this.chunkOccurrences.set(term, (this.chunkOccurrences.get(term) ?? 0) + 1);
+                }
+                chunks.push({ text, tf });
+            }
+            this.chunkCount += chunks.length;
+            this.documents.set(doc.key, { chunks });
+        }
+        return this;
+    }
+    deleteDocument(key) {
+        const doc = this.documents.get(key);
+        if (!doc) {
+            return;
+        }
+        this.documents.delete(key);
+        this.chunkCount -= doc.chunks.length;
+        // Update term occurrences for the document
+        for (const chunk of doc.chunks) {
+            for (const term of chunk.tf.keys()) {
+                const currentOccurrences = this.chunkOccurrences.get(term);
+                if (typeof currentOccurrences === 'number') {
+                    const newOccurrences = currentOccurrences - 1;
+                    if (newOccurrences <= 0) {
+                        this.chunkOccurrences.delete(term);
+                    }
+                    else {
+                        this.chunkOccurrences.set(term, newOccurrences);
+                    }
+                }
+            }
+        }
+    }
+    computeSimilarityScore(chunk, queryEmbedding, idfCache) {
+        // Compute the dot product between the chunk's embedding and the query embedding
+        // Note that the chunk embedding is computed lazily on a per-term basis.
+        // This lets us skip a large number of calculations because the majority
+        // of chunks do not share any terms with the query.
+        let sum = 0;
+        for (const [term, termTfidf] of Object.entries(queryEmbedding)) {
+            const chunkTf = chunk.tf.get(term);
+            if (!chunkTf) {
+                // Term does not appear in chunk so it has no contribution
+                continue;
+            }
+            let chunkIdf = idfCache.get(term);
+            if (typeof chunkIdf !== 'number') {
+                chunkIdf = this.computeIdf(term);
+                idfCache.set(term, chunkIdf);
+            }
+            const chunkTfidf = chunkTf * chunkIdf;
+            sum += chunkTfidf * termTfidf;
+        }
+        return sum;
+    }
+    computeEmbedding(input) {
+        const tf = TfIdfCalculator.termFrequencies(input);
+        return this.computeTfidf(tf);
+    }
+    computeIdf(term) {
+        const chunkOccurrences = this.chunkOccurrences.get(term) ?? 0;
+        return chunkOccurrences > 0
+            ? Math.log((this.chunkCount + 1) / chunkOccurrences)
+            : 0;
+    }
+    computeTfidf(termFrequencies) {
+        const embedding = Object.create(null);
+        for (const [word, occurrences] of termFrequencies) {
+            const idf = this.computeIdf(word);
+            if (idf > 0) {
+                embedding[word] = occurrences * idf;
+            }
+        }
+        return embedding;
+    }
+}
+/**
+ * Normalize the scores to be between 0 and 1 and sort them decending.
+ * @param scores array of scores from {@link TfIdfCalculator.calculateScores}
+ * @returns normalized scores
+ */
+function normalizeTfIdfScores(scores) {
+    // copy of scores
+    const result = scores.slice(0);
+    // sort descending
+    result.sort((a, b) => b.score - a.score);
+    // normalize
+    const max = result[0]?.score ?? 0;
+    if (max > 0) {
+        for (const score of result) {
+            score.score /= max;
+        }
+    }
+    return result;
+}
+
+export { TfIdfCalculator, normalizeTfIdfScores };

package/dist/workers/themables.js

@@ -0,0 +1,100 @@
+import { Codicon } from './codicons.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var ThemeColor;
+(function (ThemeColor) {
+    function isThemeColor(obj) {
+        return !!obj && typeof obj === 'object' && typeof obj.id === 'string';
+    }
+    ThemeColor.isThemeColor = isThemeColor;
+})(ThemeColor || (ThemeColor = {}));
+var ThemeIcon;
+(function (ThemeIcon) {
+    ThemeIcon.iconNameSegment = '[A-Za-z0-9]+';
+    ThemeIcon.iconNameExpression = '[A-Za-z0-9-]+';
+    ThemeIcon.iconModifierExpression = '~[A-Za-z]+';
+    ThemeIcon.iconNameCharacter = '[A-Za-z0-9~-]';
+    const ThemeIconIdRegex = new RegExp(`^(${ThemeIcon.iconNameExpression})(${ThemeIcon.iconModifierExpression})?$`);
+    function asClassNameArray(icon) {
+        const match = ThemeIconIdRegex.exec(icon.id);
+        if (!match) {
+            return asClassNameArray(Codicon.error);
+        }
+        const [, id, modifier] = match;
+        const classNames = ['codicon', 'codicon-' + id];
+        if (modifier) {
+            classNames.push('codicon-modifier-' + modifier.substring(1));
+        }
+        return classNames;
+    }
+    ThemeIcon.asClassNameArray = asClassNameArray;
+    function asClassName(icon) {
+        return asClassNameArray(icon).join(' ');
+    }
+    ThemeIcon.asClassName = asClassName;
+    function asCSSSelector(icon) {
+        return '.' + asClassNameArray(icon).join('.');
+    }
+    ThemeIcon.asCSSSelector = asCSSSelector;
+    function isThemeIcon(obj) {
+        return !!obj && typeof obj === 'object' && typeof obj.id === 'string' && (typeof obj.color === 'undefined' || ThemeColor.isThemeColor(obj.color));
+    }
+    ThemeIcon.isThemeIcon = isThemeIcon;
+    const _regexFromString = new RegExp(`^\\$\\((${ThemeIcon.iconNameExpression}(?:${ThemeIcon.iconModifierExpression})?)\\)$`);
+    function fromString(str) {
+        const match = _regexFromString.exec(str);
+        if (!match) {
+            return undefined;
+        }
+        const [, name] = match;
+        return { id: name };
+    }
+    ThemeIcon.fromString = fromString;
+    function fromId(id) {
+        return { id };
+    }
+    ThemeIcon.fromId = fromId;
+    function modify(icon, modifier) {
+        let id = icon.id;
+        const tildeIndex = id.lastIndexOf('~');
+        if (tildeIndex !== -1) {
+            id = id.substring(0, tildeIndex);
+        }
+        if (modifier) {
+            id = `${id}~${modifier}`;
+        }
+        return { id };
+    }
+    ThemeIcon.modify = modify;
+    function getModifier(icon) {
+        const tildeIndex = icon.id.lastIndexOf('~');
+        if (tildeIndex !== -1) {
+            return icon.id.substring(tildeIndex + 1);
+        }
+        return undefined;
+    }
+    ThemeIcon.getModifier = getModifier;
+    function isEqual(ti1, ti2) {
+        return ti1.id === ti2.id && ti1.color?.id === ti2.color?.id;
+    }
+    ThemeIcon.isEqual = isEqual;
+    /**
+     * Returns whether specified icon is defined and has 'file' ID.
+     */
+    function isFile(icon) {
+        return icon?.id === Codicon.file.id;
+    }
+    ThemeIcon.isFile = isFile;
+    /**
+     * Returns whether specified icon is defined and has 'folder' ID.
+     */
+    function isFolder(icon) {
+        return icon?.id === Codicon.folder.id;
+    }
+    ThemeIcon.isFolder = isFolder;
+})(ThemeIcon || (ThemeIcon = {}));
+
+export { ThemeColor, ThemeIcon };