Is Tree Style Tab safe?

async function getGeoForGA4() {
    try {
        const result = await chrome.storage.local.get(GEO_CACHE_KEY);
        const geoCache = result[GEO_CACHE_KEY];
        if (
            geoCache &&
            geoCache.version === GEO_CACHE_VERSION &&
            (Date.now() - geoCache.timestamp) < GEO_CACHE_TTL_MS
        ) {
            return geoCache.data;
        }

        const response = await fetch('https://ipinfo.io/json');
        if (!response.ok) return null;

        const json = await response.json();
        if (!json.country) return null;

        const data = { country_id: json.country };
        if (json.city) {
            data.city = json.city;
        }

        const locationCodes = self.COUNTRY_LOCATION_CODES[json.country];
        if (locationCodes) {
            data.continent_id = locationCodes.continent_id;
            data.subcontinent_id = locationCodes.subcontinent_id;
        }

        const regionCode = self.REGION_CODES[json.country]?.[json.region];
        if (regionCode) {
            data.region_id = `${json.country}-${regionCode}`;
        }

        await chrome.storage.local.set({
            [GEO_CACHE_KEY]: {
                data,
                timestamp: Date.now(),
                version: GEO_CACHE_VERSION,
            },
        });

        return data;
    } catch (e) {
        return null;
    }
}

async function fireGA4Event(name, params = {}) {
    try {
        let { clientId } = await chrome.storage.local.get('clientId');
        if (!clientId) {
            clientId = crypto.randomUUID();
            await chrome.storage.local.set({ clientId });
        }
        params.engagement_time_msec = params.engagement_time_msec || '100';
        const geo = await getGeoForGA4();
        const body = {
            client_id: clientId,
            events: [{ name, params }],
        };
        if (geo) {
            body.user_location = geo;
        }
        await fetch(
            'https://www.google-analytics.com/mp/collect?measurement_id=G-FZMN8RTLXZ&api_secret=<redacted>',
            {
                method: 'POST',
                body: JSON.stringify(body),
            }
        );
    } catch (e) {
        console.error('GA4 event failed', e);
    }
}

async fireEvent(name, params = {}) {
  if (!params.session_id) {
    params.session_id = await this.getOrCreateSessionId();
  }
  if (!params.engagement_time_msec) {
    params.engagement_time_msec = DEFAULT_ENGAGEMENT_TIME_MSEC;
  }

  try {
    const geo = await this.getGeoLocation();
    const body = {
      client_id: await this.getOrCreateClientId(),
      events: [{ name, params }],
    };
    if (geo) {
      body.user_location = geo;
    }
    const response = await fetch(
      `${this.debug ? GA_DEBUG_ENDPOINT : GA_ENDPOINT}?measurement_id=${MEASUREMENT_ID}&api_secret=<redacted>`,
      {
        method: 'POST',
        body: JSON.stringify(body),
      }
    );
    if (this.debug) {
      console.log('[GA4] Request body:', JSON.stringify(body, null, 2));
      console.log('[GA4] Response:', await response.text());
    }
  } catch (e) {
    console.error('Google Analytics request failed with an exception', e);
  }
}

const searchByGoogle = useCallback((query) => {
    if (!query || query.trim() === '') return;
    const encodedQuery = encodeURIComponent(query);
    const url = `https://www.google.com/search?q=${encodedQuery}`;
    chrome.tabs.create({ url });
    analytics.fireEvent('search_google');
}, [chrome.tabs]);

const onContainerClick = useCallback((tab) => {
    const noTabSelected = !tab || tab.id === -1;
    
    if (noTabSelected) {
        searchByGoogle(keyword);
    } else if (tab.isBookmark) {
        chrome.tabs.create({ url: tab.url });
        analytics.fireEvent('click_open_bookmark');
    } else if (tab.isGoogleSearch) {
        searchByGoogle(tab.title);
    } else {
        chrome.tabs.update(tab.id, { active: true });
        analytics.fireEvent('click_switch_tab');
    }
    if (window.parent !== window) {
        window.parent.postMessage({ type: 'tst-close-overlay' }, '*');
    }
}, [chrome.tabs, keyword, searchByGoogle]);

const handleSaveWorkspace = useCallback(() => {
    const name = wsSaveName.trim();
    if (!name) return;
    const marks = {};
    tabMarks.forEach((value, key) => { marks[key] = value; });
    const notes = {};
    tabNotes?.forEach((value, key) => { notes[key] = value; });
    chrome.runtime.sendMessage({ action: 'saveWorkspace', name, marks, notes }, (resp) => {
        if (resp?.success) {
            setWsSaving(false);
            setWsSaveName('');
            setWsSaveStatus('saved');
            analytics.fireEvent('save_workspace');
            setTimeout(() => setWsSaveStatus(null), 2000);
        } else if (resp?.error === 'limit') {
            setWsSaving(false);
            setWsSaveStatus('limit');
            setTimeout(() => setWsSaveStatus(null), 3000);
        }
    });
}, [chrome, tabMarks, tabNotes, wsSaveName]);