@bquery/bquery 1.8.2 → 1.10.0

package/dist/concurrency-BU1wPEsZ.js

@@ -0,0 +1,826 @@
+import { n as E } from "./core-CongXJuo.js";
+import { n as w, r as L } from "./readonly-C0ZwS1Tf.js";
+var p = class extends Error {
+  constructor(e, r, t) {
+    super(e), this.name = "TaskWorkerError", this.code = r, t !== void 0 && (this.cause = t);
+  }
+}, q = class extends p {
+  constructor(e = "Concurrency tasks are not supported in this environment.", r) {
+    super(e, "UNSUPPORTED", r), this.name = "TaskWorkerUnsupportedError";
+  }
+}, I = class extends p {
+  constructor(e, r) {
+    super(e, "SERIALIZATION", r), this.name = "TaskWorkerSerializationError";
+  }
+}, N = class extends p {
+  constructor(e, r) {
+    super(e, "TIMEOUT", r), this.name = "TaskWorkerTimeoutError";
+  }
+}, R = class extends p {
+  constructor(e = "The worker task was aborted.", r) {
+    super(e, "ABORT", r), this.name = "TaskWorkerAbortError";
+  }
+}, oe = /* @__PURE__ */ new Set([
+  "ABORT",
+  "BUSY",
+  "METHOD_NOT_FOUND",
+  "QUEUE_CLEARED",
+  "QUEUE_FULL",
+  "SERIALIZATION",
+  "TERMINATED",
+  "TIMEOUT",
+  "UNSUPPORTED",
+  "WORKER"
+]), se = /\{\s*\[native code\]\s*\}$/u, ae = (e) => typeof e == "string" && oe.has(e), z = (e) => {
+  if (!(typeof e != "number" || !Number.isFinite(e) || e <= 0))
+    return e;
+}, S = (e) => {
+  const r = Function.prototype.toString.call(e).trim();
+  if (!r || se.test(r)) throw new I("Task handlers must be standalone user-defined functions or arrow functions.");
+  try {
+    if (typeof new Function(`return (${r});`)() != "function") throw new TypeError("Task handler did not revive as a function.");
+  } catch (t) {
+    throw new I("Task handlers must be standalone functions that can be reconstructed in a worker context.", t);
+  }
+  return r;
+}, _ = (e, r) => {
+  const t = new Blob([e], { type: "text/javascript" }), n = URL.createObjectURL(t);
+  try {
+    return new Worker(n, r ? { name: r } : void 0);
+  } finally {
+    URL.revokeObjectURL(n);
+  }
+}, j = (e) => {
+  const r = e?.message || "Worker task failed.", t = ae(e?.code) ? e.code : "WORKER", n = t === "TIMEOUT" ? new N(r) : new p(r, t);
+  return n.name = e?.name || n.name, e?.stack && (n.stack = e.stack), n;
+};
+function ie() {
+  const e = typeof globalThis.Worker == "function", r = typeof globalThis.Blob == "function", t = typeof globalThis.URL < "u" && globalThis.URL !== null && typeof globalThis.URL.createObjectURL == "function" && typeof globalThis.URL.revokeObjectURL == "function";
+  return {
+    worker: e,
+    blob: r,
+    objectUrl: t,
+    abortController: typeof globalThis.AbortController == "function",
+    supported: e && r && t
+  };
+}
+function F() {
+  return ie().supported;
+}
+var D = "bq:rpc", ue = (e) => {
+  const r = Object.keys(e);
+  if (r.length === 0) throw new I("RPC workers require at least one standalone method handler.");
+  return r.map((t) => {
+    const n = e[t];
+    if (typeof n != "function") throw new I(`RPC handler "${t}" must be a standalone function.`);
+    return [t, S(n)];
+  });
+}, ce = (e) => `'use strict';
+const serializeError = (error) => {
+  if (error && typeof error === 'object') {
+    return {
+      code: typeof error.code === 'string' ? error.code : undefined,
+      message: typeof error.message === 'string' ? error.message : 'Worker RPC call failed.',
+      name: typeof error.name === 'string' ? error.name : 'Error',
+      stack: typeof error.stack === 'string' ? error.stack : undefined,
+    };
+  }
+
+  return {
+    message: typeof error === 'string' ? error : 'Worker RPC call failed.',
+    name: 'Error',
+  };
+};
+
+const handlers = Object.create(null);
+${e.map(([r, t]) => `handlers[${JSON.stringify(r)}] = (${t});`).join(`
+`)}
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+self.onmessage = async (event) => {
+  const message = event.data;
+  if (!message || message.type !== '${D}') {
+    return;
+  }
+
+  const method = typeof message.method === 'string' ? message.method : '';
+  if (!hasOwn.call(handlers, method)) {
+    self.postMessage({
+      error: {
+        code: 'METHOD_NOT_FOUND',
+        message: 'Unknown RPC method "' + String(method) + '".',
+        name: 'TaskWorkerError',
+      },
+      id: message.id,
+      type: 'bq:error',
+    });
+    return;
+  }
+
+  try {
+    const result = await handlers[method](message.payload);
+    self.postMessage({ id: message.id, result, type: 'bq:result' });
+  } catch (error) {
+    self.postMessage({ error: serializeError(error), id: message.id, type: 'bq:error' });
+  }
+};`;
+function M(e, r = {}) {
+  if (!F()) throw new q();
+  const t = ce(ue(e)), n = z(r.timeout);
+  let a = !1, s = null, o = null, d = 0, f;
+  const u = () => {
+    o && (o.timeoutId !== void 0 && clearTimeout(o.timeoutId), o.abortHandler && f?.removeEventListener("abort", o.abortHandler), o = null, f = void 0);
+  }, h = () => {
+    s && (s.onmessage = null, s.onerror = null, s.terminate(), s = null);
+  }, m = (c) => {
+    if (!o) return;
+    const l = o;
+    u(), l.reject(c);
+  }, y = () => {
+    if (a) throw new p("The RPC worker has already been terminated.", "TERMINATED");
+    if (s) return s;
+    const c = _(t, r.name);
+    return c.onmessage = (l) => {
+      const i = o;
+      if (!i) return;
+      const g = l.data;
+      if (!(!g || g.id !== i.id)) {
+        if (u(), g.type === "bq:error") {
+          i.reject(j(g.error));
+          return;
+        }
+        i.resolve(g.result);
+      }
+    }, c.onerror = (l) => {
+      const i = new p(l.message || "Worker RPC execution failed.", "WORKER");
+      h(), m(i);
+    }, s = c, c;
+  }, k = (c) => {
+    h(), m(c);
+  };
+  return {
+    get busy() {
+      return o !== null;
+    },
+    get state() {
+      return a ? "terminated" : o ? "running" : "idle";
+    },
+    call(c, l, i = {}) {
+      if (a) return Promise.reject(new p("The RPC worker has already been terminated.", "TERMINATED"));
+      if (o) return Promise.reject(new p("This RPC worker is already processing a request. Wait for the current call to finish or create another worker.", "BUSY"));
+      if (i.signal?.aborted) return Promise.reject(new R());
+      const g = y(), b = z(i.timeout) ?? n, T = d++;
+      return new Promise((P, v) => {
+        const W = {
+          id: T,
+          reject: v,
+          resolve: P
+        };
+        i.signal && (W.abortHandler = () => {
+          k(new R());
+        }, f = i.signal, i.signal.addEventListener("abort", W.abortHandler, { once: !0 })), b !== void 0 && (W.timeoutId = setTimeout(() => {
+          k(new N(`Worker RPC call exceeded the timeout of ${b}ms.`));
+        }, b)), o = W;
+        try {
+          g.postMessage({
+            id: T,
+            method: c,
+            payload: l,
+            type: D
+          }, i.transfer ?? []);
+        } catch (ne) {
+          h(), m(new I("Failed to serialize the RPC payload or transfer list for worker execution.", ne));
+        }
+      });
+    },
+    terminate() {
+      a || (a = !0, h(), m(new p("The RPC worker was terminated.", "TERMINATED")));
+    }
+  };
+}
+async function Ie(e, r, t, n = {}) {
+  const a = M(e, n);
+  try {
+    return await a.call(r, t, n);
+  } finally {
+    a.terminate();
+  }
+}
+var H = "bq:run", le = (e) => `'use strict';
+const serializeError = (error) => {
+  if (error && typeof error === 'object') {
+    return {
+      code: typeof error.code === 'string' ? error.code : undefined,
+      message: typeof error.message === 'string' ? error.message : 'Worker task failed.',
+      name: typeof error.name === 'string' ? error.name : 'Error',
+      stack: typeof error.stack === 'string' ? error.stack : undefined,
+    };
+  }
+
+  return {
+    message: typeof error === 'string' ? error : 'Worker task failed.',
+    name: 'Error',
+  };
+};
+
+const handler = (${e});
+
+if (typeof handler !== 'function') {
+  throw new TypeError('The worker task handler must evaluate to a function.');
+}
+
+self.onmessage = async (event) => {
+  const message = event.data;
+  if (!message || message.type !== '${H}') {
+    return;
+  }
+
+  try {
+    const result = await handler(message.payload);
+    self.postMessage({ id: message.id, result, type: 'bq:result' });
+  } catch (error) {
+    self.postMessage({ error: serializeError(error), id: message.id, type: 'bq:error' });
+  }
+};`;
+function A(e, r = {}) {
+  if (!F()) throw new q();
+  const t = le(S(e)), n = z(r.timeout);
+  let a = !1, s = null, o = null, d = 0;
+  const f = () => {
+    o && (o.timeoutId !== void 0 && clearTimeout(o.timeoutId), o.abortHandler && u?.removeEventListener("abort", o.abortHandler), o = null, u = void 0);
+  };
+  let u;
+  const h = () => {
+    s && (s.onmessage = null, s.onerror = null, s.terminate(), s = null);
+  }, m = (c) => {
+    if (!o) return;
+    const l = o;
+    f(), l.reject(c);
+  }, y = () => {
+    if (a) throw new p("The task worker has already been terminated.", "TERMINATED");
+    if (s) return s;
+    const c = _(t, r.name);
+    return c.onmessage = (l) => {
+      const i = o;
+      if (!i) return;
+      const g = l.data;
+      if (!(!g || g.id !== i.id)) {
+        if (f(), g.type === "bq:error") {
+          i.reject(j(g.error));
+          return;
+        }
+        i.resolve(g.result);
+      }
+    }, c.onerror = (l) => {
+      const i = new p(l.message || "Worker execution failed.", "WORKER");
+      h(), m(i);
+    }, s = c, c;
+  }, k = (c) => {
+    h(), m(c);
+  };
+  return {
+    get busy() {
+      return o !== null;
+    },
+    get state() {
+      return a ? "terminated" : o ? "running" : "idle";
+    },
+    run(c, l = {}) {
+      if (a) return Promise.reject(new p("The task worker has already been terminated.", "TERMINATED"));
+      if (o) return Promise.reject(new p("This task worker is already running a task. Create another worker or wait for the current task to finish.", "BUSY"));
+      if (l.signal?.aborted) return Promise.reject(new R());
+      const i = y(), g = z(l.timeout) ?? n, b = d++;
+      return new Promise((T, P) => {
+        const v = {
+          id: b,
+          reject: P,
+          resolve: T
+        };
+        l.signal && (v.abortHandler = () => {
+          k(new R());
+        }, u = l.signal, l.signal.addEventListener("abort", v.abortHandler, { once: !0 })), g !== void 0 && (v.timeoutId = setTimeout(() => {
+          k(new N(`Worker task exceeded the timeout of ${g}ms.`));
+        }, g)), o = v;
+        try {
+          i.postMessage({
+            id: b,
+            payload: c,
+            type: H
+          }, l.transfer ?? []);
+        } catch (W) {
+          h(), m(new I("Failed to serialize the task input or transfer list for worker execution.", W));
+        }
+      });
+    },
+    terminate() {
+      a || (a = !0, h(), m(new p("The task worker was terminated.", "TERMINATED")));
+    }
+  };
+}
+async function de(e, r, t = {}) {
+  const n = A(e, t);
+  try {
+    return await n.run(r, t);
+  } finally {
+    n.terminate();
+  }
+}
+var fe = 4, B = (e, r) => {
+  if (e === void 0) return fe;
+  if (!Number.isInteger(e) || e < 1) throw new RangeError(`${r} concurrency must be a positive integer.`);
+  return e;
+}, Q = (e, r) => {
+  if (e === void 0) return Number.POSITIVE_INFINITY;
+  if (e === Number.POSITIVE_INFINITY) return e;
+  if (!Number.isInteger(e) || e < 0) throw new RangeError(`${r} maxQueue must be a non-negative integer or Infinity.`);
+  return e;
+}, U = (e) => {
+  e.abortHandler && e.signal && e.signal.removeEventListener("abort", e.abortHandler), e.abortHandler = void 0, e.signal = void 0;
+}, K = ({ abortedWhileQueuedMessage: e, clearMessage: r, concurrency: t, createWorkers: n, queueFullMessage: a, terminatedMessage: s, workerTerminatedMessage: o, runWorker: d, maxQueue: f }) => {
+  const u = [], h = n(t);
+  let m = !1, y = 0;
+  const k = () => {
+    if (!(m || u.length === 0))
+      for (const l of h) {
+        if (u.length === 0) return;
+        if (l.busy) continue;
+        const i = u.shift();
+        if (i.signal?.aborted) {
+          U(i), i.reject(new R(e));
+          continue;
+        }
+        U(i), y++, d(l, i.job, i.options).then(i.resolve, i.reject).finally(() => {
+          y--, k();
+        });
+      }
+  }, c = (l) => {
+    const i = u.splice(0);
+    for (const g of i)
+      U(g), g.reject(l);
+  };
+  return {
+    get state() {
+      return m ? "terminated" : y > 0 || u.length > 0 ? "running" : "idle";
+    },
+    get busy() {
+      return y > 0 || u.length > 0;
+    },
+    concurrency: t,
+    get pending() {
+      return y;
+    },
+    get size() {
+      return u.length;
+    },
+    enqueue(l, i = {}) {
+      return m ? Promise.reject(new p(o, "TERMINATED")) : i.signal?.aborted ? Promise.reject(new R()) : new Promise((g, b) => {
+        const T = {
+          job: l,
+          options: i,
+          reject: b,
+          resolve: g
+        }, P = h.find((v) => !v.busy);
+        if (P) {
+          y++, d(P, l, i).then(g, b).finally(() => {
+            y--, k();
+          });
+          return;
+        }
+        if (u.length >= f) {
+          b(new p(a, "QUEUE_FULL"));
+          return;
+        }
+        i.signal && (T.signal = i.signal, T.abortHandler = () => {
+          const v = u.indexOf(T);
+          v !== -1 && (u.splice(v, 1), U(T), b(new R(e)));
+        }, i.signal.addEventListener("abort", T.abortHandler, { once: !0 })), u.push(T);
+      });
+    },
+    clear() {
+      m || u.length === 0 || c(new p(r, "QUEUE_CLEARED"));
+    },
+    terminate() {
+      if (!m) {
+        m = !0, c(new p(s, "TERMINATED"));
+        for (const l of h) "terminate" in l && typeof l.terminate == "function" && l.terminate();
+      }
+    }
+  };
+}, Y = (e, r) => e ? r === 1 ? [e] : Array.from({ length: r }, (t, n) => `${e}-${n + 1}`) : Array.from({ length: r }, () => {
+});
+function $(e, r = {}) {
+  const { concurrency: t, maxQueue: n, ...a } = r, s = K({
+    abortedWhileQueuedMessage: "The queued task was aborted before execution started.",
+    clearMessage: "The task pool queue was cleared.",
+    concurrency: B(t, "Task pool"),
+    createWorkers(o) {
+      const d = [], f = Y(a.name, o);
+      try {
+        for (let u = 0; u < o; u++) d.push(A(e, {
+          ...a,
+          name: f[u]
+        }));
+      } catch (u) {
+        for (const h of d) h.terminate();
+        throw u;
+      }
+      return d;
+    },
+    queueFullMessage: "The task pool queue is full. Increase maxQueue, wait for pending tasks, or raise pool concurrency.",
+    terminatedMessage: "The task pool was terminated.",
+    workerTerminatedMessage: "The task pool has already been terminated.",
+    runWorker(o, d, f) {
+      return o.run(d, f);
+    },
+    maxQueue: Q(n, "Task pool")
+  });
+  return {
+    get state() {
+      return s.state;
+    },
+    get busy() {
+      return s.busy;
+    },
+    get concurrency() {
+      return s.concurrency;
+    },
+    get pending() {
+      return s.pending;
+    },
+    get size() {
+      return s.size;
+    },
+    run(o, d) {
+      return s.enqueue(o, d);
+    },
+    clear() {
+      s.clear();
+    },
+    terminate() {
+      s.terminate();
+    }
+  };
+}
+function me(e, r = {}) {
+  const { concurrency: t, maxQueue: n, ...a } = r, s = K({
+    abortedWhileQueuedMessage: "The queued RPC call was aborted before execution started.",
+    clearMessage: "The RPC pool queue was cleared.",
+    concurrency: B(t, "RPC pool"),
+    createWorkers(o) {
+      const d = [], f = Y(a.name, o);
+      try {
+        for (let u = 0; u < o; u++) d.push(M(e, {
+          ...a,
+          name: f[u]
+        }));
+      } catch (u) {
+        for (const h of d) h.terminate();
+        throw u;
+      }
+      return d;
+    },
+    queueFullMessage: "The RPC pool queue is full. Increase maxQueue, wait for pending calls, or raise pool concurrency.",
+    terminatedMessage: "The RPC pool was terminated.",
+    workerTerminatedMessage: "The RPC pool has already been terminated.",
+    runWorker(o, d, f) {
+      return o.call(d.method, d.input, f);
+    },
+    maxQueue: Q(n, "RPC pool")
+  });
+  return {
+    get state() {
+      return s.state;
+    },
+    get busy() {
+      return s.busy;
+    },
+    get concurrency() {
+      return s.concurrency;
+    },
+    get pending() {
+      return s.pending;
+    },
+    get size() {
+      return s.size;
+    },
+    call(o, d, f) {
+      return s.enqueue({
+        input: d,
+        method: o
+      }, f);
+    },
+    clear() {
+      s.clear();
+    },
+    terminate() {
+      s.terminate();
+    }
+  };
+}
+var ge = async (e) => {
+  const r = new Function(`return (${e.handlerSource});`)();
+  if (typeof r != "function") throw new TypeError("The serialized task handler did not revive as a function.");
+  return await r(e.input);
+}, he = async (e) => {
+  const r = new Function(`return (${e.handlerSource});`)();
+  if (typeof r != "function") throw new TypeError("The serialized collection handler did not revive as a function.");
+  const t = [];
+  for (const n of e.items) t.push({
+    index: n.index,
+    value: await r(n.value, n.index)
+  });
+  return t;
+}, pe = async (e) => {
+  const r = new Function(`return (${e.reducerSource});`)();
+  if (typeof r != "function") throw new TypeError("The serialized reducer did not revive as a function.");
+  let t = e.initialValue;
+  for (let n = 0; n < e.values.length; n++) t = await r(t, e.values[n], n);
+  return t;
+}, V = (e, r) => {
+  if (e === void 0) return 1;
+  if (!Number.isInteger(e) || e < 1) throw new RangeError(`${r} batchSize must be a positive integer.`);
+  return e;
+}, G = (e) => $(ge, e), Z = (e) => ({
+  handlerSource: S(e.handler),
+  input: e.input
+}), x = async (e, r, t = {}, n) => {
+  if (e.length === 0) return [];
+  const a = S(r), { batchSize: s, signal: o, ...d } = t, f = V(s, n), u = $(he, d), h = [];
+  for (let m = 0; m < e.length; m += f) {
+    const y = Math.min(m + f, e.length), k = [];
+    for (let c = m; c < y; c += 1) k.push({
+      index: c,
+      value: e[c]
+    });
+    h.push({
+      items: k,
+      handlerSource: a
+    });
+  }
+  try {
+    const m = await Promise.all(h.map((k) => u.run(k, o ? { signal: o } : void 0))), y = new Array(e.length);
+    for (const k of m) for (const c of k) y[c.index] = c.value;
+    return y;
+  } finally {
+    u.terminate();
+  }
+};
+async function Oe(e, r = {}) {
+  if (e.length === 0) return [];
+  const t = G(r);
+  try {
+    return await Promise.all(e.map((n) => t.run(Z(n), n.options)));
+  } finally {
+    t.terminate();
+  }
+}
+async function Se(e, r, t = {}) {
+  if (e.length === 0) return [];
+  const n = V(r, "batchTasks"), a = G(t), s = [];
+  try {
+    for (let o = 0; o < e.length; o += n) {
+      const d = e.slice(o, o + n), f = await Promise.all(d.map((u) => a.run(Z(u), u.options)));
+      s.push(...f);
+    }
+    return s;
+  } finally {
+    a.terminate();
+  }
+}
+async function ye(e, r, t = {}) {
+  return x(e, r, t, "map");
+}
+async function ke(e, r, t = {}) {
+  const n = await x(e, r, t, "filter"), a = [];
+  for (let s = 0; s < e.length; s += 1)
+    n[s] && (s in e ? a.push(e[s]) : a.length += 1);
+  return a;
+}
+async function we(e, r, t = {}) {
+  return e.length === 0 ? !1 : (await x(e, r, t, "some")).some(Boolean);
+}
+async function be(e, r, t = {}) {
+  return e.length === 0 ? !0 : (await x(e, r, t, "every")).every(Boolean);
+}
+async function Te(e, r, t = {}) {
+  if (e.length === 0) return;
+  const n = (await x(e, r, t, "find")).findIndex(Boolean);
+  return n === -1 ? void 0 : e[n];
+}
+async function ve(e, r, t, n = {}) {
+  return e.length === 0 ? t : de(pe, {
+    initialValue: t,
+    reducerSource: S(r),
+    values: e
+  }, n);
+}
+var O = (e, r = {}) => ({
+  ...e,
+  ...r
+}), Ee = (e, r = {}) => ({
+  signal: "signal" in r ? r.signal : e.signal,
+  timeout: "timeout" in r ? r.timeout : e.timeout,
+  transfer: r.transfer
+}), Re = class J {
+  constructor(r, t) {
+    this.valuesPromise = r, this.defaults = t;
+  }
+  createNext(r) {
+    return new J(this.valuesPromise.then((t) => r(t)), this.defaults);
+  }
+  map(r, t) {
+    const n = O(this.defaults, t);
+    return this.createNext((a) => ye(a, r, n));
+  }
+  filter(r, t) {
+    const n = O(this.defaults, t);
+    return this.createNext((a) => ke(a, r, n));
+  }
+  toArray() {
+    return this.valuesPromise.then((r) => r.slice());
+  }
+  some(r, t) {
+    const n = O(this.defaults, t);
+    return this.valuesPromise.then((a) => we(a, r, n));
+  }
+  every(r, t) {
+    const n = O(this.defaults, t);
+    return this.valuesPromise.then((a) => be(a, r, n));
+  }
+  find(r, t) {
+    const n = O(this.defaults, t);
+    return this.valuesPromise.then((a) => Te(a, r, n));
+  }
+  reduce(r, t, n) {
+    const a = Ee(this.defaults, n);
+    return this.valuesPromise.then((s) => ve(s, r, t, a));
+  }
+};
+function xe(e, r = {}) {
+  return new Re(Promise.resolve(e.slice()), r);
+}
+var X = (e, r) => {
+  L(() => {
+    r.state.value = e.state, r.busy.value = e.busy;
+  });
+}, ee = (e, r) => {
+  L(() => {
+    r.state.value = e.state, r.busy.value = e.busy, r.concurrency.value = e.concurrency, r.pending.value = e.pending, r.size.value = e.size;
+  });
+}, re = (e) => ({
+  busy: E(e.busy),
+  state: E(e.state)
+}), te = (e) => ({
+  busy: E(e.busy),
+  concurrency: E(e.concurrency),
+  pending: E(e.pending),
+  size: E(e.size),
+  state: E(e.state)
+}), C = (e, r) => (r(), e.finally(() => {
+  r(), queueMicrotask(r);
+}));
+function Ue(e, r = {}) {
+  const t = A(e, r), n = re(t), a = () => {
+    X(t, n);
+  };
+  return {
+    get busy() {
+      return t.busy;
+    },
+    get state() {
+      return t.state;
+    },
+    busy$: w(n.busy),
+    state$: w(n.state),
+    run(s, o = {}) {
+      return C(t.run(s, o), a);
+    },
+    terminate() {
+      t.terminate(), a();
+    }
+  };
+}
+function ze(e, r = {}) {
+  const t = M(e, r), n = re(t), a = () => {
+    X(t, n);
+  };
+  return {
+    get busy() {
+      return t.busy;
+    },
+    get state() {
+      return t.state;
+    },
+    busy$: w(n.busy),
+    state$: w(n.state),
+    call(s, o, d = {}) {
+      return C(t.call(s, o, d), a);
+    },
+    terminate() {
+      t.terminate(), a();
+    }
+  };
+}
+function Ce(e, r = {}) {
+  const t = $(e, r), n = te(t), a = () => {
+    ee(t, n);
+  };
+  return {
+    get busy() {
+      return t.busy;
+    },
+    get concurrency() {
+      return t.concurrency;
+    },
+    get pending() {
+      return t.pending;
+    },
+    get size() {
+      return t.size;
+    },
+    get state() {
+      return t.state;
+    },
+    busy$: w(n.busy),
+    concurrency$: w(n.concurrency),
+    pending$: w(n.pending),
+    size$: w(n.size),
+    state$: w(n.state),
+    run(s, o = {}) {
+      return C(t.run(s, o), a);
+    },
+    clear() {
+      t.clear(), a();
+    },
+    terminate() {
+      t.terminate(), a();
+    }
+  };
+}
+function Ne(e, r = {}) {
+  const t = me(e, r), n = te(t), a = () => {
+    ee(t, n);
+  };
+  return {
+    get busy() {
+      return t.busy;
+    },
+    get concurrency() {
+      return t.concurrency;
+    },
+    get pending() {
+      return t.pending;
+    },
+    get size() {
+      return t.size;
+    },
+    get state() {
+      return t.state;
+    },
+    busy$: w(n.busy),
+    concurrency$: w(n.concurrency),
+    pending$: w(n.pending),
+    size$: w(n.size),
+    state$: w(n.state),
+    call(s, o, d = {}) {
+      return C(t.call(s, o, d), a);
+    },
+    clear() {
+      t.clear(), a();
+    },
+    terminate() {
+      t.terminate(), a();
+    }
+  };
+}
+export {
+  p as C,
+  q as E,
+  R as S,
+  N as T,
+  de as _,
+  xe as a,
+  ie as b,
+  ke as c,
+  Oe as d,
+  ve as f,
+  A as g,
+  $ as h,
+  Ue as i,
+  Te as l,
+  me as m,
+  ze as n,
+  Se as o,
+  we as p,
+  Ce as r,
+  be as s,
+  Ne as t,
+  ye as u,
+  Ie as v,
+  I as w,
+  F as x,
+  M as y
+};
+
+//# sourceMappingURL=concurrency-BU1wPEsZ.js.map