@codingame/monaco-vscode-210e86a9-a91b-5273-b05d-390c776dde1f-common 16.1.1 → 17.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-210e86a9-a91b-5273-b05d-390c776dde1f-common",
-  "version": "16.1.1",
+  "version": "17.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package (chat, extensions, interactive, notebook, terminal, view-common)",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "16.1.1"
+    "@codingame/monaco-vscode-api": "17.0.0"
   },
   "exports": {
     ".": {

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/lineRange.js

@@ -29,10 +29,7 @@ class LineRange {
         }
     }
     join(other) {
-        return ( new LineRange(
-            Math.min(this.startLineNumber, other.startLineNumber),
-            Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive) - this.startLineNumber
-        ));
+        return LineRange.fromLineNumbers(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));
     }
     get endLineNumberExclusive() {
         return this.startLineNumber + this.lineCount;

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.js

@@ -1,10 +1,9 @@
 
-import { compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { compareBy, numberComparator, concatArrays } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { assertFn, checkAdjacentItems } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { concatArrays } from '../utils.js';
 import { LineRangeEdit } from './editing.js';
 import { LineRange } from './lineRange.js';
 import { rangeIsBeforeOrTouching, rangeContainsPosition, lengthBetweenPositions, addLength } from './rangeUtils.js';

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/modifiedBaseRange.js

@@ -1,5 +1,5 @@
 
-import { equals, tieBreakComparators, compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { equals, concatArrays, tieBreakComparators, compareBy, numberComparator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { splitLines } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { Constants } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uint';
@@ -7,7 +7,6 @@ import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/c
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { RangeEdit, LineRangeEdit } from './editing.js';
 import { MappingAlignment, DetailedLineRangeMapping } from './mapping.js';
-import { concatArrays } from '../utils.js';
 
 class ModifiedBaseRange {
     static fromDiffs(diffs1, diffs2, baseTextModel, input1TextModel, input2TextModel) {

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/conflictActions.d.ts

@@ -0,0 +1,30 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ICodeEditor, IViewZoneChangeAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { ModifiedBaseRange } from "../model/modifiedBaseRange.js";
+import { MergeEditorViewModel } from "@codingame/monaco-vscode-view-common-service-override/vscode/vs/workbench/contrib/mergeEditor/browser/view/viewModel";
+export declare class ConflictActionsFactory extends Disposable {
+    private readonly _editor;
+    private readonly _styleClassName;
+    private readonly _styleElement;
+    constructor(_editor: ICodeEditor);
+    private _updateLensStyle;
+    private _getLayoutInfo;
+    createWidget(viewZoneChangeAccessor: IViewZoneChangeAccessor, lineNumber: number, items: IObservable<IContentWidgetAction[]>, viewZoneIdsToCleanUp: string[]): IDisposable;
+}
+export declare class ActionsSource {
+    private readonly viewModel;
+    private readonly modifiedBaseRange;
+    constructor(viewModel: MergeEditorViewModel, modifiedBaseRange: ModifiedBaseRange);
+    private getItemsInput;
+    readonly itemsInput1: IObservable<IContentWidgetAction[]>;
+    readonly itemsInput2: IObservable<IContentWidgetAction[]>;
+    readonly resultItems: IObservable<IContentWidgetAction[]>;
+    readonly isEmpty: IObservable<boolean>;
+    readonly inputIsEmpty: IObservable<boolean>;
+}
+export interface IContentWidgetAction {
+    text: string;
+    tooltip?: string;
+    action?: () => Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/conflictActions.js

@@ -0,0 +1,269 @@
+
+import { isInShadowDOM, h, $, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { createStyleSheet } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/domStylesheets';
+import { renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { EditorOption, EDITOR_FONT_DEFAULTS } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ModifiedBaseRangeStateKind, ModifiedBaseRangeState } from '../model/modifiedBaseRange.js';
+import { FixedZoneWidget } from './fixedZoneWidget.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+
+class ConflictActionsFactory extends Disposable {
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._register(this._editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.codeLensFontSize) || e.hasChanged(EditorOption.codeLensFontFamily)) {
+                this._updateLensStyle();
+            }
+        }));
+        this._styleClassName = '_conflictActionsFactory_' + ( hash(this._editor.getId()).toString(16));
+        this._styleElement = createStyleSheet(isInShadowDOM(this._editor.getContainerDomNode())
+            ? this._editor.getContainerDomNode()
+            : undefined, undefined, this._store);
+        this._updateLensStyle();
+    }
+    _updateLensStyle() {
+        const { codeLensHeight, fontSize } = this._getLayoutInfo();
+        const fontFamily = this._editor.getOption(EditorOption.codeLensFontFamily);
+        const editorFontInfo = this._editor.getOption(EditorOption.fontInfo);
+        const fontFamilyVar = `--codelens-font-family${this._styleClassName}`;
+        const fontFeaturesVar = `--codelens-font-features${this._styleClassName}`;
+        let newStyle = `
+		.${this._styleClassName} { line-height: ${codeLensHeight}px; font-size: ${fontSize}px; padding-right: ${Math.round(fontSize * 0.5)}px; font-feature-settings: var(${fontFeaturesVar}) }
+		.monaco-workbench .${this._styleClassName} span.codicon { line-height: ${codeLensHeight}px; font-size: ${fontSize}px; }
+		`;
+        if (fontFamily) {
+            newStyle += `${this._styleClassName} { font-family: var(${fontFamilyVar}), ${EDITOR_FONT_DEFAULTS.fontFamily}}`;
+        }
+        this._styleElement.textContent = newStyle;
+        this._editor.getContainerDomNode().style?.setProperty(fontFamilyVar, fontFamily ?? 'inherit');
+        this._editor.getContainerDomNode().style?.setProperty(fontFeaturesVar, editorFontInfo.fontFeatureSettings);
+    }
+    _getLayoutInfo() {
+        const lineHeightFactor = Math.max(1.3, this._editor.getOption(EditorOption.lineHeight) / this._editor.getOption(EditorOption.fontSize));
+        let fontSize = this._editor.getOption(EditorOption.codeLensFontSize);
+        if (!fontSize || fontSize < 5) {
+            fontSize = (this._editor.getOption(EditorOption.fontSize) * .9) | 0;
+        }
+        return {
+            fontSize,
+            codeLensHeight: (fontSize * lineHeightFactor) | 0,
+        };
+    }
+    createWidget(viewZoneChangeAccessor, lineNumber, items, viewZoneIdsToCleanUp) {
+        const layoutInfo = this._getLayoutInfo();
+        return ( new ActionsContentWidget(
+            this._editor,
+            viewZoneChangeAccessor,
+            lineNumber,
+            layoutInfo.codeLensHeight + 2,
+            this._styleClassName,
+            items,
+            viewZoneIdsToCleanUp
+        ));
+    }
+}
+class ActionsSource {
+    constructor(viewModel, modifiedBaseRange) {
+        this.viewModel = viewModel;
+        this.modifiedBaseRange = modifiedBaseRange;
+        this.itemsInput1 = this.getItemsInput(1);
+        this.itemsInput2 = this.getItemsInput(2);
+        this.resultItems = derived(this, reader => {
+            const viewModel = this.viewModel;
+            const modifiedBaseRange = this.modifiedBaseRange;
+            const state = viewModel.model.getState(modifiedBaseRange).read(reader);
+            const model = viewModel.model;
+            const result = [];
+            if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
+                result.push({
+                    text: ( localize(7856, "Manual Resolution")),
+                    tooltip: ( localize(7857, "This conflict has been resolved manually.")),
+                });
+            }
+            else if (state.kind === ModifiedBaseRangeStateKind.base) {
+                result.push({
+                    text: ( localize(7858, 'No Changes Accepted')),
+                    tooltip: ( localize(
+                        7859,
+                        'The current resolution of this conflict equals the common ancestor of both the right and left changes.'
+                    )),
+                });
+            }
+            else {
+                const labels = [];
+                if (state.includesInput1) {
+                    labels.push(model.input1.title);
+                }
+                if (state.includesInput2) {
+                    labels.push(model.input2.title);
+                }
+                if (state.kind === ModifiedBaseRangeStateKind.both && state.firstInput === 2) {
+                    labels.reverse();
+                }
+                result.push({
+                    text: `${labels.join(' + ')}`
+                });
+            }
+            const stateToggles = [];
+            if (state.includesInput1) {
+                stateToggles.push(command(( localize(7860, 'Remove {0}', model.input1.title)), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, state.withInputValue(1, false), true, tx);
+                        model.telemetry.reportRemoveInvoked(1, state.includesInput(2));
+                    });
+                }, ( localize(7861, 'Remove {0} from the result document.', model.input1.title))));
+            }
+            if (state.includesInput2) {
+                stateToggles.push(command(( localize(7860, 'Remove {0}', model.input2.title)), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, state.withInputValue(2, false), true, tx);
+                        model.telemetry.reportRemoveInvoked(2, state.includesInput(1));
+                    });
+                }, ( localize(7861, 'Remove {0} from the result document.', model.input2.title))));
+            }
+            if (state.kind === ModifiedBaseRangeStateKind.both &&
+                state.firstInput === 2) {
+                stateToggles.reverse();
+            }
+            result.push(...stateToggles);
+            if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
+                result.push(command(( localize(7862, 'Reset to base')), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, ModifiedBaseRangeState.base, true, tx);
+                        model.telemetry.reportResetToBaseInvoked();
+                    });
+                }, ( localize(
+                    7863,
+                    'Reset this conflict to the common ancestor of both the right and left changes.'
+                ))));
+            }
+            return result;
+        });
+        this.isEmpty = derived(this, reader => {
+            return this.itemsInput1.read(reader).length + this.itemsInput2.read(reader).length + this.resultItems.read(reader).length === 0;
+        });
+        this.inputIsEmpty = derived(this, reader => {
+            return this.itemsInput1.read(reader).length + this.itemsInput2.read(reader).length === 0;
+        });
+    }
+    getItemsInput(inputNumber) {
+        return derived(reader => {
+            const viewModel = this.viewModel;
+            const modifiedBaseRange = this.modifiedBaseRange;
+            if (!viewModel.model.hasBaseRange(modifiedBaseRange)) {
+                return [];
+            }
+            const state = viewModel.model.getState(modifiedBaseRange).read(reader);
+            const handled = viewModel.model.isHandled(modifiedBaseRange).read(reader);
+            const model = viewModel.model;
+            const result = [];
+            const inputData = inputNumber === 1 ? viewModel.model.input1 : viewModel.model.input2;
+            const showNonConflictingChanges = viewModel.showNonConflictingChanges.read(reader);
+            if (!modifiedBaseRange.isConflicting && handled && !showNonConflictingChanges) {
+                return [];
+            }
+            const otherInputNumber = inputNumber === 1 ? 2 : 1;
+            if (state.kind !== ModifiedBaseRangeStateKind.unrecognized && !state.isInputIncluded(inputNumber)) {
+                if (!state.isInputIncluded(otherInputNumber) || !this.viewModel.shouldUseAppendInsteadOfAccept.read(reader)) {
+                    result.push(command(( localize(7864, "Accept {0}", inputData.title)), async () => {
+                        transaction((tx) => {
+                            model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
+                            model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
+                        });
+                    }, ( localize(7865, "Accept {0} in the result document.", inputData.title))));
+                    if (modifiedBaseRange.canBeCombined) {
+                        const commandName = modifiedBaseRange.isOrderRelevant
+                            ? ( localize(7866, "Accept Combination ({0} First)", inputData.title))
+                            : ( localize(7867, "Accept Combination"));
+                        result.push(command(commandName, async () => {
+                            transaction((tx) => {
+                                model.setState(modifiedBaseRange, ModifiedBaseRangeState.base
+                                    .withInputValue(inputNumber, true)
+                                    .withInputValue(otherInputNumber, true, true), true, tx);
+                                model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
+                            });
+                        }, ( localize(
+                            7868,
+                            "Accept an automatic combination of both sides in the result document."
+                        ))));
+                    }
+                }
+                else {
+                    result.push(command(( localize(7869, "Append {0}", inputData.title)), async () => {
+                        transaction((tx) => {
+                            model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
+                            model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
+                        });
+                    }, ( localize(7870, "Append {0} to the result document.", inputData.title))));
+                    if (modifiedBaseRange.canBeCombined) {
+                        result.push(command(( localize(7871, "Accept Combination", inputData.title)), async () => {
+                            transaction((tx) => {
+                                model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, true), inputNumber, tx);
+                                model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
+                            });
+                        }, ( localize(
+                            7868,
+                            "Accept an automatic combination of both sides in the result document."
+                        ))));
+                    }
+                }
+                if (!model.isInputHandled(modifiedBaseRange, inputNumber).read(reader)) {
+                    result.push(command(( localize(7872, 'Ignore')), async () => {
+                        transaction((tx) => {
+                            model.setInputHandled(modifiedBaseRange, inputNumber, true, tx);
+                        });
+                    }, ( localize(7873, "Don't take this side of the conflict."))));
+                }
+            }
+            return result;
+        });
+    }
+}
+function command(title, action, tooltip) {
+    return {
+        text: title,
+        action,
+        tooltip,
+    };
+}
+class ActionsContentWidget extends FixedZoneWidget {
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, className, items, viewZoneIdsToCleanUp) {
+        super(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp);
+        this._domNode = h('div.merge-editor-conflict-actions').root;
+        this.widgetDomNode.appendChild(this._domNode);
+        this._domNode.classList.add(className);
+        this._register(autorun(reader => {
+            const i = items.read(reader);
+            this.setState(i);
+        }));
+    }
+    setState(items) {
+        const children = [];
+        let isFirst = true;
+        for (const item of items) {
+            if (isFirst) {
+                isFirst = false;
+            }
+            else {
+                children.push($('span', undefined, '\u00a0|\u00a0'));
+            }
+            const title = renderLabelWithIcons(item.text);
+            if (item.action) {
+                children.push($('a', { title: item.tooltip, role: 'button', onclick: () => item.action() }, ...title));
+            }
+            else {
+                children.push($('span', { title: item.tooltip }, ...title));
+            }
+        }
+        reset(this._domNode, ...children);
+    }
+}
+
+export { ActionsSource, ConflictActionsFactory };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/fixedZoneWidget.d.ts

@@ -0,0 +1,11 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditor, IViewZoneChangeAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+export declare abstract class FixedZoneWidget extends Disposable {
+    private readonly editor;
+    private static counter;
+    private readonly overlayWidgetId;
+    private readonly viewZoneId;
+    protected readonly widgetDomNode: HTMLDivElement;
+    private readonly overlayWidget;
+    constructor(editor: ICodeEditor, viewZoneAccessor: IViewZoneChangeAccessor, afterLineNumber: number, height: number, viewZoneIdsToCleanUp: string[]);
+}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/fixedZoneWidget.js

@@ -0,0 +1,43 @@
+
+import { h } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+
+class FixedZoneWidget extends Disposable {
+    static { this.counter = 0; }
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp) {
+        super();
+        this.editor = editor;
+        this.overlayWidgetId = `fixedZoneWidget-${FixedZoneWidget.counter++}`;
+        this.widgetDomNode = h('div.fixed-zone-widget').root;
+        this.overlayWidget = {
+            getId: () => this.overlayWidgetId,
+            getDomNode: () => this.widgetDomNode,
+            getPosition: () => null
+        };
+        this.viewZoneId = viewZoneAccessor.addZone({
+            domNode: document.createElement('div'),
+            afterLineNumber: afterLineNumber,
+            heightInPx: height,
+            ordinal: 50000 + 1,
+            onComputedHeight: (height) => {
+                this.widgetDomNode.style.height = `${height}px`;
+            },
+            onDomNodeTop: (top) => {
+                this.widgetDomNode.style.top = `${top}px`;
+            }
+        });
+        viewZoneIdsToCleanUp.push(this.viewZoneId);
+        this._register(Event.runAndSubscribe(this.editor.onDidLayoutChange, () => {
+            this.widgetDomNode.style.left = this.editor.getLayoutInfo().contentLeft + 'px';
+        }));
+        this.editor.addOverlayWidget(this.overlayWidget);
+        this._register({
+            dispose: () => {
+                this.editor.removeOverlayWidget(this.overlayWidget);
+            },
+        });
+    }
+}
+
+export { FixedZoneWidget };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/utils.d.ts

@@ -1,34 +0,0 @@
-import { CompareResult } from "@codingame/monaco-vscode-api/vscode/vs/base/common/arrays";
-import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { CodeEditorWidget } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget";
-import { IModelDeltaDecoration } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-export declare function setStyle(element: HTMLElement, style: {
-    width?: number | string;
-    height?: number | string;
-    left?: number | string;
-    top?: number | string;
-}): void;
-export declare function applyObservableDecorations(editor: CodeEditorWidget, decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
-export declare function leftJoin<TLeft, TRight>(left: Iterable<TLeft>, right: readonly TRight[], compare: (left: TLeft, right: TRight) => CompareResult): IterableIterator<{
-    left: TLeft;
-    rights: TRight[];
-}>;
-export declare function join<TLeft, TRight>(left: Iterable<TLeft>, right: readonly TRight[], compare: (left: TLeft, right: TRight) => CompareResult): IterableIterator<{
-    left?: TLeft;
-    rights: TRight[];
-}>;
-export declare function concatArrays<TArr extends any[]>(...arrays: TArr): TArr[number][number][];
-export declare function elementAtOrUndefined<T>(arr: T[], index: number): T | undefined;
-export declare function setFields<T extends {}>(obj: T, fields: Partial<T>): T;
-export declare function deepMerge<T extends {}>(source1: T, source2: Partial<T>): T;
-export declare class PersistentStore<T> {
-    private readonly key;
-    private readonly storageService;
-    private hasValue;
-    private value;
-    constructor(key: string, storageService: IStorageService);
-    get(): Readonly<T> | undefined;
-    set(newValue: T | undefined): void;
-}

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/utils.js

@@ -1,109 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { ArrayQueue, CompareResult } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { autorunOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-
-function setStyle(element, style) {
-    Object.entries(style).forEach(([key, value]) => {
-        element.style.setProperty(key, toSize(value));
-    });
-}
-function toSize(value) {
-    return typeof value === 'number' ? `${value}px` : value;
-}
-function applyObservableDecorations(editor, decorations) {
-    const d = ( new DisposableStore());
-    let decorationIds = [];
-    d.add(autorunOpts({ debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
-        const d = decorations.read(reader);
-        editor.changeDecorations(a => {
-            decorationIds = a.deltaDecorations(decorationIds, d);
-        });
-    }));
-    d.add({
-        dispose: () => {
-            editor.changeDecorations(a => {
-                decorationIds = a.deltaDecorations(decorationIds, []);
-            });
-        }
-    });
-    return d;
-}
-function* leftJoin(left, right, compare) {
-    const rightQueue = ( new ArrayQueue(right));
-    for (const leftElement of left) {
-        rightQueue.takeWhile(rightElement => CompareResult.isGreaterThan(compare(leftElement, rightElement)));
-        const equals = rightQueue.takeWhile(rightElement => CompareResult.isNeitherLessOrGreaterThan(compare(leftElement, rightElement)));
-        yield { left: leftElement, rights: equals || [] };
-    }
-}
-function* join(left, right, compare) {
-    const rightQueue = ( new ArrayQueue(right));
-    for (const leftElement of left) {
-        const skipped = rightQueue.takeWhile(rightElement => CompareResult.isGreaterThan(compare(leftElement, rightElement)));
-        if (skipped) {
-            yield { rights: skipped };
-        }
-        const equals = rightQueue.takeWhile(rightElement => CompareResult.isNeitherLessOrGreaterThan(compare(leftElement, rightElement)));
-        yield { left: leftElement, rights: equals || [] };
-    }
-}
-function concatArrays(...arrays) {
-    return [].concat(...arrays);
-}
-function setFields(obj, fields) {
-    return Object.assign(obj, fields);
-}
-function deepMerge(source1, source2) {
-    const result = {};
-    for (const key in source1) {
-        result[key] = source1[key];
-    }
-    for (const key in source2) {
-        const source2Value = source2[key];
-        if (typeof result[key] === 'object' && source2Value && typeof source2Value === 'object') {
-            result[key] = deepMerge(result[key], source2Value);
-        }
-        else {
-            result[key] = source2Value;
-        }
-    }
-    return result;
-}
-let PersistentStore = class PersistentStore {
-    constructor(key, storageService) {
-        this.key = key;
-        this.storageService = storageService;
-        this.hasValue = false;
-        this.value = undefined;
-    }
-    get() {
-        if (!this.hasValue) {
-            const value = this.storageService.get(this.key, StorageScope.PROFILE);
-            if (value !== undefined) {
-                try {
-                    this.value = JSON.parse(value);
-                }
-                catch (e) {
-                    onUnexpectedError(e);
-                }
-            }
-            this.hasValue = true;
-        }
-        return this.value;
-    }
-    set(newValue) {
-        this.value = newValue;
-        this.storageService.store(this.key, JSON.stringify(this.value), StorageScope.PROFILE, StorageTarget.USER);
-    }
-};
-PersistentStore = ( __decorate([
-    ( __param(1, IStorageService))
-], PersistentStore));
-
-export { PersistentStore, applyObservableDecorations, concatArrays, deepMerge, join, leftJoin, setFields, setStyle };