@codingame/monaco-vscode-api 1.83.8 → 1.83.9

package/service-override/layout.js

@@ -1,229 +0,0 @@
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { isAncestorUsingFlowTo } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { IPaneCompositePartService } from '../vscode/src/vs/workbench/services/panecomposite/browser/panecomposite.js';
-import { IViewDescriptorService } from '../vscode/src/vs/workbench/common/views.js';
-import { isChrome, isFirefox, isSafari, isWindows, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { IEditorGroupsService } from '../vscode/src/vs/workbench/services/editor/common/editorGroupsService.js';
-import { IStatusbarService } from '../vscode/src/vs/workbench/services/statusbar/browser/statusbar.js';
-import { onRenderWorkbench } from '../lifecycle.js';
-import { getWorkbenchContainer } from '../workbench.js';
-class LayoutService {
-    constructor(container = getWorkbenchContainer()) {
-        this.container = container;
-        this.onDidChangeFullscreen = Event.None;
-        this.onDidChangeZenMode = Event.None;
-        this.onDidChangeWindowMaximized = Event.None;
-        this.onDidChangeCenteredLayout = Event.None;
-        this.onDidChangePanelPosition = Event.None;
-        this.onDidChangePanelAlignment = Event.None;
-        this.onDidChangeNotificationsVisibility = Event.None;
-        this.openedDefaultEditors = false;
-        this.whenRestored = Promise.resolve();
-        this.parts = new Map();
-        this.hiddenParts = new Set();
-        this._onDidChangePartVisibility = new Emitter();
-        this.onDidChangePartVisibility = this._onDidChangePartVisibility.event;
-        this.offset = { top: 0, quickPickTop: 0 };
-        this._onDidLayout = new Emitter();
-        this.onDidLayout = this._onDidLayout.event;
-        window.addEventListener('resize', () => this.layout());
-        this.layout();
-    }
-    init(accessor) {
-        this.editorGroupService = accessor.get(IEditorGroupsService);
-        this.paneCompositeService = accessor.get(IPaneCompositePartService);
-        this.statusBarService = accessor.get(IStatusbarService);
-        this.viewDescriptorService = accessor.get(IViewDescriptorService);
-    }
-    focusPart(part) {
-        switch (part) {
-            case "workbench.parts.editor" :
-                this.editorGroupService.activeGroup.focus();
-                break;
-            case "workbench.parts.panel" : {
-                const activePanel = this.paneCompositeService.getActivePaneComposite(1 );
-                activePanel?.focus();
-                break;
-            }
-            case "workbench.parts.sidebar" : {
-                const activeViewlet = this.paneCompositeService.getActivePaneComposite(0 );
-                activeViewlet?.focus();
-                break;
-            }
-            case "workbench.parts.activitybar" :
-                this.getPart("workbench.parts.activitybar" ).focus();
-                break;
-            case "workbench.parts.statusbar" :
-                this.statusBarService.focus();
-                break;
-            default: {
-                const container = this.getContainer(part);
-                container?.focus();
-            }
-        }
-    }
-    getDimension(part) {
-        return this.getPart(part).dimension;
-    }
-    toggleMaximizedPanel() {
-    }
-    hasWindowBorder() {
-        return false;
-    }
-    getWindowBorderWidth() {
-        return 0;
-    }
-    getWindowBorderRadius() {
-        return undefined;
-    }
-    toggleMenuBar() {
-    }
-    setPanelPosition() {
-    }
-    getPanelAlignment() {
-        return 'left';
-    }
-    setPanelAlignment() {
-    }
-    toggleZenMode() {
-    }
-    isEditorLayoutCentered() {
-        return false;
-    }
-    centerEditorLayout() {
-    }
-    resizePart() {
-    }
-    isWindowMaximized() {
-        return false;
-    }
-    updateWindowMaximizedState() {
-    }
-    getVisibleNeighborPart() {
-        return undefined;
-    }
-    getMaximumEditorDimensions() {
-        return new dom.Dimension(Infinity, Infinity);
-    }
-    isPanelMaximized() {
-        return false;
-    }
-    getPanelPosition() {
-        return 2 ;
-    }
-    hasFocus(part) {
-        const activeElement = document.activeElement;
-        if (activeElement == null) {
-            return false;
-        }
-        const container = this.getContainer(part);
-        return !(container == null) && isAncestorUsingFlowTo(activeElement, container);
-    }
-    getContainer(part) {
-        if (this.parts.get(part) == null) {
-            return undefined;
-        }
-        return this.getPart(part).getContainer();
-    }
-    getPart(key) {
-        const part = this.parts.get(key);
-        if (part == null) {
-            throw new Error(`Unknown part ${key}`);
-        }
-        return part;
-    }
-    hasViews(id) {
-        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
-        if (viewContainer == null) {
-            return false;
-        }
-        const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
-        if (viewContainerModel == null) {
-            return false;
-        }
-        return viewContainerModel.activeViewDescriptors.length >= 1;
-    }
-    setPartHidden(hidden, part) {
-        if (hidden) {
-            this.hiddenParts.add(part);
-        }
-        else {
-            this.hiddenParts.delete(part);
-        }
-        this._onDidChangePartVisibility.fire();
-        const location = {
-            ["workbench.parts.sidebar" ]: 0 ,
-            ["workbench.parts.auxiliarybar" ]: 2 ,
-            ["workbench.parts.panel" ]: 1
-        }[part];
-        if (location != null) {
-            const paneComposite = this.paneCompositeService.getActivePaneComposite(location);
-            if (paneComposite != null && hidden) {
-                this.paneCompositeService.hideActivePaneComposite(location);
-            }
-            else if (paneComposite == null && !hidden) {
-                let panelToOpen = this.paneCompositeService.getLastActivePaneCompositeId(location);
-                if (panelToOpen == null || !this.hasViews(panelToOpen)) {
-                    panelToOpen = this.viewDescriptorService
-                        .getViewContainersByLocation(location)
-                        .find(viewContainer => this.hasViews(viewContainer.id))?.id;
-                }
-                if (panelToOpen != null) {
-                    void this.paneCompositeService.openPaneComposite(panelToOpen, location, true);
-                }
-            }
-        }
-        this.getPart(part).setVisible(!hidden);
-    }
-    isVisible(part) {
-        return !( this.hiddenParts.has(part));
-    }
-    getSideBarPosition() {
-        return 0 ;
-    }
-    registerPart(part) {
-        this.parts.set(part.getId(), part);
-    }
-    isRestored() {
-        return true;
-    }
-    get dimension() { return this._dimension; }
-    layout() {
-        this._dimension = dom.getClientArea(window.document.body);
-        this._onDidLayout.fire(this._dimension);
-    }
-    get hasContainer() {
-        return true;
-    }
-    focus() {
-        StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor()?.focus();
-    }
-}
-onRenderWorkbench((accessor) => {
-    const layoutService = accessor.get(ILayoutService);
-    if (layoutService instanceof LayoutService) {
-        layoutService.init(accessor);
-    }
-    const platformClass = isWindows ? 'windows' : isLinux ? 'linux' : 'mac';
-    const workbenchClasses = coalesce([
-        'monaco-workbench',
-        platformClass,
-        'web',
-        isChrome ? 'chromium' : isFirefox ? 'firefox' : isSafari ? 'safari' : undefined
-    ]);
-    layoutService.container.classList.add(...workbenchClasses);
-    document.body.classList.add(platformClass);
-    document.body.classList.add('web');
-});
-function getServiceOverride(container) {
-    return {
-        [( ILayoutService.toString())]: new SyncDescriptor(LayoutService, [container], true)
-    };
-}
-export { LayoutService, getServiceOverride as default };

package/service-override/output.js

@@ -1,23 +0,0 @@
-import { __decorate, __param } from '../external/tslib/tslib.es6.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ILoggerService, getLogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { FileLoggerService } from '../vscode/src/vs/platform/log/common/fileLog.js';
-import '../vscode/src/vs/workbench/contrib/output/browser/output.contribution.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { logsPath } from '../workbench.js';
-let _FileLoggerService = class _FileLoggerService extends FileLoggerService {
-    constructor(logLevel, fileService, environmentService) {
-        super(logLevel ?? getLogLevel(environmentService), logsPath, fileService);
-    }
-};
-_FileLoggerService = __decorate([
-    ( __param(1, IFileService)),
-    ( __param(2, IEnvironmentService))
-], _FileLoggerService);
-function getServiceOverride(logLevel) {
-    return {
-        [( ILoggerService.toString())]: new SyncDescriptor(_FileLoggerService, [logLevel], true)
-    };
-}
-export { getServiceOverride as default };

package/service-override/quickaccess.js

@@ -1,98 +0,0 @@
-import { __decorate, __param } from '../external/tslib/tslib.es6.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { StandaloneQuickInputService } from 'monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { QuickInputService } from '../vscode/src/vs/workbench/services/quickinput/browser/quickInputService.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { StandaloneCodeEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
-import { CommandsQuickAccessProvider } from '../vscode/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js';
-import '../vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoLineQuickAccess.js';
-import '../vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js';
-import '../vscode/src/vs/workbench/browser/actions/quickAccessActions.js';
-import '../vscode/src/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js';
-let isKeybindingConfigurationVisible = () => {
-    return false;
-};
-let shouldUseGlobalPicker = (_activeCodeEditor, _activeCodeEditorStandalone) => {
-    return false;
-};
-const original = CommandsQuickAccessProvider.prototype['getCommandPicks'];
-CommandsQuickAccessProvider.prototype['getCommandPicks'] = async function (token) {
-    let result = await original.call(this, token);
-    if (!isKeybindingConfigurationVisible()) {
-        result = ( result.map(picks => ({
-            ...picks,
-            buttons: picks.buttons?.filter(button => button.tooltip !== 'Configure Keybinding')
-        })));
-    }
-    return result;
-};
-let DelegateQuickInputService = class DelegateQuickInputService {
-    constructor(instantiationService) {
-        this.instantiationService = instantiationService;
-        this.workbenchQuickInputService = instantiationService.createInstance(QuickInputService);
-    }
-    get activeService() {
-        const activeCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
-        if (activeCodeEditor == null || shouldUseGlobalPicker(activeCodeEditor, activeCodeEditor instanceof StandaloneCodeEditor)) {
-            return this.workbenchQuickInputService;
-        }
-        this.standaloneQuickInputService ?? (this.standaloneQuickInputService = this.instantiationService.createInstance(StandaloneQuickInputService));
-        return this.standaloneQuickInputService;
-    }
-    get quickAccess() { return this.activeService.quickAccess; }
-    get backButton() { return this.activeService.backButton; }
-    get onShow() { return this.activeService.onShow; }
-    get onHide() { return this.activeService.onHide; }
-    createQuickWidget() {
-        return this.activeService.createQuickWidget();
-    }
-    pick(picks, options = {}, token = CancellationToken.None) {
-        return this.activeService .pick(picks, options, token);
-    }
-    input(options, token) {
-        return this.activeService.input(options, token);
-    }
-    createQuickPick() {
-        return this.activeService.createQuickPick();
-    }
-    createInputBox() {
-        return this.activeService.createInputBox();
-    }
-    focus() {
-        return this.activeService.focus();
-    }
-    toggle() {
-        return this.activeService.toggle();
-    }
-    navigate(next, quickNavigate) {
-        return this.activeService.navigate(next, quickNavigate);
-    }
-    accept() {
-        return this.activeService.accept();
-    }
-    back() {
-        return this.activeService.back();
-    }
-    cancel() {
-        return this.activeService.cancel();
-    }
-};
-DelegateQuickInputService = __decorate([
-    ( __param(0, IInstantiationService))
-], DelegateQuickInputService);
-function getServiceOverride({ isKeybindingConfigurationVisible: _isKeybindingConfigurationVisible, shouldUseGlobalPicker: _shouldUseGlobalPicker } = {}) {
-    if (_isKeybindingConfigurationVisible != null) {
-        isKeybindingConfigurationVisible = _isKeybindingConfigurationVisible;
-    }
-    if (_shouldUseGlobalPicker != null) {
-        shouldUseGlobalPicker = _shouldUseGlobalPicker;
-    }
-    return {
-        [( IQuickInputService.toString())]: new SyncDescriptor(DelegateQuickInputService, [], true)
-    };
-}
-export { getServiceOverride as default };

package/vscode/src/vs/base/common/console.js

@@ -1,58 +0,0 @@
-function parse(entry) {
-    const args = [];
-    let stack;
-    try {
-        const parsedArguments = JSON.parse(entry.arguments);
-        const stackArgument = parsedArguments[parsedArguments.length - 1];
-        if (stackArgument && stackArgument.__$stack) {
-            parsedArguments.pop();
-            stack = stackArgument.__$stack;
-        }
-        args.push(...parsedArguments);
-    }
-    catch (error) {
-        args.push('Unable to log remote console arguments', entry.arguments);
-    }
-    return { args, stack };
-}
-function findFirstFrame(stack) {
-    if (!stack) {
-        return stack;
-    }
-    const newlineIndex = stack.indexOf('\n');
-    if (newlineIndex === -1) {
-        return stack;
-    }
-    return stack.substring(0, newlineIndex);
-}
-function log(entry, label) {
-    const { args, stack } = parse(entry);
-    const isOneStringArg = typeof args[0] === 'string' && args.length === 1;
-    let topFrame = findFirstFrame(stack);
-    if (topFrame) {
-        topFrame = `(${topFrame.trim()})`;
-    }
-    let consoleArgs = [];
-    if (typeof args[0] === 'string') {
-        if (topFrame && isOneStringArg) {
-            consoleArgs = [`%c[${label}] %c${args[0]} %c${topFrame}`, color('blue'), color(''), color('grey')];
-        }
-        else {
-            consoleArgs = [`%c[${label}] %c${args[0]}`, color('blue'), color(''), ...args.slice(1)];
-        }
-    }
-    else {
-        consoleArgs = [`%c[${label}]%`, color('blue'), ...args];
-    }
-    if (topFrame && !isOneStringArg) {
-        consoleArgs.push(topFrame);
-    }
-    if (typeof console[entry.severity] !== 'function') {
-        throw new Error('Unknown console method');
-    }
-    console[entry.severity].apply(console, consoleArgs);
-}
-function color(color) {
-    return `color: ${color}`;
-}
-export { log, parse };

package/vscode/src/vs/base/common/keybindingParser.js

@@ -1,87 +0,0 @@
-import { ScanCodeUtils, KeyCodeUtils } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
-import { ScanCodeChord, KeyCodeChord, Keybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
-class KeybindingParser {
-    static _readModifiers(input) {
-        input = input.toLowerCase().trim();
-        let ctrl = false;
-        let shift = false;
-        let alt = false;
-        let meta = false;
-        let matchedModifier;
-        do {
-            matchedModifier = false;
-            if (/^ctrl(\+|\-)/.test(input)) {
-                ctrl = true;
-                input = input.substr('ctrl-'.length);
-                matchedModifier = true;
-            }
-            if (/^shift(\+|\-)/.test(input)) {
-                shift = true;
-                input = input.substr('shift-'.length);
-                matchedModifier = true;
-            }
-            if (/^alt(\+|\-)/.test(input)) {
-                alt = true;
-                input = input.substr('alt-'.length);
-                matchedModifier = true;
-            }
-            if (/^meta(\+|\-)/.test(input)) {
-                meta = true;
-                input = input.substr('meta-'.length);
-                matchedModifier = true;
-            }
-            if (/^win(\+|\-)/.test(input)) {
-                meta = true;
-                input = input.substr('win-'.length);
-                matchedModifier = true;
-            }
-            if (/^cmd(\+|\-)/.test(input)) {
-                meta = true;
-                input = input.substr('cmd-'.length);
-                matchedModifier = true;
-            }
-        } while (matchedModifier);
-        let key;
-        const firstSpaceIdx = input.indexOf(' ');
-        if (firstSpaceIdx > 0) {
-            key = input.substring(0, firstSpaceIdx);
-            input = input.substring(firstSpaceIdx);
-        }
-        else {
-            key = input;
-            input = '';
-        }
-        return {
-            remains: input,
-            ctrl,
-            shift,
-            alt,
-            meta,
-            key
-        };
-    }
-    static parseChord(input) {
-        const mods = this._readModifiers(input);
-        const scanCodeMatch = mods.key.match(/^\[([^\]]+)\]$/);
-        if (scanCodeMatch) {
-            const strScanCode = scanCodeMatch[1];
-            const scanCode = ScanCodeUtils.lowerCaseToEnum(strScanCode);
-            return [( new ScanCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, scanCode)), mods.remains];
-        }
-        const keyCode = KeyCodeUtils.fromUserSettings(mods.key);
-        return [( new KeyCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode)), mods.remains];
-    }
-    static parseKeybinding(input) {
-        if (!input) {
-            return null;
-        }
-        const chords = [];
-        let chord;
-        while (input.length > 0) {
-            [chord, input] = this.parseChord(input);
-            chords.push(chord);
-        }
-        return (chords.length > 0 ? ( new Keybinding(chords)) : null);
-    }
-}
-export { KeybindingParser };

package/vscode/src/vs/base/common/prefixTree.js

@@ -1,130 +0,0 @@
-const unset = Symbol('unset');
-class WellDefinedPrefixTree {
-    constructor() {
-        this.root = ( new Node());
-        this._size = 0;
-    }
-    get size() {
-        return this._size;
-    }
-    insert(key, value) {
-        this.opNode(key, n => n.value = value);
-    }
-    mutate(key, mutate) {
-        this.opNode(key, n => n.value = mutate(n.value === unset ? undefined : n.value));
-    }
-    delete(key) {
-        const path = [{ part: '', node: this.root }];
-        let i = 0;
-        for (const part of key) {
-            const node = path[i].node.children?.get(part);
-            if (!node) {
-                return undefined;
-            }
-            path.push({ part, node });
-            i++;
-        }
-        const value = path[i].node.value;
-        if (value === unset) {
-            return;
-        }
-        this._size--;
-        for (; i > 0; i--) {
-            const parent = path[i - 1];
-            parent.node.children.delete(path[i].part);
-            if (parent.node.children.size > 0 || parent.node.value !== unset) {
-                break;
-            }
-        }
-        return value;
-    }
-    find(key) {
-        let node = this.root;
-        for (const segment of key) {
-            const next = node.children?.get(segment);
-            if (!next) {
-                return undefined;
-            }
-            node = next;
-        }
-        return node.value === unset ? undefined : node.value;
-    }
-    hasKeyOrParent(key) {
-        let node = this.root;
-        for (const segment of key) {
-            const next = node.children?.get(segment);
-            if (!next) {
-                return false;
-            }
-            if (next.value !== unset) {
-                return true;
-            }
-            node = next;
-        }
-        return false;
-    }
-    hasKeyOrChildren(key) {
-        let node = this.root;
-        for (const segment of key) {
-            const next = node.children?.get(segment);
-            if (!next) {
-                return false;
-            }
-            node = next;
-        }
-        return true;
-    }
-    hasKey(key) {
-        let node = this.root;
-        for (const segment of key) {
-            const next = node.children?.get(segment);
-            if (!next) {
-                return false;
-            }
-            node = next;
-        }
-        return node.value !== unset;
-    }
-    opNode(key, fn) {
-        let node = this.root;
-        for (const part of key) {
-            if (!node.children) {
-                const next = ( new Node());
-                node.children = ( new Map([[part, next]]));
-                node = next;
-            }
-            else if (!( node.children.has(part))) {
-                const next = ( new Node());
-                node.children.set(part, next);
-                node = next;
-            }
-            else {
-                node = node.children.get(part);
-            }
-        }
-        if (node.value === unset) {
-            this._size++;
-        }
-        fn(node);
-    }
-    *values() {
-        const stack = [this.root];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (node.value !== unset) {
-                yield node.value;
-            }
-            if (node.children) {
-                for (const child of ( node.children.values())) {
-                    stack.push(child);
-                }
-            }
-        }
-    }
-}
-class Node {
-    constructor() {
-        this.value = unset;
-    }
-}
-export { WellDefinedPrefixTree };