monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/findSectionHeaders.js

@@ -0,0 +1,128 @@
+import { isMultilineRegexSource } from '../model/textModelSearch.js';
+import { regExpLeadsToEndlessLoop } from '../../../base/common/strings.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const trimDashesRegex = /^-+|-+$/g;
+const CHUNK_SIZE = 100;
+const MAX_SECTION_LINES = 5;
+/**
+ * Find section headers in the model.
+ *
+ * @param model the text model to search in
+ * @param options options to search with
+ * @returns an array of section headers
+ */
+function findSectionHeaders(model, options) {
+    let headers = [];
+    if (options.findRegionSectionHeaders && options.foldingRules?.markers) {
+        const regionHeaders = collectRegionHeaders(model, options);
+        headers = headers.concat(regionHeaders);
+    }
+    if (options.findMarkSectionHeaders) {
+        const markHeaders = collectMarkHeaders(model, options);
+        headers = headers.concat(markHeaders);
+    }
+    return headers;
+}
+function collectRegionHeaders(model, options) {
+    const regionHeaders = [];
+    const endLineNumber = model.getLineCount();
+    for (let lineNumber = 1; lineNumber <= endLineNumber; lineNumber++) {
+        const lineContent = model.getLineContent(lineNumber);
+        const match = lineContent.match(options.foldingRules.markers.start);
+        if (match) {
+            const range = { startLineNumber: lineNumber, startColumn: match[0].length + 1, endLineNumber: lineNumber, endColumn: lineContent.length + 1 };
+            if (range.endColumn > range.startColumn) {
+                const sectionHeader = {
+                    range,
+                    ...getHeaderText(lineContent.substring(match[0].length)),
+                    shouldBeInComments: false
+                };
+                if (sectionHeader.text || sectionHeader.hasSeparatorLine) {
+                    regionHeaders.push(sectionHeader);
+                }
+            }
+        }
+    }
+    return regionHeaders;
+}
+function collectMarkHeaders(model, options) {
+    const markHeaders = [];
+    const endLineNumber = model.getLineCount();
+    // Validate regex to prevent infinite loops
+    if (!options.markSectionHeaderRegex || options.markSectionHeaderRegex.trim() === '') {
+        return markHeaders;
+    }
+    // Create regex with flags for:
+    // - 'd' for indices to get proper match positions
+    // - 'm' for multi-line mode so ^ and $ match line starts/ends
+    // - 's' for dot-all mode so . matches newlines
+    const multiline = isMultilineRegexSource(options.markSectionHeaderRegex);
+    const regex = new RegExp(options.markSectionHeaderRegex, `gdm${multiline ? 's' : ''}`);
+    // Check if the regex would lead to an endless loop
+    if (regExpLeadsToEndlessLoop(regex)) {
+        return markHeaders;
+    }
+    // Process text in overlapping chunks for better performance
+    for (let startLine = 1; startLine <= endLineNumber; startLine += CHUNK_SIZE - MAX_SECTION_LINES) {
+        const endLine = Math.min(startLine + CHUNK_SIZE - 1, endLineNumber);
+        const lines = [];
+        // Collect lines for the current chunk
+        for (let i = startLine; i <= endLine; i++) {
+            lines.push(model.getLineContent(i));
+        }
+        const text = lines.join('\n');
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            // Calculate which line this match starts on by counting newlines before it
+            const precedingText = text.substring(0, match.index);
+            const lineOffset = (precedingText.match(/\n/g) || []).length;
+            const lineNumber = startLine + lineOffset;
+            // Calculate match height to check overlap properly
+            const matchLines = match[0].split('\n');
+            const matchHeight = matchLines.length;
+            const matchEndLine = lineNumber + matchHeight - 1;
+            // Calculate start column - need to find the start of the line containing the match
+            const lineStartIndex = precedingText.lastIndexOf('\n') + 1;
+            const startColumn = match.index - lineStartIndex + 1;
+            // Calculate end column - need to handle multi-line matches
+            const lastMatchLine = matchLines[matchLines.length - 1];
+            const endColumn = matchHeight === 1 ? startColumn + match[0].length : lastMatchLine.length + 1;
+            const range = {
+                startLineNumber: lineNumber,
+                startColumn,
+                endLineNumber: matchEndLine,
+                endColumn
+            };
+            const text2 = (match.groups ?? {})['label'] ?? '';
+            const hasSeparatorLine = ((match.groups ?? {})['separator'] ?? '') !== '';
+            const sectionHeader = {
+                range,
+                text: text2,
+                hasSeparatorLine,
+                shouldBeInComments: true
+            };
+            if (sectionHeader.text || sectionHeader.hasSeparatorLine) {
+                // only push if the previous one doesn't have this same linbe
+                if (markHeaders.length === 0 || markHeaders[markHeaders.length - 1].range.endLineNumber < sectionHeader.range.startLineNumber) {
+                    markHeaders.push(sectionHeader);
+                }
+            }
+            // Move lastIndex past the current match to avoid infinite loop
+            regex.lastIndex = match.index + match[0].length;
+        }
+    }
+    return markHeaders;
+}
+function getHeaderText(text) {
+    text = text.trim();
+    const hasSeparatorLine = text.startsWith('-');
+    text = text.replace(trimDashesRegex, '');
+    return { text, hasSeparatorLine };
+}
+
+export { collectMarkHeaders, findSectionHeaders };

package/dist/workers/editor/common/fixBrackets.js

@@ -0,0 +1,67 @@
+import { LanguageAgnosticBracketTokens } from './bracketPairsTree/brackets.js';
+import { lengthAdd, lengthGetColumnCountIfZeroLineCount, lengthZero } from './bracketPairsTree/length.js';
+import { parseDocument } from './bracketPairsTree/parser.js';
+import { DenseKeyProvider } from './bracketPairsTree/smallImmutableSet.js';
+import { TextBufferTokenizer } from './bracketPairsTree/tokenizer.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function fixBracketsInLine(tokens, languageConfigurationService) {
+    const denseKeyProvider = new DenseKeyProvider();
+    const bracketTokens = new LanguageAgnosticBracketTokens(denseKeyProvider, (languageId) => languageConfigurationService.getLanguageConfiguration(languageId));
+    const tokenizer = new TextBufferTokenizer(new StaticTokenizerSource([tokens]), bracketTokens);
+    const node = parseDocument(tokenizer, [], undefined, true);
+    let str = '';
+    const line = tokens.getLineContent();
+    function processNode(node, offset) {
+        if (node.kind === 2 /* AstNodeKind.Pair */) {
+            processNode(node.openingBracket, offset);
+            offset = lengthAdd(offset, node.openingBracket.length);
+            if (node.child) {
+                processNode(node.child, offset);
+                offset = lengthAdd(offset, node.child.length);
+            }
+            if (node.closingBracket) {
+                processNode(node.closingBracket, offset);
+                offset = lengthAdd(offset, node.closingBracket.length);
+            }
+            else {
+                const singleLangBracketTokens = bracketTokens.getSingleLanguageBracketTokens(node.openingBracket.languageId);
+                const closingTokenText = singleLangBracketTokens.findClosingTokenText(node.openingBracket.bracketIds);
+                str += closingTokenText;
+            }
+        }
+        else if (node.kind === 3 /* AstNodeKind.UnexpectedClosingBracket */) ;
+        else if (node.kind === 0 /* AstNodeKind.Text */ || node.kind === 1 /* AstNodeKind.Bracket */) {
+            str += line.substring(lengthGetColumnCountIfZeroLineCount(offset), lengthGetColumnCountIfZeroLineCount(lengthAdd(offset, node.length)));
+        }
+        else if (node.kind === 4 /* AstNodeKind.List */) {
+            for (const child of node.children) {
+                processNode(child, offset);
+                offset = lengthAdd(offset, child.length);
+            }
+        }
+    }
+    processNode(node, lengthZero);
+    return str;
+}
+class StaticTokenizerSource {
+    constructor(lines) {
+        this.lines = lines;
+        this.tokenization = {
+            getLineTokens: (lineNumber) => {
+                return this.lines[lineNumber - 1];
+            }
+        };
+    }
+    getLineCount() {
+        return this.lines.length;
+    }
+    getLineLength(lineNumber) {
+        return this.lines[lineNumber - 1].getLineContent().length;
+    }
+}
+
+export { fixBracketsInLine };

package/dist/workers/editor/common/fixedArray.js

@@ -0,0 +1,70 @@
+import { arrayInsert } from '../../../base/common/arrays.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * An array that avoids being sparse by always
+ * filling up unused indices with a default value.
+ */
+class FixedArray {
+    constructor(_default) {
+        this._default = _default;
+        this._store = [];
+    }
+    get(index) {
+        if (index < this._store.length) {
+            return this._store[index];
+        }
+        return this._default;
+    }
+    set(index, value) {
+        while (index >= this._store.length) {
+            this._store[this._store.length] = this._default;
+        }
+        this._store[index] = value;
+    }
+    replace(index, oldLength, newLength) {
+        if (index >= this._store.length) {
+            return;
+        }
+        if (oldLength === 0) {
+            this.insert(index, newLength);
+            return;
+        }
+        else if (newLength === 0) {
+            this.delete(index, oldLength);
+            return;
+        }
+        const before = this._store.slice(0, index);
+        const after = this._store.slice(index + oldLength);
+        const insertArr = arrayFill(newLength, this._default);
+        this._store = before.concat(insertArr, after);
+    }
+    delete(deleteIndex, deleteCount) {
+        if (deleteCount === 0 || deleteIndex >= this._store.length) {
+            return;
+        }
+        this._store.splice(deleteIndex, deleteCount);
+    }
+    insert(insertIndex, insertCount) {
+        if (insertCount === 0 || insertIndex >= this._store.length) {
+            return;
+        }
+        const arr = [];
+        for (let i = 0; i < insertCount; i++) {
+            arr[i] = this._default;
+        }
+        this._store = arrayInsert(this._store, insertIndex, arr);
+    }
+}
+function arrayFill(length, value) {
+    const arr = [];
+    for (let i = 0; i < length; i++) {
+        arr[i] = value;
+    }
+    return arr;
+}
+
+export { FixedArray };

package/dist/workers/editor/common/fontInfo.js

@@ -0,0 +1,172 @@
+import { isMacintosh, isWindows } from '../../../base/common/platform.js';
+import { EditorZoom } from './editorZoom.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Determined from empirical observations.
+ * @internal
+ */
+const GOLDEN_LINE_HEIGHT_RATIO = isMacintosh ? 1.5 : 1.35;
+/**
+ * @internal
+ */
+const MINIMUM_LINE_HEIGHT = 8;
+class BareFontInfo {
+    /**
+     * @internal
+     */
+    static _create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom) {
+        if (lineHeight === 0) {
+            lineHeight = GOLDEN_LINE_HEIGHT_RATIO * fontSize;
+        }
+        else if (lineHeight < MINIMUM_LINE_HEIGHT) {
+            // Values too small to be line heights in pixels are in ems.
+            lineHeight = lineHeight * fontSize;
+        }
+        // Enforce integer, minimum constraints
+        lineHeight = Math.round(lineHeight);
+        if (lineHeight < MINIMUM_LINE_HEIGHT) {
+            lineHeight = MINIMUM_LINE_HEIGHT;
+        }
+        const editorZoomLevelMultiplier = 1 + (ignoreEditorZoom ? 0 : EditorZoom.getZoomLevel() * 0.1);
+        fontSize *= editorZoomLevelMultiplier;
+        lineHeight *= editorZoomLevelMultiplier;
+        if (fontVariationSettings === FONT_VARIATION_TRANSLATE) {
+            if (fontWeight === 'normal' || fontWeight === 'bold') {
+                fontVariationSettings = FONT_VARIATION_OFF;
+            }
+            else {
+                const fontWeightAsNumber = parseInt(fontWeight, 10);
+                fontVariationSettings = `'wght' ${fontWeightAsNumber}`;
+                fontWeight = 'normal';
+            }
+        }
+        return new BareFontInfo({
+            pixelRatio: pixelRatio,
+            fontFamily: fontFamily,
+            fontWeight: fontWeight,
+            fontSize: fontSize,
+            fontFeatureSettings: fontFeatureSettings,
+            fontVariationSettings,
+            lineHeight: lineHeight,
+            letterSpacing: letterSpacing
+        });
+    }
+    /**
+     * @internal
+     */
+    constructor(opts) {
+        this._bareFontInfoBrand = undefined;
+        this.pixelRatio = opts.pixelRatio;
+        this.fontFamily = String(opts.fontFamily);
+        this.fontWeight = String(opts.fontWeight);
+        this.fontSize = opts.fontSize;
+        this.fontFeatureSettings = opts.fontFeatureSettings;
+        this.fontVariationSettings = opts.fontVariationSettings;
+        this.lineHeight = opts.lineHeight | 0;
+        this.letterSpacing = opts.letterSpacing;
+    }
+    /**
+     * @internal
+     */
+    getId() {
+        return `${this.pixelRatio}-${this.fontFamily}-${this.fontWeight}-${this.fontSize}-${this.fontFeatureSettings}-${this.fontVariationSettings}-${this.lineHeight}-${this.letterSpacing}`;
+    }
+    /**
+     * @internal
+     */
+    getMassagedFontFamily() {
+        const fallbackFontFamily = EDITOR_FONT_DEFAULTS.fontFamily;
+        const fontFamily = BareFontInfo._wrapInQuotes(this.fontFamily);
+        if (this.fontFamily !== fallbackFontFamily) {
+            return `${fontFamily}, ${fallbackFontFamily}`;
+        }
+        return fontFamily;
+    }
+    static _wrapInQuotes(fontFamily) {
+        if (/[,"']/.test(fontFamily)) {
+            // Looks like the font family might be already escaped
+            return fontFamily;
+        }
+        if (/[+ ]/.test(fontFamily)) {
+            // Wrap a font family using + or <space> with quotes
+            return `"${fontFamily}"`;
+        }
+        return fontFamily;
+    }
+}
+// change this whenever `FontInfo` members are changed
+const SERIALIZED_FONT_INFO_VERSION = 2;
+class FontInfo extends BareFontInfo {
+    /**
+     * @internal
+     */
+    constructor(opts, isTrusted) {
+        super(opts);
+        this._editorStylingBrand = undefined;
+        this.version = SERIALIZED_FONT_INFO_VERSION;
+        this.isTrusted = isTrusted;
+        this.isMonospace = opts.isMonospace;
+        this.typicalHalfwidthCharacterWidth = opts.typicalHalfwidthCharacterWidth;
+        this.typicalFullwidthCharacterWidth = opts.typicalFullwidthCharacterWidth;
+        this.canUseHalfwidthRightwardsArrow = opts.canUseHalfwidthRightwardsArrow;
+        this.spaceWidth = opts.spaceWidth;
+        this.middotWidth = opts.middotWidth;
+        this.wsmiddotWidth = opts.wsmiddotWidth;
+        this.maxDigitWidth = opts.maxDigitWidth;
+    }
+    /**
+     * @internal
+     */
+    equals(other) {
+        return (this.fontFamily === other.fontFamily
+            && this.fontWeight === other.fontWeight
+            && this.fontSize === other.fontSize
+            && this.fontFeatureSettings === other.fontFeatureSettings
+            && this.fontVariationSettings === other.fontVariationSettings
+            && this.lineHeight === other.lineHeight
+            && this.letterSpacing === other.letterSpacing
+            && this.typicalHalfwidthCharacterWidth === other.typicalHalfwidthCharacterWidth
+            && this.typicalFullwidthCharacterWidth === other.typicalFullwidthCharacterWidth
+            && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow
+            && this.spaceWidth === other.spaceWidth
+            && this.middotWidth === other.middotWidth
+            && this.wsmiddotWidth === other.wsmiddotWidth
+            && this.maxDigitWidth === other.maxDigitWidth);
+    }
+}
+/**
+ * @internal
+ */
+const FONT_VARIATION_OFF = 'normal';
+/**
+ * @internal
+ */
+const FONT_VARIATION_TRANSLATE = 'translate';
+/**
+ * @internal
+ */
+const DEFAULT_WINDOWS_FONT_FAMILY = 'Consolas, \'Courier New\', monospace';
+/**
+ * @internal
+ */
+const DEFAULT_MAC_FONT_FAMILY = 'Menlo, Monaco, \'Courier New\', monospace';
+/**
+ * @internal
+ */
+const DEFAULT_LINUX_FONT_FAMILY = '\'Droid Sans Mono\', \'monospace\', monospace';
+/**
+ * @internal
+ */
+const EDITOR_FONT_DEFAULTS = {
+    fontFamily: (isMacintosh ? DEFAULT_MAC_FONT_FAMILY : (isWindows ? DEFAULT_WINDOWS_FONT_FAMILY : DEFAULT_LINUX_FONT_FAMILY)),
+    fontWeight: 'normal',
+    fontSize: (isMacintosh ? 12 : 14),
+    lineHeight: 0,
+    letterSpacing: 0,
+};
+
+export { BareFontInfo, DEFAULT_LINUX_FONT_FAMILY, DEFAULT_MAC_FONT_FAMILY, DEFAULT_WINDOWS_FONT_FAMILY, EDITOR_FONT_DEFAULTS, FONT_VARIATION_OFF, FONT_VARIATION_TRANSLATE, FontInfo, GOLDEN_LINE_HEIGHT_RATIO, MINIMUM_LINE_HEIGHT, SERIALIZED_FONT_INFO_VERSION };

package/dist/workers/editor/common/fontInfoFromSettings.js

@@ -0,0 +1,29 @@
+import { EditorOptions } from './editorOptions.js';
+import { BareFontInfo } from './fontInfo.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function createBareFontInfoFromValidatedSettings(options, pixelRatio, ignoreEditorZoom) {
+    const fontFamily = options.get(58 /* EditorOption.fontFamily */);
+    const fontWeight = options.get(62 /* EditorOption.fontWeight */);
+    const fontSize = options.get(61 /* EditorOption.fontSize */);
+    const fontFeatureSettings = options.get(60 /* EditorOption.fontLigatures */);
+    const fontVariationSettings = options.get(63 /* EditorOption.fontVariations */);
+    const lineHeight = options.get(75 /* EditorOption.lineHeight */);
+    const letterSpacing = options.get(72 /* EditorOption.letterSpacing */);
+    return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
+}
+function createBareFontInfoFromRawSettings(opts, pixelRatio, ignoreEditorZoom = false) {
+    const fontFamily = EditorOptions.fontFamily.validate(opts.fontFamily);
+    const fontWeight = EditorOptions.fontWeight.validate(opts.fontWeight);
+    const fontSize = EditorOptions.fontSize.validate(opts.fontSize);
+    const fontFeatureSettings = EditorOptions.fontLigatures2.validate(opts.fontLigatures);
+    const fontVariationSettings = EditorOptions.fontVariations.validate(opts.fontVariations);
+    const lineHeight = EditorOptions.lineHeight.validate(opts.lineHeight);
+    const letterSpacing = EditorOptions.letterSpacing.validate(opts.letterSpacing);
+    return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
+}
+
+export { createBareFontInfoFromRawSettings, createBareFontInfoFromValidatedSettings };

package/dist/workers/editor/common/getIconClasses.js

@@ -0,0 +1,106 @@
+import { Schemas } from '../../../base/common/network.js';
+import { DataUri } from '../../../base/common/resources.js';
+import { URI } from '../../../base/common/uri.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { FileKind } from '../../../platform/files/common/files.js';
+import { ThemeIcon } from '../../../base/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 fileIconDirectoryRegex = /(?:\/|^)(?:([^\/]+)\/)?([^\/]+)$/;
+function getIconClasses(modelService, languageService, resource, fileKind, icon) {
+    if (ThemeIcon.isThemeIcon(icon)) {
+        return [`codicon-${icon.id}`, 'predefined-file-icon'];
+    }
+    if (URI.isUri(icon)) {
+        return [];
+    }
+    // we always set these base classes even if we do not have a path
+    const classes = fileKind === FileKind.ROOT_FOLDER ? ['rootfolder-icon'] : fileKind === FileKind.FOLDER ? ['folder-icon'] : ['file-icon'];
+    if (resource) {
+        // Get the path and name of the resource. For data-URIs, we need to parse specially
+        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 = fileIconSelectorEscape(match[2].toLowerCase());
+                if (match[1]) {
+                    classes.push(`${fileIconSelectorEscape(match[1].toLowerCase())}-name-dir-icon`); // parent directory
+                }
+            }
+            else {
+                name = fileIconSelectorEscape(resource.authority.toLowerCase());
+            }
+        }
+        // Root Folders
+        if (fileKind === FileKind.ROOT_FOLDER) {
+            classes.push(`${name}-root-name-folder-icon`);
+        }
+        // Folders
+        else if (fileKind === FileKind.FOLDER) {
+            classes.push(`${name}-name-folder-icon`);
+        }
+        // Files
+        else {
+            // Name & Extension(s)
+            if (name) {
+                classes.push(`${name}-name-file-icon`);
+                classes.push(`name-file-icon`); // extra segment to increase file-name score
+                // Avoid doing an explosive combination of extensions for very long filenames
+                // (most file systems do not allow files > 255 length) with lots of `.` characters
+                // https://github.com/microsoft/vscode/issues/116199
+                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`); // add each combination of all found extensions if more than one
+                    }
+                }
+                classes.push(`ext-file-icon`); // extra segment to increase file-ext score
+            }
+            // Detected Mode
+            const detectedLanguageId = detectLanguageId(modelService, languageService, resource);
+            if (detectedLanguageId) {
+                classes.push(`${fileIconSelectorEscape(detectedLanguageId)}-lang-file-icon`);
+            }
+        }
+    }
+    return classes;
+}
+function detectLanguageId(modelService, languageService, resource) {
+    if (!resource) {
+        return null; // we need a resource at least
+    }
+    let languageId = null;
+    // Data URI: check for encoded metadata
+    if (resource.scheme === Schemas.data) {
+        const metadata = DataUri.parseMetaData(resource);
+        const mime = metadata.get(DataUri.META_DATA_MIME);
+        if (mime) {
+            languageId = languageService.getLanguageIdByMimeType(mime);
+        }
+    }
+    // Any other URI: check for model if existing
+    else {
+        const model = modelService.getModel(resource);
+        if (model) {
+            languageId = model.getLanguageId();
+        }
+    }
+    // only take if the language id is specific (aka no just plain text)
+    if (languageId && languageId !== PLAINTEXT_LANGUAGE_ID) {
+        return languageId;
+    }
+    // otherwise fallback to path based detection
+    return languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+}
+function fileIconSelectorEscape(str) {
+    return str.replace(/[\s]/g, '/'); // HTML class names can not contain certain whitespace characters (https://dom.spec.whatwg.org/#interface-domtokenlist), use / instead, which doesn't exist in file names.
+}
+
+export { fileIconSelectorEscape, getIconClasses };

package/dist/workers/editor/common/getPositionOffsetTransformerFromTextModel.js

@@ -0,0 +1,24 @@
+import './positionToOffset.js';
+import { PositionOffsetTransformerBase } from './positionToOffsetImpl.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function getPositionOffsetTransformerFromTextModel(textModel) {
+    return new PositionOffsetTransformerWithTextModel(textModel);
+}
+class PositionOffsetTransformerWithTextModel extends PositionOffsetTransformerBase {
+    constructor(_textModel) {
+        super();
+        this._textModel = _textModel;
+    }
+    getOffset(position) {
+        return this._textModel.getOffsetAt(position);
+    }
+    getPosition(offset) {
+        return this._textModel.getPositionAt(offset);
+    }
+}
+
+export { getPositionOffsetTransformerFromTextModel };

package/dist/workers/editor/common/glyphLanesModel.js

@@ -0,0 +1,61 @@
+import { GlyphMarginLane } from '../model.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const MAX_LANE = GlyphMarginLane.Right;
+class GlyphMarginLanesModel {
+    constructor(maxLine) {
+        this.persist = 0;
+        this._requiredLanes = 1; // always render at least one lane
+        this.lanes = new Uint8Array(Math.ceil(((maxLine + 1) * MAX_LANE) / 8));
+    }
+    reset(maxLine) {
+        const bytes = Math.ceil(((maxLine + 1) * MAX_LANE) / 8);
+        if (this.lanes.length < bytes) {
+            this.lanes = new Uint8Array(bytes);
+        }
+        else {
+            this.lanes.fill(0);
+        }
+        this._requiredLanes = 1;
+    }
+    get requiredLanes() {
+        return this._requiredLanes;
+    }
+    push(lane, range, persist) {
+        if (persist) {
+            this.persist |= (1 << (lane - 1));
+        }
+        for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {
+            const bit = (MAX_LANE * i) + (lane - 1);
+            this.lanes[bit >>> 3] |= (1 << (bit % 8));
+            this._requiredLanes = Math.max(this._requiredLanes, this.countAtLine(i));
+        }
+    }
+    getLanesAtLine(lineNumber) {
+        const lanes = [];
+        let bit = MAX_LANE * lineNumber;
+        for (let i = 0; i < MAX_LANE; i++) {
+            if (this.persist & (1 << i) || this.lanes[bit >>> 3] & (1 << (bit % 8))) {
+                lanes.push(i + 1);
+            }
+            bit++;
+        }
+        return lanes.length ? lanes : [GlyphMarginLane.Center];
+    }
+    countAtLine(lineNumber) {
+        let bit = MAX_LANE * lineNumber;
+        let count = 0;
+        for (let i = 0; i < MAX_LANE; i++) {
+            if (this.persist & (1 << i) || this.lanes[bit >>> 3] & (1 << (bit % 8))) {
+                count++;
+            }
+            bit++;
+        }
+        return count;
+    }
+}
+
+export { GlyphMarginLanesModel };