@omniviewdev/runtime 0.2.3 → 0.4.0

package/dist/calls-BmUnjINC.js

@@ -0,0 +1,677 @@
+import { n as M, b as I, o as x, h as k, R as H } from "./index-D2mKAO8s.js";
+var D = Function.prototype.toString, h = typeof Reflect == "object" && Reflect !== null && Reflect.apply, g, j;
+if (typeof h == "function" && typeof Object.defineProperty == "function")
+  try {
+    g = Object.defineProperty({}, "length", {
+      get: function() {
+        throw j;
+      }
+    }), j = {}, h(function() {
+      throw 42;
+    }, null, g);
+  } catch (r) {
+    r !== j && (h = null);
+  }
+else
+  h = null;
+var N = /^\s*class\b/, A = function(e) {
+  try {
+    var t = D.call(e);
+    return N.test(t);
+  } catch {
+    return !1;
+  }
+}, S = function(e) {
+  try {
+    return A(e) ? !1 : (D.call(e), !0);
+  } catch {
+    return !1;
+  }
+}, m = Object.prototype.toString, q = "[object Object]", z = "[object Function]", G = "[object GeneratorFunction]", J = "[object HTMLAllCollection]", W = "[object HTML document.all class]", K = "[object HTMLCollection]", Q = typeof Symbol == "function" && !!Symbol.toStringTag, V = !(0 in [,]), E = function() {
+  return !1;
+};
+if (typeof document == "object") {
+  var X = document.all;
+  m.call(X) === m.call(document.all) && (E = function(e) {
+    if ((V || !e) && (typeof e > "u" || typeof e == "object"))
+      try {
+        var t = m.call(e);
+        return (t === J || t === W || t === K || t === q) && e("") == null;
+      } catch {
+      }
+    return !1;
+  });
+}
+function Y(r) {
+  if (E(r))
+    return !0;
+  if (!r || typeof r != "function" && typeof r != "object")
+    return !1;
+  try {
+    h(r, null, g);
+  } catch (e) {
+    if (e !== j)
+      return !1;
+  }
+  return !A(r) && S(r);
+}
+function Z(r) {
+  if (E(r))
+    return !0;
+  if (!r || typeof r != "function" && typeof r != "object")
+    return !1;
+  if (Q)
+    return S(r);
+  if (A(r))
+    return !1;
+  var e = m.call(r);
+  return e !== z && e !== G && !/^\[object HTML/.test(e) ? !1 : S(r);
+}
+const f = h ? Y : Z;
+var w;
+class R extends Error {
+  /**
+   * Constructs a new `CancelError` instance.
+   * @param message - The error message.
+   * @param options - Options to be forwarded to the Error constructor.
+   */
+  constructor(e, t) {
+    super(e, t), this.name = "CancelError";
+  }
+}
+class v extends Error {
+  /**
+   * Constructs a new `CancelledRejectionError` instance.
+   * @param promise - The promise that caused the error originally.
+   * @param reason - The rejection reason.
+   * @param info - An optional informative message specifying the circumstances in which the error was thrown.
+   *               Defaults to the string `"Unhandled rejection in cancelled promise."`.
+   */
+  constructor(e, t, n) {
+    super((n ?? "Unhandled rejection in cancelled promise.") + " Reason: " + $(t), { cause: t }), this.promise = e, this.name = "CancelledRejectionError";
+  }
+}
+const u = Symbol("barrier"), T = Symbol("cancelImpl"), P = (w = Symbol.species) !== null && w !== void 0 ? w : Symbol("speciesPolyfill");
+class l extends Promise {
+  /**
+   * Creates a new `CancellablePromise`.
+   *
+   * @param executor - A callback used to initialize the promise. This callback is passed two arguments:
+   *                   a `resolve` callback used to resolve the promise with a value
+   *                   or the result of another promise (possibly cancellable),
+   *                   and a `reject` callback used to reject the promise with a provided reason or error.
+   *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object
+   *                   (it has a `then` _and_ a `cancel` method),
+   *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.
+   *                   If any one of the two callbacks is called _after_ the promise has been cancelled,
+   *                   the provided values will be cancelled and resolved as usual,
+   *                   but their results will be discarded.
+   *                   However, if the resolution process ultimately ends up in a rejection
+   *                   that is not due to cancellation, the rejection reason
+   *                   will be wrapped in a {@link CancelledRejectionError}
+   *                   and bubbled up as an unhandled rejection.
+   * @param oncancelled - It is the caller's responsibility to ensure that any operation
+   *                      started by the executor is properly halted upon cancellation.
+   *                      This optional callback can be used to that purpose.
+   *                      It will be called _synchronously_ with a cancellation cause
+   *                      when cancellation is requested, _after_ the promise has already rejected
+   *                      with a {@link CancelError}, but _before_
+   *                      any {@link then}/{@link catch}/{@link finally} callback runs.
+   *                      If the callback returns a thenable, the promise returned from {@link cancel}
+   *                      will only fulfill after the former has settled.
+   *                      Unhandled exceptions or rejections from the callback will be wrapped
+   *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.
+   *                      If the `resolve` callback is called before cancellation with a cancellable promise,
+   *                      cancellation requests on this promise will be diverted to that promise,
+   *                      and the original `oncancelled` callback will be discarded.
+   */
+  constructor(e, t) {
+    let n, o;
+    if (super((s, p) => {
+      n = s, o = p;
+    }), this.constructor[P] !== Promise)
+      throw new TypeError("CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.");
+    let c = {
+      promise: this,
+      resolve: n,
+      reject: o,
+      get oncancelled() {
+        return t ?? null;
+      },
+      set oncancelled(s) {
+        t = s ?? void 0;
+      }
+    };
+    const i = {
+      get root() {
+        return i;
+      },
+      resolving: !1,
+      settled: !1
+    };
+    Object.defineProperties(this, {
+      [u]: {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      },
+      [T]: {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: L(c, i)
+      }
+    });
+    const a = B(c, i);
+    try {
+      e(U(c, i), a);
+    } catch (s) {
+      i.resolving ? console.log("Unhandled exception in CancellablePromise executor.", s) : a(s);
+    }
+  }
+  /**
+   * Cancels immediately the execution of the operation associated with this promise.
+   * The promise rejects with a {@link CancelError} instance as reason,
+   * with the {@link CancelError#cause} property set to the given argument, if any.
+   *
+   * Has no effect if called after the promise has already settled;
+   * repeated calls in particular are safe, but only the first one
+   * will set the cancellation cause.
+   *
+   * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_
+   * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.
+   * Therefore, the following idioms are all equally correct:
+   * ```ts
+   * new CancellablePromise((resolve, reject) => { ... }).cancel();
+   * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();
+   * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();
+   * ```
+   * Whenever some cancelled promise in a chain rejects with a `CancelError`
+   * with the same cancellation cause as itself, the error will be discarded silently.
+   * However, the `CancelError` _will still be delivered_ to all attached rejection handlers
+   * added by {@link then} and related methods:
+   * ```ts
+   * let cancellable = new CancellablePromise((resolve, reject) => { ... });
+   * cancellable.then(() => { ... }).catch(console.log);
+   * cancellable.cancel(); // A CancelError is printed to the console.
+   * ```
+   * If the `CancelError` is not handled downstream by the time it reaches
+   * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,
+   * just like normal rejections would:
+   * ```ts
+   * let cancellable = new CancellablePromise((resolve, reject) => { ... });
+   * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...
+   * cancellable.cancel(); // Unhandled rejection event on chained!
+   * ```
+   * Therefore, it is important to either cancel whole promise chains from their tail,
+   * as shown in the correct idioms above, or take care of handling errors everywhere.
+   *
+   * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)
+   * and all handlers attached up to the call to cancel have run.
+   * If the cancel callback returns a thenable, the promise returned by `cancel`
+   * will also wait for that thenable to settle.
+   * This enables callers to wait for the cancelled operation to terminate
+   * without being forced to handle potential errors at the call site.
+   * ```ts
+   * cancellable.cancel().then(() => {
+   *     // Cleanup finished, it's safe to do something else.
+   * }, (err) => {
+   *     // Unreachable: the promise returned from cancel will never reject.
+   * });
+   * ```
+   * Note that the returned promise will _not_ handle implicitly any rejection
+   * that might have occurred already in the cancelled chain.
+   * It will just track whether registered handlers have been executed or not.
+   * Therefore, unhandled rejections will never be silently handled by calling cancel.
+   */
+  cancel(e) {
+    return new l((t) => {
+      Promise.all([
+        this[T](new R("Promise cancelled.", { cause: e })),
+        _(this)
+      ]).then(() => t(), () => t());
+    });
+  }
+  /**
+   * Binds promise cancellation to the abort event of the given {@link AbortSignal}.
+   * If the signal has already aborted, the promise will be cancelled immediately.
+   * When either condition is verified, the cancellation cause will be set
+   * to the signal's abort reason (see {@link AbortSignal#reason}).
+   *
+   * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.
+   * Only the first signal to abort will set the cancellation cause.
+   *
+   * For more details about the cancellation process,
+   * see {@link cancel} and the `CancellablePromise` constructor.
+   *
+   * This method enables `await`ing cancellable promises without having
+   * to store them for future cancellation, e.g.:
+   * ```ts
+   * await longRunningOperation().cancelOn(signal);
+   * ```
+   * instead of:
+   * ```ts
+   * let promiseToBeCancelled = longRunningOperation();
+   * await promiseToBeCancelled;
+   * ```
+   *
+   * @returns This promise, for method chaining.
+   */
+  cancelOn(e) {
+    return e.aborted ? this.cancel(e.reason) : e.addEventListener("abort", () => void this.cancel(e.reason), { capture: !0 }), this;
+  }
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.
+   *
+   * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,
+   * with the same semantics as the `oncancelled` argument of the constructor.
+   * When the parent promise rejects or is cancelled, the `onrejected` callback will run,
+   * _even after the returned promise has been cancelled:_
+   * in that case, should it reject or throw, the reason will be wrapped
+   * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.
+   *
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A `CancellablePromise` for the completion of whichever callback is executed.
+   * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:
+   *
+   *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`
+   *     and the returned promise _will resolve regularly_ with its result;
+   *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_
+   *     the `onrejected` handler will still be invoked with the parent's `CancelError`,
+   *     but its result will be discarded
+   *     and the returned promise will reject with a `CancelError` as well.
+   *
+   * The promise returned from {@link cancel} will fulfill only after all attached handlers
+   * up the entire promise chain have been run.
+   *
+   * If either callback returns a cancellable promise,
+   * cancellation requests will be diverted to it,
+   * and the specified `oncancelled` callback will be discarded.
+   */
+  then(e, t, n) {
+    if (!(this instanceof l))
+      throw new TypeError("CancellablePromise.prototype.then called on an invalid object.");
+    if (f(e) || (e = C), f(t) || (t = F), e === C && t == F)
+      return new l((c) => c(this));
+    const o = {};
+    return this[u] = o, new l((c, i) => {
+      super.then((a) => {
+        var s;
+        this[u] === o && (this[u] = null), (s = o.resolve) === null || s === void 0 || s.call(o);
+        try {
+          c(e(a));
+        } catch (p) {
+          i(p);
+        }
+      }, (a) => {
+        var s;
+        this[u] === o && (this[u] = null), (s = o.resolve) === null || s === void 0 || s.call(o);
+        try {
+          c(t(a));
+        } catch (p) {
+          i(p);
+        }
+      });
+    }, async (c) => {
+      try {
+        return n == null ? void 0 : n(c);
+      } finally {
+        await this.cancel(c);
+      }
+    });
+  }
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   *
+   * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,
+   * with the same semantics as the `oncancelled` argument of the constructor.
+   * When the parent promise rejects or is cancelled, the `onrejected` callback will run,
+   * _even after the returned promise has been cancelled:_
+   * in that case, should it reject or throw, the reason will be wrapped
+   * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.
+   *
+   * It is equivalent to
+   * ```ts
+   * cancellablePromise.then(undefined, onrejected, oncancelled);
+   * ```
+   * and the same caveats apply.
+   *
+   * @returns A Promise for the completion of the callback.
+   * Cancellation requests on the returned promise
+   * will propagate up the chain to the parent promise,
+   * but not in the other direction.
+   *
+   * The promise returned from {@link cancel} will fulfill only after all attached handlers
+   * up the entire promise chain have been run.
+   *
+   * If `onrejected` returns a cancellable promise,
+   * cancellation requests will be diverted to it,
+   * and the specified `oncancelled` callback will be discarded.
+   * See {@link then} for more details.
+   */
+  catch(e, t) {
+    return this.then(void 0, e, t);
+  }
+  /**
+   * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The
+   * resolved value cannot be accessed or modified from the callback.
+   * The returned promise will settle in the same state as the original one
+   * after the provided callback has completed execution,
+   * unless the callback throws or returns a rejecting promise,
+   * in which case the returned promise will reject as well.
+   *
+   * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,
+   * with the same semantics as the `oncancelled` argument of the constructor.
+   * Once the parent promise settles, the `onfinally` callback will run,
+   * _even after the returned promise has been cancelled:_
+   * in that case, should it reject or throw, the reason will be wrapped
+   * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.
+   *
+   * This method is implemented in terms of {@link then} and the same caveats apply.
+   * It is polyfilled, hence available in every OS/webview version.
+   *
+   * @returns A Promise for the completion of the callback.
+   * Cancellation requests on the returned promise
+   * will propagate up the chain to the parent promise,
+   * but not in the other direction.
+   *
+   * The promise returned from {@link cancel} will fulfill only after all attached handlers
+   * up the entire promise chain have been run.
+   *
+   * If `onfinally` returns a cancellable promise,
+   * cancellation requests will be diverted to it,
+   * and the specified `oncancelled` callback will be discarded.
+   * See {@link then} for more details.
+   */
+  finally(e, t) {
+    if (!(this instanceof l))
+      throw new TypeError("CancellablePromise.prototype.finally called on an invalid object.");
+    return f(e) ? this.then((n) => l.resolve(e()).then(() => n), (n) => l.resolve(e()).then(() => {
+      throw n;
+    }), t) : this.then(e, e, t);
+  }
+  /**
+   * We use the `[Symbol.species]` static property, if available,
+   * to disable the built-in automatic subclassing features from {@link Promise}.
+   * It is critical for performance reasons that extenders do not override this.
+   * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing
+   * is either accepted or retired, this implementation will have to be revised accordingly.
+   *
+   * @ignore
+   * @internal
+   */
+  static get [P]() {
+    return Promise;
+  }
+  static all(e) {
+    let t = Array.from(e);
+    const n = t.length === 0 ? l.resolve(t) : new l((o, c) => {
+      Promise.all(t).then(o, c);
+    }, (o) => b(n, t, o));
+    return n;
+  }
+  static allSettled(e) {
+    let t = Array.from(e);
+    const n = t.length === 0 ? l.resolve(t) : new l((o, c) => {
+      Promise.allSettled(t).then(o, c);
+    }, (o) => b(n, t, o));
+    return n;
+  }
+  static any(e) {
+    let t = Array.from(e);
+    const n = t.length === 0 ? l.resolve(t) : new l((o, c) => {
+      Promise.any(t).then(o, c);
+    }, (o) => b(n, t, o));
+    return n;
+  }
+  static race(e) {
+    let t = Array.from(e);
+    const n = new l((o, c) => {
+      Promise.race(t).then(o, c);
+    }, (o) => b(n, t, o));
+    return n;
+  }
+  /**
+   * Creates a new cancelled CancellablePromise for the provided cause.
+   *
+   * @group Static Methods
+   */
+  static cancel(e) {
+    const t = new l(() => {
+    });
+    return t.cancel(e), t;
+  }
+  /**
+   * Creates a new CancellablePromise that cancels
+   * after the specified timeout, with the provided cause.
+   *
+   * If the {@link AbortSignal.timeout} factory method is available,
+   * it is used to base the timeout on _active_ time rather than _elapsed_ time.
+   * Otherwise, `timeout` falls back to {@link setTimeout}.
+   *
+   * @group Static Methods
+   */
+  static timeout(e, t) {
+    const n = new l(() => {
+    });
+    return AbortSignal && typeof AbortSignal == "function" && AbortSignal.timeout && typeof AbortSignal.timeout == "function" ? AbortSignal.timeout(e).addEventListener("abort", () => void n.cancel(t)) : setTimeout(() => void n.cancel(t), e), n;
+  }
+  static sleep(e, t) {
+    return new l((n) => {
+      setTimeout(() => n(t), e);
+    });
+  }
+  /**
+   * Creates a new rejected CancellablePromise for the provided reason.
+   *
+   * @group Static Methods
+   */
+  static reject(e) {
+    return new l((t, n) => n(e));
+  }
+  static resolve(e) {
+    return e instanceof l ? e : new l((t) => t(e));
+  }
+  /**
+   * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions
+   * and a getter/setter for the cancellation callback.
+   *
+   * This method is polyfilled, hence available in every OS/webview version.
+   *
+   * @group Static Methods
+   */
+  static withResolvers() {
+    let e = { oncancelled: null };
+    return e.promise = new l((t, n) => {
+      e.resolve = t, e.reject = n;
+    }, (t) => {
+      var n;
+      (n = e.oncancelled) === null || n === void 0 || n.call(e, t);
+    }), e;
+  }
+}
+function L(r, e) {
+  let t;
+  return (n) => {
+    if (e.settled || (e.settled = !0, e.reason = n, r.reject(n), Promise.prototype.then.call(r.promise, void 0, (o) => {
+      if (o !== n)
+        throw o;
+    })), !(!e.reason || !r.oncancelled))
+      return t = new Promise((o) => {
+        try {
+          o(r.oncancelled(e.reason.cause));
+        } catch (c) {
+          Promise.reject(new v(r.promise, c, "Unhandled exception in oncancelled callback."));
+        }
+      }).catch((o) => {
+        Promise.reject(new v(r.promise, o, "Unhandled rejection in oncancelled callback."));
+      }), r.oncancelled = null, t;
+  };
+}
+function U(r, e) {
+  return (t) => {
+    if (!e.resolving) {
+      if (e.resolving = !0, t === r.promise) {
+        if (e.settled)
+          return;
+        e.settled = !0, r.reject(new TypeError("A promise cannot be resolved with itself."));
+        return;
+      }
+      if (t != null && (typeof t == "object" || typeof t == "function")) {
+        let n;
+        try {
+          n = t.then;
+        } catch (o) {
+          e.settled = !0, r.reject(o);
+          return;
+        }
+        if (f(n)) {
+          try {
+            let i = t.cancel;
+            if (f(i)) {
+              const a = (s) => {
+                Reflect.apply(i, t, [s]);
+              };
+              e.reason ? L(Object.assign(Object.assign({}, r), { oncancelled: a }), e)(e.reason) : r.oncancelled = a;
+            }
+          } catch {
+          }
+          const o = {
+            root: e.root,
+            resolving: !1,
+            get settled() {
+              return this.root.settled;
+            },
+            set settled(i) {
+              this.root.settled = i;
+            },
+            get reason() {
+              return this.root.reason;
+            }
+          }, c = B(r, o);
+          try {
+            Reflect.apply(n, t, [U(r, o), c]);
+          } catch (i) {
+            c(i);
+          }
+          return;
+        }
+      }
+      e.settled || (e.settled = !0, r.resolve(t));
+    }
+  };
+}
+function B(r, e) {
+  return (t) => {
+    if (!e.resolving)
+      if (e.resolving = !0, e.settled) {
+        try {
+          if (t instanceof R && e.reason instanceof R && Object.is(t.cause, e.reason.cause))
+            return;
+        } catch {
+        }
+        Promise.reject(new v(r.promise, t));
+      } else
+        e.settled = !0, r.reject(t);
+  };
+}
+function b(r, e, t) {
+  const n = [];
+  for (const o of e) {
+    let c;
+    try {
+      if (!f(o.then) || (c = o.cancel, !f(c)))
+        continue;
+    } catch {
+      continue;
+    }
+    let i;
+    try {
+      i = Reflect.apply(c, o, [t]);
+    } catch (a) {
+      Promise.reject(new v(r, a, "Unhandled exception in cancel method."));
+      continue;
+    }
+    i && n.push((i instanceof Promise ? i : Promise.resolve(i)).catch((a) => {
+      Promise.reject(new v(r, a, "Unhandled rejection in cancel method."));
+    }));
+  }
+  return Promise.all(n);
+}
+function C(r) {
+  return r;
+}
+function F(r) {
+  throw r;
+}
+function $(r) {
+  try {
+    if (r instanceof Error || typeof r != "object" || r.toString !== Object.prototype.toString)
+      return "" + r;
+  } catch {
+  }
+  try {
+    return JSON.stringify(r);
+  } catch {
+  }
+  try {
+    return Object.prototype.toString.call(r);
+  } catch {
+  }
+  return "<could not convert error to string>";
+}
+function _(r) {
+  var e;
+  let t = (e = r[u]) !== null && e !== void 0 ? e : {};
+  return "promise" in t || Object.assign(t, d()), r[u] == null && (t.resolve(), r[u] = t), t.promise;
+}
+let d = Promise.withResolvers;
+d && typeof d == "function" ? d = d.bind(Promise) : d = function() {
+  let r, e;
+  return { promise: new Promise((n, o) => {
+    r = n, e = o;
+  }), resolve: r, reject: e };
+};
+k && (window._wails = window._wails || {});
+const ee = M(x.Call), te = M(x.CancelCall), y = /* @__PURE__ */ new Map(), re = 0, ne = 0;
+function oe() {
+  let r;
+  do
+    r = I();
+  while (y.has(r));
+  return r;
+}
+function O(r) {
+  const e = oe(), t = l.withResolvers();
+  y.set(e, { resolve: t.resolve, reject: t.reject });
+  const n = ee(re, Object.assign({ "call-id": e }, r));
+  let o = !0;
+  n.then((i) => {
+    o = !1, y.delete(e), t.resolve(i);
+  }, (i) => {
+    o = !1, y.delete(e), t.reject(i);
+  });
+  const c = () => (y.delete(e), te(ne, { "call-id": e }).catch((i) => {
+    console.error("Error while requesting binding call cancellation:", i);
+  }));
+  return t.oncancelled = () => o ? c() : n.then(c), t.promise;
+}
+function ce(r, ...e) {
+  return O({ methodName: r, args: e });
+}
+function ie(r, ...e) {
+  return O({ methodID: r, args: e });
+}
+const se = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ByID: ie,
+  ByName: ce,
+  Call: O,
+  RuntimeError: H
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ie as B,
+  se as c
+};

package/dist/calls-DZctVyoQ.cjs

@@ -0,0 +1 @@
+"use strict";const d=require("./index-D_aIcqH0.cjs");var M=Function.prototype.toString,p=typeof Reflect=="object"&&Reflect!==null&&Reflect.apply,S,m;if(typeof p=="function"&&typeof Object.defineProperty=="function")try{S=Object.defineProperty({},"length",{get:function(){throw m}}),m={},p(function(){throw 42},null,S)}catch(r){r!==m&&(p=null)}else p=null;var B=/^\s*class\b/,E=function(e){try{var t=M.call(e);return B.test(t)}catch{return!1}},R=function(e){try{return E(e)?!1:(M.call(e),!0)}catch{return!1}},w=Object.prototype.toString,N="[object Object]",k="[object Function]",H="[object GeneratorFunction]",q="[object HTMLAllCollection]",z="[object HTML document.all class]",G="[object HTMLCollection]",J=typeof Symbol=="function"&&!!Symbol.toStringTag,W=!(0 in[,]),O=function(){return!1};if(typeof document=="object"){var K=document.all;w.call(K)===w.call(document.all)&&(O=function(e){if((W||!e)&&(typeof e>"u"||typeof e=="object"))try{var t=w.call(e);return(t===q||t===z||t===G||t===N)&&e("")==null}catch{}return!1})}function Q(r){if(O(r))return!0;if(!r||typeof r!="function"&&typeof r!="object")return!1;try{p(r,null,S)}catch(e){if(e!==m)return!1}return!E(r)&&R(r)}function V(r){if(O(r))return!0;if(!r||typeof r!="function"&&typeof r!="object")return!1;if(J)return R(r);if(E(r))return!1;var e=w.call(r);return e!==k&&e!==H&&!/^\[object HTML/.test(e)?!1:R(r)}const f=p?Q:V;var g;class A extends Error{constructor(e,t){super(e,t),this.name="CancelError"}}class b extends Error{constructor(e,t,n){super((n??"Unhandled rejection in cancelled promise.")+" Reason: "+X(t),{cause:t}),this.promise=e,this.name="CancelledRejectionError"}}const u=Symbol("barrier"),P=Symbol("cancelImpl"),C=(g=Symbol.species)!==null&&g!==void 0?g:Symbol("speciesPolyfill");class l extends Promise{constructor(e,t){let n,o;if(super((s,y)=>{n=s,o=y}),this.constructor[C]!==Promise)throw new TypeError("CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.");let c={promise:this,resolve:n,reject:o,get oncancelled(){return t??null},set oncancelled(s){t=s??void 0}};const i={get root(){return i},resolving:!1,settled:!1};Object.defineProperties(this,{[u]:{configurable:!1,enumerable:!1,writable:!0,value:null},[P]:{configurable:!1,enumerable:!1,writable:!1,value:x(c,i)}});const a=I(c,i);try{e(L(c,i),a)}catch(s){i.resolving?console.log("Unhandled exception in CancellablePromise executor.",s):a(s)}}cancel(e){return new l(t=>{Promise.all([this[P](new A("Promise cancelled.",{cause:e})),Y(this)]).then(()=>t(),()=>t())})}cancelOn(e){return e.aborted?this.cancel(e.reason):e.addEventListener("abort",()=>void this.cancel(e.reason),{capture:!0}),this}then(e,t,n){if(!(this instanceof l))throw new TypeError("CancellablePromise.prototype.then called on an invalid object.");if(f(e)||(e=D),f(t)||(t=F),e===D&&t==F)return new l(c=>c(this));const o={};return this[u]=o,new l((c,i)=>{super.then(a=>{var s;this[u]===o&&(this[u]=null),(s=o.resolve)===null||s===void 0||s.call(o);try{c(e(a))}catch(y){i(y)}},a=>{var s;this[u]===o&&(this[u]=null),(s=o.resolve)===null||s===void 0||s.call(o);try{c(t(a))}catch(y){i(y)}})},async c=>{try{return n==null?void 0:n(c)}finally{await this.cancel(c)}})}catch(e,t){return this.then(void 0,e,t)}finally(e,t){if(!(this instanceof l))throw new TypeError("CancellablePromise.prototype.finally called on an invalid object.");return f(e)?this.then(n=>l.resolve(e()).then(()=>n),n=>l.resolve(e()).then(()=>{throw n}),t):this.then(e,e,t)}static get[C](){return Promise}static all(e){let t=Array.from(e);const n=t.length===0?l.resolve(t):new l((o,c)=>{Promise.all(t).then(o,c)},o=>j(n,t,o));return n}static allSettled(e){let t=Array.from(e);const n=t.length===0?l.resolve(t):new l((o,c)=>{Promise.allSettled(t).then(o,c)},o=>j(n,t,o));return n}static any(e){let t=Array.from(e);const n=t.length===0?l.resolve(t):new l((o,c)=>{Promise.any(t).then(o,c)},o=>j(n,t,o));return n}static race(e){let t=Array.from(e);const n=new l((o,c)=>{Promise.race(t).then(o,c)},o=>j(n,t,o));return n}static cancel(e){const t=new l(()=>{});return t.cancel(e),t}static timeout(e,t){const n=new l(()=>{});return AbortSignal&&typeof AbortSignal=="function"&&AbortSignal.timeout&&typeof AbortSignal.timeout=="function"?AbortSignal.timeout(e).addEventListener("abort",()=>void n.cancel(t)):setTimeout(()=>void n.cancel(t),e),n}static sleep(e,t){return new l(n=>{setTimeout(()=>n(t),e)})}static reject(e){return new l((t,n)=>n(e))}static resolve(e){return e instanceof l?e:new l(t=>t(e))}static withResolvers(){let e={oncancelled:null};return e.promise=new l((t,n)=>{e.resolve=t,e.reject=n},t=>{var n;(n=e.oncancelled)===null||n===void 0||n.call(e,t)}),e}}function x(r,e){let t;return n=>{if(e.settled||(e.settled=!0,e.reason=n,r.reject(n),Promise.prototype.then.call(r.promise,void 0,o=>{if(o!==n)throw o})),!(!e.reason||!r.oncancelled))return t=new Promise(o=>{try{o(r.oncancelled(e.reason.cause))}catch(c){Promise.reject(new b(r.promise,c,"Unhandled exception in oncancelled callback."))}}).catch(o=>{Promise.reject(new b(r.promise,o,"Unhandled rejection in oncancelled callback."))}),r.oncancelled=null,t}}function L(r,e){return t=>{if(!e.resolving){if(e.resolving=!0,t===r.promise){if(e.settled)return;e.settled=!0,r.reject(new TypeError("A promise cannot be resolved with itself."));return}if(t!=null&&(typeof t=="object"||typeof t=="function")){let n;try{n=t.then}catch(o){e.settled=!0,r.reject(o);return}if(f(n)){try{let i=t.cancel;if(f(i)){const a=s=>{Reflect.apply(i,t,[s])};e.reason?x(Object.assign(Object.assign({},r),{oncancelled:a}),e)(e.reason):r.oncancelled=a}}catch{}const o={root:e.root,resolving:!1,get settled(){return this.root.settled},set settled(i){this.root.settled=i},get reason(){return this.root.reason}},c=I(r,o);try{Reflect.apply(n,t,[L(r,o),c])}catch(i){c(i)}return}}e.settled||(e.settled=!0,r.resolve(t))}}}function I(r,e){return t=>{if(!e.resolving)if(e.resolving=!0,e.settled){try{if(t instanceof A&&e.reason instanceof A&&Object.is(t.cause,e.reason.cause))return}catch{}Promise.reject(new b(r.promise,t))}else e.settled=!0,r.reject(t)}}function j(r,e,t){const n=[];for(const o of e){let c;try{if(!f(o.then)||(c=o.cancel,!f(c)))continue}catch{continue}let i;try{i=Reflect.apply(c,o,[t])}catch(a){Promise.reject(new b(r,a,"Unhandled exception in cancel method."));continue}i&&n.push((i instanceof Promise?i:Promise.resolve(i)).catch(a=>{Promise.reject(new b(r,a,"Unhandled rejection in cancel method."))}))}return Promise.all(n)}function D(r){return r}function F(r){throw r}function X(r){try{if(r instanceof Error||typeof r!="object"||r.toString!==Object.prototype.toString)return""+r}catch{}try{return JSON.stringify(r)}catch{}try{return Object.prototype.toString.call(r)}catch{}return"<could not convert error to string>"}function Y(r){var e;let t=(e=r[u])!==null&&e!==void 0?e:{};return"promise"in t||Object.assign(t,h()),r[u]==null&&(t.resolve(),r[u]=t),t.promise}let h=Promise.withResolvers;h&&typeof h=="function"?h=h.bind(Promise):h=function(){let r,e;return{promise:new Promise((n,o)=>{r=n,e=o}),resolve:r,reject:e}};d.hasDOM&&(window._wails=window._wails||{});const Z=d.newRuntimeCaller(d.objectNames.Call),$=d.newRuntimeCaller(d.objectNames.CancelCall),v=new Map,_=0,ee=0;function te(){let r;do r=d.nanoid();while(v.has(r));return r}function T(r){const e=te(),t=l.withResolvers();v.set(e,{resolve:t.resolve,reject:t.reject});const n=Z(_,Object.assign({"call-id":e},r));let o=!0;n.then(i=>{o=!1,v.delete(e),t.resolve(i)},i=>{o=!1,v.delete(e),t.reject(i)});const c=()=>(v.delete(e),$(ee,{"call-id":e}).catch(i=>{console.error("Error while requesting binding call cancellation:",i)}));return t.oncancelled=()=>o?c():n.then(c),t.promise}function re(r,...e){return T({methodName:r,args:e})}function U(r,...e){return T({methodID:r,args:e})}const ne=Object.freeze(Object.defineProperty({__proto__:null,ByID:U,ByName:re,Call:T,RuntimeError:d.RuntimeError},Symbol.toStringTag,{value:"Module"}));exports.ByID=U;exports.calls=ne;