Is MathSolver safe?

class LingappsConfig {
  constructor() {
    this.baseUrl = "https://services.lingapps.dk";
    this.application = "cas";
    this.licenseName = "casLicense";
    this.googleAnalyticsTrackingId = "UA-79284543-25";
  }
}

const Events = {
  SessionLoggedIn: () => new GoogleAnalyticsEvent("Session", "Logged in"),
  MathCalculate: () => new GoogleAnalyticsEvent("Math", "Calculate"),
  MathSolve: () => new GoogleAnalyticsEvent("Math", "Solve"),
  MathParseGoogleLatex: () => new GoogleAnalyticsEvent("Math", "Parse Google Latex"),
  MathLatexToImage: () => new GoogleAnalyticsEvent("Math", "Latex to image"),
  UserClickTriangleCalculator: () => new GoogleAnalyticsEvent("User click", "Triangle calculator"),
  UserClickInsertUnit: (value) => new GoogleAnalyticsEvent("User click", "Insert unit", value),
  UserClickInsertSymbol: (value) => new GoogleAnalyticsEvent("User click", "Insert symbol", value)
};

class GoogleAnalyticsClient {
  constructor(userService, config) {
    this._userService = userService;
    this._config = config;
  }

  async _send(category, action, label, value) {
    const session = await this._userService.getSession();
    const identifier = session
      ? await async function hashEmail(email) {
          const encoded = new TextEncoder().encode(email);
          const digest = await crypto.subtle.digest("SHA-256", encoded);
          return Array.from(new Uint8Array(digest))
            .map(byte => byte.toString(16).padStart(2, "0"))
            .join("");
        }(session.user.email)
      : "NO_SESSION";

    const body = {
      v: 1,
      tid: this._config.googleAnalyticsTrackingId,
      t: "event",
      uid: identifier,
      cid: identifier,
      an: "MathSolver",
      aid: chrome.runtime.id,
      av: chrome.runtime.getManifest().version,
      ec: category,
      ea: action
    };

    if (label !== undefined) {
      body.el = label;
    }
    if (value !== undefined) {
      body.ev = value;
    }

    const encodedBody = Object.entries(body)
      .map(([key, entryValue]) => encodeURIComponent(key) + "=" + encodeURIComponent(entryValue))
      .join("&");

    try {
      await fetch("https://www.google-analytics.com/collect", {
        method: "POST",
        body: encodedBody
      });
    } catch (error) {
    }
  }

  async send(event) {
    await this._send(event.category, event.action, event.label, 1);
  }
}

class GoogleAnalyticsMiddleware {
  constructor(googleAnalyticsService) {
    this._googleAnalyticsService = googleAnalyticsService;
  }

  async onRequest(request) {
    if (request.url.includes("/cas/calculate")) {
      this._googleAnalyticsService.send(Events.MathCalculate());
    } else if (request.url.includes("/cas/solve")) {
      this._googleAnalyticsService.send(Events.MathSolve());
    } else if (request.url.includes("/cas/parseGLatex")) {
      this._googleAnalyticsService.send(Events.MathParseGoogleLatex());
    } else if (request.url.includes("/cas/latexToImage")) {
      this._googleAnalyticsService.send(Events.MathLatexToImage());
    }
    return request;
  }

  async onResponse(response) {
    return response;
  }

  async onError(error) {
  }
}