@codingame/monaco-vscode-api 2.2.2 → 3.1.0

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

@@ -1,9 +1,147 @@
+import { compareBy, numberComparator } from './arrays.js';
+import { groupBy } from './collections.js';
+import { SetMap } from './map.js';
 import { createSingleCallFunction } from './functional.js';
 import { Iterable } from './iterator.js';
+let disposableTracker = null;
+class DisposableTracker {
+    constructor() {
+        this.livingDisposables = ( new Map());
+    }
+    static { this.idx = 0; }
+    getDisposableData(d) {
+        let val = this.livingDisposables.get(d);
+        if (!val) {
+            val = { parent: null, source: null, isSingleton: false, value: d, idx: DisposableTracker.idx++ };
+            this.livingDisposables.set(d, val);
+        }
+        return val;
+    }
+    trackDisposable(d) {
+        const data = this.getDisposableData(d);
+        if (!data.source) {
+            data.source =
+                ( new Error()).stack;
+        }
+    }
+    setParent(child, parent) {
+        const data = this.getDisposableData(child);
+        data.parent = parent;
+    }
+    markAsDisposed(x) {
+        this.livingDisposables.delete(x);
+    }
+    markAsSingleton(disposable) {
+        this.getDisposableData(disposable).isSingleton = true;
+    }
+    getRootParent(data, cache) {
+        const cacheValue = cache.get(data);
+        if (cacheValue) {
+            return cacheValue;
+        }
+        const result = data.parent ? this.getRootParent(this.getDisposableData(data.parent), cache) : data;
+        cache.set(data, result);
+        return result;
+    }
+    getTrackedDisposables() {
+        const rootParentCache = ( new Map());
+        const leaking = [...this.livingDisposables.entries()]
+            .filter(([, v]) => v.source !== null && !this.getRootParent(v, rootParentCache).isSingleton)
+            .flatMap(([k]) => k);
+        return leaking;
+    }
+    computeLeakingDisposables(maxReported = 10, preComputedLeaks) {
+        let uncoveredLeakingObjs;
+        if (preComputedLeaks) {
+            uncoveredLeakingObjs = preComputedLeaks;
+        }
+        else {
+            const rootParentCache = ( new Map());
+            const leakingObjects = [...( this.livingDisposables.values())]
+                .filter((info) => info.source !== null && !this.getRootParent(info, rootParentCache).isSingleton);
+            if (leakingObjects.length === 0) {
+                return;
+            }
+            const leakingObjsSet = ( new Set(( leakingObjects.map(o => o.value))));
+            uncoveredLeakingObjs = leakingObjects.filter(l => {
+                return !(l.parent && ( leakingObjsSet.has(l.parent)));
+            });
+            if (uncoveredLeakingObjs.length === 0) {
+                throw new Error('There are cyclic diposable chains!');
+            }
+        }
+        if (!uncoveredLeakingObjs) {
+            return undefined;
+        }
+        function getStackTracePath(leaking) {
+            function removePrefix(array, linesToRemove) {
+                while (array.length > 0 && ( linesToRemove.some(
+                    regexp => typeof regexp === 'string' ? regexp === array[0] : array[0].match(regexp)
+                ))) {
+                    array.shift();
+                }
+            }
+            const lines = ( leaking.source.split('\n').map(p => p.trim().replace('at ', ''))).filter(l => l !== '');
+            removePrefix(lines, ['Error', /^trackDisposable \(.*\)$/, /^DisposableTracker.trackDisposable \(.*\)$/]);
+            return lines.reverse();
+        }
+        const stackTraceStarts = ( new SetMap());
+        for (const leaking of uncoveredLeakingObjs) {
+            const stackTracePath = getStackTracePath(leaking);
+            for (let i = 0; i <= stackTracePath.length; i++) {
+                stackTraceStarts.add(stackTracePath.slice(0, i).join('\n'), leaking);
+            }
+        }
+        uncoveredLeakingObjs.sort(compareBy(l => l.idx, numberComparator));
+        let message = '';
+        let i = 0;
+        for (const leaking of uncoveredLeakingObjs.slice(0, maxReported)) {
+            i++;
+            const stackTracePath = getStackTracePath(leaking);
+            const stackTraceFormattedLines = [];
+            for (let i = 0; i < stackTracePath.length; i++) {
+                let line = stackTracePath[i];
+                const starts = stackTraceStarts.get(stackTracePath.slice(0, i + 1).join('\n'));
+                line = `(shared with ${starts.size}/${uncoveredLeakingObjs.length} leaks) at ${line}`;
+                const prevStarts = stackTraceStarts.get(stackTracePath.slice(0, i).join('\n'));
+                const continuations = groupBy(( [...prevStarts].map(d => getStackTracePath(d)[i])), v => v);
+                delete continuations[stackTracePath[i]];
+                for (const [cont, set] of Object.entries(continuations)) {
+                    stackTraceFormattedLines.unshift(`    - stacktraces of ${set.length} other leaks continue with ${cont}`);
+                }
+                stackTraceFormattedLines.unshift(line);
+            }
+            message += `\n\n\n==================== Leaking disposable ${i}/${uncoveredLeakingObjs.length}: ${leaking.value.constructor.name} ====================\n${stackTraceFormattedLines.join('\n')}\n============================================================\n\n`;
+        }
+        if (uncoveredLeakingObjs.length > maxReported) {
+            message += `\n\n\n... and ${uncoveredLeakingObjs.length - maxReported} more leaking disposables\n\n`;
+        }
+        return { leaks: uncoveredLeakingObjs, details: message };
+    }
+}
+function setDisposableTracker(tracker) {
+    disposableTracker = tracker;
+}
 function trackDisposable(x) {
+    disposableTracker?.trackDisposable(x);
     return x;
 }
+function markAsDisposed(disposable) {
+    disposableTracker?.markAsDisposed(disposable);
+}
+function setParentOfDisposable(child, parent) {
+    disposableTracker?.setParent(child, parent);
+}
+function setParentOfDisposables(children, parent) {
+    if (!disposableTracker) {
+        return;
+    }
+    for (const child of children) {
+        disposableTracker.setParent(child, parent);
+    }
+}
 function markAsSingleton(singleton) {
+    disposableTracker?.markAsSingleton(singleton);
     return singleton;
 }
 function isDisposable(thing) {
@@ -45,11 +183,13 @@ function disposeIfDisposable(disposables) {
 }
 function combinedDisposable(...disposables) {
     const parent = toDisposable(() => dispose(disposables));
+    setParentOfDisposables(disposables, parent);
     return parent;
 }
 function toDisposable(fn) {
     const self = trackDisposable({
         dispose: createSingleCallFunction(() => {
+            markAsDisposed(self);
             fn();
         })
     });
@@ -60,11 +200,13 @@ class DisposableStore {
     constructor() {
         this._toDispose = ( new Set());
         this._isDisposed = false;
+        trackDisposable(this);
     }
     dispose() {
         if (this._isDisposed) {
             return;
         }
+        markAsDisposed(this);
         this._isDisposed = true;
         this.clear();
     }
@@ -89,6 +231,7 @@ class DisposableStore {
         if (o === this) {
             throw new Error('Cannot register a disposable on itself!');
         }
+        setParentOfDisposable(o, this);
         if (this._isDisposed) {
             if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
                 console.warn(( new Error(
@@ -117,6 +260,7 @@ class DisposableStore {
         }
         if (( this._toDispose.has(o))) {
             this._toDispose.delete(o);
+            setParentOfDisposable(o, null);
         }
     }
 }
@@ -124,8 +268,11 @@ class Disposable {
     static { this.None = ( Object.freeze({ dispose() { } })); }
     constructor() {
         this._store = ( new DisposableStore());
+        trackDisposable(this);
+        setParentOfDisposable(this._store, this);
     }
     dispose() {
+        markAsDisposed(this);
         this._store.dispose();
     }
     _register(o) {
@@ -138,6 +285,7 @@ class Disposable {
 class MutableDisposable {
     constructor() {
         this._isDisposed = false;
+        trackDisposable(this);
     }
     get value() {
         return this._isDisposed ? undefined : this._value;
@@ -147,6 +295,9 @@ class MutableDisposable {
             return;
         }
         this._value?.dispose();
+        if (value) {
+            setParentOfDisposable(value, this);
+        }
         this._value = value;
     }
     clear() {
@@ -154,12 +305,16 @@ class MutableDisposable {
     }
     dispose() {
         this._isDisposed = true;
+        markAsDisposed(this);
         this._value?.dispose();
         this._value = undefined;
     }
     clearAndLeak() {
         const oldValue = this._value;
         this._value = undefined;
+        if (oldValue) {
+            setParentOfDisposable(oldValue, null);
+        }
         return oldValue;
     }
 }
@@ -249,8 +404,10 @@ class DisposableMap {
     constructor() {
         this._store = ( new Map());
         this._isDisposed = false;
+        trackDisposable(this);
     }
     dispose() {
+        markAsDisposed(this);
         this._isDisposed = true;
         this.clearAndDisposeAll();
     }
@@ -299,4 +456,4 @@ class DisposableMap {
         return this._store[Symbol.iterator]();
     }
 }
-export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsSingleton, toDisposable, trackDisposable };
+export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, DisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, toDisposable, trackDisposable };

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

@@ -30,6 +30,7 @@ var Schemas;
     Schemas.vscodeSettings = 'vscode-settings';
     Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
     Schemas.vscodeTerminal = 'vscode-terminal';
+    Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
     Schemas.vscodeChatSesssion = 'vscode-chat-editor';
     Schemas.webviewPanel = 'webview-panel';
     Schemas.vscodeWebview = 'vscode-webview';
@@ -38,6 +39,8 @@ var Schemas;
     Schemas.tmp = 'tmp';
     Schemas.vsls = 'vsls';
     Schemas.vscodeSourceControl = 'vscode-scm';
+    Schemas.codeSetting = 'code-setting';
+    Schemas.codeFeature = 'code-feature';
 })(Schemas || (Schemas = {})));
 function matchesScheme(target, scheme) {
     if (URI.isUri(target)) {

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

@@ -1,24 +1,21 @@
 import { assertFn } from '../assert.js';
-import { toDisposable, DisposableStore } from '../lifecycle.js';
-import { getFunctionName } from './base.js';
+import { toDisposable, DisposableStore, trackDisposable, markAsDisposed } from '../lifecycle.js';
+import { DebugNameData } from './debugName.js';
 function autorun(fn) {
-    return ( new AutorunObserver(undefined, fn, undefined, undefined));
+    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined, undefined));
 }
 function autorunOpts(options, fn) {
-    return ( new AutorunObserver(options.debugName, fn, undefined, undefined));
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined, undefined));
 }
 function autorunHandleChanges(options, fn) {
-    return ( new AutorunObserver(
-        options.debugName,
-        fn,
-        options.createEmptyChangeSummary,
-        options.handleChange
-    ));
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.createEmptyChangeSummary, options.handleChange));
 }
 function autorunWithStore(fn) {
     const store = ( new DisposableStore());
     const disposable = autorunOpts({
-        debugName: () => getFunctionName(fn) || '(anonymous)',
+        owner: undefined,
+        debugName: undefined,
+        debugReferenceFn: fn,
     }, reader => {
         store.clear();
         fn(reader, store);
@@ -28,25 +25,21 @@ function autorunWithStore(fn) {
         store.dispose();
     });
 }
+function autorunDelta(observable, handler) {
+    let _lastValue;
+    return autorunOpts({ debugReferenceFn: handler }, (reader) => {
+        const newValue = observable.read(reader);
+        const lastValue = _lastValue;
+        _lastValue = newValue;
+        handler({ lastValue, newValue });
+    });
+}
 class AutorunObserver {
     get debugName() {
-        if (typeof this._debugName === 'string') {
-            return this._debugName;
-        }
-        if (typeof this._debugName === 'function') {
-            const name = this._debugName();
-            if (name !== undefined) {
-                return name;
-            }
-        }
-        const name = getFunctionName(this._runFn);
-        if (name !== undefined) {
-            return name;
-        }
-        return '(anonymous)';
+        return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_debugName, _runFn, createChangeSummary, _handleChange) {
-        this._debugName = _debugName;
+    constructor(_debugNameData, _runFn, createChangeSummary, _handleChange) {
+        this._debugNameData = _debugNameData;
         this._runFn = _runFn;
         this.createChangeSummary = createChangeSummary;
         this._handleChange = _handleChange;
@@ -57,6 +50,7 @@ class AutorunObserver {
         this.dependenciesToBeRemoved = ( new Set());
         this.changeSummary = this.createChangeSummary?.();
         this._runIfNeeded();
+        trackDisposable(this);
     }
     dispose() {
         this.disposed = true;
@@ -64,6 +58,7 @@ class AutorunObserver {
             o.removeObserver(this);
         }
         this.dependencies.clear();
+        markAsDisposed(this);
     }
     _runIfNeeded() {
         if (this.state === 3 ) {
@@ -146,13 +141,4 @@ class AutorunObserver {
 ( (function(autorun) {
     autorun.Observer = AutorunObserver;
 })(autorun || (autorun = {})));
-function autorunDelta(observable, handler) {
-    let _lastValue;
-    return autorunOpts({ debugName: () => getFunctionName(handler) }, (reader) => {
-        const newValue = observable.read(reader);
-        const lastValue = _lastValue;
-        _lastValue = newValue;
-        handler({ lastValue, newValue });
-    });
-}
 export { AutorunObserver, autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore };

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

@@ -1,3 +1,4 @@
+import { DebugNameData, getFunctionName } from './debugName.js';
 let _recomputeInitiallyAndOnChange;
 function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
     _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
@@ -143,86 +144,6 @@ class TransactionImpl {
         this.updatingObservers = null;
     }
 }
-const countPerName = ( new Map());
-const cachedDebugName = ( new WeakMap());
-function getDebugName(self, debugNameFn, fn, owner) {
-    const cached = cachedDebugName.get(self);
-    if (cached) {
-        return cached;
-    }
-    const dbgName = computeDebugName(self, debugNameFn, fn, owner);
-    if (dbgName) {
-        let count = countPerName.get(dbgName) ?? 0;
-        count++;
-        countPerName.set(dbgName, count);
-        const result = count === 1 ? dbgName : `${dbgName}#${count}`;
-        cachedDebugName.set(self, result);
-        return result;
-    }
-    return undefined;
-}
-function computeDebugName(self, debugNameFn, fn, owner) {
-    const cached = cachedDebugName.get(self);
-    if (cached) {
-        return cached;
-    }
-    const ownerStr = owner ? formatOwner(owner) + `.` : '';
-    let result;
-    if (debugNameFn !== undefined) {
-        if (typeof debugNameFn === 'function') {
-            result = debugNameFn();
-            if (result !== undefined) {
-                return ownerStr + result;
-            }
-        }
-        else {
-            return ownerStr + debugNameFn;
-        }
-    }
-    if (fn !== undefined) {
-        result = getFunctionName(fn);
-        if (result !== undefined) {
-            return ownerStr + result;
-        }
-    }
-    if (owner !== undefined) {
-        for (const key in owner) {
-            if (owner[key] === self) {
-                return ownerStr + key;
-            }
-        }
-    }
-    return undefined;
-}
-const countPerClassName = ( new Map());
-const ownerId = ( new WeakMap());
-function formatOwner(owner) {
-    const id = ownerId.get(owner);
-    if (id) {
-        return id;
-    }
-    const className = getClassName(owner);
-    let count = countPerClassName.get(className) ?? 0;
-    count++;
-    countPerClassName.set(className, count);
-    const result = count === 1 ? className : `${className}#${count}`;
-    ownerId.set(owner, result);
-    return result;
-}
-function getClassName(obj) {
-    const ctor = obj.constructor;
-    if (ctor) {
-        return ctor.name;
-    }
-    return 'Object';
-}
-function getFunctionName(fn) {
-    const fnSrc = ( fn.toString());
-    const regexp = /\/\*\*\s*@description\s*([^*]*)\*\//;
-    const match = regexp.exec(fnSrc);
-    const result = match ? match[1] : undefined;
-    return result?.trim();
-}
 function observableValue(nameOrOwner, initialValue) {
     if (typeof nameOrOwner === 'string') {
         return ( new ObservableValue(undefined, nameOrOwner, initialValue));
@@ -233,7 +154,7 @@ function observableValue(nameOrOwner, initialValue) {
 }
 class ObservableValue extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, undefined, this._owner) ?? 'ObservableValue';
+        return ( new DebugNameData(this._owner, this._debugName, undefined)).getDebugName(this) ?? 'ObservableValue';
     }
     constructor(_owner, _debugName, initialValue) {
         super();
@@ -294,4 +215,4 @@ class DisposableObservableValue extends ObservableValue {
         this._value?.dispose();
     }
 }
-export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, getDebugName, getFunctionName, globalTransaction, observableValue, subtransaction, transaction };
+export { BaseObservable, ConvenientObservable, DisposableObservableValue, ObservableValue, TransactionImpl, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange, asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction };

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

@@ -0,0 +1,100 @@
+class DebugNameData {
+    constructor(owner, debugNameSource, referenceFn) {
+        this.owner = owner;
+        this.debugNameSource = debugNameSource;
+        this.referenceFn = referenceFn;
+    }
+    getDebugName(target) {
+        return getDebugName(target, this);
+    }
+}
+const countPerName = ( new Map());
+const cachedDebugName = ( new WeakMap());
+function getDebugName(target, data) {
+    const cached = cachedDebugName.get(target);
+    if (cached) {
+        return cached;
+    }
+    const dbgName = computeDebugName(target, data);
+    if (dbgName) {
+        let count = countPerName.get(dbgName) ?? 0;
+        count++;
+        countPerName.set(dbgName, count);
+        const result = count === 1 ? dbgName : `${dbgName}#${count}`;
+        cachedDebugName.set(target, result);
+        return result;
+    }
+    return undefined;
+}
+function computeDebugName(self, data) {
+    const cached = cachedDebugName.get(self);
+    if (cached) {
+        return cached;
+    }
+    const ownerStr = data.owner ? formatOwner(data.owner) + `.` : '';
+    let result;
+    const debugNameSource = data.debugNameSource;
+    if (debugNameSource !== undefined) {
+        if (typeof debugNameSource === 'function') {
+            result = debugNameSource();
+            if (result !== undefined) {
+                return ownerStr + result;
+            }
+        }
+        else {
+            return ownerStr + debugNameSource;
+        }
+    }
+    const referenceFn = data.referenceFn;
+    if (referenceFn !== undefined) {
+        result = getFunctionName(referenceFn);
+        if (result !== undefined) {
+            return ownerStr + result;
+        }
+    }
+    if (data.owner !== undefined) {
+        const key = findKey(data.owner, self);
+        if (key !== undefined) {
+            return ownerStr + key;
+        }
+    }
+    return undefined;
+}
+function findKey(obj, value) {
+    for (const key in obj) {
+        if (obj[key] === value) {
+            return key;
+        }
+    }
+    return undefined;
+}
+const countPerClassName = ( new Map());
+const ownerId = ( new WeakMap());
+function formatOwner(owner) {
+    const id = ownerId.get(owner);
+    if (id) {
+        return id;
+    }
+    const className = getClassName(owner);
+    let count = countPerClassName.get(className) ?? 0;
+    count++;
+    countPerClassName.set(className, count);
+    const result = count === 1 ? className : `${className}#${count}`;
+    ownerId.set(owner, result);
+    return result;
+}
+function getClassName(obj) {
+    const ctor = obj.constructor;
+    if (ctor) {
+        return ctor.name;
+    }
+    return 'Object';
+}
+function getFunctionName(fn) {
+    const fnSrc = ( fn.toString());
+    const regexp = /\/\*\*\s*@description\s*([^*]*)\*\//;
+    const match = regexp.exec(fnSrc);
+    const result = match ? match[1] : undefined;
+    return result?.trim();
+}
+export { DebugNameData, getDebugName, getFunctionName };

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

@@ -1,50 +1,20 @@
 import { assertFn } from '../assert.js';
 import { DisposableStore } from '../lifecycle.js';
-import { getFunctionName, BaseObservable, getDebugName, _setDerivedOpts } from './base.js';
+import { BaseObservable, _setDerivedOpts } from './base.js';
+import { DebugNameData } from './debugName.js';
 const defaultEqualityComparer = (a, b) => a === b;
 function derived(computeFnOrOwner, computeFn) {
     if (computeFn !== undefined) {
-        return ( new Derived(
-            computeFnOrOwner,
-            undefined,
-            computeFn,
-            undefined,
-            undefined,
-            undefined,
-            defaultEqualityComparer
-        ));
-    }
-    return ( new Derived(
-        undefined,
-        undefined,
-        computeFnOrOwner,
-        undefined,
-        undefined,
-        undefined,
-        defaultEqualityComparer
-    ));
+        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, undefined, defaultEqualityComparer));
+    }
+    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, undefined, defaultEqualityComparer));
 }
 function derivedOpts(options, computeFn) {
-    return ( new Derived(
-        options.owner,
-        options.debugName,
-        computeFn,
-        undefined,
-        undefined,
-        options.onLastObserverRemoved,
-        options.equalityComparer ?? defaultEqualityComparer
-    ));
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, undefined, options.onLastObserverRemoved, options.equalityComparer ?? defaultEqualityComparer));
 }
+_setDerivedOpts(derivedOpts);
 function derivedHandleChanges(options, computeFn) {
-    return ( new Derived(
-        options.owner,
-        options.debugName,
-        computeFn,
-        options.createEmptyChangeSummary,
-        options.handleChange,
-        undefined,
-        options.equalityComparer ?? defaultEqualityComparer
-    ));
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.createEmptyChangeSummary, options.handleChange, undefined, options.equalityComparer ?? defaultEqualityComparer));
 }
 function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
     let computeFn;
@@ -58,7 +28,7 @@ function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
         computeFn = computeFnOrUndefined;
     }
     const store = ( new DisposableStore());
-    return ( new Derived(owner, (() => getFunctionName(computeFn) ?? '(anonymous)'), r => {
+    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
         store.clear();
         return computeFn(r, store);
     }, undefined, undefined, () => store.dispose(), defaultEqualityComparer));
@@ -75,7 +45,7 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
         computeFn = computeFnOrUndefined;
     }
     const store = ( new DisposableStore());
-    return ( new Derived(owner, (() => getFunctionName(computeFn) ?? '(anonymous)'), r => {
+    return ( new Derived(( new DebugNameData(owner, undefined, computeFn)), r => {
         store.clear();
         const result = computeFn(r);
         if (result) {
@@ -84,15 +54,13 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
         return result;
     }, undefined, undefined, () => store.dispose(), defaultEqualityComparer));
 }
-_setDerivedOpts(derivedOpts);
 class Derived extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, this._computeFn, this._owner) ?? '(anonymous)';
+        return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_owner, _debugName, _computeFn, createChangeSummary, _handleChange, _handleLastObserverRemoved = undefined, _equalityComparator) {
+    constructor(_debugNameData, _computeFn, createChangeSummary, _handleChange, _handleLastObserverRemoved = undefined, _equalityComparator) {
         super();
-        this._owner = _owner;
-        this._debugName = _debugName;
+        this._debugNameData = _debugNameData;
         this._computeFn = _computeFn;
         this.createChangeSummary = createChangeSummary;
         this._handleChange = _handleChange;
@@ -245,4 +213,4 @@ class Derived extends BaseObservable {
         }
     }
 }
-export { Derived, derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithStore };
+export { Derived, defaultEqualityComparer, derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithStore };