@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/browser/parts/editor/sideBySideEditor.js

@@ -1,387 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/sidebysideeditor.css";
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Dimension, $, multibyteAwareBtoa, clearNode } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { SIDE_BY_SIDE_EDITOR_ID, SideBySideEditor as SideBySideEditor$1, EditorExtensions, isEditorPaneWithSelection } from '../../../common/editor.js';
-import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
-import { Emitter, Relay, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { DEFAULT_EDITOR_MIN_DIMENSIONS } from './editor.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER, SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER } from '../../../common/theme.js';
-import { AbstractEditorWithViewState } from './editorWithViewState.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-function isSideBySideEditorViewState(thing) {
-    const candidate = thing;
-    return typeof candidate?.primary === 'object' && typeof candidate.secondary === 'object';
-}
-let SideBySideEditor = class SideBySideEditor extends AbstractEditorWithViewState {
-    get minimumPrimaryWidth() { return this.primaryEditorPane ? this.primaryEditorPane.minimumWidth : 0; }
-    get maximumPrimaryWidth() { return this.primaryEditorPane ? this.primaryEditorPane.maximumWidth : Number.POSITIVE_INFINITY; }
-    get minimumPrimaryHeight() { return this.primaryEditorPane ? this.primaryEditorPane.minimumHeight : 0; }
-    get maximumPrimaryHeight() { return this.primaryEditorPane ? this.primaryEditorPane.maximumHeight : Number.POSITIVE_INFINITY; }
-    get minimumSecondaryWidth() { return this.secondaryEditorPane ? this.secondaryEditorPane.minimumWidth : 0; }
-    get maximumSecondaryWidth() { return this.secondaryEditorPane ? this.secondaryEditorPane.maximumWidth : Number.POSITIVE_INFINITY; }
-    get minimumSecondaryHeight() { return this.secondaryEditorPane ? this.secondaryEditorPane.minimumHeight : 0; }
-    get maximumSecondaryHeight() { return this.secondaryEditorPane ? this.secondaryEditorPane.maximumHeight : Number.POSITIVE_INFINITY; }
-    set minimumWidth(value) { }
-    set maximumWidth(value) { }
-    set minimumHeight(value) { }
-    set maximumHeight(value) { }
-    get minimumWidth() { return this.minimumPrimaryWidth + this.minimumSecondaryWidth; }
-    get maximumWidth() { return this.maximumPrimaryWidth + this.maximumSecondaryWidth; }
-    get minimumHeight() { return this.minimumPrimaryHeight + this.minimumSecondaryHeight; }
-    get maximumHeight() { return this.maximumPrimaryHeight + this.maximumSecondaryHeight; }
-    constructor(telemetryService, instantiationService, themeService, storageService, configurationService, textResourceConfigurationService, editorService, editorGroupService) {
-        super(SideBySideEditor.ID, SideBySideEditor.VIEW_STATE_PREFERENCE_KEY, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);
-        this.configurationService = configurationService;
-        this.onDidCreateEditors = this._register(( (new Emitter())));
-        this._onDidChangeSizeConstraints = this._register(( (new Relay())));
-        this.onDidChangeSizeConstraints = Event.any(this.onDidCreateEditors.event, this._onDidChangeSizeConstraints.event);
-        this._onDidChangeSelection = this._register(( (new Emitter())));
-        this.onDidChangeSelection = this._onDidChangeSelection.event;
-        this.primaryEditorPane = undefined;
-        this.secondaryEditorPane = undefined;
-        this.splitviewDisposables = this._register(( (new DisposableStore())));
-        this.editorDisposables = this._register(( (new DisposableStore())));
-        this.orientation = this.configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING) === 'vertical' ? 0  : 1 ;
-        this.dimension = ( (new Dimension(0, 0)));
-        this.lastFocusedSide = undefined;
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
-    }
-    onConfigurationUpdated(event) {
-        if (event.affectsConfiguration(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING)) {
-            this.orientation = this.configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING) === 'vertical' ? 0  : 1 ;
-            if (this.splitview) {
-                this.recreateSplitview();
-            }
-        }
-    }
-    recreateSplitview() {
-        const container = assertIsDefined(this.getContainer());
-        const ratio = this.getSplitViewRatio();
-        if (this.splitview) {
-            container.removeChild(this.splitview.el);
-            this.splitviewDisposables.clear();
-        }
-        this.createSplitView(container, ratio);
-        this.layout(this.dimension);
-    }
-    getSplitViewRatio() {
-        let ratio = undefined;
-        if (this.splitview) {
-            const leftViewSize = this.splitview.getViewSize(0);
-            const rightViewSize = this.splitview.getViewSize(1);
-            if (Math.abs(leftViewSize - rightViewSize) > 1) {
-                const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
-                ratio = leftViewSize / totalSize;
-            }
-        }
-        return ratio;
-    }
-    createEditor(parent) {
-        parent.classList.add('side-by-side-editor');
-        this.secondaryEditorContainer = $('.side-by-side-editor-container.editor-instance');
-        this.primaryEditorContainer = $('.side-by-side-editor-container.editor-instance');
-        this.createSplitView(parent);
-    }
-    createSplitView(parent, ratio) {
-        this.splitview = this.splitviewDisposables.add(( (new SplitView(parent, { orientation: this.orientation }))));
-        this.splitviewDisposables.add(this.splitview.onDidSashReset(() => this.splitview?.distributeViewSizes()));
-        if (this.orientation === 1 ) {
-            this.splitview.orthogonalEndSash = this._boundarySashes?.bottom;
-        }
-        else {
-            this.splitview.orthogonalStartSash = this._boundarySashes?.left;
-            this.splitview.orthogonalEndSash = this._boundarySashes?.right;
-        }
-        let leftSizing = Sizing.Distribute;
-        let rightSizing = Sizing.Distribute;
-        if (ratio) {
-            const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
-            leftSizing = Math.round(totalSize * ratio);
-            rightSizing = totalSize - leftSizing;
-            this.splitview.layout(this.orientation === 1  ? this.dimension.width : this.dimension.height);
-        }
-        const secondaryEditorContainer = assertIsDefined(this.secondaryEditorContainer);
-        this.splitview.addView({
-            element: secondaryEditorContainer,
-            layout: size => this.layoutPane(this.secondaryEditorPane, size),
-            minimumSize: this.orientation === 1  ? DEFAULT_EDITOR_MIN_DIMENSIONS.width : DEFAULT_EDITOR_MIN_DIMENSIONS.height,
-            maximumSize: Number.POSITIVE_INFINITY,
-            onDidChange: Event.None
-        }, leftSizing);
-        const primaryEditorContainer = assertIsDefined(this.primaryEditorContainer);
-        this.splitview.addView({
-            element: primaryEditorContainer,
-            layout: size => this.layoutPane(this.primaryEditorPane, size),
-            minimumSize: this.orientation === 1  ? DEFAULT_EDITOR_MIN_DIMENSIONS.width : DEFAULT_EDITOR_MIN_DIMENSIONS.height,
-            maximumSize: Number.POSITIVE_INFINITY,
-            onDidChange: Event.None
-        }, rightSizing);
-        this.updateStyles();
-    }
-    getTitle() {
-        if (this.input) {
-            return this.input.getName();
-        }
-        return (
-             (localize('sideBySideEditor', "Side by Side Editor"))
-        );
-    }
-    async setInput(input, options, context, token) {
-        const oldInput = this.input;
-        await super.setInput(input, options, context, token);
-        if (!oldInput || !input.matches(oldInput)) {
-            if (oldInput) {
-                this.disposeEditors();
-            }
-            this.createEditors(input);
-        }
-        const { primary, secondary, viewState } = this.loadViewState(input, options, context);
-        this.lastFocusedSide = viewState?.focus;
-        if (typeof viewState?.ratio === 'number' && this.splitview) {
-            const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
-            this.splitview.resizeView(0, Math.round(totalSize * viewState.ratio));
-        }
-        else {
-            this.splitview?.distributeViewSizes();
-        }
-        await Promise.all([
-            this.secondaryEditorPane?.setInput(input.secondary, secondary, context, token),
-            this.primaryEditorPane?.setInput(input.primary, primary, context, token)
-        ]);
-        if (typeof options?.target === 'number') {
-            this.lastFocusedSide = options.target;
-        }
-    }
-    loadViewState(input, options, context) {
-        const viewState = isSideBySideEditorViewState(options?.viewState) ? options?.viewState : this.loadEditorViewState(input, context);
-        let primaryOptions = Object.create(null);
-        let secondaryOptions = undefined;
-        if (options?.target === SideBySideEditor$1.SECONDARY) {
-            secondaryOptions = { ...options };
-        }
-        else {
-            primaryOptions = { ...options };
-        }
-        primaryOptions.viewState = viewState?.primary;
-        if (viewState?.secondary) {
-            if (!secondaryOptions) {
-                secondaryOptions = { viewState: viewState.secondary };
-            }
-            else {
-                secondaryOptions.viewState = viewState?.secondary;
-            }
-        }
-        return { primary: primaryOptions, secondary: secondaryOptions, viewState };
-    }
-    createEditors(newInput) {
-        this.secondaryEditorPane = this.doCreateEditor(newInput.secondary, assertIsDefined(this.secondaryEditorContainer));
-        this.primaryEditorPane = this.doCreateEditor(newInput.primary, assertIsDefined(this.primaryEditorContainer));
-        this.layout(this.dimension);
-        this._onDidChangeSizeConstraints.input = Event.any(( (Event.map(this.secondaryEditorPane.onDidChangeSizeConstraints, () => undefined))), ( (Event.map(this.primaryEditorPane.onDidChangeSizeConstraints, () => undefined))));
-        this.onDidCreateEditors.fire(undefined);
-        this.editorDisposables.add(this.primaryEditorPane.onDidFocus(() => this.onDidFocusChange(SideBySideEditor$1.PRIMARY)));
-        this.editorDisposables.add(this.secondaryEditorPane.onDidFocus(() => this.onDidFocusChange(SideBySideEditor$1.SECONDARY)));
-    }
-    doCreateEditor(editorInput, container) {
-        const editorPaneDescriptor = ( (Registry.as(EditorExtensions.EditorPane))).getEditorPane(editorInput);
-        if (!editorPaneDescriptor) {
-            throw new Error('No editor pane descriptor for editor found');
-        }
-        const editorPane = editorPaneDescriptor.instantiate(this.instantiationService);
-        editorPane.create(container);
-        editorPane.setVisible(this.isVisible(), this.group);
-        if (isEditorPaneWithSelection(editorPane)) {
-            this.editorDisposables.add(editorPane.onDidChangeSelection(e => this._onDidChangeSelection.fire(e)));
-        }
-        this.editorDisposables.add(editorPane);
-        return editorPane;
-    }
-    onDidFocusChange(side) {
-        this.lastFocusedSide = side;
-        this._onDidChangeControl.fire();
-    }
-    getSelection() {
-        const lastFocusedEditorPane = this.getLastFocusedEditorPane();
-        if (isEditorPaneWithSelection(lastFocusedEditorPane)) {
-            const selection = lastFocusedEditorPane.getSelection();
-            if (selection) {
-                return (
-                     (new SideBySideAwareEditorPaneSelection(
-                        selection,
-                        lastFocusedEditorPane === this.primaryEditorPane ? SideBySideEditor$1.PRIMARY : SideBySideEditor$1.SECONDARY
-                    ))
-                );
-            }
-        }
-        return undefined;
-    }
-    setOptions(options) {
-        super.setOptions(options);
-        if (typeof options?.target === 'number') {
-            this.lastFocusedSide = options.target;
-        }
-        this.getLastFocusedEditorPane()?.setOptions(options);
-    }
-    setEditorVisible(visible, group) {
-        this.primaryEditorPane?.setVisible(visible, group);
-        this.secondaryEditorPane?.setVisible(visible, group);
-        super.setEditorVisible(visible, group);
-    }
-    clearInput() {
-        super.clearInput();
-        this.primaryEditorPane?.clearInput();
-        this.secondaryEditorPane?.clearInput();
-        this.disposeEditors();
-    }
-    focus() {
-        this.getLastFocusedEditorPane()?.focus();
-    }
-    getLastFocusedEditorPane() {
-        if (this.lastFocusedSide === SideBySideEditor$1.SECONDARY) {
-            return this.secondaryEditorPane;
-        }
-        return this.primaryEditorPane;
-    }
-    layout(dimension) {
-        this.dimension = dimension;
-        const splitview = assertIsDefined(this.splitview);
-        splitview.layout(this.orientation === 1  ? dimension.width : dimension.height);
-    }
-    setBoundarySashes(sashes) {
-        this._boundarySashes = sashes;
-        if (this.splitview) {
-            this.splitview.orthogonalEndSash = sashes.bottom;
-        }
-    }
-    layoutPane(pane, size) {
-        pane?.layout(this.orientation === 1  ? ( (new Dimension(size, this.dimension.height))) : ( (new Dimension(this.dimension.width, size))));
-    }
-    getControl() {
-        return this.getLastFocusedEditorPane()?.getControl();
-    }
-    getPrimaryEditorPane() {
-        return this.primaryEditorPane;
-    }
-    getSecondaryEditorPane() {
-        return this.secondaryEditorPane;
-    }
-    tracksEditorViewState(input) {
-        return input instanceof SideBySideEditorInput;
-    }
-    computeEditorViewState(resource) {
-        if (!this.input || !isEqual(resource, this.toEditorViewStateResource(this.input))) {
-            return;
-        }
-        const primarViewState = this.primaryEditorPane?.getViewState();
-        const secondaryViewState = this.secondaryEditorPane?.getViewState();
-        if (!primarViewState || !secondaryViewState) {
-            return;
-        }
-        return {
-            primary: primarViewState,
-            secondary: secondaryViewState,
-            focus: this.lastFocusedSide,
-            ratio: this.getSplitViewRatio()
-        };
-    }
-    toEditorViewStateResource(input) {
-        let primary;
-        let secondary;
-        if (input instanceof SideBySideEditorInput) {
-            primary = input.primary.resource;
-            secondary = input.secondary.resource;
-        }
-        if (!secondary || !primary) {
-            return undefined;
-        }
-        return (
-             (URI.from({ scheme: 'sideBySide', path: `${multibyteAwareBtoa(( ( secondary.toString())))}${multibyteAwareBtoa(( ( primary.toString())))}` }))
-        );
-    }
-    updateStyles() {
-        super.updateStyles();
-        if (this.primaryEditorContainer) {
-            if (this.orientation === 1 ) {
-                this.primaryEditorContainer.style.borderLeftWidth = '1px';
-                this.primaryEditorContainer.style.borderLeftStyle = 'solid';
-                this.primaryEditorContainer.style.borderLeftColor = this.getColor(SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER) ?? '';
-                this.primaryEditorContainer.style.borderTopWidth = '0';
-            }
-            else {
-                this.primaryEditorContainer.style.borderTopWidth = '1px';
-                this.primaryEditorContainer.style.borderTopStyle = 'solid';
-                this.primaryEditorContainer.style.borderTopColor = this.getColor(SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER) ?? '';
-                this.primaryEditorContainer.style.borderLeftWidth = '0';
-            }
-        }
-    }
-    dispose() {
-        this.disposeEditors();
-        super.dispose();
-    }
-    disposeEditors() {
-        this.editorDisposables.clear();
-        this.secondaryEditorPane = undefined;
-        this.primaryEditorPane = undefined;
-        this.lastFocusedSide = undefined;
-        if (this.secondaryEditorContainer) {
-            clearNode(this.secondaryEditorContainer);
-        }
-        if (this.primaryEditorContainer) {
-            clearNode(this.primaryEditorContainer);
-        }
-    }
-};
-SideBySideEditor.ID = SIDE_BY_SIDE_EDITOR_ID;
-SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING = 'workbench.editor.splitInGroupLayout';
-SideBySideEditor.VIEW_STATE_PREFERENCE_KEY = 'sideBySideEditorViewState';
-SideBySideEditor = ( (__decorate([
-    ( (__param(0, ITelemetryService))),
-    ( (__param(1, IInstantiationService))),
-    ( (__param(2, IThemeService))),
-    ( (__param(3, IStorageService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, ITextResourceConfigurationService))),
-    ( (__param(6, IEditorService))),
-    ( (__param(7, IEditorGroupsService)))
-], SideBySideEditor)));
-class SideBySideAwareEditorPaneSelection {
-    constructor(selection, side) {
-        this.selection = selection;
-        this.side = side;
-    }
-    compare(other) {
-        if (!(other instanceof SideBySideAwareEditorPaneSelection)) {
-            return 3 ;
-        }
-        if (this.side !== other.side) {
-            return 3 ;
-        }
-        return this.selection.compare(other.selection);
-    }
-    restore(options) {
-        const sideBySideEditorOptions = {
-            ...options,
-            target: this.side
-        };
-        return this.selection.restore(sideBySideEditorOptions);
-    }
-}
-export { SideBySideEditor };

package/dist/vscode/vs/workbench/browser/parts/editor/textDiffEditor.js

@@ -1,289 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { assertIsDefined, withUndefinedAsNull, isObject, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { AbstractTextEditor } from '../../../../../../override/vs/workbench/browser/parts/editor/textEditor.js';
-import { TEXT_DIFF_EDITOR_ID, isTextEditorViewState, createTooLargeFileError, EditorExtensions, isEditorInput } from '../../../common/editor.js';
-import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';
-import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
-import { DiffNavigator } from 'monaco-editor/esm/vs/editor/browser/widget/diffNavigator.js';
-import { DiffEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditorWidget.js';
-import { TextDiffEditorModel } from '../../../common/editor/textDiffEditorModel.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { multibyteAwareBtoa } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { TooLargeFileOperationError, ByteSize, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
-    get scopedContextKeyService() {
-        if (!this.diffEditorControl) {
-            return undefined;
-        }
-        const originalEditor = this.diffEditorControl.getOriginalEditor();
-        const modifiedEditor = this.diffEditorControl.getModifiedEditor();
-        return (originalEditor.hasTextFocus() ? originalEditor : modifiedEditor).invokeWithinContext(accessor => accessor.get(IContextKeyService));
-    }
-    constructor(telemetryService, instantiationService, storageService, configurationService, editorService, themeService, editorGroupService, fileService, preferencesService) {
-        super(TextDiffEditor.ID, telemetryService, instantiationService, storageService, configurationService, themeService, editorService, editorGroupService, fileService);
-        this.preferencesService = preferencesService;
-        this.diffEditorControl = undefined;
-        this.diffNavigatorDisposables = this._register(( (new DisposableStore())));
-    }
-    getTitle() {
-        if (this.input) {
-            return this.input.getName();
-        }
-        return (
-             (localize('textDiffEditor', "Text Diff Editor"))
-        );
-    }
-    createEditorControl(parent, configuration) {
-        this.diffEditorControl = this._register(this.instantiationService.createInstance(DiffEditorWidget, parent, configuration, {}));
-    }
-    updateEditorControlOptions(options) {
-        this.diffEditorControl?.updateOptions(options);
-    }
-    getMainControl() {
-        return this.diffEditorControl?.getModifiedEditor();
-    }
-    async setInput(input, options, context, token) {
-        this.diffNavigatorDisposables.clear();
-        await super.setInput(input, options, context, token);
-        try {
-            const resolvedModel = await input.resolve(options);
-            if (token.isCancellationRequested) {
-                return undefined;
-            }
-            if (!(resolvedModel instanceof TextDiffEditorModel)) {
-                this.openAsBinary(input, options);
-                return undefined;
-            }
-            const control = assertIsDefined(this.diffEditorControl);
-            const resolvedDiffEditorModel = resolvedModel;
-            control.setModel(withUndefinedAsNull(resolvedDiffEditorModel.textDiffEditorModel));
-            let hasPreviousViewState = false;
-            if (!isTextEditorViewState(options?.viewState)) {
-                hasPreviousViewState = this.restoreTextDiffEditorViewState(input, options, context, control);
-            }
-            let optionsGotApplied = false;
-            if (options) {
-                optionsGotApplied = applyTextEditorOptions(options, control, 1 );
-            }
-            this.diffNavigator = this.instantiationService.createInstance(DiffNavigator, control, {
-                alwaysRevealFirst: !optionsGotApplied && !hasPreviousViewState,
-                findResultLoop: this.getMainControl()?.getOption(39 ).loop
-            });
-            this.diffNavigatorDisposables.add(this.diffNavigator);
-            control.updateOptions({
-                readOnly: resolvedDiffEditorModel.modifiedModel?.isReadonly(),
-                originalEditable: !resolvedDiffEditorModel.originalModel?.isReadonly()
-            });
-        }
-        catch (error) {
-            await this.handleSetInputError(error, input, options);
-        }
-    }
-    async handleSetInputError(error, input, options) {
-        if (this.isFileBinaryError(error)) {
-            return this.openAsBinary(input, options);
-        }
-        if (error.fileOperationResult === 7  && this.group) {
-            let message;
-            if (error instanceof TooLargeFileOperationError) {
-                message = ( (localize(
-                    'fileTooLargeForHeapErrorWithSize',
-                    "At least one file is not displayed in the text compare editor because it is very large ({0}).",
-                    ByteSize.formatSize(error.size)
-                )));
-            }
-            else {
-                message = ( (localize(
-                    'fileTooLargeForHeapErrorWithoutSize',
-                    "At least one file is not displayed in the text compare editor because it is very large."
-                )));
-            }
-            throw createTooLargeFileError(this.group, input, options, message, this.preferencesService);
-        }
-        throw error;
-    }
-    restoreTextDiffEditorViewState(editor, options, context, control) {
-        const editorViewState = this.loadEditorViewState(editor, context);
-        if (editorViewState) {
-            if (options?.selection && editorViewState.modified) {
-                editorViewState.modified.cursorState = [];
-            }
-            control.restoreViewState(editorViewState);
-            return true;
-        }
-        return false;
-    }
-    openAsBinary(input, options) {
-        const original = input.original;
-        const modified = input.modified;
-        const binaryDiffInput = this.instantiationService.createInstance(DiffEditorInput, input.getName(), input.getDescription(), original, modified, true);
-        const fileEditorFactory = ( (Registry.as(EditorExtensions.EditorFactory))).getFileEditorFactory();
-        if (fileEditorFactory.isFileEditor(original)) {
-            original.setForceOpenAsBinary();
-        }
-        if (fileEditorFactory.isFileEditor(modified)) {
-            modified.setForceOpenAsBinary();
-        }
-        (this.group ?? this.editorGroupService.activeGroup).replaceEditors([{
-                editor: input,
-                replacement: binaryDiffInput,
-                options: {
-                    ...options,
-                    activation: EditorActivation.PRESERVE,
-                    pinned: this.group?.isPinned(input),
-                    sticky: this.group?.isSticky(input)
-                }
-            }]);
-    }
-    setOptions(options) {
-        super.setOptions(options);
-        if (options) {
-            applyTextEditorOptions(options, assertIsDefined(this.diffEditorControl), 0 );
-        }
-    }
-    shouldHandleConfigurationChangeEvent(e, resource) {
-        if (super.shouldHandleConfigurationChangeEvent(e, resource)) {
-            return true;
-        }
-        return e.affectsConfiguration(resource, 'diffEditor');
-    }
-    computeConfiguration(configuration) {
-        const editorConfiguration = super.computeConfiguration(configuration);
-        if (isObject(configuration.diffEditor)) {
-            const diffEditorConfiguration = deepClone(configuration.diffEditor);
-            diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
-            delete diffEditorConfiguration.codeLens;
-            diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
-            delete diffEditorConfiguration.wordWrap;
-            Object.assign(editorConfiguration, diffEditorConfiguration);
-        }
-        return editorConfiguration;
-    }
-    getConfigurationOverrides() {
-        const readOnly = this.input instanceof DiffEditorInput && this.input.modified.hasCapability(2 );
-        return {
-            ...super.getConfigurationOverrides(),
-            readOnly,
-            originalEditable: this.input instanceof DiffEditorInput && !this.input.original.hasCapability(2 ),
-            lineDecorationsWidth: '2ch'
-        };
-    }
-    updateReadonly(input) {
-        if (input instanceof DiffEditorInput) {
-            this.diffEditorControl?.updateOptions({
-                readOnly: input.hasCapability(2 ),
-                originalEditable: !input.original.hasCapability(2 ),
-            });
-        }
-        else {
-            super.updateReadonly(input);
-        }
-    }
-    isFileBinaryError(error) {
-        if (Array.isArray(error)) {
-            const errors = error;
-            return (
-                 (errors.some(error => this.isFileBinaryError(error)))
-            );
-        }
-        return error.textFileOperationResult === 0 ;
-    }
-    clearInput() {
-        super.clearInput();
-        this.diffNavigatorDisposables.clear();
-        this.diffEditorControl?.setModel(null);
-    }
-    getDiffNavigator() {
-        return this.diffNavigator;
-    }
-    getControl() {
-        return this.diffEditorControl;
-    }
-    focus() {
-        this.diffEditorControl?.focus();
-    }
-    hasFocus() {
-        return this.diffEditorControl?.hasTextFocus() || super.hasFocus();
-    }
-    setEditorVisible(visible, group) {
-        super.setEditorVisible(visible, group);
-        if (visible) {
-            this.diffEditorControl?.onVisible();
-        }
-        else {
-            this.diffEditorControl?.onHide();
-        }
-    }
-    layout(dimension) {
-        this.diffEditorControl?.layout(dimension);
-    }
-    setBoundarySashes(sashes) {
-        this.diffEditorControl?.setBoundarySashes(sashes);
-    }
-    tracksEditorViewState(input) {
-        return input instanceof DiffEditorInput;
-    }
-    computeEditorViewState(resource) {
-        if (!this.diffEditorControl) {
-            return undefined;
-        }
-        const model = this.diffEditorControl.getModel();
-        if (!model || !model.modified || !model.original) {
-            return undefined;
-        }
-        const modelUri = this.toEditorViewStateResource(model);
-        if (!modelUri) {
-            return undefined;
-        }
-        if (!isEqual(modelUri, resource)) {
-            return undefined;
-        }
-        return withNullAsUndefined(this.diffEditorControl.saveViewState());
-    }
-    toEditorViewStateResource(modelOrInput) {
-        let original;
-        let modified;
-        if (modelOrInput instanceof DiffEditorInput) {
-            original = modelOrInput.original.resource;
-            modified = modelOrInput.modified.resource;
-        }
-        else if (!isEditorInput(modelOrInput)) {
-            original = modelOrInput.original.uri;
-            modified = modelOrInput.modified.uri;
-        }
-        if (!original || !modified) {
-            return undefined;
-        }
-        return (
-             (URI.from({ scheme: 'diff', path: `${multibyteAwareBtoa(( ( original.toString())))}${multibyteAwareBtoa(( ( modified.toString())))}` }))
-        );
-    }
-};
-TextDiffEditor.ID = TEXT_DIFF_EDITOR_ID;
-TextDiffEditor = ( (__decorate([
-    ( (__param(0, ITelemetryService))),
-    ( (__param(1, IInstantiationService))),
-    ( (__param(2, IStorageService))),
-    ( (__param(3, ITextResourceConfigurationService))),
-    ( (__param(4, IEditorService))),
-    ( (__param(5, IThemeService))),
-    ( (__param(6, IEditorGroupsService))),
-    ( (__param(7, IFileService))),
-    ( (__param(8, IPreferencesService)))
-], TextDiffEditor)));
-export { TextDiffEditor };

package/dist/vscode-default-extensions/bat/language-configuration.json.js

@@ -1,2 +0,0 @@
-var languageConfiguration = "{\n\t\"comments\": {\n\t\t\"lineComment\": \"@REM\"\n\t},\n\t\"brackets\": [\n\t\t[\"{\", \"}\"],\n\t\t[\"[\", \"]\"],\n\t\t[\"(\", \")\"]\n\t],\n\t\"autoClosingPairs\": [\n\t\t[\"{\", \"}\"],\n\t\t[\"[\", \"]\"],\n\t\t[\"(\", \")\"],\n\t\t{ \"open\": \"\\\"\", \"close\": \"\\\"\", \"notIn\": [\"string\"] }\n\t],\n\t\"surroundingPairs\": [\n\t\t[\"{\", \"}\"],\n\t\t[\"[\", \"]\"],\n\t\t[\"(\", \")\"],\n\t\t[\"%\", \"%\"],\n\t\t[\"\\\"\", \"\\\"\"]\n\t],\n\t\"folding\": {\n\t\t\"markers\": {\n\t\t\t\"start\": \"^\\\\s*(::|REM|@REM)\\\\s*#region\",\n\t\t\t\"end\": \"^\\\\s*(::|REM|@REM)\\\\s*#endregion\"\n\t\t}\n\t}\n}\n";
-export { languageConfiguration as default };