@codingame/monaco-vscode-api 2.2.2 → 3.0.0

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 { 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;
@@ -146,13 +139,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 };

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

@@ -0,0 +1,94 @@
+import { autorun } from './autorun.js';
+import { observableValue, transaction } from './base.js';
+import { derived } from './derived.js';
+class ObservableLazy {
+    get cachedValue() { return this._value; }
+    constructor(_computeValue) {
+        this._computeValue = _computeValue;
+        this._value = observableValue(this, undefined);
+    }
+    getValue() {
+        let v = this._value.get();
+        if (!v) {
+            v = this._computeValue();
+            this._value.set(v, undefined);
+        }
+        return v;
+    }
+}
+class ObservablePromise {
+    constructor(promise) {
+        this._value = observableValue(this, undefined);
+        this.promiseResult = this._value;
+        this.promise = promise.then(value => {
+            transaction(tx => {
+                this._value.set(( new PromiseResult(value, undefined)), tx);
+            });
+            return value;
+        }, error => {
+            transaction(tx => {
+                this._value.set(( new PromiseResult(undefined, error)), tx);
+            });
+            throw error;
+        });
+    }
+}
+class PromiseResult {
+    constructor(
+    data,
+    error) {
+        this.data = data;
+        this.error = error;
+    }
+    getDataOrThrow() {
+        if (this.error) {
+            throw this.error;
+        }
+        return this.data;
+    }
+}
+class ObservableLazyPromise {
+    constructor(_computePromise) {
+        this._computePromise = _computePromise;
+        this._lazyValue = ( new ObservableLazy(() => ( new ObservablePromise(this._computePromise()))));
+        this.cachedPromiseResult = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));
+    }
+    getPromise() {
+        return this._lazyValue.getValue().promise;
+    }
+}
+function waitForState(observable, predicate, isError) {
+    return ( new Promise((resolve, reject) => {
+        let isImmediateRun = true;
+        let shouldDispose = false;
+        const stateObs = ( observable.map(state => {
+            return {
+                isFinished: predicate(state),
+                error: isError ? isError(state) : false,
+                state
+            };
+        }));
+        const d = autorun(reader => {
+            const { isFinished, error, state } = stateObs.read(reader);
+            if (isFinished || error) {
+                if (isImmediateRun) {
+                    shouldDispose = true;
+                }
+                else {
+                    d.dispose();
+                }
+                if (error) {
+                    reject(error === true ? state : error);
+                }
+                else {
+                    resolve(state);
+                }
+            }
+        });
+        isImmediateRun = false;
+        if (shouldDispose) {
+            d.dispose();
+        }
+    }));
+}
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, waitForState };

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

@@ -1,6 +1,7 @@
 import { toDisposable, DisposableStore } from '../lifecycle.js';
 import { autorun } from './autorun.js';
-import { ConvenientObservable, BaseObservable, subtransaction, getFunctionName, transaction, getDebugName, _setKeepObserved, _setRecomputeInitiallyAndOnChange, observableValue } from './base.js';
+import { ConvenientObservable, BaseObservable, subtransaction, transaction, _setKeepObserved, _setRecomputeInitiallyAndOnChange, observableValue } from './base.js';
+import { getFunctionName, DebugNameData } from './debugName.js';
 import { derivedOpts, derived } from './derived.js';
 function constObservable(value) {
     return ( new ConstObservable(value));
@@ -31,29 +32,6 @@ function observableFromPromise(promise) {
     });
     return observable;
 }
-function waitForState(observable, predicate) {
-    return ( new Promise(resolve => {
-        let didRun = false;
-        let shouldDispose = false;
-        const stateObs = ( observable.map(state => ({ isFinished: predicate(state), state })));
-        const d = autorun(reader => {
-            const { isFinished, state } = stateObs.read(reader);
-            if (isFinished) {
-                if (!didRun) {
-                    shouldDispose = true;
-                }
-                else {
-                    d.dispose();
-                }
-                resolve(state);
-            }
-        });
-        didRun = true;
-        if (shouldDispose) {
-            d.dispose();
-        }
-    }));
-}
 function observableFromEvent(event, getValue) {
     return ( new FromEventObservable(event, getValue));
 }
@@ -168,7 +146,7 @@ function observableSignal(debugNameOrOwner) {
 }
 class ObservableSignal extends BaseObservable {
     get debugName() {
-        return getDebugName(this, this._debugName, undefined, this._owner) ?? 'Observable Signal';
+        return ( new DebugNameData(this._owner, this._debugName, undefined)).getDebugName(this) ?? 'Observable Signal';
     }
     constructor(_debugName, _owner) {
         super();
@@ -293,7 +271,7 @@ function derivedObservableWithWritableCache(owner, computeFn) {
 function mapObservableArrayCached(owner, items, map, keySelector) {
     let m = ( new ArrayMap(map, keySelector));
     const self = derivedOpts({
-        debugName: () => getDebugName(m, undefined, map, owner),
+        debugReferenceFn: map,
         owner,
         onLastObserverRemoved: () => {
             m.dispose();
@@ -344,4 +322,4 @@ class ArrayMap {
         return this._items;
     }
 }
-export { FromEventObservable, constObservable, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromEvent, observableFromPromise, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, waitForState, wasEventTriggeredRecently };
+export { FromEventObservable, KeepAliveObserver, constObservable, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromEvent, observableFromPromise, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, wasEventTriggeredRecently };

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

@@ -18,29 +18,45 @@ class WellDefinedPrefixTree {
         this.opNode(key, n => n._value = mutate(n._value === unset ? undefined : n._value));
     }
     delete(key) {
-        const path = [{ part: '', node: this.root }];
-        let i = 0;
-        for (const part of key) {
-            const node = path[i].node.children?.get(part);
-            if (!node) {
-                return undefined;
-            }
-            path.push({ part, node });
-            i++;
+        const path = this.getPathToKey(key);
+        if (!path) {
+            return;
         }
+        let i = path.length - 1;
         const value = path[i].node._value;
         if (value === unset) {
             return;
         }
         this._size--;
+        path[i].node._value = unset;
         for (; i > 0; i--) {
+            const { node, part } = path[i];
+            if (node.children?.size || node._value !== unset) {
+                break;
+            }
+            path[i - 1].node.children.delete(part);
+        }
+        return value;
+    }
+    *deleteRecursive(key) {
+        const path = this.getPathToKey(key);
+        if (!path) {
+            return;
+        }
+        const subtree = path[path.length - 1].node;
+        for (let i = path.length - 1; i > 0; i--) {
             const parent = path[i - 1];
             parent.node.children.delete(path[i].part);
             if (parent.node.children.size > 0 || parent.node._value !== unset) {
                 break;
             }
         }
-        return value;
+        for (const node of bfsIterate(subtree)) {
+            if (node._value !== unset) {
+                this._size--;
+                yield node._value;
+            }
+        }
     }
     find(key) {
         let node = this.root;
@@ -89,6 +105,19 @@ class WellDefinedPrefixTree {
         }
         return node._value !== unset;
     }
+    getPathToKey(key) {
+        const path = [{ part: '', node: this.root }];
+        let i = 0;
+        for (const part of key) {
+            const node = path[i].node.children?.get(part);
+            if (!node) {
+                return;
+            }
+            path.push({ part, node });
+            i++;
+        }
+        return path;
+    }
     opNode(key, fn, onDescend) {
         let node = this.root;
         for (const part of key) {
@@ -107,22 +136,27 @@ class WellDefinedPrefixTree {
             }
             onDescend?.(node);
         }
-        if (node._value === unset) {
-            this._size++;
-        }
+        const sizeBefore = node._value === unset ? 0 : 1;
         fn(node);
+        const sizeAfter = node._value === unset ? 0 : 1;
+        this._size += sizeAfter - sizeBefore;
     }
     *values() {
-        const stack = [this.root];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (node._value !== unset) {
-                yield node._value;
+        for (const { _value } of bfsIterate(this.root)) {
+            if (_value !== unset) {
+                yield _value;
             }
-            if (node.children) {
-                for (const child of ( node.children.values())) {
-                    stack.push(child);
-                }
+        }
+    }
+}
+function* bfsIterate(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        yield node;
+        if (node.children) {
+            for (const child of ( node.children.values())) {
+                stack.push(child);
             }
         }
     }

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

@@ -107,7 +107,7 @@ interface IProductConfiguration {
     readonly webExtensionTips?: readonly string[];
     readonly languageExtensionTips?: readonly string[];
     readonly trustedExtensionUrlPublicKeys?: IStringDictionary<string[]>;
-    readonly trustedExtensionAuthAccess?: readonly string[];
+    readonly trustedExtensionAuthAccess?: string[] | IStringDictionary<string[]>;
     readonly trustedExtensionProtocolHandlers?: readonly string[];
     readonly commandPaletteSuggestedCommandIds?: string[];
     readonly crashReporter?: {