monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/standaloneStrings.js

@@ -0,0 +1,42 @@
+import { localize } from '../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var InspectTokensNLS;
+(function (InspectTokensNLS) {
+    InspectTokensNLS.inspectTokensAction = localize(786, "Developer: Inspect Tokens");
+})(InspectTokensNLS || (InspectTokensNLS = {}));
+var GoToLineNLS;
+(function (GoToLineNLS) {
+    GoToLineNLS.gotoLineActionLabel = localize(787, "Go to Line/Column...");
+})(GoToLineNLS || (GoToLineNLS = {}));
+var QuickHelpNLS;
+(function (QuickHelpNLS) {
+    QuickHelpNLS.helpQuickAccessActionLabel = localize(788, "Show all Quick Access Providers");
+})(QuickHelpNLS || (QuickHelpNLS = {}));
+var QuickCommandNLS;
+(function (QuickCommandNLS) {
+    QuickCommandNLS.quickCommandActionLabel = localize(789, "Command Palette");
+    QuickCommandNLS.quickCommandHelp = localize(790, "Show And Run Commands");
+})(QuickCommandNLS || (QuickCommandNLS = {}));
+var QuickOutlineNLS;
+(function (QuickOutlineNLS) {
+    QuickOutlineNLS.quickOutlineActionLabel = localize(791, "Go to Symbol...");
+    QuickOutlineNLS.quickOutlineByCategoryActionLabel = localize(792, "Go to Symbol by Category...");
+})(QuickOutlineNLS || (QuickOutlineNLS = {}));
+var StandaloneCodeEditorNLS;
+(function (StandaloneCodeEditorNLS) {
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = localize(793, "Editor content");
+})(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}));
+var ToggleHighContrastNLS;
+(function (ToggleHighContrastNLS) {
+    ToggleHighContrastNLS.toggleHighContrast = localize(794, "Toggle High Contrast Theme");
+})(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}));
+var StandaloneServicesNLS;
+(function (StandaloneServicesNLS) {
+    StandaloneServicesNLS.bulkEditServiceSummary = localize(795, "Made {0} edits in {1} files");
+})(StandaloneServicesNLS || (StandaloneServicesNLS = {}));
+
+export { GoToLineNLS, InspectTokensNLS, QuickCommandNLS, QuickHelpNLS, QuickOutlineNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/dist/workers/standaloneTheme.js

@@ -0,0 +1,9 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const IStandaloneThemeService = createDecorator('themeService');
+
+export { IStandaloneThemeService };

package/dist/workers/standaloneThemeService.js

@@ -0,0 +1,367 @@
+import { isInShadowDOM } from '../../../base/browser/dom.js';
+import { createStyleSheet } from '../../../base/browser/domStylesheets.js';
+import { addMatchMediaChangeListener } from '../../../base/browser/browser.js';
+import { Color } from '../../../base/common/color.js';
+import { Emitter } from '../../../base/common/event.js';
+import { TokenizationRegistry } from '../../common/languages.js';
+import { TokenMetadata } from '../../common/encodedTokenAttributes.js';
+import { generateTokensCSSForColorMap, TokenTheme } from '../../common/languages/supports/tokenization.js';
+import { hc_light, hc_black, vs_dark, vs } from '../common/themes.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+import { Extensions, asCssVariableName } from '../../../platform/theme/common/colorUtils.js';
+import '../../../platform/theme/common/colors/baseColors.js';
+import '../../../platform/theme/common/colors/chartsColors.js';
+import '../../../platform/theme/common/colors/editorColors.js';
+import '../../../platform/theme/common/colors/inputColors.js';
+import '../../../platform/theme/common/colors/listColors.js';
+import '../../../platform/theme/common/colors/menuColors.js';
+import '../../../platform/theme/common/colors/minimapColors.js';
+import '../../../platform/theme/common/colors/miscColors.js';
+import '../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../platform/theme/common/colors/searchColors.js';
+import { Extensions as Extensions$1 } from '../../../platform/theme/common/themeService.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { isHighContrast, isDark, ColorScheme } from '../../../platform/theme/common/theme.js';
+import { UnthemedProductIconTheme, getIconsStyleSheet } from '../../../platform/theme/browser/iconsStyleSheet.js';
+import { mainWindow } from '../../../base/browser/window.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const VS_LIGHT_THEME_NAME = 'vs';
+const VS_DARK_THEME_NAME = 'vs-dark';
+const HC_BLACK_THEME_NAME = 'hc-black';
+const HC_LIGHT_THEME_NAME = 'hc-light';
+const colorRegistry = Registry.as(Extensions.ColorContribution);
+const themingRegistry = Registry.as(Extensions$1.ThemingContribution);
+class StandaloneTheme {
+    constructor(name, standaloneThemeData) {
+        this.semanticHighlighting = false;
+        this.themeData = standaloneThemeData;
+        const base = standaloneThemeData.base;
+        if (name.length > 0) {
+            if (isBuiltinTheme(name)) {
+                this.id = name;
+            }
+            else {
+                this.id = base + ' ' + name;
+            }
+            this.themeName = name;
+        }
+        else {
+            this.id = base;
+            this.themeName = base;
+        }
+        this.colors = null;
+        this.defaultColors = Object.create(null);
+        this._tokenTheme = null;
+    }
+    get base() {
+        return this.themeData.base;
+    }
+    notifyBaseUpdated() {
+        if (this.themeData.inherit) {
+            this.colors = null;
+            this._tokenTheme = null;
+        }
+    }
+    getColors() {
+        if (!this.colors) {
+            const colors = new Map();
+            for (const id in this.themeData.colors) {
+                colors.set(id, Color.fromHex(this.themeData.colors[id]));
+            }
+            if (this.themeData.inherit) {
+                const baseData = getBuiltinRules(this.themeData.base);
+                for (const id in baseData.colors) {
+                    if (!colors.has(id)) {
+                        colors.set(id, Color.fromHex(baseData.colors[id]));
+                    }
+                }
+            }
+            this.colors = colors;
+        }
+        return this.colors;
+    }
+    getColor(colorId, useDefault) {
+        const color = this.getColors().get(colorId);
+        if (color) {
+            return color;
+        }
+        if (useDefault !== false) {
+            return this.getDefault(colorId);
+        }
+        return undefined;
+    }
+    getDefault(colorId) {
+        let color = this.defaultColors[colorId];
+        if (color) {
+            return color;
+        }
+        color = colorRegistry.resolveDefaultColor(colorId, this);
+        this.defaultColors[colorId] = color;
+        return color;
+    }
+    defines(colorId) {
+        return this.getColors().has(colorId);
+    }
+    get type() {
+        switch (this.base) {
+            case VS_LIGHT_THEME_NAME: return ColorScheme.LIGHT;
+            case HC_BLACK_THEME_NAME: return ColorScheme.HIGH_CONTRAST_DARK;
+            case HC_LIGHT_THEME_NAME: return ColorScheme.HIGH_CONTRAST_LIGHT;
+            default: return ColorScheme.DARK;
+        }
+    }
+    get tokenTheme() {
+        if (!this._tokenTheme) {
+            let rules = [];
+            let encodedTokensColors = [];
+            if (this.themeData.inherit) {
+                const baseData = getBuiltinRules(this.themeData.base);
+                rules = baseData.rules;
+                if (baseData.encodedTokensColors) {
+                    encodedTokensColors = baseData.encodedTokensColors;
+                }
+            }
+            // Pick up default colors from `editor.foreground` and `editor.background` if available
+            const editorForeground = this.themeData.colors['editor.foreground'];
+            const editorBackground = this.themeData.colors['editor.background'];
+            if (editorForeground || editorBackground) {
+                const rule = { token: '' };
+                if (editorForeground) {
+                    rule.foreground = editorForeground;
+                }
+                if (editorBackground) {
+                    rule.background = editorBackground;
+                }
+                rules.push(rule);
+            }
+            rules = rules.concat(this.themeData.rules);
+            if (this.themeData.encodedTokensColors) {
+                encodedTokensColors = this.themeData.encodedTokensColors;
+            }
+            this._tokenTheme = TokenTheme.createFromRawTokenTheme(rules, encodedTokensColors);
+        }
+        return this._tokenTheme;
+    }
+    getTokenStyleMetadata(type, modifiers, modelLanguage) {
+        // use theme rules match
+        const style = this.tokenTheme._match([type].concat(modifiers).join('.'));
+        const metadata = style.metadata;
+        const foreground = TokenMetadata.getForeground(metadata);
+        const fontStyle = TokenMetadata.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 */)
+        };
+    }
+    get tokenColorMap() {
+        return [];
+    }
+}
+function isBuiltinTheme(themeName) {
+    return (themeName === VS_LIGHT_THEME_NAME
+        || themeName === VS_DARK_THEME_NAME
+        || themeName === HC_BLACK_THEME_NAME
+        || themeName === HC_LIGHT_THEME_NAME);
+}
+function getBuiltinRules(builtinTheme) {
+    switch (builtinTheme) {
+        case VS_LIGHT_THEME_NAME:
+            return vs;
+        case VS_DARK_THEME_NAME:
+            return vs_dark;
+        case HC_BLACK_THEME_NAME:
+            return hc_black;
+        case HC_LIGHT_THEME_NAME:
+            return hc_light;
+    }
+}
+function newBuiltInTheme(builtinTheme) {
+    const themeData = getBuiltinRules(builtinTheme);
+    return new StandaloneTheme(builtinTheme, themeData);
+}
+class StandaloneThemeService extends Disposable {
+    constructor() {
+        super();
+        this._onColorThemeChange = this._register(new Emitter());
+        this.onDidColorThemeChange = this._onColorThemeChange.event;
+        this._onProductIconThemeChange = this._register(new Emitter());
+        this.onDidProductIconThemeChange = this._onProductIconThemeChange.event;
+        this._environment = Object.create(null);
+        this._builtInProductIconTheme = new UnthemedProductIconTheme();
+        this._autoDetectHighContrast = true;
+        this._knownThemes = new Map();
+        this._knownThemes.set(VS_LIGHT_THEME_NAME, newBuiltInTheme(VS_LIGHT_THEME_NAME));
+        this._knownThemes.set(VS_DARK_THEME_NAME, newBuiltInTheme(VS_DARK_THEME_NAME));
+        this._knownThemes.set(HC_BLACK_THEME_NAME, newBuiltInTheme(HC_BLACK_THEME_NAME));
+        this._knownThemes.set(HC_LIGHT_THEME_NAME, newBuiltInTheme(HC_LIGHT_THEME_NAME));
+        const iconsStyleSheet = this._register(getIconsStyleSheet(this));
+        this._codiconCSS = iconsStyleSheet.getCSS();
+        this._themeCSS = '';
+        this._allCSS = `${this._codiconCSS}\n${this._themeCSS}`;
+        this._globalStyleElement = null;
+        this._styleElements = [];
+        this._colorMapOverride = null;
+        this.setTheme(VS_LIGHT_THEME_NAME);
+        this._onOSSchemeChanged();
+        this._register(iconsStyleSheet.onDidChange(() => {
+            this._codiconCSS = iconsStyleSheet.getCSS();
+            this._updateCSS();
+        }));
+        addMatchMediaChangeListener(mainWindow, '(forced-colors: active)', () => {
+            // Update theme selection for auto-detecting high contrast
+            this._onOSSchemeChanged();
+        });
+    }
+    registerEditorContainer(domNode) {
+        if (isInShadowDOM(domNode)) {
+            return this._registerShadowDomContainer(domNode);
+        }
+        return this._registerRegularEditorContainer();
+    }
+    _registerRegularEditorContainer() {
+        if (!this._globalStyleElement) {
+            this._globalStyleElement = createStyleSheet(undefined, style => {
+                style.className = 'monaco-colors';
+                style.textContent = this._allCSS;
+            });
+            this._styleElements.push(this._globalStyleElement);
+        }
+        return Disposable.None;
+    }
+    _registerShadowDomContainer(domNode) {
+        const styleElement = createStyleSheet(domNode, style => {
+            style.className = 'monaco-colors';
+            style.textContent = this._allCSS;
+        });
+        this._styleElements.push(styleElement);
+        return {
+            dispose: () => {
+                for (let i = 0; i < this._styleElements.length; i++) {
+                    if (this._styleElements[i] === styleElement) {
+                        this._styleElements.splice(i, 1);
+                        return;
+                    }
+                }
+            }
+        };
+    }
+    defineTheme(themeName, themeData) {
+        if (!/^[a-z0-9\-]+$/i.test(themeName)) {
+            throw new Error('Illegal theme name!');
+        }
+        if (!isBuiltinTheme(themeData.base) && !isBuiltinTheme(themeName)) {
+            throw new Error('Illegal theme base!');
+        }
+        // set or replace theme
+        this._knownThemes.set(themeName, new StandaloneTheme(themeName, themeData));
+        if (isBuiltinTheme(themeName)) {
+            this._knownThemes.forEach(theme => {
+                if (theme.base === themeName) {
+                    theme.notifyBaseUpdated();
+                }
+            });
+        }
+        if (this._theme.themeName === themeName) {
+            this.setTheme(themeName); // refresh theme
+        }
+    }
+    getColorTheme() {
+        return this._theme;
+    }
+    setColorMapOverride(colorMapOverride) {
+        this._colorMapOverride = colorMapOverride;
+        this._updateThemeOrColorMap();
+    }
+    setTheme(themeName) {
+        let theme;
+        if (this._knownThemes.has(themeName)) {
+            theme = this._knownThemes.get(themeName);
+        }
+        else {
+            theme = this._knownThemes.get(VS_LIGHT_THEME_NAME);
+        }
+        this._updateActualTheme(theme);
+    }
+    _updateActualTheme(desiredTheme) {
+        if (!desiredTheme || this._theme === desiredTheme) {
+            // Nothing to do
+            return;
+        }
+        this._theme = desiredTheme;
+        this._updateThemeOrColorMap();
+    }
+    _onOSSchemeChanged() {
+        if (this._autoDetectHighContrast) {
+            const wantsHighContrast = mainWindow.matchMedia(`(forced-colors: active)`).matches;
+            if (wantsHighContrast !== isHighContrast(this._theme.type)) {
+                // switch to high contrast or non-high contrast but stick to dark or light
+                let newThemeName;
+                if (isDark(this._theme.type)) {
+                    newThemeName = wantsHighContrast ? HC_BLACK_THEME_NAME : VS_DARK_THEME_NAME;
+                }
+                else {
+                    newThemeName = wantsHighContrast ? HC_LIGHT_THEME_NAME : VS_LIGHT_THEME_NAME;
+                }
+                this._updateActualTheme(this._knownThemes.get(newThemeName));
+            }
+        }
+    }
+    setAutoDetectHighContrast(autoDetectHighContrast) {
+        this._autoDetectHighContrast = autoDetectHighContrast;
+        this._onOSSchemeChanged();
+    }
+    _updateThemeOrColorMap() {
+        const cssRules = [];
+        const hasRule = {};
+        const ruleCollector = {
+            addRule: (rule) => {
+                if (!hasRule[rule]) {
+                    cssRules.push(rule);
+                    hasRule[rule] = true;
+                }
+            }
+        };
+        themingRegistry.getThemingParticipants().forEach(p => p(this._theme, ruleCollector, this._environment));
+        const colorVariables = [];
+        for (const item of colorRegistry.getColors()) {
+            const color = this._theme.getColor(item.id, true);
+            if (color) {
+                colorVariables.push(`${asCssVariableName(item.id)}: ${color.toString()};`);
+            }
+        }
+        ruleCollector.addRule(`.monaco-editor, .monaco-diff-editor, .monaco-component { ${colorVariables.join('\n')} }`);
+        const colorMap = this._colorMapOverride || this._theme.tokenTheme.getColorMap();
+        ruleCollector.addRule(generateTokensCSSForColorMap(colorMap));
+        // If the OS has forced-colors active, disable forced color adjustment for
+        // Monaco editor elements so that VS Code's built-in high contrast themes
+        // (hc-black / hc-light) are used instead of the OS forcing system colors.
+        ruleCollector.addRule(`.monaco-editor, .monaco-diff-editor, .monaco-component { forced-color-adjust: none; }`);
+        this._themeCSS = cssRules.join('\n');
+        this._updateCSS();
+        TokenizationRegistry.setColorMap(colorMap);
+        this._onColorThemeChange.fire(this._theme);
+    }
+    _updateCSS() {
+        this._allCSS = `${this._codiconCSS}\n${this._themeCSS}`;
+        this._styleElements.forEach(styleElement => styleElement.textContent = this._allCSS);
+    }
+    getFileIconTheme() {
+        return {
+            hasFileIcons: false,
+            hasFolderIcons: false,
+            hidesExplorerArrows: false
+        };
+    }
+    getProductIconTheme() {
+        return this._builtInProductIconTheme;
+    }
+}
+
+export { HC_BLACK_THEME_NAME, HC_LIGHT_THEME_NAME, StandaloneThemeService, VS_DARK_THEME_NAME, VS_LIGHT_THEME_NAME };

package/dist/workers/standaloneTreeSitterLibraryService.js

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class StandaloneTreeSitterLibraryService {
+    getParserClass() {
+        throw new Error('not implemented in StandaloneTreeSitterLibraryService');
+    }
+    supportsLanguage(languageId, reader) {
+        return false;
+    }
+    getLanguage(languageId, ignoreSupportsCheck, reader) {
+        return undefined;
+    }
+    getInjectionQueries(languageId, reader) {
+        return null;
+    }
+    getHighlightingQueries(languageId, reader) {
+        return null;
+    }
+}
+
+export { StandaloneTreeSitterLibraryService };

package/dist/workers/standaloneWebWorker.js

@@ -0,0 +1,55 @@
+import { EditorWorkerClient } from '../../browser/services/editorWorkerService.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Create a new web worker that has model syncing capabilities built in.
+ * Specify an AMD module to load that will `create` an object that will be proxied.
+ */
+function createWebWorker(modelService, opts) {
+    return new MonacoWebWorkerImpl(modelService, opts);
+}
+class MonacoWebWorkerImpl extends EditorWorkerClient {
+    constructor(modelService, opts) {
+        super(opts.worker, opts.keepIdleModels || false, modelService);
+        this._foreignModuleHost = opts.host || null;
+        this._foreignProxy = this._getProxy().then(proxy => {
+            return new Proxy({}, {
+                get(target, prop, receiver) {
+                    if (prop === 'then') {
+                        // Don't forward the call when the proxy is returned in an async function and the runtime tries to .then it.
+                        return undefined;
+                    }
+                    if (typeof prop !== 'string') {
+                        throw new Error(`Not supported`);
+                    }
+                    return (...args) => {
+                        return proxy.$fmr(prop, args);
+                    };
+                }
+            });
+        });
+    }
+    // foreign host request
+    fhr(method, args) {
+        if (!this._foreignModuleHost || typeof this._foreignModuleHost[method] !== 'function') {
+            return Promise.reject(new Error('Missing method ' + method + ' or missing main thread foreign host.'));
+        }
+        try {
+            return Promise.resolve(this._foreignModuleHost[method].apply(this._foreignModuleHost, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    getProxy() {
+        return this._foreignProxy;
+    }
+    withSyncedResources(resources) {
+        return this.workerWithSyncedResources(resources).then(_ => this.getProxy());
+    }
+}
+
+export { createWebWorker };

package/dist/workers/stickyScrollActions.js

@@ -0,0 +1,132 @@
+import { EditorAction2 } from '../../../browser/editorExtensions.js';
+import { localize, localize2 } from '../../../../nls.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { StickyScrollController } from './stickyScrollController.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ToggleStickyScroll extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.action.toggleStickyScroll',
+            title: {
+                ...localize2(1448, "Toggle Editor Sticky Scroll"),
+                mnemonicTitle: localize(1444, "&&Toggle Editor Sticky Scroll"),
+            },
+            metadata: {
+                description: localize2(1449, "Toggle/enable the editor sticky scroll which shows the nested scopes at the top of the viewport"),
+            },
+            category: Categories.View,
+            toggled: {
+                condition: ContextKeyExpr.equals('config.editor.stickyScroll.enabled', true),
+                title: localize(1445, "Sticky Scroll"),
+                mnemonicTitle: localize(1446, "&&Sticky Scroll"),
+            },
+            menu: [
+                { id: MenuId.CommandPalette },
+                { id: MenuId.MenubarAppearanceMenu, group: '4_editor', order: 3 },
+                { id: MenuId.StickyScrollContext }
+            ]
+        });
+    }
+    async runEditorCommand(accessor, editor) {
+        const configurationService = accessor.get(IConfigurationService);
+        const newValue = !configurationService.getValue('editor.stickyScroll.enabled');
+        const isFocused = StickyScrollController.get(editor)?.isFocused();
+        configurationService.updateValue('editor.stickyScroll.enabled', newValue);
+        if (isFocused) {
+            editor.focus();
+        }
+    }
+}
+const weight = 100 /* KeybindingWeight.EditorContrib */;
+class FocusStickyScroll extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.action.focusStickyScroll',
+            title: {
+                ...localize2(1450, "Focus Editor Sticky Scroll"),
+                mnemonicTitle: localize(1447, "&&Focus Editor Sticky Scroll"),
+            },
+            precondition: ContextKeyExpr.and(ContextKeyExpr.has('config.editor.stickyScroll.enabled'), EditorContextKeys.stickyScrollVisible),
+            menu: [
+                { id: MenuId.CommandPalette },
+            ]
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        StickyScrollController.get(editor)?.focus();
+    }
+}
+class SelectNextStickyScrollLine extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.action.selectNextStickyScrollLine',
+            title: localize2(1451, "Select the next editor sticky scroll line"),
+            precondition: EditorContextKeys.stickyScrollFocused.isEqualTo(true),
+            keybinding: {
+                weight,
+                primary: 18 /* KeyCode.DownArrow */
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        StickyScrollController.get(editor)?.focusNext();
+    }
+}
+class SelectPreviousStickyScrollLine extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.action.selectPreviousStickyScrollLine',
+            title: localize2(1452, "Select the previous sticky scroll line"),
+            precondition: EditorContextKeys.stickyScrollFocused.isEqualTo(true),
+            keybinding: {
+                weight,
+                primary: 16 /* KeyCode.UpArrow */
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        StickyScrollController.get(editor)?.focusPrevious();
+    }
+}
+class GoToStickyScrollLine extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.action.goToFocusedStickyScrollLine',
+            title: localize2(1453, "Go to the focused sticky scroll line"),
+            precondition: EditorContextKeys.stickyScrollFocused.isEqualTo(true),
+            keybinding: {
+                weight,
+                primary: 3 /* KeyCode.Enter */
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        StickyScrollController.get(editor)?.goToFocused();
+    }
+}
+class SelectEditor extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.action.selectEditor',
+            title: localize2(1454, "Select Editor"),
+            precondition: EditorContextKeys.stickyScrollFocused.isEqualTo(true),
+            keybinding: {
+                weight,
+                primary: 9 /* KeyCode.Escape */
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        StickyScrollController.get(editor)?.selectEditor();
+    }
+}
+
+export { FocusStickyScroll, GoToStickyScrollLine, SelectEditor, SelectNextStickyScrollLine, SelectPreviousStickyScrollLine, ToggleStickyScroll };

package/dist/workers/stickyScrollContribution.js

@@ -0,0 +1,16 @@
+import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { ToggleStickyScroll, FocusStickyScroll, SelectPreviousStickyScrollLine, SelectNextStickyScrollLine, GoToStickyScrollLine, SelectEditor } from './stickyScrollActions.js';
+import { StickyScrollController } from './stickyScrollController.js';
+import { registerAction2 } from '../../../../platform/actions/common/actions.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+registerEditorContribution(StickyScrollController.ID, StickyScrollController, 1 /* EditorContributionInstantiation.AfterFirstRender */);
+registerAction2(ToggleStickyScroll);
+registerAction2(FocusStickyScroll);
+registerAction2(SelectPreviousStickyScrollLine);
+registerAction2(SelectNextStickyScrollLine);
+registerAction2(GoToStickyScrollLine);
+registerAction2(SelectEditor);