@codingame/monaco-vscode-api 1.85.1 → 1.85.3

package/vscode/src/vs/workbench/services/preferences/browser/keybindingsEditorModel.js

@@ -0,0 +1,588 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { coalesce, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString, matchesCamelCase } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { UILabelProvider, AriaLabelProvider, UserSettingsLabelProvider } from 'monaco-editor/esm/vs/base/common/keybindingLabels.js';
+import { MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { EditorModel } from '../../../common/editor/editorModel.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ResolvedKeybindingItem } from 'monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+import { getAllUnboundCommands } from '../../keybinding/browser/unboundCommands.js';
+import { isString, isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { ExtensionIdentifier, ExtensionIdentifierMap } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+var KeybindingsEditorModel_1;
+const KEYBINDING_ENTRY_TEMPLATE_ID = 'keybinding.entry.template';
+const SOURCE_SYSTEM = ( localizeWithPath(
+    'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+    'default',
+    "System"
+));
+const SOURCE_EXTENSION = ( localizeWithPath(
+    'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+    'extension',
+    "Extension"
+));
+const SOURCE_USER = ( localizeWithPath(
+    'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+    'user',
+    "User"
+));
+const wordFilter = or(matchesPrefix, matchesWords, matchesContiguousSubString);
+const SOURCE_REGEX = /@source:\s*(user|default|system|extension)/i;
+const EXTENSION_REGEX = /@ext:\s*((".+")|([^\s]+))/i;
+let KeybindingsEditorModel = KeybindingsEditorModel_1 = class KeybindingsEditorModel extends EditorModel {
+    constructor(os, keybindingsService, extensionService) {
+        super();
+        this.keybindingsService = keybindingsService;
+        this.extensionService = extensionService;
+        this._keybindingItems = [];
+        this._keybindingItemsSortedByPrecedence = [];
+        this.modifierLabels = {
+            ui: UILabelProvider.modifierLabels[os],
+            aria: AriaLabelProvider.modifierLabels[os],
+            user: UserSettingsLabelProvider.modifierLabels[os]
+        };
+    }
+    fetch(searchValue, sortByPrecedence = false) {
+        let keybindingItems = sortByPrecedence ? this._keybindingItemsSortedByPrecedence : this._keybindingItems;
+        const commandIdMatches = /@command:\s*(.+)/i.exec(searchValue);
+        if (commandIdMatches && commandIdMatches[1]) {
+            return ( keybindingItems.filter(k => k.command === commandIdMatches[1])
+                .map(
+                keybindingItem => ({ id: KeybindingsEditorModel_1.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
+            ));
+        }
+        if (SOURCE_REGEX.test(searchValue)) {
+            keybindingItems = this.filterBySource(keybindingItems, searchValue);
+            searchValue = searchValue.replace(SOURCE_REGEX, '');
+        }
+        else {
+            const extensionMatches = EXTENSION_REGEX.exec(searchValue);
+            if (extensionMatches && (extensionMatches[2] || extensionMatches[3])) {
+                const extensionId = extensionMatches[2] ? extensionMatches[2].substring(1, extensionMatches[2].length - 1) : extensionMatches[3];
+                keybindingItems = this.filterByExtension(keybindingItems, extensionId);
+                searchValue = searchValue.replace(EXTENSION_REGEX, '');
+            }
+            else {
+                const keybindingMatches = /@keybinding:\s*((\".+\")|(\S+))/i.exec(searchValue);
+                if (keybindingMatches && (keybindingMatches[2] || keybindingMatches[3])) {
+                    searchValue = keybindingMatches[2] || `"${keybindingMatches[3]}"`;
+                }
+            }
+        }
+        searchValue = searchValue.trim();
+        if (!searchValue) {
+            return ( keybindingItems.map(
+                keybindingItem => ({ id: KeybindingsEditorModel_1.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
+            ));
+        }
+        return this.filterByText(keybindingItems, searchValue);
+    }
+    filterBySource(keybindingItems, searchValue) {
+        if (/@source:\s*default/i.test(searchValue) || /@source:\s*system/i.test(searchValue)) {
+            return keybindingItems.filter(k => k.source === SOURCE_SYSTEM);
+        }
+        if (/@source:\s*user/i.test(searchValue)) {
+            return keybindingItems.filter(k => k.source === SOURCE_USER);
+        }
+        if (/@source:\s*extension/i.test(searchValue)) {
+            return keybindingItems.filter(k => !isString(k.source) || k.source === SOURCE_EXTENSION);
+        }
+        return keybindingItems;
+    }
+    filterByExtension(keybindingItems, extension) {
+        extension = extension.toLowerCase().trim();
+        return keybindingItems.filter(k => !isString(k.source) && (ExtensionIdentifier.equals(k.source.identifier, extension) || k.source.displayName?.toLowerCase() === extension.toLowerCase()));
+    }
+    filterByText(keybindingItems, searchValue) {
+        const quoteAtFirstChar = searchValue.charAt(0) === '"';
+        const quoteAtLastChar = searchValue.charAt(searchValue.length - 1) === '"';
+        const completeMatch = quoteAtFirstChar && quoteAtLastChar;
+        if (quoteAtFirstChar) {
+            searchValue = searchValue.substring(1);
+        }
+        if (quoteAtLastChar) {
+            searchValue = searchValue.substring(0, searchValue.length - 1);
+        }
+        searchValue = searchValue.trim();
+        const result = [];
+        const words = searchValue.split(' ');
+        const keybindingWords = this.splitKeybindingWords(words);
+        for (const keybindingItem of keybindingItems) {
+            const keybindingMatches = ( new KeybindingItemMatches(
+                this.modifierLabels,
+                keybindingItem,
+                searchValue,
+                words,
+                keybindingWords,
+                completeMatch
+            ));
+            if (keybindingMatches.commandIdMatches
+                || keybindingMatches.commandLabelMatches
+                || keybindingMatches.commandDefaultLabelMatches
+                || keybindingMatches.sourceMatches
+                || keybindingMatches.whenMatches
+                || keybindingMatches.keybindingMatches
+                || keybindingMatches.extensionIdMatches
+                || keybindingMatches.extensionLabelMatches) {
+                result.push({
+                    id: KeybindingsEditorModel_1.getId(keybindingItem),
+                    templateId: KEYBINDING_ENTRY_TEMPLATE_ID,
+                    commandLabelMatches: keybindingMatches.commandLabelMatches || undefined,
+                    commandDefaultLabelMatches: keybindingMatches.commandDefaultLabelMatches || undefined,
+                    keybindingItem,
+                    keybindingMatches: keybindingMatches.keybindingMatches || undefined,
+                    commandIdMatches: keybindingMatches.commandIdMatches || undefined,
+                    sourceMatches: keybindingMatches.sourceMatches || undefined,
+                    whenMatches: keybindingMatches.whenMatches || undefined,
+                    extensionIdMatches: keybindingMatches.extensionIdMatches || undefined,
+                    extensionLabelMatches: keybindingMatches.extensionLabelMatches || undefined
+                });
+            }
+        }
+        return result;
+    }
+    splitKeybindingWords(wordsSeparatedBySpaces) {
+        const result = [];
+        for (const word of wordsSeparatedBySpaces) {
+            result.push(...coalesce(word.split('+')));
+        }
+        return result;
+    }
+    async resolve(actionLabels = ( new Map())) {
+        const extensions = ( new ExtensionIdentifierMap());
+        for (const extension of this.extensionService.extensions) {
+            extensions.set(extension.identifier, extension);
+        }
+        this._keybindingItemsSortedByPrecedence = [];
+        const boundCommands = ( new Map());
+        for (const keybinding of this.keybindingsService.getKeybindings()) {
+            if (keybinding.command) {
+                this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel_1.toKeybindingEntry(keybinding.command, keybinding, actionLabels, extensions));
+                boundCommands.set(keybinding.command, true);
+            }
+        }
+        const commandsWithDefaultKeybindings = ( this.keybindingsService.getDefaultKeybindings().map(keybinding => keybinding.command));
+        for (const command of getAllUnboundCommands(boundCommands)) {
+            const keybindingItem = ( new ResolvedKeybindingItem(
+                undefined,
+                command,
+                null,
+                undefined,
+                commandsWithDefaultKeybindings.indexOf(command) === -1,
+                null,
+                false
+            ));
+            this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel_1.toKeybindingEntry(command, keybindingItem, actionLabels, extensions));
+        }
+        this._keybindingItemsSortedByPrecedence = distinct(this._keybindingItemsSortedByPrecedence, keybindingItem => KeybindingsEditorModel_1.getId(keybindingItem));
+        this._keybindingItems = this._keybindingItemsSortedByPrecedence.slice(0).sort((a, b) => KeybindingsEditorModel_1.compareKeybindingData(a, b));
+        return super.resolve();
+    }
+    static getId(keybindingItem) {
+        return keybindingItem.command + (keybindingItem?.keybinding?.getAriaLabel() ?? '') + keybindingItem.when + (isString(keybindingItem.source) ? keybindingItem.source : keybindingItem.source.identifier.value);
+    }
+    static compareKeybindingData(a, b) {
+        if (a.keybinding && !b.keybinding) {
+            return -1;
+        }
+        if (b.keybinding && !a.keybinding) {
+            return 1;
+        }
+        if (a.commandLabel && !b.commandLabel) {
+            return -1;
+        }
+        if (b.commandLabel && !a.commandLabel) {
+            return 1;
+        }
+        if (a.commandLabel && b.commandLabel) {
+            if (a.commandLabel !== b.commandLabel) {
+                return a.commandLabel.localeCompare(b.commandLabel);
+            }
+        }
+        if (a.command === b.command) {
+            return a.keybindingItem.isDefault ? 1 : -1;
+        }
+        return a.command.localeCompare(b.command);
+    }
+    static toKeybindingEntry(command, keybindingItem, actions, extensions) {
+        const menuCommand = MenuRegistry.getCommand(command);
+        const editorActionLabel = actions.get(command);
+        let source = SOURCE_USER;
+        if (keybindingItem.isDefault) {
+            const extensionId = keybindingItem.extensionId ?? (keybindingItem.resolvedKeybinding ? undefined : menuCommand?.source?.id);
+            source = extensionId ? extensions.get(extensionId) ?? SOURCE_EXTENSION : SOURCE_SYSTEM;
+        }
+        return {
+            keybinding: keybindingItem.resolvedKeybinding,
+            keybindingItem,
+            command,
+            commandLabel: KeybindingsEditorModel_1.getCommandLabel(menuCommand, editorActionLabel),
+            commandDefaultLabel: KeybindingsEditorModel_1.getCommandDefaultLabel(menuCommand),
+            when: keybindingItem.when ? keybindingItem.when.serialize() : '',
+            source
+        };
+    }
+    static getCommandDefaultLabel(menuCommand) {
+        if (!Language.isDefaultVariant()) {
+            if (menuCommand && menuCommand.title && menuCommand.title.original) {
+                const category = menuCommand.category ? menuCommand.category.original : undefined;
+                const title = menuCommand.title.original;
+                return category ? ( localizeWithPath(
+                    'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+                    'cat.title',
+                    "{0}: {1}",
+                    category,
+                    title
+                )) : title;
+            }
+        }
+        return null;
+    }
+    static getCommandLabel(menuCommand, editorActionLabel) {
+        if (menuCommand) {
+            const category = menuCommand.category ? typeof menuCommand.category === 'string' ? menuCommand.category : menuCommand.category.value : undefined;
+            const title = typeof menuCommand.title === 'string' ? menuCommand.title : menuCommand.title.value;
+            return category ? ( localizeWithPath(
+                'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+                'cat.title',
+                "{0}: {1}",
+                category,
+                title
+            )) : title;
+        }
+        if (editorActionLabel) {
+            return editorActionLabel;
+        }
+        return '';
+    }
+};
+KeybindingsEditorModel = KeybindingsEditorModel_1 = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IExtensionService))
+], KeybindingsEditorModel));
+class KeybindingItemMatches {
+    constructor(modifierLabels, keybindingItem, searchValue, words, keybindingWords, completeMatch) {
+        this.modifierLabels = modifierLabels;
+        this.commandIdMatches = null;
+        this.commandLabelMatches = null;
+        this.commandDefaultLabelMatches = null;
+        this.sourceMatches = null;
+        this.whenMatches = null;
+        this.keybindingMatches = null;
+        this.extensionIdMatches = null;
+        this.extensionLabelMatches = null;
+        if (!completeMatch) {
+            this.commandIdMatches = this.matches(searchValue, keybindingItem.command, or(matchesWords, matchesCamelCase), words);
+            this.commandLabelMatches = keybindingItem.commandLabel ? this.matches(searchValue, keybindingItem.commandLabel, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.commandLabel, true), words) : null;
+            this.commandDefaultLabelMatches = keybindingItem.commandDefaultLabel ? this.matches(searchValue, keybindingItem.commandDefaultLabel, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.commandDefaultLabel, true), words) : null;
+            this.whenMatches = keybindingItem.when ? this.matches(null, keybindingItem.when, or(matchesWords, matchesCamelCase), words) : null;
+            if (isString(keybindingItem.source)) {
+                this.sourceMatches = this.matches(searchValue, keybindingItem.source, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.source, true), words);
+            }
+            else {
+                this.extensionLabelMatches = keybindingItem.source.displayName ? this.matches(searchValue, keybindingItem.source.displayName, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.commandLabel, true), words) : null;
+            }
+        }
+        this.keybindingMatches = keybindingItem.keybinding ? this.matchesKeybinding(keybindingItem.keybinding, searchValue, keybindingWords, completeMatch) : null;
+    }
+    matches(searchValue, wordToMatchAgainst, wordMatchesFilter, words) {
+        let matches = searchValue ? wordFilter(searchValue, wordToMatchAgainst) : null;
+        if (!matches) {
+            matches = this.matchesWords(words, wordToMatchAgainst, wordMatchesFilter);
+        }
+        if (matches) {
+            matches = this.filterAndSort(matches);
+        }
+        return matches;
+    }
+    matchesWords(words, wordToMatchAgainst, wordMatchesFilter) {
+        let matches = [];
+        for (const word of words) {
+            const wordMatches = wordMatchesFilter(word, wordToMatchAgainst);
+            if (wordMatches) {
+                matches = [...(matches || []), ...wordMatches];
+            }
+            else {
+                matches = null;
+                break;
+            }
+        }
+        return matches;
+    }
+    filterAndSort(matches) {
+        return distinct(matches, (a => a.start + '.' + a.end)).filter(match => !( matches.some(
+            m => !(m.start === match.start && m.end === match.end) && (m.start <= match.start && m.end >= match.end)
+        ))).sort((a, b) => a.start - b.start);
+    }
+    matchesKeybinding(keybinding, searchValue, words, completeMatch) {
+        const [firstPart, chordPart] = keybinding.getChords();
+        const userSettingsLabel = keybinding.getUserSettingsLabel();
+        const ariaLabel = keybinding.getAriaLabel();
+        const label = keybinding.getLabel();
+        if ((userSettingsLabel && strings.compareIgnoreCase(searchValue, userSettingsLabel) === 0)
+            || (ariaLabel && strings.compareIgnoreCase(searchValue, ariaLabel) === 0)
+            || (label && strings.compareIgnoreCase(searchValue, label) === 0)) {
+            return {
+                firstPart: this.createCompleteMatch(firstPart),
+                chordPart: this.createCompleteMatch(chordPart)
+            };
+        }
+        const firstPartMatch = {};
+        let chordPartMatch = {};
+        const matchedWords = [];
+        const firstPartMatchedWords = [];
+        let chordPartMatchedWords = [];
+        let matchFirstPart = true;
+        for (let index = 0; index < words.length; index++) {
+            const word = words[index];
+            let firstPartMatched = false;
+            let chordPartMatched = false;
+            matchFirstPart = matchFirstPart && !firstPartMatch.keyCode;
+            let matchChordPart = !chordPartMatch.keyCode;
+            if (matchFirstPart) {
+                firstPartMatched = this.matchPart(firstPart, firstPartMatch, word, completeMatch);
+                if (firstPartMatch.keyCode) {
+                    for (const cordPartMatchedWordIndex of chordPartMatchedWords) {
+                        if (firstPartMatchedWords.indexOf(cordPartMatchedWordIndex) === -1) {
+                            matchedWords.splice(matchedWords.indexOf(cordPartMatchedWordIndex), 1);
+                        }
+                    }
+                    chordPartMatch = {};
+                    chordPartMatchedWords = [];
+                    matchChordPart = false;
+                }
+            }
+            if (matchChordPart) {
+                chordPartMatched = this.matchPart(chordPart, chordPartMatch, word, completeMatch);
+            }
+            if (firstPartMatched) {
+                firstPartMatchedWords.push(index);
+            }
+            if (chordPartMatched) {
+                chordPartMatchedWords.push(index);
+            }
+            if (firstPartMatched || chordPartMatched) {
+                matchedWords.push(index);
+            }
+            matchFirstPart = matchFirstPart && this.isModifier(word);
+        }
+        if (matchedWords.length !== words.length) {
+            return null;
+        }
+        if (completeMatch) {
+            if (!this.isCompleteMatch(firstPart, firstPartMatch)) {
+                return null;
+            }
+            if (!isEmptyObject(chordPartMatch) && !this.isCompleteMatch(chordPart, chordPartMatch)) {
+                return null;
+            }
+        }
+        return this.hasAnyMatch(firstPartMatch) || this.hasAnyMatch(chordPartMatch) ? { firstPart: firstPartMatch, chordPart: chordPartMatch } : null;
+    }
+    matchPart(chord, match, word, completeMatch) {
+        let matched = false;
+        if (this.matchesMetaModifier(chord, word)) {
+            matched = true;
+            match.metaKey = true;
+        }
+        if (this.matchesCtrlModifier(chord, word)) {
+            matched = true;
+            match.ctrlKey = true;
+        }
+        if (this.matchesShiftModifier(chord, word)) {
+            matched = true;
+            match.shiftKey = true;
+        }
+        if (this.matchesAltModifier(chord, word)) {
+            matched = true;
+            match.altKey = true;
+        }
+        if (this.matchesKeyCode(chord, word, completeMatch)) {
+            match.keyCode = true;
+            matched = true;
+        }
+        return matched;
+    }
+    matchesKeyCode(chord, word, completeMatch) {
+        if (!chord) {
+            return false;
+        }
+        const ariaLabel = chord.keyAriaLabel || '';
+        if (completeMatch || ariaLabel.length === 1 || word.length === 1) {
+            if (strings.compareIgnoreCase(ariaLabel, word) === 0) {
+                return true;
+            }
+        }
+        else {
+            if (matchesContiguousSubString(word, ariaLabel)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matchesMetaModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.metaKey) {
+            return false;
+        }
+        return this.wordMatchesMetaModifier(word);
+    }
+    matchesCtrlModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.ctrlKey) {
+            return false;
+        }
+        return this.wordMatchesCtrlModifier(word);
+    }
+    matchesShiftModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.shiftKey) {
+            return false;
+        }
+        return this.wordMatchesShiftModifier(word);
+    }
+    matchesAltModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.altKey) {
+            return false;
+        }
+        return this.wordMatchesAltModifier(word);
+    }
+    hasAnyMatch(keybindingMatch) {
+        return !!keybindingMatch.altKey ||
+            !!keybindingMatch.ctrlKey ||
+            !!keybindingMatch.metaKey ||
+            !!keybindingMatch.shiftKey ||
+            !!keybindingMatch.keyCode;
+    }
+    isCompleteMatch(chord, match) {
+        if (!chord) {
+            return true;
+        }
+        if (!match.keyCode) {
+            return false;
+        }
+        if (chord.metaKey && !match.metaKey) {
+            return false;
+        }
+        if (chord.altKey && !match.altKey) {
+            return false;
+        }
+        if (chord.ctrlKey && !match.ctrlKey) {
+            return false;
+        }
+        if (chord.shiftKey && !match.shiftKey) {
+            return false;
+        }
+        return true;
+    }
+    createCompleteMatch(chord) {
+        const match = {};
+        if (chord) {
+            match.keyCode = true;
+            if (chord.metaKey) {
+                match.metaKey = true;
+            }
+            if (chord.altKey) {
+                match.altKey = true;
+            }
+            if (chord.ctrlKey) {
+                match.ctrlKey = true;
+            }
+            if (chord.shiftKey) {
+                match.shiftKey = true;
+            }
+        }
+        return match;
+    }
+    isModifier(word) {
+        if (this.wordMatchesAltModifier(word)) {
+            return true;
+        }
+        if (this.wordMatchesCtrlModifier(word)) {
+            return true;
+        }
+        if (this.wordMatchesMetaModifier(word)) {
+            return true;
+        }
+        if (this.wordMatchesShiftModifier(word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesAltModifier(word) {
+        if (strings.equalsIgnoreCase(this.modifierLabels.ui.altKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.aria.altKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.user.altKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(( localizeWithPath(
+            'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+            'option',
+            "option"
+        )), word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesCtrlModifier(word) {
+        if (strings.equalsIgnoreCase(this.modifierLabels.ui.ctrlKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.aria.ctrlKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.user.ctrlKey, word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesMetaModifier(word) {
+        if (strings.equalsIgnoreCase(this.modifierLabels.ui.metaKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.aria.metaKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.user.metaKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(( localizeWithPath(
+            'vs/workbench/services/preferences/browser/keybindingsEditorModel',
+            'meta',
+            "meta"
+        )), word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesShiftModifier(word) {
+        if (strings.equalsIgnoreCase(this.modifierLabels.ui.shiftKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.aria.shiftKey, word)) {
+            return true;
+        }
+        if (strings.equalsIgnoreCase(this.modifierLabels.user.shiftKey, word)) {
+            return true;
+        }
+        return false;
+    }
+}
+export { KEYBINDING_ENTRY_TEMPLATE_ID, KeybindingsEditorModel };

package/vscode/src/vs/workbench/services/preferences/common/preferencesEditorInput.js

@@ -0,0 +1,43 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IPreferencesService } from './preferences.js';
+var SettingsEditor2Input_1;
+let SettingsEditor2Input = class SettingsEditor2Input extends EditorInput {
+    static { SettingsEditor2Input_1 = this; }
+    static { this.ID = 'workbench.input.settings2'; }
+    constructor(_preferencesService) {
+        super();
+        this.resource = ( URI.from({
+            scheme: Schemas.vscodeSettings,
+            path: `settingseditor`
+        }));
+        this._settingsModel = _preferencesService.createSettings2EditorModel();
+    }
+    matches(otherInput) {
+        return super.matches(otherInput) || otherInput instanceof SettingsEditor2Input_1;
+    }
+    get typeId() {
+        return SettingsEditor2Input_1.ID;
+    }
+    getName() {
+        return ( nls.localizeWithPath(
+            'vs/workbench/services/preferences/common/preferencesEditorInput',
+            'settingsEditor2InputName',
+            "Settings"
+        ));
+    }
+    async resolve() {
+        return this._settingsModel;
+    }
+    dispose() {
+        this._settingsModel.dispose();
+        super.dispose();
+    }
+};
+SettingsEditor2Input = SettingsEditor2Input_1 = ( __decorate([
+    ( __param(0, IPreferencesService))
+], SettingsEditor2Input));
+export { SettingsEditor2Input };

package/vscode/src/vs/workbench/services/search/common/search.js

@@ -1,6 +1,6 @@
 import { mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
-import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import * as Objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as extpath from 'monaco-editor/esm/vs/base/common/extpath.js';
 import { getNLines } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -104,8 +104,8 @@ function getExcludes(configuration, includeSearchExcludes = true) {
         return fileExcludes || searchExcludes;
     }
     let allExcludes = Object.create(null);
-    allExcludes = objects.mixin(allExcludes, objects.deepClone(fileExcludes));
-    allExcludes = objects.mixin(allExcludes, objects.deepClone(searchExcludes), true);
+    allExcludes = Objects.mixin(allExcludes, Objects.deepClone(fileExcludes));
+    allExcludes = Objects.mixin(allExcludes, Objects.deepClone(searchExcludes), true);
     return allExcludes;
 }
 function pathIncludedInQuery(queryProps, fsPath) {