monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,128 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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 };