@vscode/markdown-editor 0.0.2-8 → 0.0.2-80

package/dist/_observables/observableInternal/changeTracker.d.ts

@@ -1,44 +0,0 @@
-import { IObservableWithChange, IReader } from './base';
-export interface IChangeTracker<TChangeSummary> {
-    createChangeSummary(previousChangeSummary: TChangeSummary | undefined): TChangeSummary;
-    handleChange(ctx: IChangeContext, change: TChangeSummary): boolean;
-    beforeUpdate?(reader: IReader, change: TChangeSummary): void;
-}
-export interface IChangeContext {
-    readonly changedObservable: IObservableWithChange<any, any>;
-    readonly change: unknown;
-    /**
-     * Returns if the given observable caused the change.
-     */
-    didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is {
-        change: TChange;
-    };
-}
-/**
- * Subscribes to and records changes and the last value of the given observables.
- * Don't use the key "changes", as it is reserved for the changes array!
-*/
-export declare function recordChanges<TObs extends Record<any, IObservableWithChange<any, any>>>(obs: TObs): IChangeTracker<{
-    [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']>;
-} & {
-    changes: readonly ({
-        [TKey in keyof TObs]: {
-            key: TKey;
-            change: TObs[TKey]['TChange'];
-        };
-    }[keyof TObs])[];
-}>;
-/**
- * Subscribes to and records changes and the last value of the given observables.
- * Don't use the key "changes", as it is reserved for the changes array!
-*/
-export declare function recordChangesLazy<TObs extends Record<any, IObservableWithChange<any, any>>>(getObs: () => TObs): IChangeTracker<{
-    [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']>;
-} & {
-    changes: readonly ({
-        [TKey in keyof TObs]: {
-            key: TKey;
-            change: TObs[TKey]['TChange'];
-        };
-    }[keyof TObs])[];
-}>;

package/dist/_observables/observableInternal/commonFacade/cancellation.d.ts

@@ -1,24 +0,0 @@
-export declare class CancellationError extends Error {
-    constructor(message?: string);
-}
-export interface CancellationToken {
-    readonly isCancellationRequested: boolean;
-    readonly onCancellationRequested: (listener: () => void) => {
-        dispose: () => void;
-    };
-}
-export declare class CancellationTokenSource {
-    private _isCancelled;
-    private _listeners;
-    get token(): CancellationToken;
-    cancel(): void;
-    dispose(): void;
-}
-/**
- * Creates a CancellationToken that is cancelled when the given disposable is disposed.
- */
-export declare function cancelOnDispose(disposable: {
-    add: (d: {
-        dispose: () => void;
-    }) => void;
-}): CancellationToken;

package/dist/_observables/observableInternal/commonFacade/deps.d.ts

@@ -1,24 +0,0 @@
-import { IDisposable } from '../../disposables';
-export { DisposableStore, IDisposable } from '../../disposables';
-export declare function markAsDisposed(_obj: any): void;
-export declare function trackDisposable(_obj: any): void;
-export declare function assertFn(_condition: () => boolean): void;
-export declare function toDisposable(fn: () => void): IDisposable;
-export declare class BugIndicatingError extends Error {
-    constructor(message?: string);
-}
-export declare function onBugIndicatingError(error: any): void;
-export declare function onUnexpectedError(error: any): void;
-export type EqualityComparer<T> = (a: T, b: T) => boolean;
-/**
- * Compares two items for equality using strict equality.
-*/
-export declare const strictEquals: EqualityComparer<any>;
-export interface IValueWithChangeEvent<T> {
-    readonly onDidChange: Event<void>;
-    get value(): T;
-}
-export interface Event<T> {
-    (listener: (e: T) => any, thisArgs?: any): IDisposable;
-}
-export declare function isDefined<T>(arg: T | undefined | null): arg is T;

package/dist/_observables/observableInternal/debugLocation.d.ts

@@ -1,21 +0,0 @@
-export type DebugLocation = DebugLocationImpl | undefined;
-export declare namespace DebugLocation {
-    function enable(): void;
-    function ofCaller(): DebugLocation;
-    function ofNthCaller(n: number): DebugLocation;
-}
-declare class DebugLocationImpl implements ILocation {
-    readonly fileName: string;
-    readonly line: number;
-    readonly column: number;
-    readonly id: string;
-    static fromStack(stack: string, parentIdx: number): DebugLocationImpl | undefined;
-    constructor(fileName: string, line: number, column: number, id: string);
-}
-export interface ILocation {
-    fileName: string;
-    line: number;
-    column: number;
-    id: string;
-}
-export {};

package/dist/_observables/observableInternal/debugName.d.ts

@@ -1,33 +0,0 @@
-export interface IDebugNameData {
-    /**
-     * The owner object of an observable.
-     * Used for debugging only, such as computing a name for the observable by iterating over the fields of the owner.
-     */
-    readonly owner?: DebugOwner | undefined;
-    /**
-     * A string or function that returns a string that represents the name of the observable.
-     * Used for debugging only.
-     */
-    readonly debugName?: DebugNameSource | undefined;
-    /**
-     * A function that points to the defining function of the object.
-     * Used for debugging only.
-     */
-    readonly debugReferenceFn?: Function | undefined;
-}
-export declare class DebugNameData {
-    readonly owner: DebugOwner | undefined;
-    readonly debugNameSource: DebugNameSource | undefined;
-    readonly referenceFn: Function | undefined;
-    constructor(owner: DebugOwner | undefined, debugNameSource: DebugNameSource | undefined, referenceFn: Function | undefined);
-    getDebugName(target: object): string | undefined;
-}
-/**
- * The owning object of an observable.
- * Is only used for debugging purposes, such as computing a name for the observable by iterating over the fields of the owner.
- */
-export type DebugOwner = object | undefined;
-export type DebugNameSource = string | (() => string | undefined);
-export declare function getDebugName(target: object, data: DebugNameData): string | undefined;
-export declare function getClassName(obj: object): string | undefined;
-export declare function getFunctionName(fn: Function): string | undefined;

package/dist/_observables/observableInternal/experimental/deferUnobserve.d.ts

@@ -1,16 +0,0 @@
-import { IObservable } from '../base';
-import { DisposableStore } from '../commonFacade/deps';
-/**
- * Wraps an observable so that its source remains observed for a grace period
- * after the wrapping observable loses all its observers.
- *
- * When the wrapping observable has observers, an autorun keeps `obs` observed
- * and forwards changes. When the last observer is removed, `obs` stays observed
- * via `keepObserved` for `maxIdleTimeMs` before being released. If a new observer
- * arrives during the grace period, the keep-alive is cancelled seamlessly.
- *
- * @param store - Controls the hard lifetime; disposing it cancels any pending grace period.
- * @param obs - The source observable to keep alive longer.
- * @param maxIdleTimeMs - Grace period in milliseconds.
- */
-export declare function deferUnobserve<T>(store: DisposableStore, obs: IObservable<T>, maxIdleTimeMs: number): IObservable<T>;

package/dist/_observables/observableInternal/experimental/reducer.d.ts

@@ -1,37 +0,0 @@
-import { EqualityComparer } from '../commonFacade/deps';
-import { IObservable, IObservableWithChange, ISettableObservable } from '../base';
-import { IChangeTracker } from '../changeTracker';
-import { DebugOwner } from '../debugName';
-import { IDerivedReader } from '../observables/derivedImpl';
-export interface IReducerOptions<T, TChangeSummary = void, TOutChange = void> {
-    /**
-     * Is called to create the initial value of the observable when it becomes observed.
-    */
-    initial: T | (() => T);
-    /**
-     * Is called to dispose the observable value when it is no longer observed.
-    */
-    disposeFinal?(value: T): void;
-    changeTracker?: IChangeTracker<TChangeSummary>;
-    equalityComparer?: EqualityComparer<T>;
-    /**
-     * Applies the changes to the value.
-     * Use `reader.reportChange` to report change details or to report a change if the same value is returned.
-    */
-    update(reader: IDerivedReader<TOutChange>, previousValue: T, changes: TChangeSummary): T;
-}
-/**
- * Creates an observable value that is based on values and changes from other observables.
- * Additionally, a reducer can report how that state changed.
-*/
-export declare function observableReducer<T, TInChanges, TOutChange = void>(owner: DebugOwner, options: IReducerOptions<T, TInChanges, TOutChange>): SimplifyObservableWithChange<T, TOutChange>;
-/**
- * Creates an observable value that is based on values and changes from other observables.
- * Additionally, a reducer can report how that state changed.
-*/
-export declare function observableReducerSettable<T, TInChanges, TOutChange = void>(owner: DebugOwner, options: IReducerOptions<T, TInChanges, TOutChange>): ISettableObservable<T, TOutChange>;
-/**
- * Returns IObservable<T> if TChange is void, otherwise IObservableWithChange<T, TChange>
-*/
-type SimplifyObservableWithChange<T, TChange> = TChange extends void ? IObservable<T> : IObservableWithChange<T, TChange>;
-export {};

package/dist/_observables/observableInternal/experimental/utils.d.ts

@@ -1,15 +0,0 @@
-import { IObservable, IReader } from '../base';
-import { DebugOwner } from '../debugName';
-/**
- * Creates an observable that has the latest changed value of the given observables.
- * Initially (and when not observed), it has the value of the last observable.
- * When observed and any of the observables change, it has the value of the last changed observable.
- * If multiple observables change in the same transaction, the last observable wins.
-*/
-export declare function latestChangedValue<T extends IObservable<any>[]>(owner: DebugOwner, observables: T): IObservable<ReturnType<T[number]['get']>>;
-/**
- * Works like a derived.
- * However, if the value is not undefined, it is cached and will not be recomputed anymore.
- * In that case, the derived will unsubscribe from its dependencies.
-*/
-export declare function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reader: IReader) => T): IObservable<T | undefined>;

package/dist/_observables/observableInternal/index.d.ts

@@ -1,25 +0,0 @@
-export { observableValueOpts } from './observables/observableValueOpts';
-export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunSelfDisposable } from './reactions/autorun';
-export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction } from './base';
-export { disposableObservableValue } from './observables/observableValue';
-export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './observables/derived';
-export { type IDerivedReader } from './observables/derivedImpl';
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from './utils/promise';
-export { derivedWithCancellationToken, waitForState } from './utils/utilsCancellation';
-export { debouncedObservableDeprecated, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, wasEventTriggeredRecently, } from './utils/utils';
-export { type DebugOwner } from './debugName';
-export { type IChangeContext, type IChangeTracker, recordChanges, recordChangesLazy } from './changeTracker';
-export { constObservable } from './observables/constObservable';
-export { type IObservableSignal, observableSignal } from './observables/observableSignal';
-export { observableFromEventOpts } from './observables/observableFromEvent';
-export { observableSignalFromEvent } from './observables/observableSignalFromEvent';
-export { asyncTransaction, globalTransaction, subtransaction, transaction, TransactionImpl } from './transaction';
-export { observableFromValueWithChangeEvent, ValueWithChangeEventFromObservable } from './utils/valueWithChangeEvent';
-export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, type RemoveUndefined } from './utils/runOnChange';
-export { derivedConstOnceDefined, latestChangedValue } from './experimental/utils';
-export { deferUnobserve } from './experimental/deferUnobserve';
-export { observableFromEvent } from './observables/observableFromEvent';
-export { observableValue } from './observables/observableValue';
-export { ObservableSet } from './set';
-export { ObservableMap } from './map';
-export { DebugLocation } from './debugLocation';

package/dist/_observables/observableInternal/logging/consoleObservableLogger.d.ts

@@ -1,40 +0,0 @@
-import { IObservable } from '../base';
-import { TransactionImpl } from '../transaction';
-import { IObservableLogger, IChangeInformation } from './logging';
-import { FromEventObservable } from '../observables/observableFromEvent';
-import { Derived } from '../observables/derivedImpl';
-import { AutorunObserver } from '../reactions/autorunImpl';
-export declare function logObservableToConsole(obs: IObservable<any>): void;
-export declare class ConsoleObservableLogger implements IObservableLogger {
-    private indentation;
-    private _filteredObjects;
-    addFilteredObj(obj: unknown): void;
-    private _isIncluded;
-    private textToConsoleArgs;
-    private formatInfo;
-    handleObservableCreated(observable: IObservable<any>): void;
-    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
-    handleObservableUpdated(observable: IObservable<unknown>, info: IChangeInformation): void;
-    private readonly changedObservablesSets;
-    formatChanges(changes: Set<IObservable<any>>): ConsoleText | undefined;
-    handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void;
-    _handleDerivedRecomputed(derived: Derived<unknown>, info: IChangeInformation): void;
-    handleDerivedCleared(derived: Derived<unknown>): void;
-    handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void;
-    handleAutorunCreated(autorun: AutorunObserver): void;
-    handleAutorunDisposed(autorun: AutorunObserver): void;
-    handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
-    handleAutorunStarted(autorun: AutorunObserver): void;
-    handleAutorunFinished(autorun: AutorunObserver): void;
-    handleBeginTransaction(transaction: TransactionImpl): void;
-    handleEndTransaction(): void;
-}
-type ConsoleText = (ConsoleText | undefined)[] | {
-    text: string;
-    style: string;
-    data?: unknown[];
-} | {
-    data: unknown[];
-};
-export declare function formatValue(value: unknown, availableLen: number): string;
-export {};

package/dist/_observables/observableInternal/logging/debugGetDependencyGraph.d.ts

@@ -1,4 +0,0 @@
-import { IObservable, IObserver } from '../base';
-export declare function debugGetDependencyGraph(obs: IObservable<any> | IObserver, options?: {
-    debugNamePostProcessor?: (name: string) => string;
-}): string;

package/dist/_observables/observableInternal/logging/debugger/debuggerRpc.d.ts

@@ -1,4 +0,0 @@
-import { API, SimpleTypedRpcConnection, MakeSideAsync } from './rpc';
-export declare function registerDebugChannel<T extends {
-    channelId: string;
-} & API>(channelId: T['channelId'], createClient: () => T['client']): SimpleTypedRpcConnection<MakeSideAsync<T['host']>>;

package/dist/_observables/observableInternal/logging/debugger/devToolsLogger.d.ts

@@ -1,43 +0,0 @@
-import { AutorunObserver } from '../../reactions/autorunImpl';
-import { TransactionImpl } from '../../transaction';
-import { IChangeInformation, IObservableLogger } from '../logging';
-import { IObservable } from '../../base';
-import { Derived } from '../../observables/derivedImpl';
-import { DebugLocation } from '../../debugLocation';
-export declare class DevToolsLogger implements IObservableLogger {
-    private static _instance;
-    static getInstance(): DevToolsLogger;
-    private _declarationId;
-    private _instanceId;
-    private readonly _declarations;
-    private readonly _instanceInfos;
-    private readonly _aliveInstances;
-    private readonly _activeTransactions;
-    private readonly _channel;
-    private getTransactionState;
-    private _getObservableInfo;
-    private _getAutorunInfo;
-    private _getInfo;
-    private _formatObservable;
-    private _formatObserver;
-    private constructor();
-    private _pendingChanges;
-    private readonly _changeThrottler;
-    private readonly _fullState;
-    private _handleChange;
-    private readonly _flushUpdates;
-    private _getDeclarationId;
-    handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
-    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
-    handleObservableUpdated(observable: IObservable<any>, changeInfo: IChangeInformation): void;
-    handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;
-    handleAutorunDisposed(autorun: AutorunObserver): void;
-    handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
-    handleAutorunStarted(autorun: AutorunObserver): void;
-    handleAutorunFinished(autorun: AutorunObserver): void;
-    handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void;
-    _handleDerivedRecomputed(observable: Derived<any>, changeInfo: IChangeInformation): void;
-    handleDerivedCleared(observable: Derived<any>): void;
-    handleBeginTransaction(transaction: TransactionImpl): void;
-    handleEndTransaction(transaction: TransactionImpl): void;
-}

package/dist/_observables/observableInternal/logging/debugger/rpc.d.ts

@@ -1,41 +0,0 @@
-export type ChannelFactory = (handler: IChannelHandler) => IChannel;
-export interface IChannel {
-    sendNotification(data: unknown): void;
-    sendRequest(data: unknown): Promise<RpcRequestResult>;
-}
-export interface IChannelHandler {
-    handleNotification(notificationData: unknown): void;
-    handleRequest(requestData: unknown): Promise<RpcRequestResult> | RpcRequestResult;
-}
-export type RpcRequestResult = {
-    type: 'result';
-    value: unknown;
-} | {
-    type: 'error';
-    value: unknown;
-};
-export type API = {
-    host: Side;
-    client: Side;
-};
-export type Side = {
-    notifications: Record<string, (...args: any[]) => void>;
-    requests: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
-};
-type MakeAsyncIfNot<TFn> = TFn extends (...args: infer TArgs) => infer TResult ? TResult extends Promise<unknown> ? TFn : (...args: TArgs) => Promise<TResult> : never;
-export type MakeSideAsync<T extends Side> = {
-    notifications: T['notifications'];
-    requests: {
-        [K in keyof T['requests']]: MakeAsyncIfNot<T['requests'][K]>;
-    };
-};
-export declare class SimpleTypedRpcConnection<T extends Side> {
-    private readonly _channelFactory;
-    private readonly _getHandler;
-    static createHost<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['host']): SimpleTypedRpcConnection<MakeSideAsync<T['client']>>;
-    static createClient<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['client']): SimpleTypedRpcConnection<MakeSideAsync<T['host']>>;
-    readonly api: T;
-    private readonly _channel;
-    private constructor();
-}
-export {};

package/dist/_observables/observableInternal/logging/debugger/utils.d.ts

@@ -1,13 +0,0 @@
-import { IDisposable } from '../../../disposables';
-export declare class Debouncer implements IDisposable {
-    private _timeout;
-    debounce(fn: () => void, timeoutMs: number): void;
-    dispose(): void;
-}
-export declare class Throttler implements IDisposable {
-    private _timeout;
-    throttle(fn: () => void, timeoutMs: number): void;
-    dispose(): void;
-}
-export declare function deepAssign<T>(target: T, source: T): void;
-export declare function deepAssignDeleteNulls<T>(target: T, source: T): void;

package/dist/_observables/observableInternal/logging/logging.d.ts

@@ -1,30 +0,0 @@
-import { AutorunObserver } from '../reactions/autorunImpl';
-import { IObservable } from '../base';
-import { TransactionImpl } from '../transaction';
-import type { Derived } from '../observables/derivedImpl';
-import { DebugLocation } from '../debugLocation';
-export declare function addLogger(logger: IObservableLogger): void;
-export declare function getLogger(): IObservableLogger | undefined;
-export declare function setLogObservableFn(fn: (obs: IObservable<any>) => void): void;
-export declare function logObservable(obs: IObservable<any>): void;
-export interface IChangeInformation {
-    oldValue: unknown;
-    newValue: unknown;
-    change: unknown;
-    didChange: boolean;
-    hadValue: boolean;
-}
-export interface IObservableLogger {
-    handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
-    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
-    handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void;
-    handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;
-    handleAutorunDisposed(autorun: AutorunObserver): void;
-    handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
-    handleAutorunStarted(autorun: AutorunObserver): void;
-    handleAutorunFinished(autorun: AutorunObserver): void;
-    handleDerivedDependencyChanged(derived: Derived<any, any, any>, observable: IObservable<any>, change: unknown): void;
-    handleDerivedCleared(observable: Derived<any, any, any>): void;
-    handleBeginTransaction(transaction: TransactionImpl): void;
-    handleEndTransaction(transaction: TransactionImpl): void;
-}

package/dist/_observables/observableInternal/map.d.ts

@@ -1,18 +0,0 @@
-import { IObservable, ITransaction } from './base';
-export declare class ObservableMap<K, V> implements Map<K, V> {
-    private readonly _data;
-    private readonly _obs;
-    readonly observable: IObservable<Map<K, V>>;
-    get size(): number;
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    set(key: K, value: V, tx?: ITransaction): this;
-    delete(key: K, tx?: ITransaction): boolean;
-    clear(tx?: ITransaction): void;
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
-    entries(): IterableIterator<[K, V]>;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    get [Symbol.toStringTag](): string;
-}

package/dist/_observables/observableInternal/observables/baseObservable.d.ts

@@ -1,58 +0,0 @@
-import { IObservableWithChange, IObserver, IReader, IObservable } from '../base';
-import { DisposableStore } from '../commonFacade/deps';
-import { DebugLocation } from '../debugLocation';
-import { DebugOwner } from '../debugName';
-import { debugGetDependencyGraph } from '../logging/debugGetDependencyGraph';
-import type { keepObserved, recomputeInitiallyAndOnChange } from '../utils/utils';
-import { derivedOpts } from './derived';
-declare let _derived: typeof derivedOpts;
-/**
- * @internal
- * This is to allow splitting files.
-*/
-export declare function _setDerivedOpts(derived: typeof _derived): void;
-declare let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
-export declare function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange): void;
-declare let _keepObserved: typeof keepObserved;
-export declare function _setKeepObserved(keepObserved: typeof _keepObserved): void;
-declare let _debugGetDependencyGraph: typeof debugGetDependencyGraph;
-export declare function _setDebugGetDependencyGraph(debugGetDependencyGraph: typeof _debugGetDependencyGraph): void;
-export declare abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
-    get TChange(): TChange;
-    abstract get(): T;
-    reportChanges(): void;
-    abstract addObserver(observer: IObserver): void;
-    abstract removeObserver(observer: IObserver): void;
-    /** @sealed */
-    read(reader: IReader | undefined): T;
-    /** @sealed */
-    map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
-    map<TNew>(owner: DebugOwner, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
-    abstract log(): IObservableWithChange<T, TChange>;
-    /**
-     * @sealed
-     * Converts an observable of an observable value into a direct observable of the value.
-    */
-    flatten<TNew>(this: IObservable<IObservableWithChange<TNew, any>>): IObservable<TNew>;
-    recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
-    /**
-     * Ensures that this observable is observed. This keeps the cache alive.
-     * However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).
-     * Use `recomputeInitiallyAndOnChange` for eager evaluation.
-     */
-    keepObserved(store: DisposableStore): IObservable<T>;
-    abstract get debugName(): string;
-    protected get debugValue(): T;
-    debugGetDependencyGraph(): string;
-}
-export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
-    protected readonly _observers: Set<IObserver>;
-    constructor(debugLocation: DebugLocation);
-    addObserver(observer: IObserver): void;
-    removeObserver(observer: IObserver): void;
-    protected onFirstObserverAdded(): void;
-    protected onLastObserverRemoved(): void;
-    log(): IObservableWithChange<T, TChange>;
-    debugGetObservers(): Set<IObserver>;
-}
-export {};

package/dist/_observables/observableInternal/observables/constObservable.d.ts

@@ -1,5 +0,0 @@
-import { IObservable } from '../base';
-/**
- * Represents an efficient observable whose value never changes.
- */
-export declare function constObservable<T>(value: T): IObservable<T>;

package/dist/_observables/observableInternal/observables/derived.d.ts

@@ -1,46 +0,0 @@
-import { IObservable, IReader, ITransaction, ISettableObservable, IObservableWithChange } from '../base';
-import { IChangeTracker } from '../changeTracker';
-import { DisposableStore, EqualityComparer, IDisposable } from '../commonFacade/deps';
-import { DebugLocation } from '../debugLocation';
-import { DebugOwner, IDebugNameData } from '../debugName';
-import { IDerivedReader } from './derivedImpl';
-/**
- * Creates an observable that is derived from other observables.
- * The value is only recomputed when absolutely needed.
- *
- * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
- */
-export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
-export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
-export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void, debugLocation?: DebugLocation): ISettableObservable<T>;
-export declare function derivedOpts<T>(options: IDebugNameData & {
-    equalsFn?: EqualityComparer<T>;
-    onLastObserverRemoved?: (() => void);
-}, computeFn: (reader: IReader) => T, debugLocation?: DebugLocation): IObservable<T>;
-/**
- * Represents an observable that is derived from other observables.
- * The value is only recomputed when absolutely needed.
- *
- * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
- *
- * Use `createEmptyChangeSummary` to create a "change summary" that can collect the changes.
- * Use `handleChange` to add a reported change to the change summary.
- * The compute function is given the last change summary.
- * The change summary is discarded after the compute function was called.
- *
- * @see derived
- */
-export declare function derivedHandleChanges<T, TDelta, TChangeSummary>(options: IDebugNameData & {
-    changeTracker: IChangeTracker<TChangeSummary>;
-    equalityComparer?: EqualityComparer<T>;
-}, computeFn: (reader: IDerivedReader<TDelta>, changeSummary: TChangeSummary) => T, debugLocation?: DebugLocation): IObservableWithChange<T, TDelta>;
-/**
- * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
-*/
-export declare function derivedWithStore<T>(computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
-/**
- * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
-*/
-export declare function derivedWithStore<T>(owner: DebugOwner, computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
-export declare function derivedDisposable<T extends IDisposable | undefined>(computeFn: (reader: IReader) => T): IObservable<T>;
-export declare function derivedDisposable<T extends IDisposable | undefined>(owner: DebugOwner, computeFn: (reader: IReader) => T): IObservable<T>;