Complete Guide to Ungoogling Links and URL Cleaning

Google Analytics UTM Parameters:

utm_source
  - Origin of traffic (google, facebook, newsletter, etc.)
  - Example: utm_source=google

utm_medium
  - Type of link/medium (cpc, organic, email, social, etc.)
  - Example: utm_medium=cpc

utm_campaign
  - Campaign name/ID
  - Example: utm_campaign=summer_sale_2024

utm_term
  - Keyword (for paid search)
  - Example: utm_term=free+tools

utm_content
  - Specific link/ad variant for A/B testing
  - Example: utm_content=button_blue

Full Example:
https://example.com/product?utm_source=google&utm_medium=cpc&utm_campaign=sale&utm_term=deals&utm_content=text_ad

Clean URL:
https://example.com/product

Common Advertising Tracking Parameters:

fbclid
  - Facebook Click ID
  - Tracks clicks from Facebook ads
  - Example: fbclid=IwAR0123456789...

gclid
  - Google Click ID
  - Tracks clicks from Google Ads
  - Example: gclid=CjwKCAiA0KqrBhAoEiwAjkzMz...

msclkid
  - Microsoft Click ID
  - Tracks clicks from Microsoft Ads
  - Example: msclkid=a1b2c3d4...

sib_cid
  - Sendinblue Campaign ID
  - Tracks email campaign clicks

ttclid
  - TikTok Click ID
  - Tracks TikTok ad clicks

Typical Tracking URL:
https://example.com/offer?fbclid=abc123&utm_source=facebook&utm_medium=cpc

With Multiple Trackers:
https://example.com?fbclid=abc&gclid=def&utm_source=ads&utm_campaign=2024

Social Media Tracking Parameters:

Facebook Tracking:
  - fbclid=... (Facebook Click ID)
  - fb_action_types, fb_action_ids

Twitter/X Tracking:
  - No standard parameter, but shares with headers

LinkedIn Tracking:
  - utm_source=linkedin (manual)
  - li_fat_id (LinkedIn tracking)

Instagram:
  - utm_source=instagram (manual)
  - Used through Facebook's system

TikTok:
  - ttclid=... (TikTok Click ID)
  - utm_source=tiktok (manual)

YouTube:
  - utm_source=youtube (manual)
  - No automatic click ID

Reddit:
  - utm_source=reddit (manual)

Example Social URLs:
  Facebook: https://example.com?fbclid=IwAR...
  TikTok: https://example.com?ttclid=abc...
  General: https://example.com?utm_source=tiktok&utm_medium=social

Google Redirect Flow:

1. User searches on Google
   - Search query: "python tutorial"
   - Google shows results

2. User clicks a result
   - Click triggers Google redirect
   - URL: https://www.google.com/url?q=https://example.com&...

3. Google Redirect Parameters
   - q: Final destination URL
   - esrc: Event source (search result rank position)
   - usg: Signature/verification code
   - sa: Search argument
   - oi: Object ID
   - ct: Click time

4. Google Tracking Data
   - Records which result was clicked
   - Records position of result
   - Records user profile (if logged in)
   - Records time between search and click

5. User Redirected
   - Browser follows redirect to actual page
   - User sees clean URL in address bar
   - Google has recorded all click data

Complete Example:
https://www.google.com/url?q=https%3A%2F%2Fexample.com%2Ftutorial%3Feid%3D123&usg=AOvVaw2...&esrc=s&oi=...

Common Google Redirect Domains and Patterns:

Search Results:
  - https://www.google.com/url?q=...
  - https://google.com/url?q=...
  - Pattern: /url?q=[encoded-url]&...

Gmail:
  - https://www.google.com/url?q=...
  - Includes email-specific tracking

Google Drive:
  - https://www.google.com/url?q=...
  - Tracks document link clicks

Google Maps:
  - https://www.google.com/url?q=...
  - Tracks place link clicks

Google News:
  - https://www.google.com/url?q=...
  - News click tracking

Characteristics:
  - Always contains ?q= parameter with URL-encoded destination
  - Contains &usg= security signature
  - May contain &esrc=, &oi=, &ct=, &sa=
  - Destination is URL-encoded (hex %XX format)
  - Redirect happens server-side at Google

// Decode Google redirect links

function decodeGoogleRedirect(googleUrl) {
  // Extract the 'q' parameter
  const url = new URL(googleUrl);
  const encodedUrl = url.searchParams.get('q');

  if (!encodedUrl) {
    return null; // Not a valid Google redirect
  }

  // Decode URL encoding
  try {
    return decodeURIComponent(encodedUrl);
  } catch (error) {
    console.error('Failed to decode:', error);
    return null;
  }
}

// Usage
const googleRedirect = 'https://www.google.com/url?q=https%3A%2F%2Fexample.com%2Ftutorial%3Fid%3D123&usg=AOvVaw...';
const actualUrl = decodeGoogleRedirect(googleRedirect);
console.log(actualUrl); // https://example.com/tutorial?id=123

// Python equivalent
/*
from urllib.parse import urlparse, parse_qs, unquote

def decode_google_redirect(google_url):
    parsed = urlparse(google_url)
    params = parse_qs(parsed.query)

    if 'q' not in params:
        return None

    encoded_url = params['q'][0]
    return unquote(encoded_url)

google_url = 'https://www.google.com/url?q=...'
actual_url = decode_google_redirect(google_url)
print(actual_url)
*/

// Manual URL cleaning - identify and remove parameters

function manuallyCleanUrl(urlString) {
  const url = new URL(urlString);
  const params = new URLSearchParams(url.search);

  // Parameters to remove
  const trackingParams = [
    'utm_source',
    'utm_medium',
    'utm_campaign',
    'utm_term',
    'utm_content',
    'fbclid',
    'gclid',
    'msclkid',
    'ttclid',
    'ref',
    'referer',
    'tracking_id',
    'affiliate_id',
    'sid',
    'sessionid',
    'wt.mc_id'
  ];

  // Remove each tracking parameter
  for (const param of trackingParams) {
    params.delete(param);
  }

  // Rebuild URL
  url.search = params.toString();
  return url.toString();
}

// Example URLs
const urls = [
  'https://example.com/product?id=123&utm_source=google&utm_campaign=sale',
  'https://shop.com?fbclid=abc123&product=xyz&ref=newsletter',
  'https://news.site/article?gclid=def456&section=tech'
];

urls.forEach(url => {
  console.log('Original:', url);
  console.log('Cleaned:', manuallyCleanUrl(url));
  console.log('---');
});

// Automated URL cleaning with whitelist approach

class UrlCleaner {
  constructor(options = {}) {
    this.trackingParams = new Set([
      // Google Analytics
      'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
      // Advertising
      'fbclid', 'gclid', 'msclkid', 'ttclid',
      // Other tracking
      'ref', 'referer', 'tracking_id', 'affiliate_id', 'sid', 'sessionid',
      // Analytics
      'wt.mc_id', 'mkttoken', 'ef_id'
    ]);

    this.safeParams = options.safeParams || new Set([
      'id', 'product', 'q', 'search', 'page', 'sort', 'filter'
    ]);

    this.mode = options.mode || 'blacklist'; // 'blacklist' or 'whitelist'
  }

  clean(urlString) {
    if (!urlString) return '';

    try {
      const url = new URL(urlString);
      const cleaned = this.cleanParams(url);
      return cleaned.toString();
    } catch {
      return urlString; // Return original if parsing fails
    }
  }

  cleanParams(url) {
    const params = new URLSearchParams(url.search);
    const toRemove = [];

    for (const [key] of params) {
      if (this.shouldRemove(key)) {
        toRemove.push(key);
      }
    }

    toRemove.forEach(key => params.delete(key));
    url.search = params.toString();
    return url;
  }

  shouldRemove(param) {
    if (this.mode === 'whitelist') {
      return !this.safeParams.has(param);
    } else {
      return this.trackingParams.has(param);
    }
  }

  addTrackingParam(param) {
    this.trackingParams.add(param);
  }

  removeTrackingParam(param) {
    this.trackingParams.delete(param);
  }
}

// Usage
const cleaner = new UrlCleaner();

const dirtyUrls = [
  'https://example.com?product=widget&utm_source=google&utm_campaign=ads',
  'https://shop.com?id=456&fbclid=abc&ref=facebook'
];

dirtyUrls.forEach(url => {
  console.log('Clean:', cleaner.clean(url));
});

// Regex-based URL cleaning (more advanced)

class RegexUrlCleaner {
  constructor() {
    // Regex patterns for common tracking parameters
    this.patterns = [
      /[?&]utm_\w+=[^&]*/g,           // All utm_* parameters
      /[?&](fbclid|gclid|msclkid|ttclid)=[^&]*/g,  // Click IDs
      /[?&](ref|referer|tracking_id|sid)=[^&]*/g,  // Other tracking
      /[?&](wt\.mc_id|mkttoken|ef_id)=[^&]*/g,    // More tracking
      /[?&](PHPSESSID|JSESSIONID|__VIEWSTATE)=[^&]*/g,  // Session data
      /[?&](campaign|source|medium|content|term)=[^&]*/g  // Generic
    ];
  }

  clean(urlString) {
    let cleaned = urlString;

    // Apply each pattern
    for (const pattern of this.patterns) {
      cleaned = cleaned.replace(pattern, '');
    }

    // Clean up multiple consecutive ? and &
    cleaned = cleaned.replace(/([?&])&+/g, '$1');
    cleaned = cleaned.replace(/^([^?]*)\?&/, '$1?');
    cleaned = cleaned.replace(/&$/, '');

    // Handle multiple domains (decode redirect)
    cleaned = this.decodeRedirects(cleaned);

    return cleaned;
  }

  decodeRedirects(url) {
    // Handle Google redirects
    if (url.includes('google.com/url')) {
      const match = url.match(/[?&]q=([^&]+)/);
      if (match) {
        return decodeURIComponent(match[1]);
      }
    }

    // Handle other redirect patterns
    if (url.includes('redirect=')) {
      const match = url.match(/redirect=([^&]+)/);
      if (match) {
        return decodeURIComponent(match[1]);
      }
    }

    return url;
  }
}

// Usage
const cleaner = new RegexUrlCleaner();

const examples = [
  'https://example.com/page?utm_source=google&utm_campaign=2024&id=123',
  'https://www.google.com/url?q=https://example.com',
  'https://shop.com?product=123&fbclid=abc123&utm_source=fb'
];

examples.forEach(url => {
  console.log('Original:  ', url);
  console.log('Cleaned:   ', cleaner.clean(url));
  console.log();
});

// Advanced URL cleaning with preservation and validation

class AdvancedUrlCleaner {
  constructor() {
    this.trackingPatterns = [
      // UTM parameters
      /utm_\w+/g,
      // Click IDs
      /(fbclid|gclid|msclkid|ttclid)/g,
      // Analytics
      /(wt\.mc_id|mkttoken|ef_id|mkt_tok)/g,
      // Affiliate
      /(aff_sub|affiliate_id|sid|affiliateid|AFFILIATE_ID)/g,
      // Social/Ref
      /(ref|fbref|twitter_id|linkedin_id)/g,
      // Unwanted
      /(tracking_id|source_id|campaign_id|visitor_id)/g
    ];

    // Parameters to always keep (whitelist)
    this.essentialParams = new Set([
      'id', 'product', 'article', 'post',
      'q', 'search', 'query',
      'page', 'p', 'offset',
      'sort', 'filter', 'category',
      'lang', 'language',
      'tab', 'section'
    ]);
  }

  clean(urlString, options = {}) {
    const {
      mode = 'conservative',
      preserveHash = true,
      validateUrl = true
    } = options;

    try {
      const url = new URL(urlString);

      // Validate
      if (validateUrl && !this.isValidUrl(url)) {
        console.warn('URL validation failed:', urlString);
      }

      const params = new URLSearchParams(url.search);
      const cleaned = this.filterParams(params, mode);

      url.search = cleaned.toString();

      // Optionally remove hash for privacy
      if (!preserveHash) {
        url.hash = '';
      }

      return url.toString();
    } catch (error) {
      console.error('URL cleaning failed:', error);
      return urlString;
    }
  }

  filterParams(params, mode) {
    const result = new URLSearchParams();

    for (const [key, value] of params) {
      if (mode === 'aggressive') {
        // Keep only whitelisted params
        if (this.essentialParams.has(key)) {
          result.set(key, value);
        }
      } else if (mode === 'conservative') {
        // Remove known tracking params
        if (!this.isTrackingParam(key)) {
          result.set(key, value);
        }
      } else if (mode === 'moderate') {
        // Remove known tracking, keep most others
        if (!this.isTrackingParam(key) && value.length < 100) {
          result.set(key, value);
        }
      }
    }

    return result;
  }

  isTrackingParam(param) {
    return this.trackingPatterns.some(pattern => {
      const regex = new RegExp(pattern);
      return regex.test(param);
    });
  }

  isValidUrl(url) {
    // Check if URL has reasonable structure
    return url.hostname &&
           url.protocol.match(/^https?:$/) &&
           url.hostname.includes('.');
  }

  // Batch cleaning
  cleanBatch(urls, options) {
    return urls.map(url => this.clean(url, options));
  }

  // Get report on removed parameters
  getCleaningReport(url) {
    const original = new URL(url);
    const cleaned = new URL(this.clean(url));

    const report = {
      original: url,
      cleaned: cleaned.toString(),
      paramsRemoved: [],
      paramsKept: []
    };

    for (const [key, value] of original.searchParams) {
      if (!cleaned.searchParams.has(key)) {
        report.paramsRemoved.push(key);
      } else {
        report.paramsKept.push(key);
      }
    }

    return report;
  }
}

// Usage
const cleaner = new AdvancedUrlCleaner();

const url = 'https://example.com/product?id=123&utm_source=google&utm_campaign=sale&fbclid=abc';
console.log('Aggressive:', cleaner.clean(url, { mode: 'aggressive' }));
console.log('Conservative:', cleaner.clean(url, { mode: 'conservative' }));
console.log('Report:', cleaner.getCleaningReport(url));

// Implementation of URL cleaner for browser extension

// Background script / content script
class BrowserUrlCleaner {
  constructor() {
    this.trackingParams = this.loadTrackingList();
    this.settings = this.loadSettings();
  }

  loadTrackingList() {
    // In real implementation, load from external list
    return [
      // UTM parameters
      'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
      // Click IDs
      'fbclid', 'gclid', 'msclkid', 'ttclid',
      // Aggregated analytics
      'wt.mc_id', 'mkttoken', 'ef_id',
      // Session tracking
      'sid', 'sessionid', 'JSESSIONID',
      // Affiliate
      'affiliate_id', 'aff_sub'
    ];
  }

  loadSettings() {
    return {
      enabled: true,
      cleanOnCopy: true,
      decodeRedirects: true,
      stripFragment: false,
      showNotification: true
    };
  }

  // Hook into link clicks
  interceptLinks() {
    document.addEventListener('click', (e) => {
      if (e.target.tagName === 'A') {
        const href = e.target.getAttribute('href');
        const cleaned = this.clean(href);
        if (cleaned !== href) {
          e.target.setAttribute('href', cleaned);
        }
      }
    }, true);
  }

  // Hook into copy operations
  interceptCopy() {
    document.addEventListener('copy', (e) => {
      if (!this.settings.cleanOnCopy) return;

      const selected = window.getSelection().toString();
      if (this.isUrl(selected)) {
        const cleaned = this.clean(selected);
        e.clipboardData.setData('text/plain', cleaned);
        e.preventDefault();
      }
    });
  }

  // Hook into context menu
  addContextMenu() {
    document.addEventListener('contextmenu', (e) => {
      if (e.target.tagName === 'A') {
        // Add option to clean link
        console.log('Add context menu option for:', e.target.href);
      }
    });
  }

  clean(urlString) {
    if (!this.isUrl(urlString)) return urlString;

    try {
      let url = new URL(urlString);

      // Decode redirects
      if (this.settings.decodeRedirects) {
        url = this.decodeRedirect(url);
      }

      // Remove tracking params
      url = this.removeTrackingParams(url);

      // Strip fragment if needed
      if (this.settings.stripFragment) {
        url.hash = '';
      }

      return url.toString();
    } catch {
      return urlString;
    }
  }

  removeTrackingParams(url) {
    const params = new URLSearchParams(url.search);
    for (const param of this.trackingParams) {
      params.delete(param);
    }
    url.search = params.toString();
    return url;
  }

  decodeRedirect(url) {
    // Google redirect
    if (url.hostname.includes('google.com') && url.pathname.includes('/url')) {
      const q = url.searchParams.get('q');
      if (q) {
        return new URL(decodeURIComponent(q));
      }
    }

    // Other redirects
    if (url.searchParams.has('redirect')) {
      const target = url.searchParams.get('redirect');
      try {
        return new URL(decodeURIComponent(target));
      } catch { }
    }

    return url;
  }

  isUrl(str) {
    try {
      new URL(str);
      return true;
    } catch {
      return false;
    }
  }
}

// Initialize
const cleaner = new BrowserUrlCleaner();
cleaner.interceptLinks();
cleaner.interceptCopy();

// Privacy-focused URL handling practices

class PrivacyUrlHandler {
  // Never store raw URLs with tracking parameters
  storeUrl(url) {
    const cleaned = this.removeTracking(url);
    return this.hashUrl(cleaned);
  }

  // Always clean before sharing
  shareUrl(url) {
    const cleaned = this.removeTracking(url);
    const shortened = this.shortenIfNeeded(cleaned);
    return shortened;
  }

  // Sanitize URLs in logs
  logUrl(url) {
    const cleaned = this.removeTracking(url);
    const sanitized = this.removePersonalInfo(cleaned);
    console.log('Accessed:', sanitized);
  }

  // Remove all tracking parameters
  removeTracking(urlString) {
    try {
      const url = new URL(urlString);
      const trackingRegex = /utm_|fbclid|gclid|msclkid|ttclid/i;

      for (const [key] of url.searchParams) {
        if (trackingRegex.test(key)) {
          url.searchParams.delete(key);
        }
      }

      return url.toString();
    } catch {
      return urlString;
    }
  }

  // Remove potential PII from URLs
  removePersonalInfo(urlString) {
    return urlString
      .replace(/[?&](email|user|account|id)=[^&]*/gi, '')
      .replace(/\/[0-9]+/g, '/[ID]') // Replace numeric IDs
      .replace(/=[a-f0-9]{32,}/gi, '=[HASH]'); // Replace hashes
  }

  // Use hash for sensitive queries
  hashUrl(urlString) {
    const hash = this.sha256(urlString);
    return {
      hash,
      url: urlString
    };
  }

  // Shorten long URLs
  shortenIfNeeded(url, maxLength = 100) {
    if (url.length > maxLength) {
      // Use shortening service
      return 'https://short.example.com/' + this.generateSlug();
    }
    return url;
  }

  // Best practices checklist
  checkPrivacy(url) {
    const checks = {
      hasTracking: /utm_|fbclid|gclid/i.test(url),
      hasUserInfo: /user|email|id=/i.test(url),
      hasSession: /session|sid|token/i.test(url),
      isHttps: url.startsWith('https://'),
      isKnownTracker: /google|facebook|doubleclick|analytics/i.test(url)
    };

    return {
      url,
      checks,
      riskScore: Object.values(checks).filter(Boolean).length,
      recommendations: this.getRecommendations(checks)
    };
  }

  getRecommendations(checks) {
    const recommendations = [];
    if (checks.hasTracking) recommendations.push('Remove tracking parameters');
    if (checks.hasUserInfo) recommendations.push('Remove personal information');
    if (!checks.isHttps) recommendations.push('Use HTTPS version');
    if (checks.isKnownTracker) recommendations.push('Consider using privacy alternative');
    return recommendations;
  }

  // Dummy SHA256 for example
  sha256(str) {
    return 'hash_' + Math.random().toString(36).substr(2, 9);
  }

  generateSlug() {
    return Math.random().toString(36).substr(2, 8);
  }
}

// Usage
const privacy = new PrivacyUrlHandler();

const url = 'https://example.com?product=123&utm_source=facebook&[email protected]';

console.log('Clean for sharing:', privacy.shareUrl(url));
console.log('Privacy check:', privacy.checkPrivacy(url));

// Secure URL sharing with cleaning and verification

class SecureUrlSharer {
  // Verify domain before sharing
  verifyDomain(urlString) {
    try {
      const url = new URL(urlString);
      const domain = url.hostname;

      // Check against known safe domains
      const safeDomains = this.loadTrustedDomains();
      return safeDomains.includes(domain) || safeDomains.some(
        d => domain.endsWith('.' + d)
      );
    } catch {
      return false;
    }
  }

  // Generate shareable link
  generateShareLink(url, platform = 'generic') {
    const cleaned = this.cleanUrl(url);

    if (!this.verifyDomain(cleaned)) {
      throw new Error('Domain not trusted');
    }

    switch (platform) {
      case 'twitter':
        return this.shareOnTwitter(cleaned);
      case 'mastodon':
        return this.shareOnMastodon(cleaned);
      case 'email':
        return this.shareViaEmail(cleaned);
      default:
        return this.genericShare(cleaned);
    }
  }

  shareOnTwitter(url) {
    const text = 'Check this out';
    return `https://twitter.com/intent/tweet?url=${encodeURIComponent(url)}&text=${encodeURIComponent(text)}`;
  }

  shareOnMastodon(url) {
    const text = 'Found this interesting';
    // Mastodon federation aware sharing
    return {
      text: `${text}\n\n${url}`,
      method: 'copy'
    };
  }

  shareViaEmail(url) {
    return `mailto:?subject=Check%20this%20out&body=${encodeURIComponent(url)}`;
  }

  genericShare(url) {
    return {
      url,
      qrCode: this.generateQrCode(url)
    };
  }

  // Clean URL comprehensively
  cleanUrl(urlString) {
    const url = new URL(urlString);

    // Remove all known tracking
    const trackingParams = [
      'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
      'fbclid', 'gclid', 'msclkid', 'ttclid'
    ];

    trackingParams.forEach(param => url.searchParams.delete(param));

    // Remove session-specific params
    for (const [key] of url.searchParams) {
      if (/session|sid|token|auth/i.test(key)) {
        url.searchParams.delete(key);
      }
    }

    return url.toString();
  }

  loadTrustedDomains() {
    return [
      'github.com', 'stackoverflow.com', 'mozilla.org',
      'wikipedia.org', 'python.org', 'nodejs.org',
      'example.com'
    ];
  }

  generateQrCode(url) {
    // Placeholder for QR code generation
    return 'https://api.qrserver.com/v1/create-qr-code/?size=200x200&data=' + encodeURIComponent(url);
  }
}

// Usage
const sharer = new SecureUrlSharer();

const url = 'https://github.com/user/repo?utm_source=twitter';
const twitterShare = sharer.generateShareLink(url, 'twitter');
console.log('Share on Twitter:', twitterShare);

const mastodon = sharer.generateShareLink(url, 'mastodon');
console.log('Share on Mastodon:', mastodon);

// Simple JavaScript URL cleaner for any project

class SimpleUrlCleaner {
  // Default tracking parameters to remove
  static TRACKING_PARAMS = [
    'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
    'fbclid', 'gclid', 'msclkid', 'ttclid',
    'ref', 'referer', 'tracking_id', 'sid', 'sessionid'
  ];

  // Clean a single URL
  static clean(urlString) {
    try {
      const url = new URL(urlString);
      const params = new URLSearchParams(url.search);

      // Remove tracking params
      this.TRACKING_PARAMS.forEach(param => params.delete(param));

      url.search = params.toString();
      return url.toString();
    } catch (error) {
      console.error('Invalid URL:', urlString);
      return urlString;
    }
  }

  // Clean multiple URLs
  static cleanBatch(urls) {
    return urls.map(url => this.clean(url));
  }

  // Add custom tracking parameter
  static addTrackingParam(param) {
    if (!this.TRACKING_PARAMS.includes(param)) {
      this.TRACKING_PARAMS.push(param);
    }
  }

  // Check if URL has tracking
  static hasTracking(urlString) {
    try {
      const url = new URL(urlString);
      for (const param of this.TRACKING_PARAMS) {
        if (url.searchParams.has(param)) {
          return true;
        }
      }
      return false;
    } catch {
      return false;
    }
  }
}

// Usage examples
const urls = [
  'https://example.com/product?id=123&utm_source=google',
  'https://shop.com?product=abc&fbclid=xyz123',
  'https://news.com/article?ref=twitter&gclid=def456'
];

// Clean single URL
console.log(SimpleUrlCleaner.clean(urls[0]));

// Clean batch
console.log(SimpleUrlCleaner.cleanBatch(urls));

// Check if has tracking
console.log(SimpleUrlCleaner.hasTracking(urls[1])); // true

// Add custom parameter
SimpleUrlCleaner.addTrackingParam('custom_tracker');

# Python URL cleaner

from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
from typing import List, Dict

class UrlCleaner:
    # Default tracking parameters
    TRACKING_PARAMS = {
        'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
        'fbclid', 'gclid', 'msclkid', 'ttclid',
        'ref', 'referer', 'tracking_id', 'sid', 'sessionid'
    }

    @classmethod
    def clean(cls, url_string: str) -> str:
        """Clean a URL by removing tracking parameters."""
        try:
            parsed = urlparse(url_string)
            params = parse_qs(parsed.query, keep_blank_values=True)

            # Remove tracking params
            for param in cls.TRACKING_PARAMS:
                params.pop(param, None)

            # Rebuild query string
            if params:
                new_query = urlencode(params, doseq=True)
            else:
                new_query = ''

            # Reconstruct URL
            return urlunparse((
                parsed.scheme,
                parsed.netloc,
                parsed.path,
                parsed.params,
                new_query,
                parsed.fragment
            ))
        except Exception as e:
            print(f"Error cleaning URL: {e}")
            return url_string

    @classmethod
    def clean_batch(cls, urls: List[str]) -> List[str]:
        """Clean multiple URLs."""
        return [cls.clean(url) for url in urls]

    @classmethod
    def has_tracking(cls, url_string: str) -> bool:
        """Check if URL contains tracking parameters."""
        try:
            parsed = urlparse(url_string)
            params = parse_qs(parsed.query)
            return bool(cls.TRACKING_PARAMS & set(params.keys()))
        except:
            return False

    @classmethod
    def add_tracking_param(cls, param: str):
        """Add custom tracking parameter."""
        cls.TRACKING_PARAMS.add(param)

# Usage
cleaner = UrlCleaner()

urls = [
    'https://example.com/product?id=123&utm_source=google',
    'https://shop.com?product=abc&fbclid=xyz123',
]

# Clean single URL
print(cleaner.clean(urls[0]))

# Clean batch
print(cleaner.clean_batch(urls))

# Check for tracking
print(cleaner.has_tracking(urls[1]))  # True

// Advanced URL cleaner with configuration and logging

class AdvancedUrlCleaner {
  constructor(config = {}) {
    this.config = {
      mode: 'smart',  // 'aggressive', 'conservative', 'smart'
      decodeRedirects: true,
      removedAds: false,
      stripFragment: false,
      normalizeUrl: true,
      ...config
    };

    this.stats = {
      cleaned: 0,
      preserved: 0,
      removed: 0
    };
  }

  clean(urlString) {
    const original = urlString;
    let url = new URL(urlString);

    // Decode redirects
    if (this.config.decodeRedirects) {
      url = this.decodeRedirects(url);
    }

    // Remove tracking
    const before = url.search;
    url = this.removeTracking(url);
    const after = url.search;

    // Normalize
    if (this.config.normalizeUrl) {
      url = this.normalizeUrl(url);
    }

    // Strip fragment
    if (this.config.stripFragment) {
      url.hash = '';
    }

    // Log changes
    this.logChanges(original, url.toString());

    return url.toString();
  }

  removeTracking(url) {
    const params = new URLSearchParams(url.search);
    const initial = params.size;

    if (this.config.mode === 'aggressive') {
      // Keep only essential params
      const essential = new Set(['id', 'q', 'search', 'page']);
      const toRemove = [];

      for (const key of params.keys()) {
        if (!essential.has(key)) {
          toRemove.push(key);
        }
      }

      toRemove.forEach(k => params.delete(k));
    } else {
      // Remove known tracking
      this.getTrackingParams().forEach(k => params.delete(k));
    }

    this.stats.removed += initial - params.size;
    this.stats.preserved += params.size;

    url.search = params.toString();
    return url;
  }

  decodeRedirects(url) {
    // Google redirect
    if (url.hostname.includes('google') && url.pathname === '/url') {
      const q = url.searchParams.get('q');
      if (q) return new URL(decodeURIComponent(q));
    }

    return url;
  }

  normalizeUrl(url) {
    // Remove empty query string
    if (url.search === '?') {
      url.search = '';
    }

    return url;
  }

  getTrackingParams() {
    return [
      'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
      'fbclid', 'gclid', 'msclkid', 'ttclid'
    ];
  }

  logChanges(original, cleaned) {
    if (original !== cleaned) {
      this.stats.cleaned++;
      console.log('Cleaned:', original.substring(0, 50) + '...');
    }
  }

  getStats() {
    return {
      ...this.stats,
      rate: this.stats.cleaned / (this.stats.cleaned + 1) * 100
    };
  }
}

// Usage
const cleaner = new AdvancedUrlCleaner({ mode: 'smart' });

const urls = [
  'https://example.com?utm_source=google&id=123',
  'https://google.com/url?q=https://example.com',
  'https://shop.com?product=xyz&fbclid=abc'
];

urls.forEach(url => {
  console.log(cleaner.clean(url));
});

console.log('Stats:', cleaner.getStats());

Ethical Guidelines for URL Cleaning:

ALWAYS SAFE TO REMOVE:
✓ UTM parameters (utm_source, utm_medium, etc.)
✓ Click IDs (fbclid, gclid, msclkid, ttclid)
✓ Analytics parameters (wt.mc_id, mkttoken)
✓ Session identifiers (if not needed for functionality)
✓ User tracking IDs
✓ Redirect parameters to known sites

CONSIDER BEFORE REMOVING:
⚠ Affiliate links (may prevent creator compensation)
⚠ Required functional parameters (id, key, token)
⚠ Authentication tokens (may break functionality)
⚠ Configuration parameters (layout, theme, etc.)
⚠ Search queries (may lose context)

NEVER REMOVE:
✗ Security tokens
✗ CSRF tokens
✗ Required API keys
✗ Validation checksums
✗ Required form parameters

BEST PRACTICES:
1. Preserve creator revenue opportunities
2. Maintain link functionality
3. Only share cleaned links where appropriate
4. Respect intended functionality
5. Be transparent about changes
6. Document removals for reference

AFFILIATE LINK ETIQUETTE:
• Support creators when possible
• Remove tracking only when sharing personally
• Keep affiliate links when sharing to support creators
• Consider alternative fair compensation