@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/common/services/editorSimpleWorker.js

@@ -0,0 +1,591 @@
+import { stringDiff } from '../../../base/common/diff/diff.js';
+import { URI } from '../../../base/common/uri.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+import { MirrorTextModel } from '../model/mirrorTextModel.js';
+import { getWordAtText, ensureValidWordDefinition } from '../core/wordHelper.js';
+import { computeLinks } from '../languages/linkComputer.js';
+import { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';
+import { createMonacoBaseAPI } from './editorBaseApi.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
+import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
+import { DiffComputer } from '../diff/legacyLinesDiffComputer.js';
+import { linesDiffComputers } from '../diff/linesDiffComputers.js';
+import { createProxyObject, getAllMethodNames } from '../../../base/common/objects.js';
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
+class MirrorModel extends MirrorTextModel {
+    get uri() {
+        return this._uri;
+    }
+    get eol() {
+        return this._eol;
+    }
+    getValue() {
+        return this.getText();
+    }
+    findMatches(regex) {
+        const matches = [];
+        for (let i = 0; i < this._lines.length; i++) {
+            const line = this._lines[i];
+            const offsetToAdd = this.offsetAt(( new Position(i + 1, 1)));
+            const iteratorOverMatches = line.matchAll(regex);
+            for (const match of iteratorOverMatches) {
+                if (match.index || match.index === 0) {
+                    match.index = match.index + offsetToAdd;
+                }
+                matches.push(match);
+            }
+        }
+        return matches;
+    }
+    getLinesContent() {
+        return this._lines.slice(0);
+    }
+    getLineCount() {
+        return this._lines.length;
+    }
+    getLineContent(lineNumber) {
+        return this._lines[lineNumber - 1];
+    }
+    getWordAtPosition(position, wordDefinition) {
+        const wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);
+        if (wordAtText) {
+            return ( new Range(
+                position.lineNumber,
+                wordAtText.startColumn,
+                position.lineNumber,
+                wordAtText.endColumn
+            ));
+        }
+        return null;
+    }
+    getWordUntilPosition(position, wordDefinition) {
+        const wordAtPosition = this.getWordAtPosition(position, wordDefinition);
+        if (!wordAtPosition) {
+            return {
+                word: '',
+                startColumn: position.column,
+                endColumn: position.column
+            };
+        }
+        return {
+            word: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),
+            startColumn: wordAtPosition.startColumn,
+            endColumn: position.column
+        };
+    }
+    words(wordDefinition) {
+        const lines = this._lines;
+        const wordenize = this._wordenize.bind(this);
+        let lineNumber = 0;
+        let lineText = '';
+        let wordRangesIdx = 0;
+        let wordRanges = [];
+        return {
+            *[Symbol.iterator]() {
+                while (true) {
+                    if (wordRangesIdx < wordRanges.length) {
+                        const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);
+                        wordRangesIdx += 1;
+                        yield value;
+                    }
+                    else {
+                        if (lineNumber < lines.length) {
+                            lineText = lines[lineNumber];
+                            wordRanges = wordenize(lineText, wordDefinition);
+                            wordRangesIdx = 0;
+                            lineNumber += 1;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    getLineWords(lineNumber, wordDefinition) {
+        const content = this._lines[lineNumber - 1];
+        const ranges = this._wordenize(content, wordDefinition);
+        const words = [];
+        for (const range of ranges) {
+            words.push({
+                word: content.substring(range.start, range.end),
+                startColumn: range.start + 1,
+                endColumn: range.end + 1
+            });
+        }
+        return words;
+    }
+    _wordenize(content, wordDefinition) {
+        const result = [];
+        let match;
+        wordDefinition.lastIndex = 0;
+        while (match = wordDefinition.exec(content)) {
+            if (match[0].length === 0) {
+                break;
+            }
+            result.push({ start: match.index, end: match.index + match[0].length });
+        }
+        return result;
+    }
+    getValueInRange(range) {
+        range = this._validateRange(range);
+        if (range.startLineNumber === range.endLineNumber) {
+            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);
+        }
+        const lineEnding = this._eol;
+        const startLineIndex = range.startLineNumber - 1;
+        const endLineIndex = range.endLineNumber - 1;
+        const resultLines = [];
+        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));
+        for (let i = startLineIndex + 1; i < endLineIndex; i++) {
+            resultLines.push(this._lines[i]);
+        }
+        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));
+        return resultLines.join(lineEnding);
+    }
+    offsetAt(position) {
+        position = this._validatePosition(position);
+        this._ensureLineStarts();
+        return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);
+    }
+    positionAt(offset) {
+        offset = Math.floor(offset);
+        offset = Math.max(0, offset);
+        this._ensureLineStarts();
+        const out = this._lineStarts.getIndexOf(offset);
+        const lineLength = this._lines[out.index].length;
+        return {
+            lineNumber: 1 + out.index,
+            column: 1 + Math.min(out.remainder, lineLength)
+        };
+    }
+    _validateRange(range) {
+        const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });
+        const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });
+        if (start.lineNumber !== range.startLineNumber
+            || start.column !== range.startColumn
+            || end.lineNumber !== range.endLineNumber
+            || end.column !== range.endColumn) {
+            return {
+                startLineNumber: start.lineNumber,
+                startColumn: start.column,
+                endLineNumber: end.lineNumber,
+                endColumn: end.column
+            };
+        }
+        return range;
+    }
+    _validatePosition(position) {
+        if (!Position.isIPosition(position)) {
+            throw new Error('bad position');
+        }
+        let { lineNumber, column } = position;
+        let hasChanged = false;
+        if (lineNumber < 1) {
+            lineNumber = 1;
+            column = 1;
+            hasChanged = true;
+        }
+        else if (lineNumber > this._lines.length) {
+            lineNumber = this._lines.length;
+            column = this._lines[lineNumber - 1].length + 1;
+            hasChanged = true;
+        }
+        else {
+            const maxCharacter = this._lines[lineNumber - 1].length + 1;
+            if (column < 1) {
+                column = 1;
+                hasChanged = true;
+            }
+            else if (column > maxCharacter) {
+                column = maxCharacter;
+                hasChanged = true;
+            }
+        }
+        if (!hasChanged) {
+            return position;
+        }
+        else {
+            return { lineNumber, column };
+        }
+    }
+}
+class EditorSimpleWorker {
+    constructor(host, foreignModuleFactory) {
+        this._host = host;
+        this._models = Object.create(null);
+        this._foreignModuleFactory = foreignModuleFactory;
+        this._foreignModule = null;
+    }
+    dispose() {
+        this._models = Object.create(null);
+    }
+    _getModel(uri) {
+        return this._models[uri];
+    }
+    _getModels() {
+        const all = [];
+        ( Object.keys(this._models)).forEach((key) => all.push(this._models[key]));
+        return all;
+    }
+    acceptNewModel(data) {
+        this._models[data.url] = ( new MirrorModel(( URI.parse(data.url)), data.lines, data.EOL, data.versionId));
+    }
+    acceptModelChanged(strURL, e) {
+        if (!this._models[strURL]) {
+            return;
+        }
+        const model = this._models[strURL];
+        model.onEvents(e);
+    }
+    acceptRemovedModel(strURL) {
+        if (!this._models[strURL]) {
+            return;
+        }
+        delete this._models[strURL];
+    }
+    async computeUnicodeHighlights(url, options, range) {
+        const model = this._getModel(url);
+        if (!model) {
+            return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };
+        }
+        return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);
+    }
+    async computeDiff(originalUrl, modifiedUrl, options, algorithm) {
+        const original = this._getModel(originalUrl);
+        const modified = this._getModel(modifiedUrl);
+        if (!original || !modified) {
+            return null;
+        }
+        return EditorSimpleWorker.computeDiff(original, modified, options, algorithm);
+    }
+    static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {
+        const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();
+        const originalLines = originalTextModel.getLinesContent();
+        const modifiedLines = modifiedTextModel.getLinesContent();
+        const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, options);
+        const identical = (result.changes.length > 0 ? false : this._modelsAreIdentical(originalTextModel, modifiedTextModel));
+        function getLineChanges(changes) {
+            return ( changes.map(
+                m => ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, m.innerChanges?.map(m => [
+                        m.originalRange.startLineNumber,
+                        m.originalRange.startColumn,
+                        m.originalRange.endLineNumber,
+                        m.originalRange.endColumn,
+                        m.modifiedRange.startLineNumber,
+                        m.modifiedRange.startColumn,
+                        m.modifiedRange.endLineNumber,
+                        m.modifiedRange.endColumn,
+                    ])])
+            ));
+        }
+        return {
+            identical,
+            quitEarly: result.hitTimeout,
+            changes: getLineChanges(result.changes),
+            moves: ( result.moves.map(m => ([
+                m.lineRangeMapping.original.startLineNumber,
+                m.lineRangeMapping.original.endLineNumberExclusive,
+                m.lineRangeMapping.modified.startLineNumber,
+                m.lineRangeMapping.modified.endLineNumberExclusive,
+                getLineChanges(m.changes)
+            ]))),
+        };
+    }
+    static _modelsAreIdentical(original, modified) {
+        const originalLineCount = original.getLineCount();
+        const modifiedLineCount = modified.getLineCount();
+        if (originalLineCount !== modifiedLineCount) {
+            return false;
+        }
+        for (let line = 1; line <= originalLineCount; line++) {
+            const originalLine = original.getLineContent(line);
+            const modifiedLine = modified.getLineContent(line);
+            if (originalLine !== modifiedLine) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async computeDirtyDiff(originalUrl, modifiedUrl, ignoreTrimWhitespace) {
+        const original = this._getModel(originalUrl);
+        const modified = this._getModel(modifiedUrl);
+        if (!original || !modified) {
+            return null;
+        }
+        const originalLines = original.getLinesContent();
+        const modifiedLines = modified.getLinesContent();
+        const diffComputer = ( new DiffComputer(originalLines, modifiedLines, {
+            shouldComputeCharChanges: false,
+            shouldPostProcessCharChanges: false,
+            shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
+            shouldMakePrettyDiff: true,
+            maxComputationTime: 1000
+        }));
+        return diffComputer.computeDiff().changes;
+    }
+    static { this._diffLimit = 100000; }
+    async computeMoreMinimalEdits(modelUrl, edits, pretty) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return edits;
+        }
+        const result = [];
+        let lastEol = undefined;
+        edits = edits.slice(0).sort((a, b) => {
+            if (a.range && b.range) {
+                return Range.compareRangesUsingStarts(a.range, b.range);
+            }
+            const aRng = a.range ? 0 : 1;
+            const bRng = b.range ? 0 : 1;
+            return aRng - bRng;
+        });
+        let writeIndex = 0;
+        for (let readIndex = 1; readIndex < edits.length; readIndex++) {
+            if (Range.getEndPosition(edits[writeIndex].range).equals(Range.getStartPosition(edits[readIndex].range))) {
+                edits[writeIndex].range = Range.fromPositions(Range.getStartPosition(edits[writeIndex].range), Range.getEndPosition(edits[readIndex].range));
+                edits[writeIndex].text += edits[readIndex].text;
+            }
+            else {
+                writeIndex++;
+                edits[writeIndex] = edits[readIndex];
+            }
+        }
+        edits.length = writeIndex + 1;
+        for (let { range, text, eol } of edits) {
+            if (typeof eol === 'number') {
+                lastEol = eol;
+            }
+            if (Range.isEmpty(range) && !text) {
+                continue;
+            }
+            const original = model.getValueInRange(range);
+            text = text.replace(/\r\n|\n|\r/g, model.eol);
+            if (original === text) {
+                continue;
+            }
+            if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {
+                result.push({ range, text });
+                continue;
+            }
+            const changes = stringDiff(original, text, pretty);
+            const editOffset = model.offsetAt(Range.lift(range).getStartPosition());
+            for (const change of changes) {
+                const start = model.positionAt(editOffset + change.originalStart);
+                const end = model.positionAt(editOffset + change.originalStart + change.originalLength);
+                const newEdit = {
+                    text: text.substr(change.modifiedStart, change.modifiedLength),
+                    range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }
+                };
+                if (model.getValueInRange(newEdit.range) !== newEdit.text) {
+                    result.push(newEdit);
+                }
+            }
+        }
+        if (typeof lastEol === 'number') {
+            result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });
+        }
+        return result;
+    }
+    computeHumanReadableDiff(modelUrl, edits, options) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return edits;
+        }
+        const result = [];
+        let lastEol = undefined;
+        edits = edits.slice(0).sort((a, b) => {
+            if (a.range && b.range) {
+                return Range.compareRangesUsingStarts(a.range, b.range);
+            }
+            const aRng = a.range ? 0 : 1;
+            const bRng = b.range ? 0 : 1;
+            return aRng - bRng;
+        });
+        for (let { range, text, eol } of edits) {
+            if (typeof eol === 'number') {
+                lastEol = eol;
+            }
+            if (Range.isEmpty(range) && !text) {
+                continue;
+            }
+            const original = model.getValueInRange(range);
+            text = text.replace(/\r\n|\n|\r/g, model.eol);
+            if (original === text) {
+                continue;
+            }
+            if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {
+                result.push({ range, text });
+                continue;
+            }
+            const originalLines = original.split(/\r\n|\n|\r/);
+            const modifiedLines = text.split(/\r\n|\n|\r/);
+            const diff = linesDiffComputers.getDefault().computeDiff(originalLines, modifiedLines, options);
+            const start = Range.lift(range).getStartPosition();
+            function addPositions(pos1, pos2) {
+                return ( new Position(
+                    pos1.lineNumber + pos2.lineNumber - 1,
+                    pos2.lineNumber === 1 ? pos1.column + pos2.column - 1 : pos2.column
+                ));
+            }
+            function getText(lines, range) {
+                const result = [];
+                for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {
+                    const line = lines[i - 1];
+                    if (i === range.startLineNumber && i === range.endLineNumber) {
+                        result.push(line.substring(range.startColumn - 1, range.endColumn - 1));
+                    }
+                    else if (i === range.startLineNumber) {
+                        result.push(line.substring(range.startColumn - 1));
+                    }
+                    else if (i === range.endLineNumber) {
+                        result.push(line.substring(0, range.endColumn - 1));
+                    }
+                    else {
+                        result.push(line);
+                    }
+                }
+                return result;
+            }
+            for (const c of diff.changes) {
+                if (c.innerChanges) {
+                    for (const x of c.innerChanges) {
+                        result.push({
+                            range: Range.fromPositions(addPositions(start, x.originalRange.getStartPosition()), addPositions(start, x.originalRange.getEndPosition())),
+                            text: getText(modifiedLines, x.modifiedRange).join(model.eol)
+                        });
+                    }
+                }
+                else {
+                    throw new BugIndicatingError('The experimental diff algorithm always produces inner changes');
+                }
+            }
+        }
+        if (typeof lastEol === 'number') {
+            result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });
+        }
+        return result;
+    }
+    async computeLinks(modelUrl) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        return computeLinks(model);
+    }
+    async computeDefaultDocumentColors(modelUrl) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        return computeDefaultDocumentColors(model);
+    }
+    static { this._suggestionsLimit = 10000; }
+    async textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
+        const sw = ( new StopWatch());
+        const wordDefRegExp = ( new RegExp(wordDef, wordDefFlags));
+        const seen = ( new Set());
+        outer: for (const url of modelUrls) {
+            const model = this._getModel(url);
+            if (!model) {
+                continue;
+            }
+            for (const word of model.words(wordDefRegExp)) {
+                if (word === leadingWord || !isNaN(Number(word))) {
+                    continue;
+                }
+                seen.add(word);
+                if (seen.size > EditorSimpleWorker._suggestionsLimit) {
+                    break outer;
+                }
+            }
+        }
+        return { words: Array.from(seen), duration: sw.elapsed() };
+    }
+    async computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return Object.create(null);
+        }
+        const wordDefRegExp = ( new RegExp(wordDef, wordDefFlags));
+        const result = Object.create(null);
+        for (let line = range.startLineNumber; line < range.endLineNumber; line++) {
+            const words = model.getLineWords(line, wordDefRegExp);
+            for (const word of words) {
+                if (!isNaN(Number(word.word))) {
+                    continue;
+                }
+                let array = result[word.word];
+                if (!array) {
+                    array = [];
+                    result[word.word] = array;
+                }
+                array.push({
+                    startLineNumber: line,
+                    startColumn: word.startColumn,
+                    endLineNumber: line,
+                    endColumn: word.endColumn
+                });
+            }
+        }
+        return result;
+    }
+    async navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        const wordDefRegExp = ( new RegExp(wordDef, wordDefFlags));
+        if (range.startColumn === range.endColumn) {
+            range = {
+                startLineNumber: range.startLineNumber,
+                startColumn: range.startColumn,
+                endLineNumber: range.endLineNumber,
+                endColumn: range.endColumn + 1
+            };
+        }
+        const selectionText = model.getValueInRange(range);
+        const wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);
+        if (!wordRange) {
+            return null;
+        }
+        const word = model.getValueInRange(wordRange);
+        const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
+        return result;
+    }
+    loadForeignModule(moduleId, createData, foreignHostMethods) {
+        const proxyMethodRequest = (method, args) => {
+            return this._host.fhr(method, args);
+        };
+        const foreignHost = createProxyObject(foreignHostMethods, proxyMethodRequest);
+        const ctx = {
+            host: foreignHost,
+            getMirrorModels: () => {
+                return this._getModels();
+            }
+        };
+        if (this._foreignModuleFactory) {
+            this._foreignModule = this._foreignModuleFactory(ctx, createData);
+            return Promise.resolve(getAllMethodNames(this._foreignModule));
+        }
+        return Promise.reject(( new Error(`Unexpected usage`)));
+    }
+    fmr(method, args) {
+        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
+            return Promise.reject(( new Error('Missing requestHandler or method: ' + method)));
+        }
+        try {
+            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+}
+if (typeof importScripts === 'function') {
+    globalThis.monaco = createMonacoBaseAPI();
+}
+export { EditorSimpleWorker };

package/vscode/src/vs/editor/common/services/editorWorker.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+const IEditorWorkerService = ( createDecorator('editorWorkerService'));
+export { IEditorWorkerService };

package/vscode/src/vs/editor/common/services/getIconClasses.js

@@ -0,0 +1,81 @@
+import { Schemas } from '../../../base/common/network.js';
+import { DataUri } from '../../../base/common/resources.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { FileKind } from '../../../platform/files/common/files.js';
+const fileIconDirectoryRegex = /(?:\/|^)(?:([^\/]+)\/)?([^\/]+)$/;
+function getIconClasses(modelService, languageService, resource, fileKind) {
+    const classes = fileKind === FileKind.ROOT_FOLDER ? ['rootfolder-icon'] : fileKind === FileKind.FOLDER ? ['folder-icon'] : ['file-icon'];
+    if (resource) {
+        let name;
+        if (resource.scheme === Schemas.data) {
+            const metadata = DataUri.parseMetaData(resource);
+            name = metadata.get(DataUri.META_DATA_LABEL);
+        }
+        else {
+            const match = resource.path.match(fileIconDirectoryRegex);
+            if (match) {
+                name = cssEscape(match[2].toLowerCase());
+                if (match[1]) {
+                    classes.push(`${cssEscape(match[1].toLowerCase())}-name-dir-icon`);
+                }
+            }
+            else {
+                name = cssEscape(resource.authority.toLowerCase());
+            }
+        }
+        if (fileKind === FileKind.ROOT_FOLDER) {
+            classes.push(`${name}-root-name-folder-icon`);
+        }
+        else if (fileKind === FileKind.FOLDER) {
+            classes.push(`${name}-name-folder-icon`);
+        }
+        else {
+            if (name) {
+                classes.push(`${name}-name-file-icon`);
+                classes.push(`name-file-icon`);
+                if (name.length <= 255) {
+                    const dotSegments = name.split('.');
+                    for (let i = 1; i < dotSegments.length; i++) {
+                        classes.push(`${dotSegments.slice(i).join('.')}-ext-file-icon`);
+                    }
+                }
+                classes.push(`ext-file-icon`);
+            }
+            const detectedLanguageId = detectLanguageId(modelService, languageService, resource);
+            if (detectedLanguageId) {
+                classes.push(`${cssEscape(detectedLanguageId)}-lang-file-icon`);
+            }
+        }
+    }
+    return classes;
+}
+function getIconClassesForLanguageId(languageId) {
+    return ['file-icon', `${cssEscape(languageId)}-lang-file-icon`];
+}
+function detectLanguageId(modelService, languageService, resource) {
+    if (!resource) {
+        return null;
+    }
+    let languageId = null;
+    if (resource.scheme === Schemas.data) {
+        const metadata = DataUri.parseMetaData(resource);
+        const mime = metadata.get(DataUri.META_DATA_MIME);
+        if (mime) {
+            languageId = languageService.getLanguageIdByMimeType(mime);
+        }
+    }
+    else {
+        const model = modelService.getModel(resource);
+        if (model) {
+            languageId = model.getLanguageId();
+        }
+    }
+    if (languageId && languageId !== PLAINTEXT_LANGUAGE_ID) {
+        return languageId;
+    }
+    return languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+}
+function cssEscape(str) {
+    return str.replace(/[\11\12\14\15\40]/g, '/');
+}
+export { getIconClasses, getIconClassesForLanguageId };