Is Primus safe?

a.onBeforeSendHeadersFn = d, a.onBeforeRequestFn = f, chrome.webRequest.onBeforeSendHeaders.addListener(d, {
  urls: ["<all_urls>"],
  types: ["xmlhttprequest", "main_frame"]
}, ["requestHeaders", "extraHeaders"]), chrome.webRequest.onBeforeRequest.addListener(f, {
  urls: ["<all_urls>"],
  types: ["xmlhttprequest", "main_frame"]
}, ["requestBody"])

console.log("captured request", f, JSON.stringify(e));
const a = {
  headers: s,
  method: r,
  url: f,
  requestId: n,
  templateRequestUrl: p,
  type: e.type
};
i && (a.queryString = i), c(n, a), await lc()

if (r?.raw?.[0]?.bytes) {
  const a = new Uint8Array(r.raw[0].bytes),
    t = (new TextDecoder).decode(a);
  c(n, {
    ...e,
    body: JSON.parse(t)
  })
}
r?.formData && c(n, {
  ...e,
  body: r.formData,
  isFormData: !0
})

Object.assign(p, {
  reqType: "web",
  host: S,
  schemaType: b,
  requests: m,
  responses: T,
  uiTemplate: x,
  templateId: u,
  calculations: s,
  PADOSERVERURL: X,
  padoExtensionVersion: e
}), await ka(p, t), qe(p, t), Je(p, t), c.formatAlgorithmParams = p, console.log("formatAlgorithmParams", p, t)

const a = Object.assign({
    isUserClick: "true"
  }, s.formatAlgorithmParams),
  c = await D(),
  t = {
    ...a,
    clientType: c?.clientType || ""
  };
await _({
  activeRequestAttestation: JSON.stringify(a)
}), console.log("pageDecode-algorithmParams", a), chrome.runtime.sendMessage({
  type: "algorithm",
  method: "getAttestation",
  params: t
})

_call(e, t = {}, i) {
  const s = {
      method: e,
      version: i || CLIENT_VERSION,
      params: t
    },
    n = JSON.stringify(s);
  return Module.cwrap("callAlgorithm", "string", ["string"])(n)
}
getAttestation(e) {
  const t = getEffectiveVersion(e?.clientType);
  if (console.log("getAttestation AlgorithmInited=", this.initialized), !this.initialized) return JSON.stringify({
    content: null,
    retcode: "2",
    retdesc: "Algorithm not initialized"
  });
  const i = this._call("getAttestation", e, t);
  return console.log("getAttestation typeof res", typeof i, "res", i), i
}

function ge({
  url: e,
  method: a,
  body: c,
  header: t,
  isFormData: d
}) {
  return {
    url: e,
    method: a,
    body: c,
    header: t || {},
    isFormData: d
  }
}

function ye({
  url: e,
  method: a,
  body: c,
  header: t,
  isFormData: d
}) {
  const f = {
    method: "GET",
    headers: {
      "Content-Type": "application/json"
    },
    credentials: "include",
    ...{
      method: a,
      body: c,
      headers: t
    }
  };
  ["POST", "PUT", "PATCH"].includes(f.method.toUpperCase()) && f.body && (i(f.body) || (f.body = JSON.stringify(f.body)));
  const b = "application/x-www-form-urlencoded";
  if (f.body && t["content-type"]?.includes(b) || t["Content-Type"]?.includes(b) && d) {
    let e = i(f.body) ? JSON.parse(f.body) : f.body;
    f.body = (r = e, Object.keys(r).map((e => encodeURIComponent(e) + "=" + encodeURIComponent(r[e]))).join("&"))
  }
  var r;
  return {
    finalOptions: f,
    url: e
  }
}
async function ve(e, a) {
  const c = await fetch(a, e);
  if (!c.ok) throw new Error(`HTTP error! status: ${c.status}`);
  const t = c.headers.get("Content-Type") || "";
  let d;
  return d = t.includes("application/json") || t.includes("+json") ? await c.json() : t.includes("text/") ? await c.text() : t.includes("application/octet-stream") ? await c.blob() : await c.text(), {
    data: d,
    contentType: t,
    finalUrl: c.url
  }
}

const a = await Se({
  ...f[e],
  header: f[e].headers,
  url: I,
  body: E
});
a && (w = a.data, A = a.contentType, T = a.finalUrl)

const {
  requests: d
} = t, {
  url: f,
  requestHeaders: b,
  method: r,
  requestId: n
} = e;
let i = "";
const s = b.reduce(((e, a) => (e[a.name] = a.value, e)), {});
let p = "";
if (d.some((e => {
    if (!1 === e.needCapture) return !1;
    if (e.queryParams?.[0]) {
      const a = f.split("?")[0];
      if (e.url === a) {
        const a = x(f, e.queryParams);
        a && (i = a)
      }
    }
    const a = u({
      requestUrl: f,
      requiredUrl: e.url,
      urlType: e.urlType,
      queryParams: e.queryParams
    });
    return a && (p = e.url), a
  }))) {
  console.log("captured request", f, JSON.stringify(e));
  const a = {
    headers: s,
    method: r,
    url: f,
    requestId: n,
    templateRequestUrl: p,
    type: e.type
  };
  i && (a.queryString = i), c(n, a), await lc()
}

if ("start" === n) {
  if (s.startHandled) return void r({
    ok: !0
  });
  s.startHandled = !0, s.phase = xe.ATTESTING, Oc(), chrome.alarms.create(bc, {
    periodInMinutes: .4
  });
  const {
    userInfo: e
  } = await w(["userInfo"]);
  e || Kc().catch((e => {
    console.log("ensureExtensionUserIdentity non-blocking error", e)
  }));
  const a = Object.assign({
      isUserClick: "true"
    }, s.formatAlgorithmParams),
    c = await D(),
    t = {
      ...a,
      clientType: c?.clientType || ""
    };
  await _({
    activeRequestAttestation: JSON.stringify(a)
  }), console.log("pageDecode-algorithmParams", a), chrome.runtime.sendMessage({
    type: "algorithm",
    method: "getAttestation",
    params: t
  })
}