@vscode/markdown-editor 0.0.2-62 → 0.0.2-63

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

@@ -1,75 +0,0 @@
-import { IObservable } from '../base';
-export declare class ObservableLazy<T> {
-    private readonly _computeValue;
-    private readonly _value;
-    /**
-     * The cached value.
-     * Does not force a computation of the value.
-     */
-    get cachedValue(): IObservable<T | undefined>;
-    constructor(_computeValue: () => T);
-    /**
-     * Returns the cached value.
-     * Computes the value if the value has not been cached yet.
-     */
-    getValue(): T;
-}
-/**
- * A promise whose state is observable.
- */
-export declare class ObservablePromise<T> {
-    static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T>;
-    private readonly _value;
-    /**
-     * The promise that this object wraps.
-     */
-    readonly promise: Promise<T>;
-    /**
-     * The current state of the promise.
-     * Is `undefined` if the promise didn't resolve yet.
-     */
-    readonly promiseResult: IObservable<PromiseResult<T> | undefined>;
-    constructor(promise: Promise<T>);
-    readonly resolvedValue: import("..").IObservableWithChange<T | undefined, void>;
-}
-export declare class PromiseResult<T> {
-    /**
-     * The value of the resolved promise.
-     * Undefined if the promise rejected.
-     */
-    readonly data: T | undefined;
-    /**
-     * The error in case of a rejected promise.
-     * Undefined if the promise resolved.
-     */
-    readonly error: unknown | undefined;
-    constructor(
-    /**
-     * The value of the resolved promise.
-     * Undefined if the promise rejected.
-     */
-    data: T | undefined, 
-    /**
-     * The error in case of a rejected promise.
-     * Undefined if the promise resolved.
-     */
-    error: unknown | undefined);
-    /**
-     * Returns the value if the promise resolved, otherwise throws the error.
-     */
-    getDataOrThrow(): T;
-}
-/**
- * A lazy promise whose state is observable.
- */
-export declare class ObservableLazyPromise<T> {
-    private readonly _computePromise;
-    private readonly _lazyValue;
-    /**
-     * Does not enforce evaluation of the promise compute function.
-     * Is undefined if the promise has not been computed yet.
-     */
-    readonly cachedPromiseResult: import("..").IObservableWithChange<PromiseResult<T> | undefined, void>;
-    constructor(_computePromise: () => Promise<T>);
-    getPromise(): Promise<T>;
-}

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

@@ -1,7 +0,0 @@
-import { IObservableWithChange } from '../base';
-import { CancellationToken } from '../commonFacade/cancellation';
-import { DisposableStore, IDisposable } from '../commonFacade/deps';
-export type RemoveUndefined<T> = T extends undefined ? never : T;
-export declare function runOnChange<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable;
-export declare function runOnChangeWithStore<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable;
-export declare function runOnChangeWithCancellationToken<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], token: CancellationToken) => Promise<void>): IDisposable;

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

@@ -1,43 +0,0 @@
-import { IObservable, IObservableWithChange, IObserver, IReader, ITransaction } from '../base';
-import { DebugOwner } from '../debugName';
-import { DisposableStore, Event, IDisposable } from '../commonFacade/deps';
-export declare function observableFromPromise<T>(promise: Promise<T>): IObservable<{
-    value?: T;
-}>;
-export declare function signalFromObservable<T>(owner: DebugOwner | undefined, observable: IObservable<T>): IObservable<void>;
-/**
- * @deprecated Use `debouncedObservable` instead.
- */
-export declare function debouncedObservableDeprecated<T>(observable: IObservable<T>, debounceMs: number, disposableStore: DisposableStore): IObservable<T | undefined>;
-/**
- * Creates an observable that debounces the input observable.
- */
-export declare function debouncedObservable<T>(observable: IObservable<T>, debounceMs: number): IObservable<T>;
-export declare function wasEventTriggeredRecently(event: Event<any>, timeoutMs: number, disposableStore: DisposableStore): IObservable<boolean>;
-/**
- * This makes sure the observable is being observed and keeps its cache alive.
- */
-export declare function keepObserved<T>(observable: IObservable<T>): IDisposable;
-/**
- * This converts the given observable into an autorun.
- */
-export declare function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>, handleValue?: (value: T) => void): IDisposable;
-export declare class KeepAliveObserver implements IObserver {
-    private readonly _forceRecompute;
-    private readonly _handleValue;
-    private _counter;
-    constructor(_forceRecompute: boolean, _handleValue: ((value: any) => void) | undefined);
-    beginUpdate<T>(observable: IObservable<T>): void;
-    endUpdate<T>(observable: IObservable<T>): void;
-    handlePossibleChange<T>(observable: IObservable<T>): void;
-    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
-}
-export declare function derivedObservableWithCache<T>(owner: DebugOwner, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T>;
-export declare function derivedObservableWithWritableCache<T>(owner: object, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T> & {
-    clearCache(transaction: ITransaction): void;
-    setCache(newValue: T | undefined, tx: ITransaction | undefined): void;
-};
-/**
- * When the items array changes, referential equal items are not mapped again.
- */
-export declare function mapObservableArrayCached<TIn, TOut, TKey = TIn>(owner: DebugOwner, items: IObservable<readonly TIn[]>, map: (input: TIn, store: DisposableStore) => TOut, keySelector?: (input: TIn) => TKey): IObservable<readonly TOut[]>;

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

@@ -1,10 +0,0 @@
-import { IReader, IObservable } from '../base';
-import { CancellationToken } from '../commonFacade/cancellation';
-/**
- * Resolves the promise when the observables state matches the predicate.
- */
-export declare function waitForState<T>(observable: IObservable<T | null | undefined>): Promise<T>;
-export declare function waitForState<T, TState extends T>(observable: IObservable<T>, predicate: (state: T) => state is TState, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<TState>;
-export declare function waitForState<T>(observable: IObservable<T>, predicate: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T>;
-export declare function derivedWithCancellationToken<T>(computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;
-export declare function derivedWithCancellationToken<T>(owner: object, computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;

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

@@ -1,10 +0,0 @@
-import { IObservable } from '../base';
-import { Event, IValueWithChangeEvent } from '../commonFacade/deps';
-import { DebugOwner } from '../debugName';
-export declare class ValueWithChangeEventFromObservable<T> implements IValueWithChangeEvent<T> {
-    readonly observable: IObservable<T>;
-    constructor(observable: IObservable<T>);
-    get onDidChange(): Event<void>;
-    get value(): T;
-}
-export declare function observableFromValueWithChangeEvent<T>(owner: DebugOwner, value: IValueWithChangeEvent<T>): IObservable<T>;

package/dist/_observables/utils.d.ts

@@ -1,15 +0,0 @@
-import { IDisposable } from "./disposables";
-import { IObservableWithChange } from "./observableInternal/index";
-type ObservableResult<T> = T extends IObservableWithChange<infer U, any> ? U : never;
-type ObservableArrayToChangesData<T extends Record<string, IObservableWithChange<any, any>>> = {
-    [Key in keyof T]: {
-        value: ObservableResult<T[Key]>;
-        changes: T[Key]['TChange'][];
-        /**
-         * The value of the observable before the changes. `undefined` if
-         */
-        previous: ObservableResult<T[Key]> | undefined;
-    };
-};
-export declare function autorunWithChanges<T extends Record<string, IObservableWithChange<any, any>>>(owner: object, observables: T, handler: (data: ObservableArrayToChangesData<T>) => void): IDisposable;
-export {};

package/dist/observables.d.ts

@@ -1,4 +0,0 @@
-
-export * from "./_observables/index";
-
-export { }

package/dist/observables.js

@@ -1,441 +0,0 @@
-import { B as w, T as F, g as C, D as u, s as c, O as T, a as v, o as V, d as _, t as g, b as k, c as S, C as y, e as z, f, h as D, i as W, j as N, k as P, l as R, m as q } from "./runOnChange-e7FtCqOQ.js";
-import { n as re, p as ne, q as ie, r as de, u as oe, v as ue, w as he, x as le, y as fe, z as be, A as ce, E as ge, F as ve, G as _e, H as pe, I as me, J as Ce, K as ye, L as Oe, M as we, N as Ve, P as Se, Q as De, R as Ue, S as Ee, U as Fe, V as Te, W as ke, X as ze, Y as We, Z as Ne, _ as Pe } from "./runOnChange-e7FtCqOQ.js";
-class L extends w {
-  get debugName() {
-    return this._debugNameData.getDebugName(this) ?? "LazyObservableValue";
-  }
-  constructor(e, t, s, r) {
-    super(r), this._debugNameData = e, this._equalityComparator = s, this._isUpToDate = !0, this._deltas = [], this._updateCounter = 0, this._value = t;
-  }
-  get() {
-    return this._update(), this._value;
-  }
-  _update() {
-    if (!this._isUpToDate)
-      if (this._isUpToDate = !0, this._deltas.length > 0) {
-        for (const e of this._deltas) {
-          C()?.handleObservableUpdated(this, { change: e, didChange: !0, oldValue: "(unknown)", newValue: this._value, hadValue: !0 });
-          for (const t of this._observers)
-            t.handleChange(this, e);
-        }
-        this._deltas.length = 0;
-      } else {
-        C()?.handleObservableUpdated(this, { change: void 0, didChange: !0, oldValue: "(unknown)", newValue: this._value, hadValue: !0 });
-        for (const e of this._observers)
-          e.handleChange(this, void 0);
-      }
-  }
-  _beginUpdate() {
-    if (this._updateCounter++, this._updateCounter === 1)
-      for (const e of this._observers)
-        e.beginUpdate(this);
-  }
-  _endUpdate() {
-    if (this._updateCounter--, this._updateCounter === 0) {
-      this._update();
-      const e = [...this._observers];
-      for (const t of e)
-        t.endUpdate(this);
-    }
-  }
-  addObserver(e) {
-    const t = !this._observers.has(e) && this._updateCounter > 0;
-    super.addObserver(e), t && e.beginUpdate(this);
-  }
-  removeObserver(e) {
-    const t = this._observers.has(e) && this._updateCounter > 0;
-    super.removeObserver(e), t && e.endUpdate(this);
-  }
-  set(e, t, s) {
-    if (s === void 0 && this._equalityComparator(this._value, e))
-      return;
-    let r;
-    t || (t = r = new F(() => {
-    }, () => `Setting ${this.debugName}`));
-    try {
-      if (this._isUpToDate = !1, this._setValue(e), s !== void 0 && this._deltas.push(s), t.updateObserver({
-        beginUpdate: () => this._beginUpdate(),
-        endUpdate: () => this._endUpdate(),
-        handleChange: (n, i) => {
-        },
-        handlePossibleChange: (n) => {
-        }
-      }, this), this._updateCounter > 1)
-        for (const n of this._observers)
-          n.handlePossibleChange(this);
-    } finally {
-      r && r.finish();
-    }
-  }
-  toString() {
-    return `${this.debugName}: ${this._value}`;
-  }
-  _setValue(e) {
-    this._value = e;
-  }
-}
-function U(a, e, t = v.ofCaller()) {
-  return a.lazy ? new L(new u(a.owner, a.debugName, void 0), e, a.equalsFn ?? c, t) : new T(new u(a.owner, a.debugName, void 0), e, a.equalsFn ?? c, t);
-}
-class H {
-  /**
-   * The cached value.
-   * Does not force a computation of the value.
-   */
-  get cachedValue() {
-    return this._value;
-  }
-  constructor(e) {
-    this._computeValue = e, this._value = V(this, void 0);
-  }
-  /**
-   * Returns the cached value.
-   * Computes the value if the value has not been cached yet.
-   */
-  getValue() {
-    let e = this._value.get();
-    return e || (e = this._computeValue(), this._value.set(e, void 0)), e;
-  }
-}
-class p {
-  static fromFn(e) {
-    return new p(e());
-  }
-  constructor(e) {
-    this._value = V(this, void 0), this.promiseResult = this._value, this.resolvedValue = _(this, (t) => {
-      const s = this.promiseResult.read(t);
-      if (s)
-        return s.getDataOrThrow();
-    }), this.promise = e.then((t) => (g((s) => {
-      this._value.set(new O(t, void 0), s);
-    }), t), (t) => {
-      throw g((s) => {
-        this._value.set(new O(void 0, t), s);
-      }), t;
-    });
-  }
-}
-class O {
-  constructor(e, t) {
-    this.data = e, this.error = t;
-  }
-  /**
-   * Returns the value if the promise resolved, otherwise throws the error.
-   */
-  getDataOrThrow() {
-    if (this.error)
-      throw this.error;
-    return this.data;
-  }
-}
-class x {
-  constructor(e) {
-    this._computePromise = e, this._lazyValue = new H(() => new p(this._computePromise())), this.cachedPromiseResult = _(this, (t) => this._lazyValue.cachedValue.read(t)?.promiseResult.read(t));
-  }
-  getPromise() {
-    return this._lazyValue.getValue().promise;
-  }
-}
-function K(a, e, t, s) {
-  return e || (e = (r) => r != null), new Promise((r, n) => {
-    let i = !0, d = !1;
-    const b = a.map((o) => ({
-      isFinished: e(o),
-      error: t ? t(o) : !1,
-      state: o
-    })), h = S((o) => {
-      const { isFinished: E, error: l, state: m } = b.read(o);
-      (E || l) && (i ? d = !0 : h.dispose(), l ? n(l === !0 ? m : l) : r(m));
-    });
-    if (s) {
-      const o = s.onCancellationRequested(() => {
-        h.dispose(), o.dispose(), n(new y());
-      });
-      if (s.isCancellationRequested) {
-        h.dispose(), o.dispose(), n(new y());
-        return;
-      }
-    }
-    i = !1, d && h.dispose();
-  });
-}
-function G(a, e) {
-  let t, s;
-  e === void 0 ? (t = a, s = void 0) : (s = a, t = e);
-  let r;
-  return new k(new u(s, void 0, t), (n) => (r && r.dispose(), r = new z(), t(n, r.token)), void 0, () => r?.dispose(), c, v.ofCaller());
-}
-function J(a) {
-  return {
-    createChangeSummary: (e) => ({
-      changes: []
-    }),
-    handleChange(e, t) {
-      for (const s in a)
-        e.didChange(a[s]) && t.changes.push({ key: s, change: e.change });
-      return !0;
-    },
-    beforeUpdate(e, t) {
-      for (const s in a) {
-        if (s === "changes")
-          throw new f('property name "changes" is reserved for change tracking');
-        t[s] = a[s].read(e);
-      }
-    }
-  };
-}
-function Q(a) {
-  let e;
-  return {
-    createChangeSummary: (t) => ({
-      changes: []
-    }),
-    handleChange(t, s) {
-      e || (e = a());
-      for (const r in e)
-        t.didChange(e[r]) && s.changes.push({ key: r, change: t.change });
-      return !0;
-    },
-    beforeUpdate(t, s) {
-      e || (e = a());
-      for (const r in e) {
-        if (r === "changes")
-          throw new f('property name "changes" is reserved for change tracking');
-        s[r] = e[r].read(t);
-      }
-    }
-  };
-}
-function I(a, e, t = v.ofCaller()) {
-  return new A(typeof a == "string" ? a : new u(a, void 0, void 0), e, t);
-}
-class A extends w {
-  constructor(e, t, s) {
-    super(s), this.event = t, this.handleEvent = () => {
-      g((r) => {
-        for (const n of this._observers)
-          r.updateObserver(n, this), n.handleChange(this, void 0);
-      }, () => this.debugName);
-    }, this.debugName = typeof e == "string" ? e : e.getDebugName(this) ?? "Observable Signal From Event";
-  }
-  onFirstObserverAdded() {
-    this.subscription = this.event(this.handleEvent);
-  }
-  onLastObserverRemoved() {
-    this.subscription.dispose(), this.subscription = void 0;
-  }
-  get() {
-  }
-}
-function B(a) {
-  return (e) => {
-    let t = !0;
-    return S((s) => {
-      a.read(s), t ? t = !1 : e();
-    });
-  };
-}
-class M {
-  constructor(e) {
-    this.observable = e;
-  }
-  get onDidChange() {
-    return B(this.observable);
-  }
-  get value() {
-    return this.observable.get();
-  }
-}
-function X(a, e) {
-  return e instanceof M ? e.observable : D(a, e.onDidChange, () => e.value);
-}
-function Y(a, e) {
-  if (e.length === 0)
-    throw new f();
-  let t = !1, s;
-  const r = D(a, (n) => {
-    const i = new N();
-    for (const d of e)
-      i.add(P({ debugName: () => R(r, new u(a, void 0, void 0)) + ".updateLastChangedValue" }, (b) => {
-        t = !0, s = d.read(b), n();
-      }));
-    return i.add({
-      dispose() {
-        t = !1, s = void 0;
-      }
-    }), i;
-  }, () => t ? s : e[e.length - 1].get());
-  return r;
-}
-function Z(a, e) {
-  return W(a, (t, s) => s ?? e(t));
-}
-function j(a, e, t) {
-  let s, r, n = !1;
-  const i = I("deferUnobserve", (d) => {
-    if (n)
-      throw new f("deferUnobserve: Cannot add observer after disposal");
-    return r !== void 0 && (clearTimeout(r), r = void 0), s || (s = q(e)), {
-      dispose() {
-        r = setTimeout(() => {
-          r = void 0, s?.dispose(), s = void 0;
-        }, t);
-      }
-    };
-  });
-  return a.add({
-    dispose() {
-      r !== void 0 && (clearTimeout(r), r = void 0), s?.dispose(), s = void 0, n = !0;
-    }
-  }), _((d) => (i.read(d), e.read(d)));
-}
-class ee {
-  constructor() {
-    this._data = /* @__PURE__ */ new Set(), this._obs = U({ equalsFn: () => !1 }, this), this.observable = this._obs;
-  }
-  get size() {
-    return this._data.size;
-  }
-  has(e) {
-    return this._data.has(e);
-  }
-  add(e, t) {
-    return this._data.has(e) || (this._data.add(e), this._obs.set(this, t)), this;
-  }
-  delete(e, t) {
-    const s = this._data.delete(e);
-    return s && this._obs.set(this, t), s;
-  }
-  clear(e) {
-    this._data.size > 0 && (this._data.clear(), this._obs.set(this, e));
-  }
-  forEach(e, t) {
-    this._data.forEach((s, r, n) => {
-      e.call(t, s, r, this);
-    });
-  }
-  *entries() {
-    for (const e of this._data)
-      yield [e, e];
-  }
-  *keys() {
-    yield* this._data.keys();
-  }
-  *values() {
-    yield* this._data.values();
-  }
-  [Symbol.iterator]() {
-    return this.values();
-  }
-  get [Symbol.toStringTag]() {
-    return "ObservableSet";
-  }
-}
-class te {
-  constructor() {
-    this._data = /* @__PURE__ */ new Map(), this._obs = U({ equalsFn: () => !1 }, this), this.observable = this._obs;
-  }
-  get size() {
-    return this._data.size;
-  }
-  has(e) {
-    return this._data.has(e);
-  }
-  get(e) {
-    return this._data.get(e);
-  }
-  set(e, t, s) {
-    const r = this._data.has(e), n = this._data.get(e);
-    return (!r || n !== t) && (this._data.set(e, t), this._obs.set(this, s)), this;
-  }
-  delete(e, t) {
-    const s = this._data.delete(e);
-    return s && this._obs.set(this, t), s;
-  }
-  clear(e) {
-    this._data.size > 0 && (this._data.clear(), this._obs.set(this, e));
-  }
-  forEach(e, t) {
-    this._data.forEach((s, r, n) => {
-      e.call(t, s, r, this);
-    });
-  }
-  *entries() {
-    yield* this._data.entries();
-  }
-  *keys() {
-    yield* this._data.keys();
-  }
-  *values() {
-    yield* this._data.values();
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  get [Symbol.toStringTag]() {
-    return "ObservableMap";
-  }
-}
-export {
-  v as DebugLocation,
-  re as Disposable,
-  N as DisposableStore,
-  H as ObservableLazy,
-  x as ObservableLazyPromise,
-  te as ObservableMap,
-  p as ObservablePromise,
-  ee as ObservableSet,
-  O as PromiseResult,
-  F as TransactionImpl,
-  M as ValueWithChangeEventFromObservable,
-  ne as asyncTransaction,
-  ie as autorun,
-  de as autorunDelta,
-  oe as autorunHandleChanges,
-  ue as autorunIterableDelta,
-  he as autorunOpts,
-  le as autorunSelfDisposable,
-  fe as autorunWithStore,
-  be as autorunWithStoreHandleChanges,
-  ce as constObservable,
-  S as createEffect,
-  P as createEffectOpts,
-  ge as debouncedObservable,
-  ve as debouncedObservableDeprecated,
-  j as deferUnobserve,
-  _ as derived,
-  Z as derivedConstOnceDefined,
-  _e as derivedDisposable,
-  pe as derivedHandleChanges,
-  W as derivedObservableWithCache,
-  me as derivedObservableWithWritableCache,
-  Ce as derivedOpts,
-  G as derivedWithCancellationToken,
-  ye as derivedWithSetter,
-  Oe as derivedWithStore,
-  we as disposableObservableValue,
-  Ve as globalTransaction,
-  q as keepObserved,
-  Y as latestChangedValue,
-  Se as mapObservableArrayCached,
-  D as observableFromEvent,
-  De as observableFromEventOpts,
-  Ue as observableFromPromise,
-  X as observableFromValueWithChangeEvent,
-  Ee as observableSignal,
-  I as observableSignalFromEvent,
-  V as observableValue,
-  U as observableValueOpts,
-  Fe as recomputeInitiallyAndOnChange,
-  J as recordChanges,
-  Q as recordChangesLazy,
-  Te as runOnChange,
-  ke as runOnChangeWithCancellationToken,
-  ze as runOnChangeWithStore,
-  We as signalFromObservable,
-  Ne as subtransaction,
-  g as transaction,
-  K as waitForState,
-  Pe as wasEventTriggeredRecently
-};
-//# sourceMappingURL=observables.js.map