monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/fullFileRenderStrategy.wgsl.js

@@ -0,0 +1,93 @@
+import { TextureAtlas } from '../atlas/textureAtlas.js';
+import { TextureAtlasPage } from '../atlas/textureAtlasPage.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const fullFileRenderStrategyWgsl = /*wgsl*/ `
+struct GlyphInfo {
+	position: vec2f,
+	size: vec2f,
+	origin: vec2f,
+};
+
+struct Vertex {
+	@location(0) position: vec2f,
+};
+
+struct Cell {
+	position: vec2f,
+	unused1: vec2f,
+	glyphIndex: f32,
+	textureIndex: f32
+};
+
+struct LayoutInfo {
+	canvasDims: vec2f,
+	viewportOffset: vec2f,
+	viewportDims: vec2f,
+}
+
+struct ScrollOffset {
+	offset: vec2f
+}
+
+struct VSOutput {
+	@builtin(position) position:   vec4f,
+	@location(1)       layerIndex: f32,
+	@location(0)       texcoord:   vec2f,
+};
+
+// Uniforms
+@group(0) @binding(${4 /* BindingId.LayoutInfoUniform */})       var<uniform>       layoutInfo:      LayoutInfo;
+@group(0) @binding(${5 /* BindingId.AtlasDimensionsUniform */})  var<uniform>       atlasDims:       vec2f;
+@group(0) @binding(${6 /* BindingId.ScrollOffset */})            var<uniform>       scrollOffset:    ScrollOffset;
+
+// Storage buffers
+@group(0) @binding(${0 /* BindingId.GlyphInfo */})               var<storage, read> glyphInfo:       array<array<GlyphInfo, ${TextureAtlasPage.maximumGlyphCount}>, ${TextureAtlas.maximumPageCount}>;
+@group(0) @binding(${1 /* BindingId.Cells */})                   var<storage, read> cells:           array<Cell>;
+
+@vertex fn vs(
+	vert: Vertex,
+	@builtin(instance_index) instanceIndex: u32,
+	@builtin(vertex_index) vertexIndex : u32
+) -> VSOutput {
+	let cell = cells[instanceIndex];
+	var glyph = glyphInfo[u32(cell.textureIndex)][u32(cell.glyphIndex)];
+
+	var vsOut: VSOutput;
+	// Multiple vert.position by 2,-2 to get it into clipspace which ranged from -1 to 1
+	vsOut.position = vec4f(
+		// Make everything relative to top left instead of center
+		vec2f(-1, 1) +
+		((vert.position * vec2f(2, -2)) / layoutInfo.canvasDims) * glyph.size +
+		((cell.position * vec2f(2, -2)) / layoutInfo.canvasDims) +
+		((glyph.origin * vec2f(2, -2)) / layoutInfo.canvasDims) +
+		(((layoutInfo.viewportOffset - scrollOffset.offset * vec2(1, -1)) * 2) / layoutInfo.canvasDims),
+		0.0,
+		1.0
+	);
+
+	vsOut.layerIndex = cell.textureIndex;
+	// Textures are flipped from natural direction on the y-axis, so flip it back
+	vsOut.texcoord = vert.position;
+	vsOut.texcoord = (
+		// Glyph offset (0-1)
+		(glyph.position / atlasDims) +
+		// Glyph coordinate (0-1)
+		(vsOut.texcoord * (glyph.size / atlasDims))
+	);
+
+	return vsOut;
+}
+
+@group(0) @binding(${2 /* BindingId.TextureSampler */}) var ourSampler: sampler;
+@group(0) @binding(${3 /* BindingId.Texture */})        var ourTexture: texture_2d_array<f32>;
+
+@fragment fn fs(vsOut: VSOutput) -> @location(0) vec4f {
+	return textureSample(ourTexture, ourSampler, vsOut.texcoord, u32(vsOut.layerIndex));
+}
+`;
+
+export { fullFileRenderStrategyWgsl };

package/dist/workers/functional.js

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Given a function, returns a function that is only calling that function once.
+ */
+function createSingleCallFunction(fn, fnDidRunCallback) {
+    const _this = this;
+    let didCall = false;
+    let result;
+    return function () {
+        if (didCall) {
+            return result;
+        }
+        didCall = true;
+        {
+            result = fn.apply(_this, arguments);
+        }
+        return result;
+    };
+}
+
+export { createSingleCallFunction };

package/dist/workers/fuzzyScorer.js

@@ -0,0 +1,143 @@
+import { fuzzyScore, createMatches } from './filters.js';
+import { sep } from './path.js';
+import { isWindows } from './platform.js';
+
+const NO_SCORE2 = [undefined, []];
+function scoreFuzzy2(target, query, patternStart = 0, wordStart = 0) {
+    // Score: multiple inputs
+    const preparedQuery = query;
+    if (preparedQuery.values && preparedQuery.values.length > 1) {
+        return doScoreFuzzy2Multiple(target, preparedQuery.values, patternStart, wordStart);
+    }
+    // Score: single input
+    return doScoreFuzzy2Single(target, query, patternStart, wordStart);
+}
+function doScoreFuzzy2Multiple(target, query, patternStart, wordStart) {
+    let totalScore = 0;
+    const totalMatches = [];
+    for (const queryPiece of query) {
+        const [score, matches] = doScoreFuzzy2Single(target, queryPiece, patternStart, wordStart);
+        if (typeof score !== 'number') {
+            // if a single query value does not match, return with
+            // no score entirely, we require all queries to match
+            return NO_SCORE2;
+        }
+        totalScore += score;
+        totalMatches.push(...matches);
+    }
+    // if we have a score, ensure that the positions are
+    // sorted in ascending order and distinct
+    return [totalScore, normalizeMatches(totalMatches)];
+}
+function doScoreFuzzy2Single(target, query, patternStart, wordStart) {
+    const score = fuzzyScore(query.original, query.originalLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
+    if (!score) {
+        return NO_SCORE2;
+    }
+    return [score[0], createMatches(score)];
+}
+function normalizeMatches(matches) {
+    // sort matches by start to be able to normalize
+    const sortedMatches = matches.sort((matchA, matchB) => {
+        return matchA.start - matchB.start;
+    });
+    // merge matches that overlap
+    const normalizedMatches = [];
+    let currentMatch = undefined;
+    for (const match of sortedMatches) {
+        // if we have no current match or the matches
+        // do not overlap, we take it as is and remember
+        // it for future merging
+        if (!currentMatch || !matchOverlaps(currentMatch, match)) {
+            currentMatch = match;
+            normalizedMatches.push(match);
+        }
+        // otherwise we merge the matches
+        else {
+            currentMatch.start = Math.min(currentMatch.start, match.start);
+            currentMatch.end = Math.max(currentMatch.end, match.end);
+        }
+    }
+    return normalizedMatches;
+}
+function matchOverlaps(matchA, matchB) {
+    if (matchA.end < matchB.start) {
+        return false; // A ends before B starts
+    }
+    if (matchB.end < matchA.start) {
+        return false; // B ends before A starts
+    }
+    return true;
+}
+/*
+ * If a query is wrapped in quotes, the user does not want to
+ * use fuzzy search for this query.
+ */
+function queryExpectsExactMatch(query) {
+    return query.startsWith('"') && query.endsWith('"');
+}
+/**
+ * Helper function to prepare a search value for scoring by removing unwanted characters
+ * and allowing to score on multiple pieces separated by whitespace character.
+ */
+const MULTIPLE_QUERY_VALUES_SEPARATOR = ' ';
+function prepareQuery(original) {
+    if (typeof original !== 'string') {
+        original = '';
+    }
+    const originalLowercase = original.toLowerCase();
+    const { pathNormalized, normalized, normalizedLowercase } = normalizeQuery(original);
+    const containsPathSeparator = pathNormalized.indexOf(sep) >= 0;
+    const expectExactMatch = queryExpectsExactMatch(original);
+    let values = undefined;
+    const originalSplit = original.split(MULTIPLE_QUERY_VALUES_SEPARATOR);
+    if (originalSplit.length > 1) {
+        for (const originalPiece of originalSplit) {
+            const expectExactMatchPiece = queryExpectsExactMatch(originalPiece);
+            const { pathNormalized: pathNormalizedPiece, normalized: normalizedPiece, normalizedLowercase: normalizedLowercasePiece } = normalizeQuery(originalPiece);
+            if (normalizedPiece) {
+                if (!values) {
+                    values = [];
+                }
+                values.push({
+                    original: originalPiece,
+                    originalLowercase: originalPiece.toLowerCase(),
+                    pathNormalized: pathNormalizedPiece,
+                    normalized: normalizedPiece,
+                    normalizedLowercase: normalizedLowercasePiece,
+                    expectContiguousMatch: expectExactMatchPiece
+                });
+            }
+        }
+    }
+    return { original, originalLowercase, pathNormalized, normalized, normalizedLowercase, values, containsPathSeparator, expectContiguousMatch: expectExactMatch };
+}
+function normalizeQuery(original) {
+    let pathNormalized;
+    if (isWindows) {
+        pathNormalized = original.replace(/\//g, sep); // Help Windows users to search for paths when using slash
+    }
+    else {
+        pathNormalized = original.replace(/\\/g, sep); // Help macOS/Linux users to search for paths when using backslash
+    }
+    // remove certain characters that help find better results:
+    // - quotes: are used for exact match search
+    // - wildcards: are used for fuzzy matching
+    // - whitespace: are used to separate queries
+    // - ellipsis: sometimes used to indicate any path segments
+    const normalized = pathNormalized.replace(/[\*\u2026\s"]/g, '');
+    return {
+        pathNormalized,
+        normalized,
+        normalizedLowercase: normalized.toLowerCase()
+    };
+}
+function pieceToQuery(arg1) {
+    if (Array.isArray(arg1)) {
+        return prepareQuery(arg1.map(piece => piece.original).join(MULTIPLE_QUERY_VALUES_SEPARATOR));
+    }
+    return prepareQuery(arg1.original);
+}
+//#endregion
+
+export { pieceToQuery, prepareQuery, scoreFuzzy2 };

package/dist/workers/getHover.js

@@ -0,0 +1,56 @@
+import { AsyncIterableProducer } from '../../../../base/common/async.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { registerModelAndPositionCommand } from '../../../browser/editorExtensions.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class HoverProviderResult {
+    constructor(provider, hover, ordinal) {
+        this.provider = provider;
+        this.hover = hover;
+        this.ordinal = ordinal;
+    }
+}
+/**
+ * Does not throw or return a rejected promise (returns undefined instead).
+ */
+async function executeProvider(provider, ordinal, model, position, token) {
+    const result = await Promise
+        .resolve(provider.provideHover(model, position, token))
+        .catch(onUnexpectedExternalError);
+    if (!result || !isValid(result)) {
+        return undefined;
+    }
+    return new HoverProviderResult(provider, result, ordinal);
+}
+function getHoverProviderResultsAsAsyncIterable(registry, model, position, token, recursive = false) {
+    const providers = registry.ordered(model, recursive);
+    const promises = providers.map((provider, index) => executeProvider(provider, index, model, position, token));
+    return AsyncIterableProducer.fromPromisesResolveOrder(promises).coalesce();
+}
+async function getHoversPromise(registry, model, position, token, recursive = false) {
+    const out = [];
+    for await (const item of getHoverProviderResultsAsAsyncIterable(registry, model, position, token, recursive)) {
+        out.push(item.hover);
+    }
+    return out;
+}
+registerModelAndPositionCommand('_executeHoverProvider', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    return getHoversPromise(languageFeaturesService.hoverProvider, model, position, CancellationToken.None);
+});
+registerModelAndPositionCommand('_executeHoverProvider_recursive', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    return getHoversPromise(languageFeaturesService.hoverProvider, model, position, CancellationToken.None, true);
+});
+function isValid(result) {
+    const hasRange = (typeof result.range !== 'undefined');
+    const hasHtmlContent = typeof result.contents !== 'undefined' && result.contents && result.contents.length > 0;
+    return hasRange && hasHtmlContent;
+}
+
+export { HoverProviderResult, getHoverProviderResultsAsAsyncIterable, getHoversPromise };

package/dist/workers/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/getLinks.js

@@ -0,0 +1,157 @@
+import { coalesce } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { DisposableStore, isDisposable } from '../../../../base/common/lifecycle.js';
+import { assertType } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Range } from '../../../common/core/range.js';
+import { IModelService } from '../../../common/services/model.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Link {
+    constructor(link, provider) {
+        this._link = link;
+        this._provider = provider;
+    }
+    toJSON() {
+        return {
+            range: this.range,
+            url: this.url,
+            tooltip: this.tooltip
+        };
+    }
+    get range() {
+        return this._link.range;
+    }
+    get url() {
+        return this._link.url;
+    }
+    get tooltip() {
+        return this._link.tooltip;
+    }
+    async resolve(token) {
+        if (this._link.url) {
+            return this._link.url;
+        }
+        if (typeof this._provider.resolveLink === 'function') {
+            return Promise.resolve(this._provider.resolveLink(this._link, token)).then(value => {
+                this._link = value || this._link;
+                if (this._link.url) {
+                    // recurse
+                    return this.resolve(token);
+                }
+                return Promise.reject(new Error('missing'));
+            });
+        }
+        return Promise.reject(new Error('missing'));
+    }
+}
+class LinksList {
+    static { this.Empty = new LinksList([]); }
+    constructor(tuples) {
+        this._disposables = new DisposableStore();
+        let links = [];
+        for (const [list, provider] of tuples) {
+            // merge all links
+            const newLinks = list.links.map(link => new Link(link, provider));
+            links = LinksList._union(links, newLinks);
+            // register disposables
+            if (isDisposable(list)) {
+                this._disposables ??= new DisposableStore();
+                this._disposables.add(list);
+            }
+        }
+        this.links = links;
+    }
+    dispose() {
+        this._disposables?.dispose();
+        this.links.length = 0;
+    }
+    static _union(oldLinks, newLinks) {
+        // reunite oldLinks with newLinks and remove duplicates
+        const result = [];
+        let oldIndex;
+        let oldLen;
+        let newIndex;
+        let newLen;
+        for (oldIndex = 0, newIndex = 0, oldLen = oldLinks.length, newLen = newLinks.length; oldIndex < oldLen && newIndex < newLen;) {
+            const oldLink = oldLinks[oldIndex];
+            const newLink = newLinks[newIndex];
+            if (Range.areIntersectingOrTouching(oldLink.range, newLink.range)) {
+                // Remove the oldLink
+                oldIndex++;
+                continue;
+            }
+            const comparisonResult = Range.compareRangesUsingStarts(oldLink.range, newLink.range);
+            if (comparisonResult < 0) {
+                // oldLink is before
+                result.push(oldLink);
+                oldIndex++;
+            }
+            else {
+                // newLink is before
+                result.push(newLink);
+                newIndex++;
+            }
+        }
+        for (; oldIndex < oldLen; oldIndex++) {
+            result.push(oldLinks[oldIndex]);
+        }
+        for (; newIndex < newLen; newIndex++) {
+            result.push(newLinks[newIndex]);
+        }
+        return result;
+    }
+}
+async function getLinks(providers, model, token) {
+    const lists = [];
+    // ask all providers for links in parallel
+    const promises = providers.ordered(model).reverse().map(async (provider, i) => {
+        try {
+            const result = await provider.provideLinks(model, token);
+            if (result) {
+                lists[i] = [result, provider];
+            }
+        }
+        catch (err) {
+            onUnexpectedExternalError(err);
+        }
+    });
+    await Promise.all(promises);
+    let res = new LinksList(coalesce(lists));
+    if (token.isCancellationRequested) {
+        res.dispose();
+        res = LinksList.Empty;
+    }
+    return res;
+}
+CommandsRegistry.registerCommand('_executeLinkProvider', async (accessor, ...args) => {
+    let [uri, resolveCount] = args;
+    assertType(uri instanceof URI);
+    if (typeof resolveCount !== 'number') {
+        resolveCount = 0;
+    }
+    const { linkProvider } = accessor.get(ILanguageFeaturesService);
+    const model = accessor.get(IModelService).getModel(uri);
+    if (!model) {
+        return [];
+    }
+    const list = await getLinks(linkProvider, model, CancellationToken.None);
+    if (!list) {
+        return [];
+    }
+    // resolve links
+    for (let i = 0; i < Math.min(resolveCount, list.links.length); i++) {
+        await list.links[i].resolve(CancellationToken.None);
+    }
+    const result = list.links.slice(0);
+    list.dispose();
+    return result;
+});
+
+export { Link, LinksList, getLinks };

package/dist/workers/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 };