@umbraco-cms/backoffice 15.3.1 → 15.4.0-rc2

package/dist-cms/monaco-editor/vs/editor/common/editorAction.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.
+ *--------------------------------------------------------------------------------------------*/
+export class InternalEditorAction {
+    constructor(id, label, alias, metadata, _precondition, _run, _contextKeyService) {
+        this.id = id;
+        this.label = label;
+        this.alias = alias;
+        this.metadata = metadata;
+        this._precondition = _precondition;
+        this._run = _run;
+        this._contextKeyService = _contextKeyService;
+    }
+    isSupported() {
+        return this._contextKeyService.contextMatchesRules(this._precondition);
+    }
+    run(args) {
+        if (!this.isSupported()) {
+            return Promise.resolve(undefined);
+        }
+        return this._run(args);
+    }
+}

package/dist-cms/monaco-editor/vs/editor/common/editorCommon.js

@@ -0,0 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * The type of the `IEditor`.
+ */
+export const EditorType = {
+    ICodeEditor: 'vs.editor.ICodeEditor',
+    IDiffEditor: 'vs.editor.IDiffEditor'
+};

package/dist-cms/monaco-editor/vs/editor/common/editorContextKeys.js

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as nls from '../../nls.js';
+import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
+export var EditorContextKeys;
+(function (EditorContextKeys) {
+    EditorContextKeys.editorSimpleInput = new RawContextKey('editorSimpleInput', false, true);
+    /**
+     * A context key that is set when the editor's text has focus (cursor is blinking).
+     * Is false when focus is in simple editor widgets (repl input, scm commit input).
+     */
+    EditorContextKeys.editorTextFocus = new RawContextKey('editorTextFocus', false, nls.localize('editorTextFocus', "Whether the editor text has focus (cursor is blinking)"));
+    /**
+     * A context key that is set when the editor's text or an editor's widget has focus.
+     */
+    EditorContextKeys.focus = new RawContextKey('editorFocus', false, nls.localize('editorFocus', "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"));
+    /**
+     * A context key that is set when any editor input has focus (regular editor, repl input...).
+     */
+    EditorContextKeys.textInputFocus = new RawContextKey('textInputFocus', false, nls.localize('textInputFocus', "Whether an editor or a rich text input has focus (cursor is blinking)"));
+    EditorContextKeys.readOnly = new RawContextKey('editorReadonly', false, nls.localize('editorReadonly', "Whether the editor is read-only"));
+    EditorContextKeys.inDiffEditor = new RawContextKey('inDiffEditor', false, nls.localize('inDiffEditor', "Whether the context is a diff editor"));
+    EditorContextKeys.isEmbeddedDiffEditor = new RawContextKey('isEmbeddedDiffEditor', false, nls.localize('isEmbeddedDiffEditor', "Whether the context is an embedded diff editor"));
+    EditorContextKeys.inMultiDiffEditor = new RawContextKey('inMultiDiffEditor', false, nls.localize('inMultiDiffEditor', "Whether the context is a multi diff editor"));
+    EditorContextKeys.multiDiffEditorAllCollapsed = new RawContextKey('multiDiffEditorAllCollapsed', undefined, nls.localize('multiDiffEditorAllCollapsed', "Whether all files in multi diff editor are collapsed"));
+    EditorContextKeys.hasChanges = new RawContextKey('diffEditorHasChanges', false, nls.localize('diffEditorHasChanges', "Whether the diff editor has changes"));
+    EditorContextKeys.comparingMovedCode = new RawContextKey('comparingMovedCode', false, nls.localize('comparingMovedCode', "Whether a moved code block is selected for comparison"));
+    EditorContextKeys.accessibleDiffViewerVisible = new RawContextKey('accessibleDiffViewerVisible', false, nls.localize('accessibleDiffViewerVisible', "Whether the accessible diff viewer is visible"));
+    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, nls.localize('diffEditorRenderSideBySideInlineBreakpointReached', "Whether the diff editor render side by side inline breakpoint is reached"));
+    EditorContextKeys.diffEditorInlineMode = new RawContextKey('diffEditorInlineMode', false, nls.localize('diffEditorInlineMode', "Whether inline mode is active"));
+    EditorContextKeys.diffEditorOriginalWritable = new RawContextKey('diffEditorOriginalWritable', false, nls.localize('diffEditorOriginalWritable', "Whether modified is writable in the diff editor"));
+    EditorContextKeys.diffEditorModifiedWritable = new RawContextKey('diffEditorModifiedWritable', false, nls.localize('diffEditorModifiedWritable', "Whether modified is writable in the diff editor"));
+    EditorContextKeys.diffEditorOriginalUri = new RawContextKey('diffEditorOriginalUri', '', nls.localize('diffEditorOriginalUri', "The uri of the original document"));
+    EditorContextKeys.diffEditorModifiedUri = new RawContextKey('diffEditorModifiedUri', '', nls.localize('diffEditorModifiedUri', "The uri of the modified document"));
+    EditorContextKeys.columnSelection = new RawContextKey('editorColumnSelection', false, nls.localize('editorColumnSelection', "Whether `editor.columnSelection` is enabled"));
+    EditorContextKeys.writable = EditorContextKeys.readOnly.toNegated();
+    EditorContextKeys.hasNonEmptySelection = new RawContextKey('editorHasSelection', false, nls.localize('editorHasSelection', "Whether the editor has text selected"));
+    EditorContextKeys.hasOnlyEmptySelection = EditorContextKeys.hasNonEmptySelection.toNegated();
+    EditorContextKeys.hasMultipleSelections = new RawContextKey('editorHasMultipleSelections', false, nls.localize('editorHasMultipleSelections', "Whether the editor has multiple selections"));
+    EditorContextKeys.hasSingleSelection = EditorContextKeys.hasMultipleSelections.toNegated();
+    EditorContextKeys.tabMovesFocus = new RawContextKey('editorTabMovesFocus', false, nls.localize('editorTabMovesFocus', "Whether `Tab` will move focus out of the editor"));
+    EditorContextKeys.tabDoesNotMoveFocus = EditorContextKeys.tabMovesFocus.toNegated();
+    EditorContextKeys.isInEmbeddedEditor = new RawContextKey('isInEmbeddedEditor', false, true);
+    EditorContextKeys.canUndo = new RawContextKey('canUndo', false, true);
+    EditorContextKeys.canRedo = new RawContextKey('canRedo', false, true);
+    EditorContextKeys.hoverVisible = new RawContextKey('editorHoverVisible', false, nls.localize('editorHoverVisible', "Whether the editor hover is visible"));
+    EditorContextKeys.hoverFocused = new RawContextKey('editorHoverFocused', false, nls.localize('editorHoverFocused', "Whether the editor hover is focused"));
+    EditorContextKeys.stickyScrollFocused = new RawContextKey('stickyScrollFocused', false, nls.localize('stickyScrollFocused', "Whether the sticky scroll is focused"));
+    EditorContextKeys.stickyScrollVisible = new RawContextKey('stickyScrollVisible', false, nls.localize('stickyScrollVisible', "Whether the sticky scroll is visible"));
+    EditorContextKeys.standaloneColorPickerVisible = new RawContextKey('standaloneColorPickerVisible', false, nls.localize('standaloneColorPickerVisible', "Whether the standalone color picker is visible"));
+    EditorContextKeys.standaloneColorPickerFocused = new RawContextKey('standaloneColorPickerFocused', false, nls.localize('standaloneColorPickerFocused', "Whether the standalone color picker is focused"));
+    /**
+     * A context key that is set when an editor is part of a larger editor, like notebooks or
+     * (future) a diff editor
+     */
+    EditorContextKeys.inCompositeEditor = new RawContextKey('inCompositeEditor', undefined, nls.localize('inCompositeEditor', "Whether the editor is part of a larger editor (e.g. notebooks)"));
+    EditorContextKeys.notInCompositeEditor = EditorContextKeys.inCompositeEditor.toNegated();
+    // -- mode context keys
+    EditorContextKeys.languageId = new RawContextKey('editorLangId', '', nls.localize('editorLangId', "The language identifier of the editor"));
+    EditorContextKeys.hasCompletionItemProvider = new RawContextKey('editorHasCompletionItemProvider', false, nls.localize('editorHasCompletionItemProvider', "Whether the editor has a completion item provider"));
+    EditorContextKeys.hasCodeActionsProvider = new RawContextKey('editorHasCodeActionsProvider', false, nls.localize('editorHasCodeActionsProvider', "Whether the editor has a code actions provider"));
+    EditorContextKeys.hasCodeLensProvider = new RawContextKey('editorHasCodeLensProvider', false, nls.localize('editorHasCodeLensProvider', "Whether the editor has a code lens provider"));
+    EditorContextKeys.hasDefinitionProvider = new RawContextKey('editorHasDefinitionProvider', false, nls.localize('editorHasDefinitionProvider', "Whether the editor has a definition provider"));
+    EditorContextKeys.hasDeclarationProvider = new RawContextKey('editorHasDeclarationProvider', false, nls.localize('editorHasDeclarationProvider', "Whether the editor has a declaration provider"));
+    EditorContextKeys.hasImplementationProvider = new RawContextKey('editorHasImplementationProvider', false, nls.localize('editorHasImplementationProvider', "Whether the editor has an implementation provider"));
+    EditorContextKeys.hasTypeDefinitionProvider = new RawContextKey('editorHasTypeDefinitionProvider', false, nls.localize('editorHasTypeDefinitionProvider', "Whether the editor has a type definition provider"));
+    EditorContextKeys.hasHoverProvider = new RawContextKey('editorHasHoverProvider', false, nls.localize('editorHasHoverProvider', "Whether the editor has a hover provider"));
+    EditorContextKeys.hasDocumentHighlightProvider = new RawContextKey('editorHasDocumentHighlightProvider', false, nls.localize('editorHasDocumentHighlightProvider', "Whether the editor has a document highlight provider"));
+    EditorContextKeys.hasDocumentSymbolProvider = new RawContextKey('editorHasDocumentSymbolProvider', false, nls.localize('editorHasDocumentSymbolProvider', "Whether the editor has a document symbol provider"));
+    EditorContextKeys.hasReferenceProvider = new RawContextKey('editorHasReferenceProvider', false, nls.localize('editorHasReferenceProvider', "Whether the editor has a reference provider"));
+    EditorContextKeys.hasRenameProvider = new RawContextKey('editorHasRenameProvider', false, nls.localize('editorHasRenameProvider', "Whether the editor has a rename provider"));
+    EditorContextKeys.hasSignatureHelpProvider = new RawContextKey('editorHasSignatureHelpProvider', false, nls.localize('editorHasSignatureHelpProvider', "Whether the editor has a signature help provider"));
+    EditorContextKeys.hasInlayHintsProvider = new RawContextKey('editorHasInlayHintsProvider', false, nls.localize('editorHasInlayHintsProvider', "Whether the editor has an inline hints provider"));
+    // -- mode context keys: formatting
+    EditorContextKeys.hasDocumentFormattingProvider = new RawContextKey('editorHasDocumentFormattingProvider', false, nls.localize('editorHasDocumentFormattingProvider', "Whether the editor has a document formatting provider"));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, nls.localize('editorHasDocumentSelectionFormattingProvider', "Whether the editor has a document selection formatting provider"));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, nls.localize('editorHasMultipleDocumentFormattingProvider', "Whether the editor has multiple document formatting providers"));
+    EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = new RawContextKey('editorHasMultipleDocumentSelectionFormattingProvider', false, nls.localize('editorHasMultipleDocumentSelectionFormattingProvider', "Whether the editor has multiple document selection formatting providers"));
+})(EditorContextKeys || (EditorContextKeys = {}));

package/dist-cms/monaco-editor/vs/editor/common/editorFeatures.js

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const editorFeatures = [];
+/**
+ * Registers an editor feature. Editor features will be instantiated only once, as soon as
+ * the first code editor is instantiated.
+ */
+export function registerEditorFeature(ctor) {
+    editorFeatures.push(ctor);
+}
+export function getEditorFeatures() {
+    return editorFeatures.slice(0);
+}

package/dist-cms/monaco-editor/vs/editor/common/editorTheme.js

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class EditorTheme {
+    get type() {
+        return this._theme.type;
+    }
+    get value() {
+        return this._theme;
+    }
+    constructor(theme) {
+        this._theme = theme;
+    }
+    update(theme) {
+        this._theme = theme;
+    }
+    getColor(color) {
+        return this._theme.getColor(color);
+    }
+}

package/dist-cms/monaco-editor/vs/editor/common/encodedTokenAttributes.js

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ */
+export class TokenMetadata {
+    static getLanguageId(metadata) {
+        return (metadata & 255 /* MetadataConsts.LANGUAGEID_MASK */) >>> 0 /* MetadataConsts.LANGUAGEID_OFFSET */;
+    }
+    static getTokenType(metadata) {
+        return (metadata & 768 /* MetadataConsts.TOKEN_TYPE_MASK */) >>> 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */;
+    }
+    static containsBalancedBrackets(metadata) {
+        return (metadata & 1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */) !== 0;
+    }
+    static getFontStyle(metadata) {
+        return (metadata & 30720 /* MetadataConsts.FONT_STYLE_MASK */) >>> 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+    }
+    static getForeground(metadata) {
+        return (metadata & 16744448 /* MetadataConsts.FOREGROUND_MASK */) >>> 15 /* MetadataConsts.FOREGROUND_OFFSET */;
+    }
+    static getBackground(metadata) {
+        return (metadata & 4278190080 /* MetadataConsts.BACKGROUND_MASK */) >>> 24 /* MetadataConsts.BACKGROUND_OFFSET */;
+    }
+    static getClassNameFromMetadata(metadata) {
+        const foreground = this.getForeground(metadata);
+        let className = 'mtk' + foreground;
+        const fontStyle = this.getFontStyle(metadata);
+        if (fontStyle & 1 /* FontStyle.Italic */) {
+            className += ' mtki';
+        }
+        if (fontStyle & 2 /* FontStyle.Bold */) {
+            className += ' mtkb';
+        }
+        if (fontStyle & 4 /* FontStyle.Underline */) {
+            className += ' mtku';
+        }
+        if (fontStyle & 8 /* FontStyle.Strikethrough */) {
+            className += ' mtks';
+        }
+        return className;
+    }
+    static getInlineStyleFromMetadata(metadata, colorMap) {
+        const foreground = this.getForeground(metadata);
+        const fontStyle = this.getFontStyle(metadata);
+        let result = `color: ${colorMap[foreground]};`;
+        if (fontStyle & 1 /* FontStyle.Italic */) {
+            result += 'font-style: italic;';
+        }
+        if (fontStyle & 2 /* FontStyle.Bold */) {
+            result += 'font-weight: bold;';
+        }
+        let textDecoration = '';
+        if (fontStyle & 4 /* FontStyle.Underline */) {
+            textDecoration += ' underline';
+        }
+        if (fontStyle & 8 /* FontStyle.Strikethrough */) {
+            textDecoration += ' line-through';
+        }
+        if (textDecoration) {
+            result += `text-decoration:${textDecoration};`;
+        }
+        return result;
+    }
+    static getPresentationFromMetadata(metadata) {
+        const foreground = this.getForeground(metadata);
+        const fontStyle = this.getFontStyle(metadata);
+        return {
+            foreground: foreground,
+            italic: Boolean(fontStyle & 1 /* FontStyle.Italic */),
+            bold: Boolean(fontStyle & 2 /* FontStyle.Bold */),
+            underline: Boolean(fontStyle & 4 /* FontStyle.Underline */),
+            strikethrough: Boolean(fontStyle & 8 /* FontStyle.Strikethrough */),
+        };
+    }
+}

package/dist-cms/monaco-editor/vs/editor/common/languageFeatureRegistry.js

@@ -0,0 +1,177 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Emitter } from '../../base/common/event.js';
+import { toDisposable } from '../../base/common/lifecycle.js';
+import { shouldSynchronizeModel } from './model.js';
+import { score } from './languageSelector.js';
+function isExclusive(selector) {
+    if (typeof selector === 'string') {
+        return false;
+    }
+    else if (Array.isArray(selector)) {
+        return selector.every(isExclusive);
+    }
+    else {
+        return !!selector.exclusive; // TODO: microsoft/TypeScript#42768
+    }
+}
+class MatchCandidate {
+    constructor(uri, languageId, notebookUri, notebookType, recursive) {
+        this.uri = uri;
+        this.languageId = languageId;
+        this.notebookUri = notebookUri;
+        this.notebookType = notebookType;
+        this.recursive = recursive;
+    }
+    equals(other) {
+        return this.notebookType === other.notebookType
+            && this.languageId === other.languageId
+            && this.uri.toString() === other.uri.toString()
+            && this.notebookUri?.toString() === other.notebookUri?.toString()
+            && this.recursive === other.recursive;
+    }
+}
+export class LanguageFeatureRegistry {
+    constructor(_notebookInfoResolver) {
+        this._notebookInfoResolver = _notebookInfoResolver;
+        this._clock = 0;
+        this._entries = [];
+        this._onDidChange = new Emitter();
+        this.onDidChange = this._onDidChange.event;
+    }
+    register(selector, provider) {
+        let entry = {
+            selector,
+            provider,
+            _score: -1,
+            _time: this._clock++
+        };
+        this._entries.push(entry);
+        this._lastCandidate = undefined;
+        this._onDidChange.fire(this._entries.length);
+        return toDisposable(() => {
+            if (entry) {
+                const idx = this._entries.indexOf(entry);
+                if (idx >= 0) {
+                    this._entries.splice(idx, 1);
+                    this._lastCandidate = undefined;
+                    this._onDidChange.fire(this._entries.length);
+                    entry = undefined;
+                }
+            }
+        });
+    }
+    has(model) {
+        return this.all(model).length > 0;
+    }
+    all(model) {
+        if (!model) {
+            return [];
+        }
+        this._updateScores(model, false);
+        const result = [];
+        // from registry
+        for (const entry of this._entries) {
+            if (entry._score > 0) {
+                result.push(entry.provider);
+            }
+        }
+        return result;
+    }
+    ordered(model, recursive = false) {
+        const result = [];
+        this._orderedForEach(model, recursive, entry => result.push(entry.provider));
+        return result;
+    }
+    orderedGroups(model) {
+        const result = [];
+        let lastBucket;
+        let lastBucketScore;
+        this._orderedForEach(model, false, entry => {
+            if (lastBucket && lastBucketScore === entry._score) {
+                lastBucket.push(entry.provider);
+            }
+            else {
+                lastBucketScore = entry._score;
+                lastBucket = [entry.provider];
+                result.push(lastBucket);
+            }
+        });
+        return result;
+    }
+    _orderedForEach(model, recursive, callback) {
+        this._updateScores(model, recursive);
+        for (const entry of this._entries) {
+            if (entry._score > 0) {
+                callback(entry);
+            }
+        }
+    }
+    _updateScores(model, recursive) {
+        const notebookInfo = this._notebookInfoResolver?.(model.uri);
+        // use the uri (scheme, pattern) of the notebook info iff we have one
+        // otherwise it's the model's/document's uri
+        const candidate = notebookInfo
+            ? new MatchCandidate(model.uri, model.getLanguageId(), notebookInfo.uri, notebookInfo.type, recursive)
+            : new MatchCandidate(model.uri, model.getLanguageId(), undefined, undefined, recursive);
+        if (this._lastCandidate?.equals(candidate)) {
+            // nothing has changed
+            return;
+        }
+        this._lastCandidate = candidate;
+        for (const entry of this._entries) {
+            entry._score = score(entry.selector, candidate.uri, candidate.languageId, shouldSynchronizeModel(model), candidate.notebookUri, candidate.notebookType);
+            if (isExclusive(entry.selector) && entry._score > 0) {
+                if (recursive) {
+                    entry._score = 0;
+                }
+                else {
+                    // support for one exclusive selector that overwrites
+                    // any other selector
+                    for (const entry of this._entries) {
+                        entry._score = 0;
+                    }
+                    entry._score = 1000;
+                    break;
+                }
+            }
+        }
+        // needs sorting
+        this._entries.sort(LanguageFeatureRegistry._compareByScoreAndTime);
+    }
+    static _compareByScoreAndTime(a, b) {
+        if (a._score < b._score) {
+            return 1;
+        }
+        else if (a._score > b._score) {
+            return -1;
+        }
+        // De-prioritize built-in providers
+        if (isBuiltinSelector(a.selector) && !isBuiltinSelector(b.selector)) {
+            return 1;
+        }
+        else if (!isBuiltinSelector(a.selector) && isBuiltinSelector(b.selector)) {
+            return -1;
+        }
+        if (a._time < b._time) {
+            return 1;
+        }
+        else if (a._time > b._time) {
+            return -1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+function isBuiltinSelector(selector) {
+    if (typeof selector === 'string') {
+        return false;
+    }
+    if (Array.isArray(selector)) {
+        return selector.some(isBuiltinSelector);
+    }
+    return Boolean(selector.isBuiltin);
+}

package/dist-cms/monaco-editor/vs/editor/common/languageSelector.js

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { match as matchGlobPattern } from '../../base/common/glob.js';
+import { normalize } from '../../base/common/path.js';
+export function score(selector, candidateUri, candidateLanguage, candidateIsSynchronized, candidateNotebookUri, candidateNotebookType) {
+    if (Array.isArray(selector)) {
+        // array -> take max individual value
+        let ret = 0;
+        for (const filter of selector) {
+            const value = score(filter, candidateUri, candidateLanguage, candidateIsSynchronized, candidateNotebookUri, candidateNotebookType);
+            if (value === 10) {
+                return value; // already at the highest
+            }
+            if (value > ret) {
+                ret = value;
+            }
+        }
+        return ret;
+    }
+    else if (typeof selector === 'string') {
+        if (!candidateIsSynchronized) {
+            return 0;
+        }
+        // short-hand notion, desugars to
+        // 'fooLang' -> { language: 'fooLang'}
+        // '*' -> { language: '*' }
+        if (selector === '*') {
+            return 5;
+        }
+        else if (selector === candidateLanguage) {
+            return 10;
+        }
+        else {
+            return 0;
+        }
+    }
+    else if (selector) {
+        // filter -> select accordingly, use defaults for scheme
+        const { language, pattern, scheme, hasAccessToAllModels, notebookType } = selector; // TODO: microsoft/TypeScript#42768
+        if (!candidateIsSynchronized && !hasAccessToAllModels) {
+            return 0;
+        }
+        // selector targets a notebook -> use the notebook uri instead
+        // of the "normal" document uri.
+        if (notebookType && candidateNotebookUri) {
+            candidateUri = candidateNotebookUri;
+        }
+        let ret = 0;
+        if (scheme) {
+            if (scheme === candidateUri.scheme) {
+                ret = 10;
+            }
+            else if (scheme === '*') {
+                ret = 5;
+            }
+            else {
+                return 0;
+            }
+        }
+        if (language) {
+            if (language === candidateLanguage) {
+                ret = 10;
+            }
+            else if (language === '*') {
+                ret = Math.max(ret, 5);
+            }
+            else {
+                return 0;
+            }
+        }
+        if (notebookType) {
+            if (notebookType === candidateNotebookType) {
+                ret = 10;
+            }
+            else if (notebookType === '*' && candidateNotebookType !== undefined) {
+                ret = Math.max(ret, 5);
+            }
+            else {
+                return 0;
+            }
+        }
+        if (pattern) {
+            let normalizedPattern;
+            if (typeof pattern === 'string') {
+                normalizedPattern = pattern;
+            }
+            else {
+                // Since this pattern has a `base` property, we need
+                // to normalize this path first before passing it on
+                // because we will compare it against `Uri.fsPath`
+                // which uses platform specific separators.
+                // Refs: https://github.com/microsoft/vscode/issues/99938
+                normalizedPattern = { ...pattern, base: normalize(pattern.base) };
+            }
+            if (normalizedPattern === candidateUri.fsPath || matchGlobPattern(normalizedPattern, candidateUri.fsPath)) {
+                ret = 10;
+            }
+            else {
+                return 0;
+            }
+        }
+        return ret;
+    }
+    else {
+        return 0;
+    }
+}