@vscode/markdown-editor 0.0.2-0

package/dist/runOnChange-owE1SMC0.js

@@ -0,0 +1,1514 @@
+let m;
+function ae(n) {
+  m ? m instanceof K ? m.loggers.push(n) : m = new K([m, n]) : m = n;
+}
+function o() {
+  return m;
+}
+let F;
+function de(n) {
+  F = n;
+}
+function oe(n) {
+  F && F(n);
+}
+class K {
+  constructor(e) {
+    this.loggers = e;
+  }
+  handleObservableCreated(e, t) {
+    for (const s of this.loggers)
+      s.handleObservableCreated(e, t);
+  }
+  handleOnListenerCountChanged(e, t) {
+    for (const s of this.loggers)
+      s.handleOnListenerCountChanged(e, t);
+  }
+  handleObservableUpdated(e, t) {
+    for (const s of this.loggers)
+      s.handleObservableUpdated(e, t);
+  }
+  handleAutorunCreated(e, t) {
+    for (const s of this.loggers)
+      s.handleAutorunCreated(e, t);
+  }
+  handleAutorunDisposed(e) {
+    for (const t of this.loggers)
+      t.handleAutorunDisposed(e);
+  }
+  handleAutorunDependencyChanged(e, t, s) {
+    for (const r of this.loggers)
+      r.handleAutorunDependencyChanged(e, t, s);
+  }
+  handleAutorunStarted(e) {
+    for (const t of this.loggers)
+      t.handleAutorunStarted(e);
+  }
+  handleAutorunFinished(e) {
+    for (const t of this.loggers)
+      t.handleAutorunFinished(e);
+  }
+  handleDerivedDependencyChanged(e, t, s) {
+    for (const r of this.loggers)
+      r.handleDerivedDependencyChanged(e, t, s);
+  }
+  handleDerivedCleared(e) {
+    for (const t of this.loggers)
+      t.handleDerivedCleared(e);
+  }
+  handleBeginTransaction(e) {
+    for (const t of this.loggers)
+      t.handleBeginTransaction(e);
+  }
+  handleEndTransaction(e) {
+    for (const t of this.loggers)
+      t.handleEndTransaction(e);
+  }
+}
+var u;
+(function(n) {
+  let e = !1;
+  function t() {
+    e = !0;
+  }
+  n.enable = t;
+  function s() {
+    return r(1);
+  }
+  n.ofCaller = s;
+  function r(i) {
+    if (!e)
+      return;
+    const a = Error, d = a.stackTraceLimit;
+    a.stackTraceLimit = 3;
+    const h = new Error().stack;
+    return a.stackTraceLimit = d, j.fromStack(h, i + 1);
+  }
+  n.ofNthCaller = r;
+})(u || (u = {}));
+class j {
+  static fromStack(e, t) {
+    const s = e.split(`
+`), r = ue(s[t + 1]);
+    if (r)
+      return new j(r.fileName, r.line, r.column, r.id);
+  }
+  constructor(e, t, s, r) {
+    this.fileName = e, this.line = t, this.column = s, this.id = r;
+  }
+}
+function ue(n) {
+  if (!n)
+    return;
+  const e = n.match(/\((.*):(\d+):(\d+)\)/);
+  if (e)
+    return {
+      fileName: e[1],
+      line: parseInt(e[2]),
+      column: parseInt(e[3]),
+      id: n
+    };
+  const t = n.match(/at ([^\(\)]*):(\d+):(\d+)/);
+  if (t)
+    return {
+      fileName: t[1],
+      line: parseInt(t[2]),
+      column: parseInt(t[3]),
+      id: n
+    };
+}
+class l {
+  constructor(e, t, s) {
+    this.owner = e, this.debugNameSource = t, this.referenceFn = s;
+  }
+  getDebugName(e) {
+    return he(e, this);
+  }
+}
+const P = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new WeakMap();
+function he(n, e) {
+  const t = B.get(n);
+  if (t)
+    return t;
+  const s = le(n, e);
+  if (s) {
+    let r = P.get(s) ?? 0;
+    r++, P.set(s, r);
+    const i = r === 1 ? s : `${s}#${r}`;
+    return B.set(n, i), i;
+  }
+}
+function le(n, e) {
+  const t = B.get(n);
+  if (t)
+    return t;
+  const s = e.owner ? fe(e.owner) + "." : "";
+  let r;
+  const i = e.debugNameSource;
+  if (i !== void 0)
+    if (typeof i == "function") {
+      if (r = i(), r !== void 0)
+        return s + r;
+    } else
+      return s + i;
+  const a = e.referenceFn;
+  if (a !== void 0 && (r = G(a), r !== void 0))
+    return s + r;
+  if (e.owner !== void 0) {
+    const d = ce(e.owner, n);
+    if (d !== void 0)
+      return s + d;
+  }
+}
+function ce(n, e) {
+  for (const t in n)
+    if (n[t] === e)
+      return t;
+}
+const Z = /* @__PURE__ */ new Map(), J = /* @__PURE__ */ new WeakMap();
+function fe(n) {
+  const e = J.get(n);
+  if (e)
+    return e;
+  const t = ee(n) ?? "Object";
+  let s = Z.get(t) ?? 0;
+  s++, Z.set(t, s);
+  const r = s === 1 ? t : `${t}#${s}`;
+  return J.set(n, r), r;
+}
+function ee(n) {
+  const e = n.constructor;
+  if (e)
+    return e.name === "Object" ? void 0 : e.name;
+}
+function G(n) {
+  const e = n.toString(), s = /\/\*\*\s*@description\s*([^*]*)\*\//.exec(e);
+  return (s ? s[1] : void 0)?.trim();
+}
+let x;
+function ge(n) {
+  x = n;
+}
+let te;
+function _e(n) {
+  te = n;
+}
+let ne;
+function be(n) {
+  ne = n;
+}
+let se;
+function pe(n) {
+  se = n;
+}
+class me {
+  get TChange() {
+    return null;
+  }
+  reportChanges() {
+    this.get();
+  }
+  /** @sealed */
+  read(e) {
+    return e ? e.readObservable(this) : this.get();
+  }
+  map(e, t, s = u.ofCaller()) {
+    const r = t === void 0 ? void 0 : e, i = t === void 0 ? e : t;
+    return x({
+      owner: r,
+      debugName: () => {
+        const a = G(i);
+        if (a !== void 0)
+          return a;
+        const h = /^\s*\(?\s*([a-zA-Z_$][a-zA-Z_$0-9]*)\s*\)?\s*=>\s*\1(?:\??)\.([a-zA-Z_$][a-zA-Z_$0-9]*)\s*$/.exec(i.toString());
+        if (h)
+          return `${this.debugName}.${h[2]}`;
+        if (!r)
+          return `${this.debugName} (mapped)`;
+      },
+      debugReferenceFn: i
+    }, (a) => i(this.read(a), a), s);
+  }
+  /**
+   * @sealed
+   * Converts an observable of an observable value into a direct observable of the value.
+  */
+  flatten() {
+    return x({
+      owner: void 0,
+      debugName: () => `${this.debugName} (flattened)`
+    }, (e) => this.read(e).read(e));
+  }
+  recomputeInitiallyAndOnChange(e, t) {
+    return e.add(te(this, t)), this;
+  }
+  /**
+   * 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(e) {
+    return e.add(ne(this)), this;
+  }
+  get debugValue() {
+    return this.get();
+  }
+  debugGetDependencyGraph() {
+    return se(this);
+  }
+}
+class R extends me {
+  constructor(e) {
+    super(), this._observers = /* @__PURE__ */ new Set(), o()?.handleObservableCreated(this, e);
+  }
+  addObserver(e) {
+    const t = this._observers.size;
+    this._observers.add(e), t === 0 && this.onFirstObserverAdded(), t !== this._observers.size && o()?.handleOnListenerCountChanged(this, this._observers.size);
+  }
+  removeObserver(e) {
+    const t = this._observers.delete(e);
+    t && this._observers.size === 0 && this.onLastObserverRemoved(), t && o()?.handleOnListenerCountChanged(this, this._observers.size);
+  }
+  onFirstObserverAdded() {
+  }
+  onLastObserverRemoved() {
+  }
+  log() {
+    const e = !!o();
+    return oe(this), e || o()?.handleObservableCreated(this, u.ofCaller()), this;
+  }
+  debugGetObservers() {
+    return this._observers;
+  }
+}
+function N(n) {
+  return {
+    dispose: n
+  };
+}
+class v extends Error {
+  constructor(e) {
+    super(e || "An unexpected bug occurred."), Object.setPrototypeOf(this, v.prototype);
+  }
+}
+function D(n) {
+  throw n;
+}
+function ve(n) {
+  console.error("Unexpected error:", n);
+}
+const _ = (n, e) => n === e;
+class f {
+  constructor() {
+    this.disposables = [], this._isDisposed = !1;
+  }
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  dispose() {
+    this.clear(), this._isDisposed = !0;
+  }
+  add(e) {
+    return e && this.disposables.push(e), e;
+  }
+  remove(e) {
+    if (!e)
+      return e;
+    const t = this.disposables.indexOf(e);
+    return t !== -1 && this.disposables.splice(t, 1), e;
+  }
+  clear() {
+    for (const e of this.disposables)
+      e.dispose();
+    this.disposables = [];
+  }
+  leakItems() {
+    this.disposables = [];
+  }
+}
+class qe {
+  constructor() {
+    this._store = new f();
+  }
+  dispose() {
+    this._store.dispose();
+  }
+  _register(e) {
+    return this._store.add(e), e;
+  }
+  _registerOrDispose(e) {
+    return e && (this._store.isDisposed ? e.dispose() : this._store.add(e)), e;
+  }
+}
+function Ce(n) {
+  switch (n) {
+    case 0:
+      return "initial";
+    case 1:
+      return "dependenciesMightHaveChanged";
+    case 2:
+      return "stale";
+    case 3:
+      return "upToDate";
+    default:
+      return "<unknown>";
+  }
+}
+class b extends R {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+  }
+  constructor(e, t, s, r = void 0, i, a) {
+    super(a), this._debugNameData = e, this._computeFn = t, this._changeTracker = s, this._handleLastObserverRemoved = r, this._equalityComparator = i, this._state = 0, this._value = void 0, this._updateCount = 0, this._dependencies = /* @__PURE__ */ new Set(), this._dependenciesToBeRemoved = /* @__PURE__ */ new Set(), this._changeSummary = void 0, this._isUpdating = !1, this._isComputing = !1, this._didReportChange = !1, this._isInBeforeUpdate = !1, this._isReaderValid = !1, this._store = void 0, this._delayedStore = void 0, this._removedObserverToCallEndUpdateOn = null, this._changeSummary = this._changeTracker?.createChangeSummary(void 0);
+  }
+  onLastObserverRemoved() {
+    this._state = 0, this._value = void 0, o()?.handleDerivedCleared(this);
+    for (const e of this._dependencies)
+      e.removeObserver(this);
+    this._dependencies.clear(), this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._delayedStore !== void 0 && (this._delayedStore.dispose(), this._delayedStore = void 0), this._handleLastObserverRemoved?.();
+  }
+  get() {
+    if (this._isComputing, this._observers.size === 0) {
+      let t;
+      try {
+        this._isReaderValid = !0;
+        let s;
+        this._changeTracker && (s = this._changeTracker.createChangeSummary(void 0), this._changeTracker.beforeUpdate?.(this, s)), t = this._computeFn(this, s);
+      } finally {
+        this._isReaderValid = !1;
+      }
+      return this.onLastObserverRemoved(), t;
+    } else {
+      do {
+        if (this._state === 1) {
+          for (const t of this._dependencies)
+            if (t.reportChanges(), this._state === 2)
+              break;
+        }
+        this._state === 1 && (this._state = 3), this._state !== 3 && this._recompute();
+      } while (this._state !== 3);
+      return this._value;
+    }
+  }
+  _recompute() {
+    let e = !1;
+    this._isComputing = !0, this._didReportChange = !1;
+    const t = this._dependenciesToBeRemoved;
+    this._dependenciesToBeRemoved = this._dependencies, this._dependencies = t;
+    try {
+      const s = this._changeSummary;
+      this._isReaderValid = !0, this._changeTracker && (this._isInBeforeUpdate = !0, this._changeTracker.beforeUpdate?.(this, s), this._isInBeforeUpdate = !1, this._changeSummary = this._changeTracker?.createChangeSummary(s));
+      const r = this._state !== 0, i = this._value;
+      this._state = 3;
+      const a = this._delayedStore;
+      a !== void 0 && (this._delayedStore = void 0);
+      try {
+        this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._value = this._computeFn(this, s);
+      } finally {
+        this._isReaderValid = !1;
+        for (const d of this._dependenciesToBeRemoved)
+          d.removeObserver(this);
+        this._dependenciesToBeRemoved.clear(), a !== void 0 && a.dispose();
+      }
+      e = this._didReportChange || r && !this._equalityComparator(i, this._value), o()?.handleObservableUpdated(this, {
+        oldValue: i,
+        newValue: this._value,
+        change: void 0,
+        didChange: e,
+        hadValue: r
+      });
+    } catch (s) {
+      D(s);
+    }
+    if (this._isComputing = !1, !this._didReportChange && e)
+      for (const s of this._observers)
+        s.handleChange(this, void 0);
+    else
+      this._didReportChange = !1;
+  }
+  toString() {
+    return `LazyDerived<${this.debugName}>`;
+  }
+  // IObserver Implementation
+  beginUpdate(e) {
+    if (this._isUpdating)
+      throw new v("Cyclic deriveds are not supported yet!");
+    this._updateCount++, this._isUpdating = !0;
+    try {
+      const t = this._updateCount === 1;
+      if (this._state === 3 && (this._state = 1, !t))
+        for (const s of this._observers)
+          s.handlePossibleChange(this);
+      if (t)
+        for (const s of this._observers)
+          s.beginUpdate(this);
+    } finally {
+      this._isUpdating = !1;
+    }
+  }
+  endUpdate(e) {
+    if (this._updateCount--, this._updateCount === 0) {
+      const t = [...this._observers];
+      for (const s of t)
+        s.endUpdate(this);
+      if (this._removedObserverToCallEndUpdateOn) {
+        const s = [...this._removedObserverToCallEndUpdateOn];
+        this._removedObserverToCallEndUpdateOn = null;
+        for (const r of s)
+          r.endUpdate(this);
+      }
+    }
+  }
+  handlePossibleChange(e) {
+    if (this._state === 3 && this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e)) {
+      this._state = 1;
+      for (const t of this._observers)
+        t.handlePossibleChange(this);
+    }
+  }
+  handleChange(e, t) {
+    if (this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e) || this._isInBeforeUpdate) {
+      o()?.handleDerivedDependencyChanged(this, e, t);
+      let s = !1;
+      try {
+        s = this._changeTracker ? this._changeTracker.handleChange({
+          changedObservable: e,
+          change: t,
+          didChange: (i) => i === e
+        }, this._changeSummary) : !0;
+      } catch (i) {
+        D(i);
+      }
+      const r = this._state === 3;
+      if (s && (this._state === 1 || r) && (this._state = 2, r))
+        for (const i of this._observers)
+          i.handlePossibleChange(this);
+    }
+  }
+  // IReader Implementation
+  _ensureReaderValid() {
+    if (!this._isReaderValid)
+      throw new v("The reader object cannot be used outside its compute function!");
+  }
+  readObservable(e) {
+    this._ensureReaderValid(), e.addObserver(this);
+    const t = e.get();
+    return this._dependencies.add(e), this._dependenciesToBeRemoved.delete(e), t;
+  }
+  reportChange(e) {
+    this._ensureReaderValid(), this._didReportChange = !0;
+    for (const t of this._observers)
+      t.handleChange(this, e);
+  }
+  get store() {
+    return this._ensureReaderValid(), this._store === void 0 && (this._store = new f()), this._store;
+  }
+  get delayedStore() {
+    return this._ensureReaderValid(), this._delayedStore === void 0 && (this._delayedStore = new f()), this._delayedStore;
+  }
+  addObserver(e) {
+    const t = !this._observers.has(e) && this._updateCount > 0;
+    super.addObserver(e), t && (this._removedObserverToCallEndUpdateOn && this._removedObserverToCallEndUpdateOn.has(e) ? this._removedObserverToCallEndUpdateOn.delete(e) : e.beginUpdate(this));
+  }
+  removeObserver(e) {
+    this._observers.has(e) && this._updateCount > 0 && (this._removedObserverToCallEndUpdateOn || (this._removedObserverToCallEndUpdateOn = /* @__PURE__ */ new Set()), this._removedObserverToCallEndUpdateOn.add(e)), super.removeObserver(e);
+  }
+  debugGetState() {
+    return {
+      state: this._state,
+      stateStr: Ce(this._state),
+      updateCount: this._updateCount,
+      isComputing: this._isComputing,
+      dependencies: this._dependencies,
+      value: this._value
+    };
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+  debugRecompute() {
+    this._isComputing ? this._state = 2 : this._recompute();
+  }
+  setValue(e, t, s) {
+    this._value = e;
+    const r = this._observers;
+    t.updateObserver(this, this);
+    for (const i of r)
+      i.handleChange(this, s);
+  }
+}
+class ye extends b {
+  constructor(e, t, s, r = void 0, i, a, d) {
+    super(e, t, s, r, i, d), this.set = a;
+  }
+}
+function Oe(n, e, t = u.ofCaller()) {
+  return e !== void 0 ? new b(new l(n, void 0, e), e, void 0, void 0, _, t) : new b(new l(void 0, void 0, n), n, void 0, void 0, _, t);
+}
+function Me(n, e, t, s = u.ofCaller()) {
+  return new ye(new l(n, void 0, e), e, void 0, void 0, _, t, s);
+}
+function V(n, e, t = u.ofCaller()) {
+  return new b(new l(n.owner, n.debugName, n.debugReferenceFn), e, void 0, n.onLastObserverRemoved, n.equalsFn ?? _, t);
+}
+ge(V);
+function He(n, e, t = u.ofCaller()) {
+  return new b(new l(n.owner, n.debugName, void 0), e, n.changeTracker, void 0, n.equalityComparer ?? _, t);
+}
+function Ke(n, e, t = u.ofCaller()) {
+  let s, r;
+  e === void 0 ? (s = n, r = void 0) : (r = n, s = e);
+  let i = new f();
+  return new b(new l(r, void 0, s), (a) => (i.isDisposed ? i = new f() : i.clear(), s(a, i)), void 0, () => i.dispose(), _, t);
+}
+function Pe(n, e, t = u.ofCaller()) {
+  let s, r;
+  e === void 0 ? (s = n, r = void 0) : (r = n, s = e);
+  let i;
+  return new b(new l(r, void 0, s), (a) => {
+    i ? i.clear() : i = new f();
+    const d = s(a);
+    return d && i.add(d), d;
+  }, void 0, () => {
+    i && (i.dispose(), i = void 0);
+  }, _, t);
+}
+function we(n) {
+  switch (n) {
+    case 1:
+      return "dependenciesMightHaveChanged";
+    case 2:
+      return "stale";
+    case 3:
+      return "upToDate";
+    default:
+      return "<unknown>";
+  }
+}
+class k {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+  }
+  constructor(e, t, s, r) {
+    this._debugNameData = e, this._runFn = t, this._changeTracker = s, this._state = 2, this._updateCount = 0, this._disposed = !1, this._dependencies = /* @__PURE__ */ new Set(), this._dependenciesToBeRemoved = /* @__PURE__ */ new Set(), this._isRunning = !1, this._store = void 0, this._delayedStore = void 0, this._changeSummary = this._changeTracker?.createChangeSummary(void 0), o()?.handleAutorunCreated(this, r), this._run();
+  }
+  dispose() {
+    if (!this._disposed) {
+      this._disposed = !0;
+      for (const e of this._dependencies)
+        e.removeObserver(this);
+      this._dependencies.clear(), this._store !== void 0 && this._store.dispose(), this._delayedStore !== void 0 && this._delayedStore.dispose(), o()?.handleAutorunDisposed(this);
+    }
+  }
+  _run() {
+    const e = this._dependenciesToBeRemoved;
+    this._dependenciesToBeRemoved = this._dependencies, this._dependencies = e, this._state = 3;
+    try {
+      if (!this._disposed) {
+        o()?.handleAutorunStarted(this);
+        const t = this._changeSummary, s = this._delayedStore;
+        s !== void 0 && (this._delayedStore = void 0);
+        try {
+          this._isRunning = !0, this._changeTracker && (this._changeTracker.beforeUpdate?.(this, t), this._changeSummary = this._changeTracker.createChangeSummary(t)), this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._runFn(this, t);
+        } catch (r) {
+          D(r);
+        } finally {
+          this._isRunning = !1, s !== void 0 && s.dispose();
+        }
+      }
+    } finally {
+      this._disposed || o()?.handleAutorunFinished(this);
+      for (const t of this._dependenciesToBeRemoved)
+        t.removeObserver(this);
+      this._dependenciesToBeRemoved.clear();
+    }
+  }
+  toString() {
+    return `Autorun<${this.debugName}>`;
+  }
+  // IObserver implementation
+  beginUpdate(e) {
+    this._state === 3 && (this._state = 1), this._updateCount++;
+  }
+  endUpdate(e) {
+    try {
+      if (this._updateCount === 1)
+        do {
+          if (this._state === 1) {
+            this._state = 3;
+            for (const t of this._dependencies)
+              if (t.reportChanges(), this._state === 2)
+                break;
+          }
+          this._state !== 3 && this._run();
+        } while (this._state !== 3);
+    } finally {
+      this._updateCount--;
+    }
+  }
+  handlePossibleChange(e) {
+    this._state === 3 && this._isDependency(e) && (this._state = 1);
+  }
+  handleChange(e, t) {
+    if (this._isDependency(e)) {
+      o()?.handleAutorunDependencyChanged(this, e, t);
+      try {
+        (this._changeTracker ? this._changeTracker.handleChange({
+          changedObservable: e,
+          change: t,
+          didChange: (r) => r === e
+        }, this._changeSummary) : !0) && (this._state = 2);
+      } catch (s) {
+        D(s);
+      }
+    }
+  }
+  _isDependency(e) {
+    return this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e);
+  }
+  // IReader implementation
+  _ensureNoRunning() {
+    if (!this._isRunning)
+      throw new v("The reader object cannot be used outside its compute function!");
+  }
+  readObservable(e) {
+    if (this._ensureNoRunning(), this._disposed)
+      return e.get();
+    e.addObserver(this);
+    const t = e.get();
+    return this._dependencies.add(e), this._dependenciesToBeRemoved.delete(e), t;
+  }
+  get store() {
+    if (this._ensureNoRunning(), this._disposed)
+      throw new v("Cannot access store after dispose");
+    return this._store === void 0 && (this._store = new f()), this._store;
+  }
+  get delayedStore() {
+    if (this._ensureNoRunning(), this._disposed)
+      throw new v("Cannot access store after dispose");
+    return this._delayedStore === void 0 && (this._delayedStore = new f()), this._delayedStore;
+  }
+  debugGetState() {
+    return {
+      isRunning: this._isRunning,
+      updateCount: this._updateCount,
+      dependencies: this._dependencies,
+      state: this._state,
+      stateStr: we(this._state)
+    };
+  }
+  debugRerun() {
+    this._isRunning ? this._state = 2 : this._run();
+  }
+}
+function L(n, e = u.ofCaller()) {
+  return new k(new l(void 0, void 0, n), n, void 0, e);
+}
+function W(n, e, t = u.ofCaller()) {
+  return new k(new l(n.owner, n.debugName, n.debugReferenceFn ?? e), e, void 0, t);
+}
+function Se(n, e, t = u.ofCaller()) {
+  return new k(new l(n.owner, n.debugName, n.debugReferenceFn ?? e), e, n.changeTracker, t);
+}
+function Te(n, e) {
+  const t = new f(), s = Se({
+    owner: n.owner,
+    debugName: n.debugName,
+    debugReferenceFn: n.debugReferenceFn ?? e,
+    changeTracker: n.changeTracker
+  }, (r, i) => {
+    t.clear(), e(r, i, t);
+  });
+  return N(() => {
+    s.dispose(), t.dispose();
+  });
+}
+function Ze(n) {
+  const e = new f(), t = W({
+    owner: void 0,
+    debugName: void 0,
+    debugReferenceFn: n
+  }, (s) => {
+    e.clear(), n(s, e);
+  });
+  return N(() => {
+    t.dispose(), e.dispose();
+  });
+}
+function Je(n, e) {
+  let t;
+  return W({ debugReferenceFn: e }, (s) => {
+    const r = n.read(s), i = t;
+    t = r, e({ lastValue: i, newValue: r });
+  });
+}
+function Qe(n, e, t = (s) => s) {
+  const s = /* @__PURE__ */ new Map();
+  return W({ debugReferenceFn: n }, (r) => {
+    const i = /* @__PURE__ */ new Map(), a = new Map(s);
+    for (const d of n(r)) {
+      const h = t(d);
+      s.has(h) ? a.delete(h) : (i.set(h, d), s.set(h, d));
+    }
+    for (const d of a.keys())
+      s.delete(d);
+    (i.size || a.size) && e({ addedValues: [...i.values()], removedValues: [...a.values()] });
+  });
+}
+function Xe(n, e = u.ofCaller()) {
+  let t, s = !1;
+  return t = L((r) => {
+    n({
+      delayedStore: r.delayedStore,
+      store: r.store,
+      readObservable: r.readObservable.bind(r),
+      dispose: () => {
+        t?.dispose(), s = !0;
+      }
+    });
+  }, e), s && t.dispose(), t;
+}
+function Q(n) {
+  const e = new Error("BugIndicatingErrorRecovery: " + n);
+  ve(e), console.error("recovered from an error that indicates a bug", e);
+}
+function A(n, e) {
+  const t = new U(n, e);
+  try {
+    n(t);
+  } finally {
+    t.finish();
+  }
+}
+let S;
+function Ye(n) {
+  if (S)
+    n(S);
+  else {
+    const e = new U(n, void 0);
+    S = e;
+    try {
+      n(e);
+    } finally {
+      e.finish(), S = void 0;
+    }
+  }
+}
+async function et(n, e) {
+  const t = new U(n, e);
+  try {
+    await n(t);
+  } finally {
+    t.finish();
+  }
+}
+function De(n, e, t) {
+  n ? e(n) : A(e, t);
+}
+class U {
+  constructor(e, t) {
+    this._fn = e, this._getDebugName = t, this._updatingObservers = [], o()?.handleBeginTransaction(this);
+  }
+  getDebugName() {
+    return this._getDebugName ? this._getDebugName() : G(this._fn);
+  }
+  updateObserver(e, t) {
+    if (!this._updatingObservers) {
+      Q("Transaction already finished!"), A((s) => {
+        s.updateObserver(e, t);
+      });
+      return;
+    }
+    this._updatingObservers.push({ observer: e, observable: t }), e.beginUpdate(t);
+  }
+  finish() {
+    const e = this._updatingObservers;
+    if (!e) {
+      Q("transaction.finish() has already been called!");
+      return;
+    }
+    for (let t = 0; t < e.length; t++) {
+      const { observer: s, observable: r } = e[t];
+      s.endUpdate(r);
+    }
+    this._updatingObservers = null, o()?.handleEndTransaction(this);
+  }
+  debugGetUpdatingObservers() {
+    return this._updatingObservers;
+  }
+}
+function z(n, e, t = u.ofCaller()) {
+  let s;
+  return typeof n == "string" ? s = new l(void 0, n, void 0) : s = new l(n, void 0, void 0), new q(s, e, _, t);
+}
+class q extends R {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "ObservableValue";
+  }
+  constructor(e, t, s, r) {
+    super(r), this._debugNameData = e, this._equalityComparator = s, this._value = t, o()?.handleObservableUpdated(this, { hadValue: !1, newValue: t, change: void 0, didChange: !0, oldValue: void 0 });
+  }
+  get() {
+    return this._value;
+  }
+  set(e, t, s) {
+    if (s === void 0 && this._equalityComparator(this._value, e))
+      return;
+    let r;
+    t || (t = r = new U(() => {
+    }, () => `Setting ${this.debugName}`));
+    try {
+      const i = this._value;
+      this._setValue(e), o()?.handleObservableUpdated(this, { oldValue: i, newValue: e, change: s, didChange: !0, hadValue: !0 });
+      for (const a of this._observers)
+        t.updateObserver(a, this), a.handleChange(this, s);
+    } finally {
+      r && r.finish();
+    }
+  }
+  toString() {
+    return `${this.debugName}: ${this._value}`;
+  }
+  _setValue(e) {
+    this._value = e;
+  }
+  debugGetState() {
+    return {
+      value: this._value
+    };
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+}
+function tt(n, e, t = u.ofCaller()) {
+  let s;
+  return typeof n == "string" ? s = new l(void 0, n, void 0) : s = new l(n, void 0, void 0), new Re(s, e, _, t);
+}
+class Re extends q {
+  _setValue(e) {
+    this._value !== e && (this._value && this._value.dispose(), this._value = e);
+  }
+  dispose() {
+    this._value?.dispose();
+  }
+}
+function I(...n) {
+  let e, t, s, r;
+  return n.length === 2 ? [t, s] = n : [e, t, s, r] = n, new p(new l(e, void 0, s), t, s, () => p.globalTransaction, _, r ?? u.ofCaller());
+}
+function nt(n, e, t, s = u.ofCaller()) {
+  return new p(new l(n.owner, n.debugName, n.debugReferenceFn ?? t), e, t, () => p.globalTransaction, n.equalsFn ?? _, s);
+}
+class p extends R {
+  constructor(e, t, s, r, i, a) {
+    super(a), this._debugNameData = e, this.event = t, this._getValue = s, this._getTransaction = r, this._equalityComparator = i, this._hasValue = !1, this.handleEvent = (d) => {
+      const h = this._getValue(d), $ = this._value, E = !this._hasValue || !this._equalityComparator($, h);
+      let M = !1;
+      E && (this._value = h, this._hasValue && (M = !0, De(this._getTransaction(), (w) => {
+        o()?.handleObservableUpdated(this, { oldValue: $, newValue: h, change: void 0, didChange: E, hadValue: this._hasValue });
+        for (const H of this._observers)
+          w.updateObserver(H, this), H.handleChange(this, void 0);
+      }, () => {
+        const w = this.getDebugName();
+        return "Event fired" + (w ? `: ${w}` : "");
+      })), this._hasValue = !0), M || o()?.handleObservableUpdated(this, { oldValue: $, newValue: h, change: void 0, didChange: E, hadValue: this._hasValue });
+    };
+  }
+  getDebugName() {
+    return this._debugNameData.getDebugName(this);
+  }
+  get debugName() {
+    const e = this.getDebugName();
+    return "From Event" + (e ? `: ${e}` : "");
+  }
+  onFirstObserverAdded() {
+    this._subscription = this.event(this.handleEvent);
+  }
+  onLastObserverRemoved() {
+    this._subscription.dispose(), this._subscription = void 0, this._hasValue = !1, this._value = void 0;
+  }
+  get() {
+    return this._subscription ? (this._hasValue || this.handleEvent(void 0), this._value) : this._getValue(void 0);
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+  debugGetState() {
+    return { value: this._value, hasValue: this._hasValue };
+  }
+}
+(function(n) {
+  n.Observer = p;
+  function e(t, s) {
+    let r = !1;
+    p.globalTransaction === void 0 && (p.globalTransaction = t, r = !0);
+    try {
+      s();
+    } finally {
+      r && (p.globalTransaction = void 0);
+    }
+  }
+  n.batchEventsGlobally = e;
+})(I || (I = {}));
+function Ne(n, e = u.ofCaller()) {
+  return typeof n == "string" ? new X(n, void 0, e) : new X(void 0, n, e);
+}
+class X extends R {
+  get debugName() {
+    return new l(this._owner, this._debugName, void 0).getDebugName(this) ?? "Observable Signal";
+  }
+  toString() {
+    return this.debugName;
+  }
+  constructor(e, t, s) {
+    super(s), this._debugName = e, this._owner = t;
+  }
+  trigger(e, t) {
+    if (!e) {
+      A((s) => {
+        this.trigger(s, t);
+      }, () => `Trigger signal ${this.debugName}`);
+      return;
+    }
+    for (const s of this._observers)
+      e.updateObserver(s, this), s.handleChange(this, t);
+  }
+  get() {
+  }
+}
+function st(n) {
+  const e = z("promiseValue", {});
+  return n.then((t) => {
+    e.set({ value: t }, void 0);
+  }), e;
+}
+function rt(n, e) {
+  return V({
+    owner: n,
+    equalsFn: () => !1
+  }, (t) => {
+    e.read(t);
+  });
+}
+function it(n, e, t) {
+  const s = z("debounced", void 0);
+  let r;
+  return t.add(L((i) => {
+    const a = n.read(i);
+    r && clearTimeout(r), r = setTimeout(() => {
+      A((d) => {
+        s.set(a, d);
+      });
+    }, e);
+  })), s;
+}
+function at(n, e) {
+  let t = !1, s, r;
+  return I((i) => {
+    const a = L((d) => {
+      const h = n.read(d);
+      t ? (r && clearTimeout(r), r = setTimeout(() => {
+        s = h, i();
+      }, e)) : (t = !0, s = h);
+    });
+    return {
+      dispose() {
+        a.dispose(), t = !1, s = void 0;
+      }
+    };
+  }, () => t ? s : n.get());
+}
+function dt(n, e, t) {
+  const s = z("triggeredRecently", !1);
+  let r;
+  return t.add(n(() => {
+    s.set(!0, void 0), r && clearTimeout(r), r = setTimeout(() => {
+      s.set(!1, void 0);
+    }, e);
+  })), s;
+}
+function Ve(n) {
+  const e = new re(!1, void 0);
+  return n.addObserver(e), N(() => {
+    n.removeObserver(e);
+  });
+}
+be(Ve);
+function ke(n, e) {
+  const t = new re(!0, e);
+  n.addObserver(t);
+  try {
+    t.beginUpdate(n);
+  } finally {
+    t.endUpdate(n);
+  }
+  return N(() => {
+    n.removeObserver(t);
+  });
+}
+_e(ke);
+class re {
+  constructor(e, t) {
+    this._forceRecompute = e, this._handleValue = t, this._counter = 0;
+  }
+  beginUpdate(e) {
+    this._counter++;
+  }
+  endUpdate(e) {
+    this._counter === 1 && this._forceRecompute && (this._handleValue ? this._handleValue(e.get()) : e.reportChanges()), this._counter--;
+  }
+  handlePossibleChange(e) {
+  }
+  handleChange(e, t) {
+  }
+}
+function ot(n, e) {
+  let t;
+  return V({ owner: n, debugReferenceFn: e }, (r) => (t = e(r, t), t));
+}
+function ut(n, e) {
+  let t;
+  const s = Ne("derivedObservableWithWritableCache"), r = Oe(n, (i) => (s.read(i), t = e(i, t), t));
+  return Object.assign(r, {
+    clearCache: (i) => {
+      t = void 0, s.trigger(i);
+    },
+    setCache: (i, a) => {
+      t = i, s.trigger(a);
+    }
+  });
+}
+function ht(n, e, t, s) {
+  let r = new Y(t, s);
+  return V({
+    debugReferenceFn: t,
+    owner: n,
+    onLastObserverRemoved: () => {
+      r.dispose(), r = new Y(t);
+    }
+  }, (a) => (r.setItems(e.read(a)), r.getItems()));
+}
+class Y {
+  constructor(e, t) {
+    this._map = e, this._keySelector = t, this._cache = /* @__PURE__ */ new Map(), this._items = [];
+  }
+  dispose() {
+    this._cache.forEach((e) => e.store.dispose()), this._cache.clear();
+  }
+  setItems(e) {
+    const t = [], s = new Set(this._cache.keys());
+    for (const r of e) {
+      const i = this._keySelector ? this._keySelector(r) : r;
+      let a = this._cache.get(i);
+      if (a)
+        s.delete(i);
+      else {
+        const d = new f();
+        a = { out: this._map(r, d), store: d }, this._cache.set(i, a);
+      }
+      t.push(a.out);
+    }
+    for (const r of s)
+      this._cache.get(r).store.dispose(), this._cache.delete(r);
+    this._items = t;
+  }
+  getItems() {
+    return this._items;
+  }
+}
+let T;
+function Ae(n) {
+  T || (T = new Ue(), ae(T)), T.addFilteredObj(n);
+}
+class Ue {
+  constructor() {
+    this.indentation = 0, this.changedObservablesSets = /* @__PURE__ */ new WeakMap();
+  }
+  addFilteredObj(e) {
+    this._filteredObjects || (this._filteredObjects = /* @__PURE__ */ new Set()), this._filteredObjects.add(e);
+  }
+  _isIncluded(e) {
+    return this._filteredObjects?.has(e) ?? !0;
+  }
+  textToConsoleArgs(e) {
+    return $e([
+      C(xe("|  ", this.indentation)),
+      e
+    ]);
+  }
+  formatInfo(e) {
+    return e.hadValue ? e.didChange ? [
+      C(" "),
+      c(O(e.oldValue, 70), {
+        color: "red",
+        strikeThrough: !0
+      }),
+      C(" "),
+      c(O(e.newValue, 60), {
+        color: "green"
+      })
+    ] : [C(" (unchanged)")] : [
+      C(" "),
+      c(O(e.newValue, 60), {
+        color: "green"
+      }),
+      C(" (initial)")
+    ];
+  }
+  handleObservableCreated(e) {
+    if (e instanceof b) {
+      const t = e;
+      this.changedObservablesSets.set(t, /* @__PURE__ */ new Set());
+    }
+  }
+  handleOnListenerCountChanged(e, t) {
+  }
+  handleObservableUpdated(e, t) {
+    if (this._isIncluded(e)) {
+      if (e instanceof b) {
+        this._handleDerivedRecomputed(e, t);
+        return;
+      }
+      console.log(...this.textToConsoleArgs([
+        y("observable value changed"),
+        c(e.debugName, { color: "BlueViolet" }),
+        ...this.formatInfo(t)
+      ]));
+    }
+  }
+  formatChanges(e) {
+    if (e.size !== 0)
+      return c(" (changed deps: " + [...e].map((t) => t.debugName).join(", ") + ")", { color: "gray" });
+  }
+  handleDerivedDependencyChanged(e, t, s) {
+    this._isIncluded(e) && this.changedObservablesSets.get(e)?.add(t);
+  }
+  _handleDerivedRecomputed(e, t) {
+    if (!this._isIncluded(e))
+      return;
+    const s = this.changedObservablesSets.get(e);
+    s && (console.log(...this.textToConsoleArgs([
+      y("derived recomputed"),
+      c(e.debugName, { color: "BlueViolet" }),
+      ...this.formatInfo(t),
+      this.formatChanges(s),
+      { data: [{ fn: e._debugNameData.referenceFn ?? e._computeFn }] }
+    ])), s.clear());
+  }
+  handleDerivedCleared(e) {
+    this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      y("derived cleared"),
+      c(e.debugName, { color: "BlueViolet" })
+    ]));
+  }
+  handleFromEventObservableTriggered(e, t) {
+    this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      y("observable from event triggered"),
+      c(e.debugName, { color: "BlueViolet" }),
+      ...this.formatInfo(t),
+      { data: [{ fn: e._getValue }] }
+    ]));
+  }
+  handleAutorunCreated(e) {
+    this._isIncluded(e) && this.changedObservablesSets.set(e, /* @__PURE__ */ new Set());
+  }
+  handleAutorunDisposed(e) {
+  }
+  handleAutorunDependencyChanged(e, t, s) {
+    this._isIncluded(e) && this.changedObservablesSets.get(e).add(t);
+  }
+  handleAutorunStarted(e) {
+    const t = this.changedObservablesSets.get(e);
+    t && (this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      y("autorun"),
+      c(e.debugName, { color: "BlueViolet" }),
+      this.formatChanges(t),
+      { data: [{ fn: e._debugNameData.referenceFn ?? e._runFn }] }
+    ])), t.clear(), this.indentation++);
+  }
+  handleAutorunFinished(e) {
+    this.indentation--;
+  }
+  handleBeginTransaction(e) {
+    let t = e.getDebugName();
+    t === void 0 && (t = ""), this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      y("transaction"),
+      c(t, { color: "BlueViolet" }),
+      { data: [{ fn: e._fn }] }
+    ])), this.indentation++;
+  }
+  handleEndTransaction() {
+    this.indentation--;
+  }
+}
+function $e(n) {
+  const e = new Array(), t = [];
+  let s = "";
+  function r(a) {
+    if ("length" in a)
+      for (const d of a)
+        d && r(d);
+    else "text" in a ? (s += `%c${a.text}`, e.push(a.style), a.data && t.push(...a.data)) : "data" in a && t.push(...a.data);
+  }
+  r(n);
+  const i = [s, ...e];
+  return i.push(...t), i;
+}
+function C(n) {
+  return c(n, { color: "black" });
+}
+function y(n) {
+  return c(Ie(`${n}: `, 10), { color: "black", bold: !0 });
+}
+function c(n, e = {
+  color: "black"
+}) {
+  function t(r) {
+    return Object.entries(r).reduce((i, [a, d]) => `${i}${a}:${d};`, "");
+  }
+  const s = {
+    color: e.color
+  };
+  return e.strikeThrough && (s["text-decoration"] = "line-through"), e.bold && (s["font-weight"] = "bold"), {
+    text: n,
+    style: t(s)
+  };
+}
+function O(n, e) {
+  try {
+    return Ee(n, e);
+  } catch {
+    return "[[???]]";
+  }
+}
+function Ee(n, e) {
+  switch (typeof n) {
+    case "number":
+      return "" + n;
+    case "string":
+      return n.length + 2 <= e ? `"${n}"` : `"${n.substr(0, e - 7)}"+...`;
+    case "boolean":
+      return n ? "true" : "false";
+    case "undefined":
+      return "undefined";
+    case "object":
+      return n === null ? "null" : Array.isArray(n) ? Fe(n, e) : Be(n, e);
+    case "symbol":
+      return n.toString();
+    case "function":
+      return `[[Function${n.name ? " " + n.name : ""}]]`;
+    default:
+      return "" + n;
+  }
+}
+function Fe(n, e) {
+  let t = "[ ", s = !0;
+  for (const r of n) {
+    if (s || (t += ", "), t.length - 5 > e) {
+      t += "...";
+      break;
+    }
+    s = !1, t += `${O(r, e - t.length)}`;
+  }
+  return t += " ]", t;
+}
+function Be(n, e) {
+  try {
+    if (typeof n.toString == "function" && n.toString !== Object.prototype.toString) {
+      const a = n.toString();
+      return a.length <= e ? a : a.substring(0, e - 3) + "...";
+    }
+  } catch {
+    return "[[Object]]";
+  }
+  const t = ee(n);
+  let s = t ? t + "(" : "{ ", r = !0, i;
+  try {
+    i = Object.entries(n);
+  } catch {
+    return t ? `${t}(...)` : "[[Object]]";
+  }
+  for (const [a, d] of i) {
+    if (r || (s += ", "), s.length - 5 > e) {
+      s += "...";
+      break;
+    }
+    r = !1, s += `${a}: ${O(d, e - s.length)}`;
+  }
+  return s += t ? ")" : " }", s;
+}
+function xe(n, e) {
+  let t = "";
+  for (let s = 1; s <= e; s++)
+    t += n;
+  return t;
+}
+function Ie(n, e) {
+  for (; n.length < e; )
+    n += " ";
+  return n;
+}
+function je(n, e) {
+  const t = e?.debugNamePostProcessor ?? ((i) => i), s = g.from(n, t);
+  return s ? ie(s, 0, /* @__PURE__ */ new Set()).trim() : "";
+}
+function ie(n, e, t) {
+  const s = "		".repeat(e), r = [];
+  if (t.has(n.sourceObj))
+    return r.push(`${s}* ${n.type} ${n.name} (already listed)`), r.join(`
+`);
+  if (t.add(n.sourceObj), r.push(`${s}* ${n.type} ${n.name}:`), r.push(`${s}  value: ${O(n.value, 50)}`), r.push(`${s}  state: ${n.state}`), n.dependencies.length > 0) {
+    r.push(`${s}  dependencies:`);
+    for (const a of n.dependencies)
+      r.push(ie(a, e + 1, t));
+  }
+  return r.join(`
+`);
+}
+class g {
+  static from(e, t) {
+    if (e instanceof k) {
+      const s = e.debugGetState();
+      return new g(e, t(e.debugName), "autorun", void 0, s.stateStr, Array.from(s.dependencies).map((r) => g.from(r, t) || g.unknown(r)));
+    } else if (e instanceof b) {
+      const s = e.debugGetState();
+      return new g(e, t(e.debugName), "derived", s.value, s.stateStr, Array.from(s.dependencies).map((r) => g.from(r, t) || g.unknown(r)));
+    } else if (e instanceof q) {
+      const s = e.debugGetState();
+      return new g(e, t(e.debugName), "observableValue", s.value, "upToDate", []);
+    } else if (e instanceof p) {
+      const s = e.debugGetState();
+      return new g(e, t(e.debugName), "fromEvent", s.value, s.hasValue ? "upToDate" : "initial", []);
+    }
+  }
+  static unknown(e) {
+    return new g(e, "(unknown)", "unknown", void 0, "unknown", []);
+  }
+  constructor(e, t, s, r, i, a) {
+    this.sourceObj = e, this.name = t, this.type = s, this.value = r, this.state = i, this.dependencies = a;
+  }
+}
+pe(je);
+de(Ae);
+class lt extends Error {
+  constructor(e = "Operation was cancelled") {
+    super(e), this.name = "CancellationError";
+  }
+}
+class Ge {
+  constructor() {
+    this._isCancelled = !1, this._listeners = /* @__PURE__ */ new Set();
+  }
+  get token() {
+    return {
+      isCancellationRequested: this._isCancelled,
+      onCancellationRequested: (e) => (this._listeners.add(e), this._isCancelled && e(), {
+        dispose: () => {
+          this._listeners.delete(e);
+        }
+      })
+    };
+  }
+  cancel() {
+    if (!this._isCancelled) {
+      this._isCancelled = !0;
+      for (const e of this._listeners)
+        e();
+    }
+  }
+  dispose() {
+    this.cancel(), this._listeners.clear();
+  }
+}
+function Le(n) {
+  const e = new Ge();
+  return n.add(e), e.token;
+}
+function We(n, e) {
+  let t, s = !0;
+  return Te({
+    changeTracker: {
+      createChangeSummary: () => ({ deltas: [], didChange: !1 }),
+      handleChange: (r, i) => {
+        if (r.didChange(n)) {
+          const a = r.change;
+          a !== void 0 && i.deltas.push(a), i.didChange = !0;
+        }
+        return !0;
+      }
+    }
+  }, (r, i) => {
+    const a = n.read(r), d = t;
+    i.didChange && (t = a, e(a, d, i.deltas)), s && (s = !1, t = a);
+  });
+}
+function ze(n, e) {
+  const t = new f(), s = We(n, (r, i, a) => {
+    t.clear(), e(r, i, a, t);
+  });
+  return {
+    dispose() {
+      s.dispose(), t.dispose();
+    }
+  };
+}
+function ct(n, e) {
+  return ze(n, (t, s, r, i) => {
+    e(t, s, r, Le(i));
+  });
+}
+export {
+  at as A,
+  R as B,
+  lt as C,
+  qe as D,
+  it as E,
+  Pe as F,
+  He as G,
+  ut as H,
+  V as I,
+  Me as J,
+  Ke as K,
+  tt as L,
+  Ye as M,
+  ht as N,
+  q as O,
+  nt as P,
+  st as Q,
+  Ne as R,
+  ke as S,
+  U as T,
+  ct as U,
+  ze as V,
+  rt as W,
+  De as X,
+  dt as Y,
+  L as a,
+  l as b,
+  u as c,
+  Oe as d,
+  b as e,
+  Ge as f,
+  o as g,
+  v as h,
+  me as i,
+  I as j,
+  ot as k,
+  f as l,
+  W as m,
+  he as n,
+  z as o,
+  Ve as p,
+  et as q,
+  We as r,
+  _ as s,
+  A as t,
+  Je as u,
+  Se as v,
+  Qe as w,
+  Xe as x,
+  Ze as y,
+  Te as z
+};
+//# sourceMappingURL=runOnChange-owE1SMC0.js.map