@codingame/monaco-vscode-api 6.0.3 → 7.0.1

package/vscode/src/vs/base/browser/ui/selectBox/selectBoxCustom.js

@@ -86,7 +86,7 @@ class SelectBoxList extends Disposable {
     }
     setTitle(title) {
         if (!this._hover && title) {
-            this._hover = this._register(getBaseLayerHoverDelegate().setupUpdatableHover(getDefaultHoverDelegate('mouse'), this.selectElement, title));
+            this._hover = this._register(getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate('mouse'), this.selectElement, title));
         }
         else if (this._hover) {
             this._hover.update(title);
@@ -349,11 +349,7 @@ class SelectBoxList extends Disposable {
         this.layoutSelectDropDown(preLayoutPosition);
         return {
             dispose: () => {
-                try {
-                    container.removeChild(this.selectDropDownContainer);
-                }
-                catch (error) {
-                }
+                this.selectDropDownContainer.remove();
             }
         };
     }
@@ -403,8 +399,8 @@ class SelectBoxList extends Disposable {
                     && maxVisibleOptionsAbove > maxVisibleOptionsBelow
                     && this.options.length > maxVisibleOptionsBelow) {
                     this._dropDownPosition = AnchorPosition.ABOVE;
-                    this.selectDropDownContainer.removeChild(this.selectDropDownListContainer);
-                    this.selectDropDownContainer.removeChild(this.selectionDetailsPane);
+                    this.selectDropDownListContainer.remove();
+                    this.selectionDetailsPane.remove();
                     this.selectDropDownContainer.appendChild(this.selectionDetailsPane);
                     this.selectDropDownContainer.appendChild(this.selectDropDownListContainer);
                     this.selectionDetailsPane.classList.remove('border-top');
@@ -412,8 +408,8 @@ class SelectBoxList extends Disposable {
                 }
                 else {
                     this._dropDownPosition = AnchorPosition.BELOW;
-                    this.selectDropDownContainer.removeChild(this.selectDropDownListContainer);
-                    this.selectDropDownContainer.removeChild(this.selectionDetailsPane);
+                    this.selectDropDownListContainer.remove();
+                    this.selectionDetailsPane.remove();
                     this.selectDropDownContainer.appendChild(this.selectDropDownListContainer);
                     this.selectDropDownContainer.appendChild(this.selectionDetailsPane);
                     this.selectionDetailsPane.classList.remove('border-bottom');
@@ -601,7 +597,7 @@ class SelectBoxList extends Disposable {
                 const child = element.childNodes.item(i);
                 const tagName = child.tagName && child.tagName.toLowerCase();
                 if (tagName === 'img') {
-                    element.removeChild(child);
+                    child.remove();
                 }
                 else {
                     cleanRenderedMarkdown(child);

package/vscode/src/vs/base/browser/ui/splitview/paneview.js

@@ -264,7 +264,7 @@ class PaneDraggable extends Disposable {
         }
         const dragImage = append(this.pane.element.ownerDocument.body, $('.monaco-drag-image', {}, this.pane.draggableElement.textContent || ''));
         e.dataTransfer.setDragImage(dragImage, -10, -10);
-        setTimeout(() => this.pane.element.ownerDocument.body.removeChild(dragImage), 0);
+        setTimeout(() => dragImage.remove(), 0);
         this.context.draggable = this;
     }
     onDragEnter(e) {

package/vscode/src/vs/base/browser/ui/splitview/splitview.js

@@ -561,7 +561,7 @@ class SplitView extends Disposable {
                 this.viewContainer.insertBefore(container, this.viewContainer.children.item(index));
             }
             const onChangeDisposable = view.onDidChange(size => this.onViewChange(item, size));
-            const containerDisposable = toDisposable(() => this.viewContainer.removeChild(container));
+            const containerDisposable = toDisposable(() => container.remove());
             const disposable = combinedDisposable(onChangeDisposable, containerDisposable);
             let viewSize;
             if (typeof size === 'number') {

package/vscode/src/vs/base/browser/ui/table/tableWidget.js

@@ -90,7 +90,7 @@ class ColumnHeader extends Disposable {
         this.onDidLayout = this._onDidLayout.event;
         this.element = $('.monaco-table-th', { 'data-col-index': index }, column.label);
         if (column.tooltip) {
-            this._register(getBaseLayerHoverDelegate().setupUpdatableHover(getDefaultHoverDelegate('mouse'), this.element, column.tooltip));
+            this._register(getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate('mouse'), this.element, column.tooltip));
         }
     }
     layout(size) {

package/vscode/src/vs/base/browser/ui/toggle/toggle.js

@@ -78,7 +78,7 @@ class Toggle extends Widget {
             classes.push('checked');
         }
         this.domNode = document.createElement('div');
-        this._hover = this._register(getBaseLayerHoverDelegate().setupUpdatableHover(opts.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
+        this._hover = this._register(getBaseLayerHoverDelegate().setupManagedHover(opts.hoverDelegate ?? getDefaultHoverDelegate('mouse'), this.domNode, this._opts.title));
         this.domNode.classList.add(...classes);
         if (!this._opts.notFocusable) {
             this.domNode.tabIndex = 0;

package/vscode/src/vs/base/browser/ui/toolbar/toolbar.d.ts

@@ -25,6 +25,14 @@ interface IToolBarOptions {
      * If true, toggled primary items are highlighted with a background color.
      */
     highlightToggledItems?: boolean;
+    /**
+     * Render action with icons (default: `true`)
+     */
+    icon?: boolean;
+    /**
+     * Render action with label (default: `false`)
+     */
+    label?: boolean;
 }
 /**
  * A widget that combines an action bar for primary actions and a dropdown for secondary actions.
@@ -36,7 +44,6 @@ declare class ToolBar extends Disposable {
     private toggleMenuActionViewItem;
     private submenuActionViewItems;
     private hasSecondaryActions;
-    private readonly lookupKeybindings;
     private readonly element;
     private _onDidChangeDropdownVisibility;
     readonly onDidChangeDropdownVisibility: Event<boolean>;

package/vscode/src/vs/base/browser/ui/toolbar/toolbar.js

@@ -19,7 +19,6 @@ class ToolBar extends Disposable {
         this.disposables = this._register(( (new DisposableStore())));
         options.hoverDelegate = options.hoverDelegate ?? this._register(createInstantHoverDelegate());
         this.options = options;
-        this.lookupKeybindings = typeof this.options.getKeyBinding === 'function';
         this.toggleMenuAction = this._register(( (new ToggleMenuAction(() => this.toggleMenuActionViewItem?.show(), options.toggleMenuTitle))));
         this.element = document.createElement('div');
         this.element.className = 'monaco-toolbar';
@@ -121,14 +120,14 @@ class ToolBar extends Disposable {
             primaryActionsToSet.push(this.toggleMenuAction);
         }
         primaryActionsToSet.forEach(action => {
-            this.actionBar.push(action, { icon: true, label: false, keybinding: this.getKeybindingLabel(action) });
+            this.actionBar.push(action, { icon: this.options.icon ?? true, label: this.options.label ?? false, keybinding: this.getKeybindingLabel(action) });
         });
     }
     isEmpty() {
         return this.actionBar.isEmpty();
     }
     getKeybindingLabel(action) {
-        const key = this.lookupKeybindings ? this.options.getKeyBinding?.(action) : undefined;
+        const key = this.options.getKeyBinding?.(action);
         return key?.getLabel() ?? undefined;
     }
     clear() {

package/vscode/src/vs/base/browser/ui/tree/abstractTree.js

@@ -603,7 +603,7 @@ class FindWidget extends Disposable {
         this._onDidDisable = ( (new Emitter()));
         this.onDidDisable = this._onDidDisable.event;
         container.appendChild(this.elements.root);
-        this._register(toDisposable(() => container.removeChild(this.elements.root)));
+        this._register(toDisposable(() => this.elements.root.remove()));
         const styles = options?.styles ?? unthemedFindWidgetStyles;
         if (styles.listFilterWidgetBackground) {
             this.elements.root.style.backgroundColor = styles.listFilterWidgetBackground;

package/vscode/src/vs/base/browser/ui/tree/asyncDataTree.js

@@ -398,9 +398,6 @@ class AsyncDataTree {
     resort(element = this.root.element, recursive = true) {
         this.tree.resort(this.getDataNode(element), recursive);
     }
-    hasElement(element) {
-        return this.tree.hasElement(this.getDataNode(element));
-    }
     hasNode(element) {
         return element === this.root.element || ( this.nodes.has(element));
     }

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

@@ -1,4 +1,4 @@
-import { BugIndicatingError, onUnexpectedError } from './errors.js';
+import { onUnexpectedError, BugIndicatingError } from './errors.js';
 function ok(value, message) {
     if (!value) {
         throw ( new Error(message ? `Assertion failed (${message})` : 'Assertion Failed'));

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

@@ -1,3 +1,4 @@
+var _a;
 function groupBy(data, groupFn) {
     const result = Object.create(null);
     for (const element of data) {
@@ -49,4 +50,51 @@ function intersection(setA, setB) {
     }
     return result;
 }
-export { diffMaps, diffSets, groupBy, intersection };
+class SetWithKey {
+    static { _a = Symbol.toStringTag; }
+    constructor(values, toKey) {
+        this.toKey = toKey;
+        this._map = ( new Map());
+        this[_a] = 'SetWithKey';
+        for (const value of values) {
+            this.add(value);
+        }
+    }
+    get size() {
+        return this._map.size;
+    }
+    add(value) {
+        const key = this.toKey(value);
+        this._map.set(key, value);
+        return this;
+    }
+    delete(value) {
+        return this._map.delete(this.toKey(value));
+    }
+    has(value) {
+        return ( this._map.has(this.toKey(value)));
+    }
+    *entries() {
+        for (const entry of ( this._map.values())) {
+            yield [entry, entry];
+        }
+    }
+    keys() {
+        return ( this.values());
+    }
+    *values() {
+        for (const entry of ( this._map.values())) {
+            yield entry;
+        }
+    }
+    clear() {
+        this._map.clear();
+    }
+    forEach(callbackfn, thisArg) {
+        this._map.forEach(entry => callbackfn.call(thisArg, entry, entry, this));
+    }
+    [Symbol.iterator]() {
+        return ( this.values());
+    }
+}
+export { SetWithKey, diffMaps, diffSets, groupBy, intersection };

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

@@ -6,11 +6,61 @@ function itemsEquals(itemEquals = strictEquals) {
 function itemEquals() {
     return (a, b) => a.equals(b);
 }
-function equalsIfDefined(v1, v2, equals) {
-    if (!v1 || !v2) {
-        return v1 === v2;
+function equalsIfDefined(equalsOrV1, v2, equals) {
+    if (equals !== undefined) {
+        const v1 = equalsOrV1;
+        if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
+            return v2 === v1;
+        }
+        return equals(v1, v2);
+    }
+    else {
+        const equals = equalsOrV1;
+        return (v1, v2) => {
+            if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
+                return v2 === v1;
+            }
+            return equals(v1, v2);
+        };
+    }
+}
+function structuralEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!structuralEquals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a && typeof a === 'object' && b && typeof b === 'object') {
+        if (Object.getPrototypeOf(a) === Object.prototype && Object.getPrototypeOf(b) === Object.prototype) {
+            const aObj = a;
+            const bObj = b;
+            const keysA = ( Object.keys(aObj));
+            const keysB = ( Object.keys(bObj));
+            const keysBSet = ( new Set(keysB));
+            if (keysA.length !== keysB.length) {
+                return false;
+            }
+            for (const key of keysA) {
+                if (!( keysBSet.has(key))) {
+                    return false;
+                }
+                if (!structuralEquals(aObj[key], bObj[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
     }
-    return equals(v1, v2);
+    return false;
 }
 function getStructuralKey(t) {
     return JSON.stringify(toNormalizedJsonStructure(t));
@@ -41,4 +91,4 @@ function toNormalizedJsonStructure(t) {
     }
     return t;
 }
-export { equalsIfDefined, getStructuralKey, itemEquals, itemsEquals, strictEquals };
+export { equalsIfDefined, getStructuralKey, itemEquals, itemsEquals, strictEquals, structuralEquals };

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

@@ -71,6 +71,19 @@ function transformErrorForSerialization(error) {
     }
     return error;
 }
+function transformErrorFromSerialization(data) {
+    let error;
+    if (data.noTelemetry) {
+        error = ( new ErrorNoTelemetry());
+    }
+    else {
+        error = ( new Error());
+        error.name = data.name;
+    }
+    error.message = data.message;
+    error.stack = data.stack;
+    return error;
+}
 const canceledName = 'Canceled';
 function isCancellationError(error) {
     if (error instanceof CancellationError) {
@@ -162,4 +175,4 @@ class BugIndicatingError extends Error {
         Object.setPrototypeOf(this, BugIndicatingError.prototype);
     }
 }
-export { BugIndicatingError, CancellationError, ErrorHandler, ErrorNoTelemetry, NotImplementedError, NotSupportedError, ReadonlyError, canceled, errorHandler, getErrorMessage, illegalArgument, illegalState, isCancellationError, onUnexpectedError, onUnexpectedExternalError, setUnexpectedErrorHandler, transformErrorForSerialization };
+export { BugIndicatingError, CancellationError, ErrorHandler, ErrorNoTelemetry, NotImplementedError, NotSupportedError, ReadonlyError, canceled, errorHandler, getErrorMessage, illegalArgument, illegalState, isCancellationError, onUnexpectedError, onUnexpectedExternalError, setUnexpectedErrorHandler, transformErrorForSerialization, transformErrorFromSerialization };

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

@@ -439,7 +439,8 @@ function setGlobalLeakWarningThreshold(n) {
     };
 }
 class LeakageMonitor {
-    constructor(_errorHandler, threshold, name = ( Math.random().toString(18)).slice(2, 5)) {
+    static { this._idPool = 1; }
+    constructor(_errorHandler, threshold, name = ( (LeakageMonitor._idPool++).toString(16)).padStart(3, '0')) {
         this._errorHandler = _errorHandler;
         this.threshold = threshold;
         this.name = name;

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

@@ -1,3 +1,4 @@
+import { SetWithKey } from './collections.js';
 import { ArrayNavigator } from './navigator.js';
 class HistoryNavigator {
     constructor(history = [], limit = 10) {
@@ -79,8 +80,9 @@ class HistoryNavigator {
 }
 class HistoryNavigator2 {
     get size() { return this._size; }
-    constructor(history, capacity = 10) {
+    constructor(history, capacity = 10, identityFn = t => t) {
         this.capacity = capacity;
+        this.identityFn = identityFn;
         if (history.length < 1) {
             throw ( new Error('not supported'));
         }
@@ -90,7 +92,7 @@ class HistoryNavigator2 {
             previous: undefined,
             next: undefined
         };
-        this.valueSet = ( new Set([history[0]]));
+        this.valueSet = ( new SetWithKey([history[0]], identityFn));
         for (let i = 1; i < history.length; i++) {
             this.add(history[i]);
         }
@@ -119,7 +121,7 @@ class HistoryNavigator2 {
         }
     }
     replaceLast(value) {
-        if (this.tail.value === value) {
+        if (this.identityFn(this.tail.value) === this.identityFn(value)) {
             return value;
         }
         const oldValue = this.tail.value;
@@ -181,8 +183,9 @@ class HistoryNavigator2 {
     }
     _deleteFromList(value) {
         let temp = this.head;
+        const valueKey = this.identityFn(value);
         while (temp !== this.tail) {
-            if (temp.value === value) {
+            if (this.identityFn(temp.value) === valueKey) {
                 if (temp === this.head) {
                     this.head = this.head.next;
                     this.head.previous = undefined;

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

@@ -41,8 +41,9 @@ var Iterable;
     }
     Iterable.first = first;
     function some(iterable, predicate) {
+        let i = 0;
         for (const element of iterable) {
-            if (predicate(element)) {
+            if (predicate(element, i++)) {
                 return true;
             }
         }
@@ -73,6 +74,13 @@ var Iterable;
         }
     }
     Iterable.map = map;
+    function* flatMap(iterable, fn) {
+        let index = 0;
+        for (const element of iterable) {
+            yield* fn(element, index++);
+        }
+    }
+    Iterable.flatMap = flatMap;
     function* concat(...iterables) {
         for (const iterable of iterables) {
             yield* iterable;

package/vscode/src/vs/base/common/map.d.ts

@@ -0,0 +1,41 @@
+import { URI } from './uri.js';
+
+interface ResourceMapKeyFn {
+    (resource: URI): string;
+}
+declare class ResourceMap<T> implements Map<URI, T> {
+    private static readonly defaultToKey;
+    readonly [Symbol.toStringTag] = "ResourceMap";
+    private readonly map;
+    private readonly toKey;
+    /**
+     *
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
+    constructor(toKey?: ResourceMapKeyFn);
+    /**
+     *
+     * @param other Another resource which this maps is created from
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
+    constructor(other?: ResourceMap<T>, toKey?: ResourceMapKeyFn);
+    /**
+     *
+     * @param other Another resource which this maps is created from
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
+    constructor(entries?: readonly (readonly [URI, T])[], toKey?: ResourceMapKeyFn);
+    set(resource: URI, value: T): this;
+    get(resource: URI): T | undefined;
+    has(resource: URI): boolean;
+    get size(): number;
+    clear(): void;
+    delete(resource: URI): boolean;
+    forEach(clb: (value: T, key: URI, map: Map<URI, T>) => void, thisArg?: any): void;
+    values(): IterableIterator<T>;
+    keys(): IterableIterator<URI>;
+    entries(): IterableIterator<[URI, T]>;
+    [Symbol.iterator](): IterableIterator<[URI, T]>;
+}
+
+export { ResourceMap };

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

@@ -52,4 +52,21 @@ class SlidingWindowAverage {
         return this._val;
     }
 }
-export { Counter, MovingAverage, SlidingWindowAverage, clamp, rot };
+function isPointWithinTriangle(x, y, ax, ay, bx, by, cx, cy) {
+    const v0x = cx - ax;
+    const v0y = cy - ay;
+    const v1x = bx - ax;
+    const v1y = by - ay;
+    const v2x = x - ax;
+    const v2y = y - ay;
+    const dot00 = v0x * v0x + v0y * v0y;
+    const dot01 = v0x * v1x + v0y * v1y;
+    const dot02 = v0x * v2x + v0y * v2y;
+    const dot11 = v1x * v1x + v1y * v1y;
+    const dot12 = v1x * v2x + v1y * v2y;
+    const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
+    const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+    const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+    return u >= 0 && v >= 0 && u + v < 1;
+}
+export { Counter, MovingAverage, SlidingWindowAverage, clamp, isPointWithinTriangle, rot };

package/vscode/src/vs/base/common/observableInternal/api.js

@@ -0,0 +1,11 @@
+import { strictEquals } from '../equals.js';
+import { ObservableValue } from './base.js';
+import { DebugNameData } from './debugName.js';
+import { LazyObservableValue } from './lazyObservableValue.js';
+function observableValueOpts(options, initialValue) {
+    if (options.lazy) {
+        return ( new LazyObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
+    }
+    return ( new ObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
+}
+export { observableValueOpts };

package/vscode/src/vs/base/common/observableInternal/autorun.js

@@ -10,6 +10,23 @@ function autorunOpts(options, fn) {
 function autorunHandleChanges(options, fn) {
     return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.createEmptyChangeSummary, options.handleChange));
 }
+function autorunWithStoreHandleChanges(options, fn) {
+    const store = ( new DisposableStore());
+    const disposable = autorunHandleChanges({
+        owner: options.owner,
+        debugName: options.debugName,
+        debugReferenceFn: options.debugReferenceFn ?? fn,
+        createEmptyChangeSummary: options.createEmptyChangeSummary,
+        handleChange: options.handleChange,
+    }, (reader, changeSummary) => {
+        store.clear();
+        fn(reader, changeSummary, store);
+    });
+    return toDisposable(() => {
+        disposable.dispose();
+        store.dispose();
+    });
+}
 function autorunWithStore(fn) {
     const store = ( new DisposableStore());
     const disposable = autorunOpts({
@@ -138,4 +155,4 @@ class AutorunObserver {
 ( (function(autorun) {
     autorun.Observer = AutorunObserver;
 })(autorun || (autorun = {})));
-export { AutorunObserver, autorun, autorunHandleChanges, autorunOpts, autorunWithStore };
+export { AutorunObserver, autorun, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };

package/vscode/src/vs/base/common/observableInternal/base.d.ts

@@ -114,5 +114,12 @@ interface IObserver {
      */
     handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
 }
+interface ITransaction {
+    /**
+     * Calls {@link Observer.beginUpdate} immediately
+     * and {@link Observer.endUpdate} when the transaction ends.
+     */
+    updateObserver(observer: IObserver, observable: IObservable<any, any>): void;
+}
 
-export type { IObservable, IObserver, IReader };
+export type { IObservable, IObserver, IReader, ITransaction };

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

@@ -1,5 +1,5 @@
 import { strictEquals } from '../equals.js';
-import { DebugNameData, getFunctionName } from './debugName.js';
+import { getFunctionName, DebugNameData } from './debugName.js';
 let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
     _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
@@ -159,9 +159,6 @@ function observableValue(nameOrOwner, initialValue) {
     }
     return ( new ObservableValue(debugNameData, initialValue, strictEquals));
 }
-function observableValueOpts(options, initialValue) {
-    return ( new ObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
-}
 class ObservableValue extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? 'ObservableValue';
@@ -227,4 +224,4 @@ class DisposableObservableValue extends ObservableValue {
         this._value?.dispose();
     }
 }
-export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, observableValueOpts, subtransaction, transaction };
+export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction };

package/vscode/src/vs/base/common/observableInternal/derived.js

@@ -47,15 +47,25 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
         owner = computeFnOrOwner;
         computeFn = computeFnOrUndefined;
     }
-    const store = ( new DisposableStore());
+    let store = undefined;
     return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
-        store.clear();
+        if (!store) {
+            store = ( new DisposableStore());
+        }
+        else {
+            store.clear();
+        }
         const result = computeFn(r);
         if (result) {
             store.add(result);
         }
         return result;
-    }, undefined, undefined, () => store.dispose(), strictEquals));
+    }, undefined, undefined, () => {
+        if (store) {
+            store.dispose();
+            store = undefined;
+        }
+    }, strictEquals));
 }
 var DerivedState;
 ( (function(DerivedState) {