@stripchatdev/ext-helper 0.1.0 → 0.1.2

package/dist/ext-helper.js

@@ -1,84 +1,84 @@
-const M = (r) => !!r && typeof r == "object" && "protocol" in r && r.protocol === "iframe_pubsub" && "version" in r && r.version === "1.0", E = (r, e) => r, g = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var u;
-(function(r) {
-  r.Base32IncorrectEncoding = "B32_ENC_INVALID", r.DecodeTimeInvalidCharacter = "DEC_TIME_CHAR", r.DecodeTimeValueMalformed = "DEC_TIME_MALFORMED", r.EncodeTimeNegative = "ENC_TIME_NEG", r.EncodeTimeSizeExceeded = "ENC_TIME_SIZE_EXCEED", r.EncodeTimeValueMalformed = "ENC_TIME_MALFORMED", r.PRNGDetectFailure = "PRNG_DETECT", r.ULIDInvalid = "ULID_INVALID", r.Unexpected = "UNEXPECTED", r.UUIDInvalid = "UUID_INVALID";
-})(u || (u = {}));
-class l extends Error {
-  constructor(e, t) {
-    super(`${t} (${e})`), this.name = "ULIDError", this.code = e;
+const T = (e) => !!e && typeof e == "object" && "protocol" in e && e.protocol === "iframe_pubsub" && "version" in e && e.version === "1.0", y = (e, t) => e, w = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var l;
+(function(e) {
+  e.Base32IncorrectEncoding = "B32_ENC_INVALID", e.DecodeTimeInvalidCharacter = "DEC_TIME_CHAR", e.DecodeTimeValueMalformed = "DEC_TIME_MALFORMED", e.EncodeTimeNegative = "ENC_TIME_NEG", e.EncodeTimeSizeExceeded = "ENC_TIME_SIZE_EXCEED", e.EncodeTimeValueMalformed = "ENC_TIME_MALFORMED", e.PRNGDetectFailure = "PRNG_DETECT", e.ULIDInvalid = "ULID_INVALID", e.Unexpected = "UNEXPECTED", e.UUIDInvalid = "UUID_INVALID";
+})(l || (l = {}));
+class f extends Error {
+  constructor(t, r) {
+    super(`${r} (${t})`), this.name = "ULIDError", this.code = t;
   }
 }
-function R(r) {
-  const e = Math.floor(r() * 32) % 32;
-  return g.charAt(e);
+function P(e) {
+  const t = Math.floor(e() * 32) % 32;
+  return w.charAt(t);
 }
-function m(r) {
-  const e = N(), t = e && (e.crypto || e.msCrypto) || null;
-  if (typeof (t == null ? void 0 : t.getRandomValues) == "function")
+function _(e) {
+  const t = H(), r = t && (t.crypto || t.msCrypto) || null;
+  if (typeof (r == null ? void 0 : r.getRandomValues) == "function")
     return () => {
       const s = new Uint8Array(1);
-      return t.getRandomValues(s), s[0] / 255;
+      return r.getRandomValues(s), s[0] / 255;
     };
-  if (typeof (t == null ? void 0 : t.randomBytes) == "function")
-    return () => t.randomBytes(1).readUInt8() / 255;
-  throw new l(u.PRNGDetectFailure, "Failed to find a reliable PRNG");
+  if (typeof (r == null ? void 0 : r.randomBytes) == "function")
+    return () => r.randomBytes(1).readUInt8() / 255;
+  throw new f(l.PRNGDetectFailure, "Failed to find a reliable PRNG");
 }
-function N() {
-  return v() ? self : typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : null;
+function H() {
+  return O() ? self : typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : null;
 }
-function y(r, e) {
-  let t = "";
-  for (; r > 0; r--)
-    t = R(e) + t;
-  return t;
+function q(e, t) {
+  let r = "";
+  for (; e > 0; e--)
+    r = P(t) + r;
+  return r;
 }
-function I(r, e = 10) {
-  if (isNaN(r))
-    throw new l(u.EncodeTimeValueMalformed, `Time must be a number: ${r}`);
-  if (r > 281474976710655)
-    throw new l(u.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${281474976710655}: ${r}`);
-  if (r < 0)
-    throw new l(u.EncodeTimeNegative, `Time must be positive: ${r}`);
-  if (Number.isInteger(r) === !1)
-    throw new l(u.EncodeTimeValueMalformed, `Time must be an integer: ${r}`);
-  let t, s = "";
-  for (let n = e; n > 0; n--)
-    t = r % 32, s = g.charAt(t) + s, r = (r - t) / 32;
+function L(e, t = 10) {
+  if (isNaN(e))
+    throw new f(l.EncodeTimeValueMalformed, `Time must be a number: ${e}`);
+  if (e > 281474976710655)
+    throw new f(l.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${281474976710655}: ${e}`);
+  if (e < 0)
+    throw new f(l.EncodeTimeNegative, `Time must be positive: ${e}`);
+  if (Number.isInteger(e) === !1)
+    throw new f(l.EncodeTimeValueMalformed, `Time must be an integer: ${e}`);
+  let r, s = "";
+  for (let n = t; n > 0; n--)
+    r = e % 32, s = w.charAt(r) + s, e = (e - r) / 32;
   return s;
 }
-function v() {
+function O() {
   return typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope;
 }
-function f(r, e) {
-  const t = m(), s = Date.now();
-  return I(s, 10) + y(16, t);
+function g(e, t) {
+  const r = _(), s = Date.now();
+  return L(s, 10) + q(16, r);
 }
-const T = ({ seq: r, uniqId: e }) => (t) => ({
+const S = ({ seq: e, uniqId: t }) => (r) => ({
   ...{
     protocol: "iframe_pubsub",
     version: "1.0",
-    id: e(),
-    seq: r(),
+    id: t(),
+    seq: e(),
     timestamp: Date.now()
   },
-  ...t
-}), b = T({
-  uniqId: () => f(),
-  seq: () => f()
+  ...r
+}), m = S({
+  uniqId: () => g(),
+  seq: () => g()
 });
-class _ {
-  constructor(e) {
+class C {
+  constructor(t) {
     this.eventHandlerMap = /* @__PURE__ */ new Map(), this.globalMessageHandler = (n, o) => {
-      if (M(n)) {
+      if (T(n)) {
         if (n.type === "event") {
-          const { eventName: c } = n, i = this.eventHandlerMap.get(c);
-          if (!i)
+          const { eventName: i } = n, a = this.eventHandlerMap.get(i);
+          if (!a)
             return;
-          i.forEach((a) => {
+          a.forEach((c) => {
             try {
-              a(n.data, o.id);
-            } catch (d) {
-              console.error("[PubSubSubscriber] globalMessageHandler: failed to handle income message", d);
+              c(n.data, o.id);
+            } catch (p) {
+              console.error("[PubSubSubscriber] globalMessageHandler: failed to handle income message", p);
             }
           });
           return;
@@ -86,110 +86,110 @@ class _ {
         console.error("[PubSubSubscriber] globalMessageHandler: unhandled message", n);
       }
     };
-    const { brokerId: t, transport: s } = e;
-    this.brokerId = t, this.transport = s, this.transport.onMessage(this.globalMessageHandler);
+    const { brokerId: r, transport: s } = t;
+    this.brokerId = r, this.transport = s, this.transport.onMessage(this.globalMessageHandler);
   }
-  subscribe(e, t) {
-    const s = E(e);
+  subscribe(t, r) {
+    const s = y(t);
     let n = this.eventHandlerMap.get(s);
-    n || (n = /* @__PURE__ */ new Set(), this.eventHandlerMap.set(s, n)), n.add(t);
-    const o = b({
+    n || (n = /* @__PURE__ */ new Set(), this.eventHandlerMap.set(s, n)), n.add(r);
+    const o = m({
       type: "subscribe",
-      eventName: e
+      eventName: t
     });
     this.transport.send(this.brokerId, o);
   }
-  unsubscribe(e, t) {
-    const s = E(e);
+  unsubscribe(t, r) {
+    const s = y(t);
     let n = this.eventHandlerMap.get(s);
     if (!n)
       return;
-    t ? n.delete(t) : this.eventHandlerMap.delete(s);
-    const o = b({
+    r ? n.delete(r) : this.eventHandlerMap.delete(s);
+    const o = m({
       type: "unsubscribe",
-      eventName: e
+      eventName: t
     });
     this.transport.send(this.brokerId, o);
   }
 }
-const w = !!Error.captureStackTrace, P = "APP_ERROR";
-class p extends Error {
-  constructor(e, t) {
-    super(e), this.name = new.target.name || P, this.cause = t, w && Error.captureStackTrace(this, this.constructor);
+const A = !!Error.captureStackTrace, D = "APP_ERROR";
+class E extends Error {
+  constructor(t, r) {
+    super(t), this.name = new.target.name || D, this.cause = r, A && Error.captureStackTrace(this, this.constructor);
   }
-  static getChainedMessage(e) {
-    let { message: t } = e;
-    return e instanceof p && e.cause && (t += `
-Caused by: ${p.getChainedMessage(e.cause)}`), t;
+  static getChainedMessage(t) {
+    let { message: r } = t;
+    return t instanceof E && t.cause && (r += `
+Caused by: ${E.getChainedMessage(t.cause)}`), r;
   }
   toJSON() {
     return {
       name: this.name,
       message: this.message,
-      cause: this.cause ? p.getChainedMessage(this.cause) : void 0
+      cause: this.cause ? E.getChainedMessage(this.cause) : void 0
     };
   }
 }
-const O = {
+const x = {
   INTERNAL_ERROR: "INTERNAL_ERROR"
-}, C = "RPC_ERROR";
-class D extends p {
-  constructor(e) {
-    super(e.message || "unknown rpc error"), this.name = C, this.code = (e == null ? void 0 : e.code) || O.INTERNAL_ERROR;
+}, G = "RPC_ERROR";
+class F extends E {
+  constructor(t) {
+    super(t.message || "unknown rpc error"), this.name = G, this.code = (t == null ? void 0 : t.code) || x.INTERNAL_ERROR;
   }
 }
-const A = (r) => !!r && typeof r == "object" && "protocol" in r && r.protocol === "iframe_rpc" && "version" in r && r.version === "1.0", S = ({ uniqId: r }) => (e) => ({
+const j = (e) => !!e && typeof e == "object" && "protocol" in e && e.protocol === "iframe_rpc" && "version" in e && e.version === "1.0", B = ({ uniqId: e }) => (t) => ({
   ...{
     protocol: "iframe_rpc",
     version: "1.0",
-    id: r(),
+    id: e(),
     timestamp: Date.now()
   },
-  ...e
-}), H = S({
-  uniqId: () => f()
+  ...t
+}), X = B({
+  uniqId: () => g()
 });
-class k {
-  constructor(e) {
+class U {
+  constructor(t) {
     this.pendingEntryMap = /* @__PURE__ */ new Map(), this.globalMessageHandler = (n) => {
-      if (A(n)) {
+      if (j(n)) {
         if (n.type === "response" && n.status === "ok") {
-          const o = n.id, c = this.pendingEntryMap.get(o);
-          if (!c) {
+          const o = n.id, i = this.pendingEntryMap.get(o);
+          if (!i) {
             console.error("[RpcClient] globalMessageHandler: got success response without pending request", n);
             return;
           }
-          this.pendingEntryMap.delete(o), c.resolve(n.result);
+          this.pendingEntryMap.delete(o), i.resolve(n.result);
           return;
         }
         if (n.type === "response" && n.status === "error") {
-          const o = n.id, c = this.pendingEntryMap.get(o);
-          if (!c) {
+          const o = n.id, i = this.pendingEntryMap.get(o);
+          if (!i) {
             console.error("[RpcClient] globalMessageHandler: got error response without pending request", n);
             return;
           }
-          this.pendingEntryMap.delete(o), c.reject(new D(n.error));
+          this.pendingEntryMap.delete(o), i.reject(new F(n.error));
           return;
         }
         console.error("[RpcClient] globalMessageHandler: invalid message schema", n);
       }
     };
-    const { serverId: t, transport: s } = e;
-    this.serverId = t, this.transport = s, this.transport.onMessage(this.globalMessageHandler);
+    const { serverId: r, transport: s } = t;
+    this.serverId = r, this.transport = s, this.transport.onMessage(this.globalMessageHandler);
   }
-  makeRequest(e, t) {
-    const s = H({
+  makeRequest(t, r) {
+    const s = X({
       type: "request",
-      method: e,
-      params: t
-    }), n = new Promise((o, c) => {
+      method: t,
+      params: r
+    }), n = new Promise((o, i) => {
       this.pendingEntryMap.set(s.id, {
-        method: e,
-        resolve: (i) => {
-          o(i);
+        method: t,
+        resolve: (a) => {
+          o(a);
         },
-        reject: (i) => {
-          c(i);
+        reject: (a) => {
+          i(a);
         }
       });
     });
@@ -197,119 +197,375 @@ class k {
       this.transport.send(this.serverId, s);
     } catch (o) {
       console.error("[RpcClient] makeRequest: failed to send rpc message", o);
-      const c = this.pendingEntryMap.get(s.id);
-      c && (this.pendingEntryMap.delete(s.id), c.reject(o));
+      const i = this.pendingEntryMap.get(s.id);
+      i && (this.pendingEntryMap.delete(s.id), i.reject(o));
     }
     return n;
   }
 }
-class L {
-  constructor(e) {
+class W {
+  constructor(t) {
     this.peers = /* @__PURE__ */ new Map(), this.onMessage = (s) => {
       const n = (o) => {
-        const { data: c, origin: i, source: a } = o;
-        if (!a) {
+        const { data: i, origin: a, source: c } = o;
+        if (!c) {
           console.error("[PostMessageTransport] onMessage: source could not be empty");
           return;
         }
-        const d = this.findPeer(a, i);
-        if (d)
+        const p = this.findPeer(c, a);
+        if (p)
           try {
-            s(c, d);
-          } catch (h) {
-            console.error("[PostMessageTransport] onMessage: failed to call cb on message", h);
+            s(i, p);
+          } catch (b) {
+            console.error("[PostMessageTransport] onMessage: failed to call cb on message", b);
           }
       };
       return this.localWindow.addEventListener("message", n), () => {
         this.localWindow.removeEventListener("message", n);
       };
     };
-    const { localWindow: t } = e;
-    this.localWindow = t || window;
+    const { localWindow: r } = t;
+    this.localWindow = r || window;
   }
-  send(e, t) {
-    const s = this.peers.get(e);
-    s && s.source.postMessage(t, s.origin);
+  send(t, r) {
+    const s = this.peers.get(t);
+    s && s.source.postMessage(r, s.origin);
   }
-  broadcast(e) {
-    this.peers.forEach((t) => {
-      t.source.postMessage(e, t.origin);
+  broadcast(t) {
+    this.peers.forEach((r) => {
+      r.source.postMessage(t, r.origin);
     });
   }
-  broadcastGroup(e, t) {
-    e.forEach((s) => {
-      this.send(s, t);
+  broadcastGroup(t, r) {
+    t.forEach((s) => {
+      this.send(s, r);
     });
   }
-  addPeer(e) {
-    this.peers.set(e.id, e);
+  addPeer(t) {
+    this.peers.set(t.id, t);
   }
-  removePeer(e) {
-    this.peers.delete(e);
+  removePeer(t) {
+    this.peers.delete(t);
   }
-  findPeer(e, t) {
+  findPeer(t, r) {
     for (const [s, n] of this.peers)
-      if (n.source === e && n.origin === t)
+      if (n.source === t && n.origin === r)
         return n;
     return null;
   }
 }
-class G {
-  constructor(e) {
+const h = {
+  name: "UnknownError",
+  message: "Unknown error"
+}, M = (e, t = 3, r = 0) => {
+  if (e instanceof Error) {
+    const s = r < t && e.cause ? M(e.cause, t, r + 1) : void 0;
+    return {
+      name: e.name,
+      message: e.message,
+      stack: e.stack,
+      cause: s
+    };
+  }
+  if (typeof e == "string")
+    return {
+      name: h.name,
+      message: e
+    };
+  if (typeof e == "number" || typeof e == "bigint" || typeof e == "boolean")
+    return {
+      name: h.name,
+      message: String(e)
+    };
+  if (e && typeof e == "object")
+    try {
+      return {
+        name: h.name,
+        message: "message" in e && typeof e.message == "string" && e.message !== "" ? e.message : JSON.stringify(e)
+      };
+    } catch {
+      return {
+        name: h.name,
+        message: "Unserializable error object"
+      };
+    }
+  return h;
+}, $ = "get", I = (e, t) => {
+  var n;
+  let r, s;
+  return e instanceof Request ? (r = e.url, s = e.method) : e instanceof URL ? r = e.toString() : r = e, {
+    method: s || ((n = t == null ? void 0 : t.method) == null ? void 0 : n.toString()) || $,
+    url: r
+  };
+}, V = (e, t, r) => ({
+  statusCode: r.status,
+  ...I(e, t)
+}), z = (e) => {
+  const t = window.fetch;
+  Object.defineProperty(window, "fetch", {
+    value: async (s, n) => {
+      try {
+        const o = new Error("synthetic error"), i = await t(s, n), a = i.clone(), c = V(s, n, a);
+        if (i.status >= 500) {
+          const u = new Error("fetch response error");
+          u.stack = o.stack, e.report({
+            kind: "fetchResponseError",
+            type: "network",
+            data: c,
+            error: u
+          });
+        }
+        const {
+          arrayBuffer: p,
+          blob: b,
+          json: k,
+          text: N
+        } = i;
+        return i.json = async function() {
+          try {
+            return await k.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "json",
+                ...c
+              }
+            }), u;
+          }
+        }, i.text = async function() {
+          try {
+            return await N.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "text",
+                ...c
+              }
+            }), u;
+          }
+        }, i.blob = async function() {
+          try {
+            return await b.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "blob",
+                ...c
+              }
+            }), u;
+          }
+        }, i.arrayBuffer = async function() {
+          try {
+            return await p.call(this);
+          } catch (u) {
+            throw e.report({
+              type: "network",
+              kind: "fetchParseBodyError",
+              error: u,
+              data: {
+                parseType: "arrayBuffer",
+                ...c
+              }
+            }), u;
+          }
+        }, i;
+      } catch (o) {
+        throw o instanceof Error && o.name === "AbortError" || e.report({
+          type: "network",
+          kind: "fetchRequestError",
+          error: o,
+          data: I(s, n)
+        }), o;
+      }
+    },
+    configurable: !1,
+    writable: !1
+  });
+}, K = (e) => {
+  window.addEventListener("unhandledrejection", ({ reason: t }) => {
+    e.report({
+      type: "runtime",
+      kind: "unhandledRejection",
+      error: t
+    });
+  }), window.addEventListener("error", ({ colno: t, error: r, filename: s, lineno: n, message: o }) => {
+    e.report({
+      type: "runtime",
+      kind: "uncaughtError",
+      error: r,
+      data: {
+        lineno: n,
+        colno: t,
+        message: o,
+        filename: s
+      }
+    });
+  });
+}, v = Symbol("patchedXHLHttpRequest"), d = Symbol("requestInfo"), J = (e) => ({
+  statusCode: e.status,
+  ...e[d]
+}), Z = (e) => (e[d] || (e[d] = {}), e[d]), Q = (e) => {
+  e[v] = !0;
+}, Y = (e) => e[v] === !0, ee = (e) => {
+  const t = XMLHttpRequest.prototype.send, r = XMLHttpRequest.prototype.open, s = function(...o) {
+    const [i, a] = o;
+    this[d] = {
+      method: i,
+      url: typeof a == "string" ? a : a.toString()
+    }, Y(this) || (Q(this), this.addEventListener("error", () => {
+      const c = new Error("XMLHttpRequest network error");
+      e.report({
+        type: "network",
+        kind: "xmlHttpRequestError",
+        data: this[d],
+        error: c
+      });
+    }), this.addEventListener("timeout", () => {
+      const c = new Error("XMLHttpRequest timeout error");
+      e.report({
+        type: "network",
+        kind: "xmlHttpRequestTimeoutError",
+        data: this[d],
+        error: c
+      });
+    }), this.addEventListener("load", () => {
+      if (this.status >= 500) {
+        const c = new Error("XMLHttpRequest response error");
+        e.report({
+          type: "network",
+          kind: "xmlHttpRequestLoadError",
+          data: J(this),
+          error: c
+        });
+      }
+    }));
+    try {
+      r.apply(this, o);
+    } catch (c) {
+      throw e.report({
+        type: "network",
+        kind: "xmlHttpRequestOpenError",
+        error: c,
+        data: this[d]
+      }), c;
+    }
+  }, n = function(o) {
+    try {
+      const i = Z(this), a = new Error("XMLHttpRequest request initiator");
+      i.requestStack = a.stack, t.call(this, o);
+    } catch (i) {
+      throw e.report({
+        type: "network",
+        kind: "xmlHttpRequestSendError",
+        error: i,
+        data: this[d]
+      }), i;
+    }
+  };
+  Object.defineProperty(XMLHttpRequest.prototype, "open", {
+    value: s,
+    configurable: !1,
+    writable: !1
+  }), Object.defineProperty(XMLHttpRequest.prototype, "send", {
+    value: n,
+    configurable: !1,
+    writable: !1
+  });
+};
+let R;
+class te {
+  constructor(t) {
+    this.onError = t;
+  }
+  report(t) {
+    const { error: r, ...s } = t;
+    this.onError({
+      ...s,
+      error: r ? M(r) : void 0
+    });
+  }
+  init() {
+    this.applyIntegrations();
+  }
+  applyIntegrations() {
+    R || (R = !0, K(this), ee(this), z(this));
+  }
+}
+class re {
+  constructor(t) {
     const {
-      serverId: t,
+      serverId: r,
       serverOrigin: s,
       serverSource: n,
       theme: o
-    } = e, c = {
-      id: t,
+    } = t, i = {
+      id: r,
       origin: s,
       source: n
-    }, i = new L({});
-    i.addPeer(c), this.rpcClient = new k({
-      transport: i,
-      serverId: t
-    }), this.subscriber = new _({
-      transport: i,
-      brokerId: c.id
-    }), document.documentElement.dataset.theme = o;
+    }, a = new W({});
+    a.addPeer(i), this.rpcClient = new U({
+      transport: a,
+      serverId: r
+    }), this.subscriber = new C({
+      transport: a,
+      brokerId: i.id
+    }), document.documentElement.dataset.theme = o, this.crashReporter = new te((c) => {
+      this.makeRequest("v1.system.report.crash", c);
+    });
   }
-  makeRequest(e, t) {
-    return this.rpcClient.makeRequest(e, t);
+  makeRequest(t, r) {
+    return this.rpcClient.makeRequest(t, r);
   }
-  subscribe(e, t) {
-    return this.subscriber.subscribe(e, t);
+  subscribe(t, r) {
+    return this.subscriber.subscribe(t, r);
   }
-  unsubscribe(e, t) {
-    return this.subscriber.unsubscribe(e, t);
+  unsubscribe(t, r) {
+    return this.subscriber.unsubscribe(t, r);
   }
   bootstrap() {
-    let e = { height: 0, width: 0 };
-    const t = document.documentElement, s = (i, a) => {
-      (e.height !== a || e.width !== i) && (e = { height: a, width: i }, this.makeRequest("v1.system.resize.notify", { height: a, width: i }));
-    }, n = (i) => {
-      for (const a of i) {
-        if (a.target !== t)
-          continue;
-        const { height: d, width: h } = a.contentRect;
-        s(h, d);
-      }
+    let t = { height: 0, width: 0 };
+    const r = () => {
+      const a = document.body;
+      return Math.max(
+        a.offsetHeight,
+        a.scrollHeight
+      );
+    }, s = () => {
+      const a = document.body;
+      return Math.max(
+        a.offsetWidth,
+        a.scrollWidth
+      );
+    }, n = () => {
+      const a = s(), c = r();
+      (t.height !== c || t.width !== a) && (t = { height: c, width: a }, this.makeRequest("v1.system.resize.notify", { height: c, width: a }));
     };
-    (() => {
-      const { height: i, width: a } = t.getBoundingClientRect();
-      s(a, i);
-    })(), new ResizeObserver(n).observe(document.documentElement);
+    n(), new ResizeObserver(n).observe(document.body), new MutationObserver(n).observe(document.body, {
+      childList: !0,
+      subtree: !0,
+      attributes: !0,
+      attributeFilter: ["style", "class", "hidden", "open"]
+    }), this.crashReporter.init();
   }
 }
-const q = () => {
-  const r = new URL(window.location.href), e = r.searchParams.get("origin") || "", t = r.searchParams.get("theme") || "dark", s = new G({
+const se = () => {
+  const e = new URL(window.location.href), t = e.searchParams.get("origin") || "", r = e.searchParams.get("theme") || "dark", s = new re({
     serverId: "server",
-    serverOrigin: e || window.parent.origin,
+    serverOrigin: t || window.parent.origin,
     serverSource: window.parent,
-    theme: t
+    theme: r
   });
   return s.bootstrap(), s;
 };
 export {
-  q as createExtHelper
+  se as createExtHelper
 };

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export declare const createExtHelper: () => ExtHelper;
 declare class ExtHelper {
     private rpcClient;
     private subscriber;
+    private crashReporter;
     constructor(props: TExtHelperProps);
     makeRequest<M extends Extract<keyof TApiContract['methods'], string>>(method: M, params: TApiContract['methods'][M]['params']): Promise<TV1Methods[M]["result"]>;
     subscribe<E extends Extract<keyof TApiContract['events'], string>>(eventName: E, handler: TAnyPubSubHandler<TApiContract['events'][E]>): void;
@@ -226,17 +227,12 @@ export declare type TV1ExtUser = {
     /** User username. */
     username: string;
     /** User activity ranking data when available. */
-    userRanking?: {
-        /** League representation of the user's activity level. Could be `grey`, `bronze`, `silver`, `gold`, `diamond`, `royal` or `legend`. */
-        league: TV1UserLeague;
-        /** Activity level from 1 to 100. */
-        level: number;
-    };
+    userRanking?: TV1UserRanking;
 };
 
 export declare type TV1Genders = 'male' | 'female' | 'group' | 'tranny';
 
-export declare type TV1Methods = TV1ExtMethods & TV1SystemMethods & TV1PaymentMethods & TV1ModelMethods & TV1ChatMethods & TV1PrivateMethods;
+export declare type TV1Methods = TV1ExtMethods & TV1SystemMethods & TV1PaymentMethods & TV1ModelMethods & TV1ChatMethods & TV1PrivateMethods & TV1MonitoringMethods;
 
 declare type TV1ModelEvents = {
     'v1.model.ext.settings.set.requested': null;
@@ -260,6 +256,23 @@ declare type TV1ModelMethods = {
 
 export declare type TV1ModelStatus = Exclude<(typeof V1_SHOW_STATUSES)[keyof typeof V1_SHOW_STATUSES], 'spy'>;
 
+declare type TV1MonitoringMethods = {
+    'v1.monitoring.report.error': {
+        params: {
+            data: unknown;
+            message: string;
+        };
+        result: null;
+    };
+    'v1.monitoring.report.log': {
+        params: {
+            data: unknown;
+            message: string;
+        };
+        result: null;
+    };
+};
+
 declare type TV1PaymentEvents = {
     'v1.payment.tokens.spend.succeeded': {
         isAnonymous: boolean;
@@ -285,7 +298,23 @@ declare type TV1PrivateMethods = {
     };
 };
 
+declare type TV1SerializedError = {
+    cause?: TV1SerializedError;
+    message: string;
+    name: string;
+    stack?: string;
+};
+
 declare type TV1SystemMethods = {
+    'v1.system.report.crash': {
+        params: {
+            data?: Record<string, unknown>;
+            error?: TV1SerializedError;
+            kind: string;
+            type: 'network' | 'runtime';
+        };
+        result: null;
+    };
     'v1.system.resize.notify': {
         params: {
             height: number;
@@ -309,6 +338,14 @@ export declare type TV1TokenSpendData = TUnknownDictionary;
  */
 declare type TV1UserLeague = 'grey' | 'bronze' | 'silver' | 'gold' | 'diamond' | 'royal' | 'legend';
 
+/** User activity ranking system */
+export declare type TV1UserRanking = {
+    /** League representation of the user's activity level. Could be `grey`, `bronze`, `silver`, `gold`, `diamond`, `royal` or `legend`. */
+    league: TV1UserLeague;
+    /** Activity level from 1 to 100. */
+    level: number;
+};
+
 export declare type TV1UserStatus = Exclude<(typeof V1_SHOW_STATUSES)[keyof typeof V1_SHOW_STATUSES], 'idle'>;
 
 export declare type TV1WhisperData = TUnknownDictionary;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stripchatdev/ext-helper",
   "private": false,
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "module": "./dist/ext-helper.js",
   "types": "./dist/index.d.ts",