@agg-build/sdk 4.17.4 → 4.18.0

package/dist/browser.mjs

@@ -0,0 +1,804 @@
+import {
+  AggWebSocket
+} from "./chunk-QXBVA5TW.mjs";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-WNQUEZJF.mjs";
+
+// ../../node_modules/.pnpm/comlink@4.4.2/node_modules/comlink/dist/esm/comlink.mjs
+var proxyMarker = /* @__PURE__ */ Symbol("Comlink.proxy");
+var createEndpoint = /* @__PURE__ */ Symbol("Comlink.endpoint");
+var releaseProxy = /* @__PURE__ */ Symbol("Comlink.releaseProxy");
+var finalizer = /* @__PURE__ */ Symbol("Comlink.finalizer");
+var throwMarker = /* @__PURE__ */ Symbol("Comlink.thrown");
+var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+var proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
+  },
+  deserialize(port) {
+    port.start();
+    return wrap(port);
+  }
+};
+var throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
+  },
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
+  }
+};
+var transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
+      return;
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+      return;
+    }
+    const { id, type, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
+    try {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type) {
+        case "GET":
+          {
+            returnValue = rawValue;
+          }
+          break;
+        case "SET":
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
+          break;
+        case "APPLY":
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
+          break;
+        case "CONSTRUCT":
+          {
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
+          }
+          break;
+        case "RELEASE":
+          {
+            returnValue = void 0;
+          }
+          break;
+        default:
+          return;
+      }
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
+    }
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
+        value: new TypeError("Unserializable return value"),
+        [throwMarker]: 0
+      });
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+    });
+  });
+  if (ep.start) {
+    ep.start();
+  }
+}
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
+}
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
+      return;
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
+    throw new Error("Proxy has been released and is not useable");
+  }
+}
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    closeEndPoint(ep);
+  });
+}
+var proxyCounter = /* @__PURE__ */ new WeakMap();
+var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
+});
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
+}
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {
+}) {
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
+        return () => {
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
+        };
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
+          type: "GET",
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
+      }
+      return createProxy(ep, pendingListeners, [...path, prop]);
+    },
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "SET",
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
+    },
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "ENDPOINT"
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "APPLY",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    },
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "CONSTRUCT",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    }
+  });
+  registerProxy(proxy2, ep);
+  return proxy2;
+}
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+var transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
+}
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
+      return [
+        {
+          type: "HANDLER",
+          name,
+          value: serializedValue
+        },
+        transferables
+      ];
+    }
+  }
+  return [
+    {
+      type: "RAW",
+      value
+    },
+    transferCache.get(value) || []
+  ];
+}
+function fromWireValue(value) {
+  switch (value.type) {
+    case "HANDLER":
+      return transferHandlers.get(value.name).deserialize(value.value);
+    case "RAW":
+      return value.value;
+  }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
+  });
+}
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+// src/market-data/worker-adapter.ts
+var WorkerAggWebSocket = class extends AggWebSocket {
+  constructor(config, factory) {
+    var _a, _b;
+    super(config);
+    this.config = config;
+    this.endpointListeners = /* @__PURE__ */ new Map();
+    this.historyOperations = 0;
+    this.currentBooks = /* @__PURE__ */ new Map();
+    this.recovering = /* @__PURE__ */ new Set();
+    this.diagnosticRevisions = /* @__PURE__ */ new Map();
+    this.deliveredRevisions = /* @__PURE__ */ new Map();
+    this.resolvedRevisions = /* @__PURE__ */ new Map();
+    this.refs = /* @__PURE__ */ new Map();
+    this.arbListeners = /* @__PURE__ */ new Map();
+    this.feedListeners = /* @__PURE__ */ new Set();
+    this.latest = /* @__PURE__ */ new Map();
+    this.generation = 0;
+    this.online = false;
+    this.stopped = false;
+    this.queued = false;
+    this.historyFailures = /* @__PURE__ */ new Set();
+    this.fallback = null;
+    this.fallbackUnsubs = /* @__PURE__ */ new Map();
+    this.historyGeneration = 0;
+    this.visibility = () => {
+      if (document.visibilityState === "visible")
+        this.resnapshot(
+          [...this.refs.values()].filter((entry) => entry.sub.channel === "orderbook").map((entry) => entry.sub.id)
+        );
+    };
+    this.fail = () => {
+      var _a, _b, _c;
+      if (this.stopped || this.fallback) return;
+      this.releaseWorker();
+      this.currentBooks.clear();
+      this.latest.clear();
+      this.recovering.clear();
+      this.diagnosticRevisions.clear();
+      this.deliveredRevisions.clear();
+      this.resolvedRevisions.clear();
+      this.online = false;
+      (_b = (_a = this.handlers).onConnectionStateChange) == null ? void 0 : _b.call(_a, false);
+      this.fallback = new AggWebSocket(__spreadProps(__spreadValues({}, this.config), { callbacks: this.fallbackCallbacks() }));
+      for (const reject of this.historyFailures) reject(new Error("Market-data worker failed"));
+      this.historyFailures.clear();
+      (_c = this.resolveFailure) == null ? void 0 : _c.call(this);
+      this.syncFallback();
+    };
+    if (((_a = config.callbacks) == null ? void 0 : _a.onTrade) && !config.callbacks.onMarketView)
+      throw new Error(
+        "Raw trade callbacks require AggWebSocket; Worker views require onMarketView opt-in"
+      );
+    this.handlers = (_b = config.callbacks) != null ? _b : {};
+    this.worker = factory();
+    const worker = this.worker;
+    const endpoint = {
+      postMessage: worker.postMessage.bind(worker),
+      addEventListener: (type, listener) => {
+        this.endpointListeners.set(listener, type);
+        worker.addEventListener(type, listener);
+      },
+      removeEventListener: (type, listener) => {
+        this.endpointListeners.delete(listener);
+        worker.removeEventListener(type, listener);
+      }
+    };
+    this.remote = wrap(endpoint);
+    this.worker.addEventListener("error", this.fail);
+    this.worker.addEventListener("messageerror", this.fail);
+    const _c = config, { callbacks: _callbacks } = _c, options = __objRest(_c, ["callbacks"]);
+    const startup = this.remote.start(
+      options,
+      proxy((event) => {
+        if (!this.fallback) this.event(event.name, event.args, event.revision);
+      })
+    ).then(() => {
+      if (this.stopped || this.fallback || !this.remote) return;
+      return this.remote.observeViews(
+        proxy((batch) => {
+          var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j;
+          if (batch.generation < this.generation || this.stopped || this.fallback) return;
+          for (const view of batch.views) {
+            if (!this.refs.has(`orderbook:${view.outcomeId}`) && !this.refs.has(`trades:${view.outcomeId}`))
+              continue;
+            if (((_a2 = this.resolvedRevisions.get(view.outcomeId)) != null ? _a2 : -1) >= view.revision) continue;
+            const integrity = ((_b2 = this.diagnosticRevisions.get(view.outcomeId)) != null ? _b2 : -1) > view.revision ? "resyncing" : view.integrity;
+            this.deliveredRevisions.set(view.outcomeId, view.revision);
+            (_d = (_c2 = this.handlers).onMarketView) == null ? void 0 : _d.call(_c2, __spreadProps(__spreadValues({}, view), { integrity }));
+            if (view.book) {
+              this.currentBooks.set(view.outcomeId, view.book);
+              if (integrity === "ok") {
+                this.recovering.delete(view.outcomeId);
+                this.diagnosticRevisions.delete(view.outcomeId);
+              } else this.recovering.add(view.outcomeId);
+              if (view.snapshot) (_f = (_e = this.handlers).onSnapshot) == null ? void 0 : _f.call(_e, view.outcomeId, view.book);
+              else (_h = (_g = this.handlers).onDelta) == null ? void 0 : _h.call(_g, view.outcomeId, view.book);
+            }
+            for (const trade of [...view.trades].reverse()) (_j = (_i = this.handlers).onTrade) == null ? void 0 : _j.call(_i, trade);
+          }
+        })
+      );
+    }).catch(this.fail);
+    const failed = new Promise((resolve) => {
+      this.resolveFailure = resolve;
+    });
+    this.ready = Promise.race([startup, failed]);
+    const startupTimeout = setTimeout(this.fail, 3e3);
+    void this.ready.then(() => clearTimeout(startupTimeout));
+    if (typeof document !== "undefined")
+      document.addEventListener("visibilitychange", this.visibility);
+  }
+  get processesCandles() {
+    return !this.fallback;
+  }
+  decodeHistory(payload) {
+    return __async(this, null, function* () {
+      this.historyOperations++;
+      try {
+        return yield this.decodeHistoryRequest(payload);
+      } finally {
+        this.historyOperations--;
+      }
+    });
+  }
+  decodeHistoryRequest(payload) {
+    return __async(this, null, function* () {
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      yield this.ready;
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      if (this.fallback) return this.fallback.decodeHistory(payload);
+      const remote = this.remote;
+      if (!remote) throw new Error("Market-data worker unavailable");
+      let rejectFailure;
+      const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+        this.historyFailures.add(reject);
+      });
+      try {
+        return yield Promise.race([remote.decodeHistory(payload), failed]);
+      } finally {
+        this.historyFailures.delete(rejectFailure);
+      }
+    });
+  }
+  loadHistory(manifest, options) {
+    return __async(this, null, function* () {
+      this.historyOperations++;
+      try {
+        return yield this.loadHistoryRequest(manifest, options);
+      } finally {
+        this.historyOperations--;
+      }
+    });
+  }
+  loadHistoryRequest(manifest, options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      if (this.fallback) return this.fallback.loadHistory(manifest, options);
+      const generation = ++this.historyGeneration;
+      const key = `${manifest.venueMarketOutcomeId}:${manifest.resolution}:${manifest.from}:${manifest.to}`;
+      (_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.throwIfAborted();
+      yield this.ready;
+      if (this.stopped) throw new Error("Market-data worker disposed");
+      (_b = options == null ? void 0 : options.signal) == null ? void 0 : _b.throwIfAborted();
+      const fallbackAfterStartup = this.fallback;
+      if (fallbackAfterStartup) return fallbackAfterStartup.loadHistory(manifest, options);
+      const remote = this.remote;
+      if (!remote) throw new Error("Market-data worker unavailable");
+      let rejectFailure;
+      const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+        this.historyFailures.add(reject);
+      });
+      const abort = () => {
+        var _a2;
+        void ((_a2 = this.remote) == null ? void 0 : _a2.cancelHistoryRange(key, generation));
+      };
+      (_c = options == null ? void 0 : options.signal) == null ? void 0 : _c.addEventListener("abort", abort, { once: true });
+      try {
+        const result = yield Promise.race([
+          remote.loadImmutableRange(key, generation, manifest),
+          failed
+        ]);
+        (_d = options == null ? void 0 : options.signal) == null ? void 0 : _d.throwIfAborted();
+        return result;
+      } finally {
+        (_e = options == null ? void 0 : options.signal) == null ? void 0 : _e.removeEventListener("abort", abort);
+        this.historyFailures.delete(rejectFailure);
+      }
+    });
+  }
+  setHostDiagnostics(provider) {
+    this.hostProvider = provider;
+  }
+  getDiagnostics() {
+    var _a, _b;
+    const subscriptions = [...this.refs.values()].map((entry) => entry.sub);
+    return this.fallback ? __spreadProps(__spreadValues({}, this.fallback.getDiagnostics()), {
+      host: (_a = this.hostProvider) == null ? void 0 : _a.call(this),
+      pendingHistoryRequests: this.historyOperations,
+      workerAttached: false,
+      bridgeListeners: this.endpointListeners.size
+    }) : {
+      connected: this.connected,
+      host: (_b = this.hostProvider) == null ? void 0 : _b.call(this),
+      transport: this.stopped ? "disposed" : "worker",
+      orderbookOutcomeIds: subscriptions.filter((sub) => sub.channel === "orderbook").map((sub) => sub.id),
+      tradeOutcomeIds: subscriptions.filter((sub) => sub.channel === "trades").map((sub) => sub.id),
+      arbMarketIds: [...this.arbListeners.keys()],
+      arbFeedSubscribers: this.feedListeners.size,
+      cachedBooks: this.currentBooks.size,
+      cachedArb: this.latest.size,
+      resyncingBooks: this.recovering.size,
+      pendingResnapshots: 0,
+      pendingHistoryRequests: this.historyOperations,
+      workerAttached: this.worker !== null,
+      bridgeListeners: this.endpointListeners.size
+    };
+  }
+  getWorkerDiagnostics() {
+    return __async(this, null, function* () {
+      yield this.ready;
+      const remote = this.remote;
+      if (this.stopped || !remote || this.fallback) return null;
+      let rejectFailure;
+      const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+        this.historyFailures.add(reject);
+      });
+      try {
+        return yield Promise.race([remote.getMeasurements(), failed]);
+      } catch (e) {
+        return null;
+      } finally {
+        this.historyFailures.delete(rejectFailure);
+      }
+    });
+  }
+  get connected() {
+    var _a, _b;
+    return !this.stopped && ((_b = (_a = this.fallback) == null ? void 0 : _a.connected) != null ? _b : this.online);
+  }
+  getBook(id) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.fallback) == null ? void 0 : _a.getBook(id)) != null ? _b : this.currentBooks.get(id)) != null ? _c : null;
+  }
+  isResyncing(id) {
+    var _a, _b;
+    return (_b = (_a = this.fallback) == null ? void 0 : _a.isResyncing(id)) != null ? _b : this.recovering.has(id);
+  }
+  getArb(id) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.fallback) == null ? void 0 : _a.getArb(id)) != null ? _b : this.latest.get(id)) != null ? _c : null;
+  }
+  subscribe(id, channel = "orderbook") {
+    return this.ref({ id, channel });
+  }
+  subscribeTrades(id) {
+    return this.subscribe(id, "trades");
+  }
+  subscribeArb(id, cb) {
+    var _a;
+    const listeners = (_a = this.arbListeners.get(id)) != null ? _a : /* @__PURE__ */ new Set();
+    listeners.add(cb);
+    this.arbListeners.set(id, listeners);
+    const unsubscribe = this.ref({ id, channel: "arb" });
+    return () => {
+      unsubscribe();
+      listeners.delete(cb);
+      if (!listeners.size) this.arbListeners.delete(id);
+    };
+  }
+  subscribeArbFeed(cb) {
+    this.feedListeners.add(cb);
+    const unsubscribe = this.ref({ id: "*", channel: "arb-feed" });
+    return () => {
+      unsubscribe();
+      this.feedListeners.delete(cb);
+    };
+  }
+  setCallbacks(callbacks) {
+    var _a;
+    this.handlers = callbacks;
+    if (callbacks.onTrade && !callbacks.onMarketView && !this.fallback) this.fail();
+    (_a = this.fallback) == null ? void 0 : _a.setCallbacks(this.fallbackCallbacks());
+  }
+  authenticate(token) {
+    this.config.initialToken = token;
+    this.run((engine) => engine.authenticate(token));
+  }
+  connect() {
+    this.run((engine) => engine.connect());
+  }
+  disconnect() {
+    this.run((engine) => engine.disconnect());
+  }
+  resnapshot(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    this.run((engine) => engine.resnapshot(ids));
+  }
+  destroy() {
+    var _a, _b;
+    if (this.stopped) return;
+    this.stopped = true;
+    this.online = false;
+    (_a = this.resolveFailure) == null ? void 0 : _a.call(this);
+    for (const reject of this.historyFailures) reject(new Error("Market-data worker disposed"));
+    this.historyFailures.clear();
+    this.refs.clear();
+    this.currentBooks.clear();
+    this.latest.clear();
+    this.arbListeners.clear();
+    this.feedListeners.clear();
+    this.recovering.clear();
+    this.diagnosticRevisions.clear();
+    this.deliveredRevisions.clear();
+    this.resolvedRevisions.clear();
+    (_b = this.fallback) == null ? void 0 : _b.destroy();
+    this.fallbackUnsubs.clear();
+    this.hostProvider = void 0;
+    this.handlers = {};
+    if (typeof document !== "undefined")
+      document.removeEventListener("visibilitychange", this.visibility);
+    this.releaseWorker();
+  }
+  releaseWorker() {
+    const worker = this.worker;
+    const remote = this.remote;
+    this.remote = null;
+    this.worker = null;
+    if (remote) remote[releaseProxy]();
+    if (!worker) return;
+    for (const [listener, type] of this.endpointListeners)
+      worker.removeEventListener(type, listener);
+    this.endpointListeners.clear();
+    worker.removeEventListener("error", this.fail);
+    worker.removeEventListener("messageerror", this.fail);
+    worker.terminate();
+  }
+  event(name, args, revision = 0) {
+    var _a, _b, _c, _d;
+    if (this.stopped) return;
+    if (name === "onConnectionStateChange") this.online = args[0];
+    if (name === "onDiagnostics") {
+      const diagnostic = args[0];
+      if (diagnostic.outcomeId && revision < ((_a = this.deliveredRevisions.get(diagnostic.outcomeId)) != null ? _a : -1))
+        return;
+      if (diagnostic.outcomeId && (this.refs.has(`orderbook:${diagnostic.outcomeId}`) || this.refs.has(`trades:${diagnostic.outcomeId}`)) && ["seq_gap", "checksum_mismatch"].includes(diagnostic.type)) {
+        this.recovering.add(diagnostic.outcomeId);
+        this.diagnosticRevisions.set(diagnostic.outcomeId, revision);
+      }
+    }
+    if (name === "onMarketResolved") {
+      const id = args[0].outcomeId;
+      if (this.refs.has(`orderbook:${id}`) || this.refs.has(`trades:${id}`))
+        this.resolvedRevisions.set(id, revision);
+      this.currentBooks.delete(id);
+    }
+    if (name === "onArbMarket") {
+      const msg = args[0];
+      this.latest.set(msg.marketId, msg);
+      for (const cb of (_b = this.arbListeners.get(msg.marketId)) != null ? _b : []) cb(msg);
+    }
+    if (name === "onArbFeed") for (const cb of this.feedListeners) cb(args[0]);
+    (_d = (_c = this.handlers)[name]) == null ? void 0 : _d.call(_c, ...args);
+  }
+  ref(sub) {
+    var _a;
+    const key = `${sub.channel}:${sub.id}`;
+    const entry = (_a = this.refs.get(key)) != null ? _a : { sub, count: 0 };
+    entry.count++;
+    this.refs.set(key, entry);
+    this.sync();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (--entry.count === 0) {
+        this.refs.delete(key);
+        if (sub.channel === "orderbook") this.recovering.delete(sub.id);
+        if (!this.refs.has(`orderbook:${sub.id}`) && !this.refs.has(`trades:${sub.id}`)) {
+          this.currentBooks.delete(sub.id);
+          this.recovering.delete(sub.id);
+          this.diagnosticRevisions.delete(sub.id);
+          this.deliveredRevisions.delete(sub.id);
+          this.resolvedRevisions.delete(sub.id);
+        }
+      }
+      this.sync();
+    };
+  }
+  sync() {
+    if (this.queued || this.stopped) return;
+    this.queued = true;
+    queueMicrotask(() => {
+      this.queued = false;
+      if (this.stopped) return;
+      if (this.fallback) {
+        this.syncFallback();
+        return;
+      }
+      const generation = ++this.generation;
+      const subscriptions = [...this.refs.values()].map((entry) => entry.sub);
+      void this.ready.then(() => {
+        var _a;
+        if (!this.stopped && !this.fallback)
+          return (_a = this.remote) == null ? void 0 : _a.setSubscriptions(subscriptions, generation);
+      }).catch(this.fail);
+    });
+  }
+  run(action) {
+    if (this.stopped) return;
+    if (this.fallback) {
+      action(this.fallback);
+      return;
+    }
+    void this.ready.then(() => {
+      var _a;
+      if (this.stopped) return;
+      const engine = (_a = this.fallback) != null ? _a : this.remote;
+      if (engine) return action(engine);
+    }).catch(this.fail);
+  }
+  fallbackCallbacks() {
+    return __spreadProps(__spreadValues({}, this.handlers), {
+      onArbMarket: (msg) => this.event("onArbMarket", [msg]),
+      onArbFeed: (msg) => this.event("onArbFeed", [msg])
+    });
+  }
+  syncFallback() {
+    for (const [key, unsubscribe] of this.fallbackUnsubs) {
+      if (!this.refs.has(key)) {
+        unsubscribe();
+        this.fallbackUnsubs.delete(key);
+      }
+    }
+    for (const [key, { sub }] of this.refs) {
+      if (this.fallbackUnsubs.has(key)) continue;
+      this.fallbackUnsubs.set(
+        key,
+        sub.channel === "arb" ? this.fallback.subscribeArb(sub.id, () => {
+        }) : sub.channel === "arb-feed" ? this.fallback.subscribeArbFeed(() => {
+        }) : this.fallback.subscribe(sub.id, sub.channel)
+      );
+    }
+  }
+};
+function createWorkerWebSocket(options, factory) {
+  var _a;
+  if (((_a = options.callbacks) == null ? void 0 : _a.onTrade) && !options.callbacks.onMarketView)
+    return new AggWebSocket(options);
+  try {
+    return new WorkerAggWebSocket(options, factory);
+  } catch (e) {
+    return new AggWebSocket(options);
+  }
+}
+export {
+  WorkerAggWebSocket,
+  createWorkerWebSocket
+};
+/*! Bundled license information:
+
+comlink/dist/esm/comlink.mjs:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/