gscdump 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3823 @@
+import { withBase, withHttps, withoutTrailingSlash } from "ufo";
+import _dayjs from "dayjs";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
+import { ofetch } from "ofetch";
+
+//#region src/analysis/types.ts
+/** Coerce nullable number to number, defaulting to 0 */
+function num(value) {
+	return value ?? 0;
+}
+/** Create a generic sorter for any metric type */
+function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
+	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
+		const mult = sortOrder === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
+	};
+}
+
+//#endregion
+//#region src/analysis/striking-distance.ts
+const sortResults$4 = createSorter((item, metric) => item[metric], "potentialClicks");
+/**
+* Finds striking distance keywords - high impressions, low CTR, position 4-20.
+* These are "quick wins" that could gain significant traffic with small ranking improvements.
+*/
+function analyzeStrikingDistance(keywords, options = {}) {
+	const { minPosition = 4, maxPosition = 20, minImpressions = 100, maxCtr = .05, sortBy = "potentialClicks", sortOrder = "desc" } = options;
+	const results = [];
+	for (const row of keywords) {
+		const position = num(row.position);
+		const impressions = num(row.impressions);
+		const ctr = num(row.ctr);
+		const clicks = num(row.clicks);
+		if (position < minPosition || position > maxPosition) continue;
+		if (impressions < minImpressions) continue;
+		if (ctr > maxCtr) continue;
+		const potentialClicks = Math.round(impressions * .15);
+		results.push({
+			keyword: row.keyword,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			potentialClicks
+		});
+	}
+	return sortResults$4(results, sortBy, sortOrder);
+}
+
+//#endregion
+//#region src/analysis/opportunity.ts
+const EXPECTED_CTR_BY_POSITION = {
+	1: .3,
+	2: .15,
+	3: .1,
+	4: .07,
+	5: .05,
+	6: .04,
+	7: .03,
+	8: .025,
+	9: .02,
+	10: .015
+};
+function getExpectedCtr(position) {
+	return EXPECTED_CTR_BY_POSITION[Math.round(Math.max(1, Math.min(position, 10)))] || .01;
+}
+/**
+* Position score: higher for positions 4-20 (improvable range).
+* Peak opportunity at positions 8-15.
+*/
+function calculatePositionScore(position) {
+	if (position <= 3) return .2;
+	if (position > 50) return .1;
+	const distance = Math.abs(position - 11);
+	return Math.max(0, 1 - distance / 15);
+}
+/**
+* Impression score using log scale.
+* Higher impressions = more traffic potential.
+*/
+function calculateImpressionScore(impressions) {
+	if (impressions <= 0) return 0;
+	return Math.min(Math.log10(impressions) / 5, 1);
+}
+/**
+* CTR gap score: difference between actual and expected CTR.
+* Higher gap = more opportunity for improvement.
+*/
+function calculateCtrGapScore(actualCtr, position) {
+	const expectedCtr = getExpectedCtr(position);
+	if (actualCtr >= expectedCtr) return 0;
+	const gap = expectedCtr - actualCtr;
+	return Math.min(gap / expectedCtr, 1);
+}
+const SORT_ORDER$1 = {
+	opportunityScore: "desc",
+	potentialClicks: "desc",
+	impressions: "desc",
+	position: "asc"
+};
+const sortResults$3 = createSorter((item, metric) => item[metric], "opportunityScore");
+/**
+* Scores keywords by optimization opportunity.
+* Composite score combining position, impressions, and CTR gap factors.
+*/
+function analyzeOpportunity(keywords, options = {}) {
+	const { minImpressions = 100, weights = {}, sortBy = "opportunityScore" } = options;
+	const positionWeight = weights.position ?? 1;
+	const impressionsWeight = weights.impressions ?? 1;
+	const ctrGapWeight = weights.ctrGap ?? 1;
+	const results = [];
+	for (const row of keywords) {
+		const impressions = num(row.impressions);
+		const position = num(row.position);
+		const ctr = num(row.ctr);
+		const clicks = num(row.clicks);
+		if (impressions < minImpressions) continue;
+		const positionScore = calculatePositionScore(position);
+		const impressionScore = calculateImpressionScore(impressions);
+		const ctrGapScore = calculateCtrGapScore(ctr, position);
+		const weightedProduct = positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight;
+		const totalWeight = positionWeight + impressionsWeight + ctrGapWeight;
+		const geometricMean = Math.pow(weightedProduct, 1 / totalWeight);
+		const opportunityScore = Math.round(geometricMean * 100);
+		const targetCtr = getExpectedCtr(Math.min(3, position));
+		const potentialClicks = Math.round(impressions * targetCtr);
+		results.push({
+			keyword: row.keyword,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			opportunityScore,
+			potentialClicks,
+			factors: {
+				positionScore,
+				impressionScore,
+				ctrGapScore
+			}
+		});
+	}
+	return sortResults$3(results, sortBy, SORT_ORDER$1[sortBy]);
+}
+
+//#endregion
+//#region src/analysis/brand.ts
+/**
+* Segments keywords into brand and non-brand based on provided brand terms.
+* Simple string matching - keyword contains any brand term (case-insensitive).
+*/
+function analyzeBrandSegmentation(keywords, options) {
+	const { brandTerms, minImpressions = 10 } = options;
+	const lowerBrandTerms = brandTerms.map((t) => t.toLowerCase());
+	const brand = [];
+	const nonBrand = [];
+	for (const row of keywords) {
+		if (num(row.impressions) < minImpressions) continue;
+		if (lowerBrandTerms.some((term) => row.keyword.toLowerCase().includes(term))) brand.push(row);
+		else nonBrand.push(row);
+	}
+	const brandClicks = brand.reduce((sum, k) => sum + num(k.clicks), 0);
+	const nonBrandClicks = nonBrand.reduce((sum, k) => sum + num(k.clicks), 0);
+	const totalClicks = brandClicks + nonBrandClicks;
+	return {
+		brand,
+		nonBrand,
+		summary: {
+			brandClicks,
+			nonBrandClicks,
+			brandShare: totalClicks > 0 ? brandClicks / totalClicks : 0,
+			brandImpressions: brand.reduce((sum, k) => sum + num(k.impressions), 0),
+			nonBrandImpressions: nonBrand.reduce((sum, k) => sum + num(k.impressions), 0)
+		}
+	};
+}
+
+//#endregion
+//#region src/analysis/concentration.ts
+/**
+* Traffic concentration analysis - measures distribution across pages/keywords.
+* Pure function operating on page or keyword data.
+*/
+/**
+* Calculates Gini coefficient for a list of values.
+* Formula: sum((2*i - n - 1) * x_i) / (n * sum(x_i))
+*/
+function calculateGini(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	const sum = sorted.reduce((a, b) => a + b, 0);
+	if (sum === 0) return 0;
+	let weightedSum = 0;
+	for (let i = 0; i < n; i++) weightedSum += (2 * (i + 1) - n - 1) * sorted[i];
+	return weightedSum / (n * sum);
+}
+/**
+* Calculates Herfindahl-Hirschman Index (HHI).
+* Formula: sum((share_i * 100)^2)
+* Range: 0-10000 (0 = perfect competition, 10000 = monopoly)
+*/
+function calculateHHI(shares) {
+	return shares.reduce((sum, share) => sum + (share * 100) ** 2, 0);
+}
+/**
+* Analyzes traffic concentration across items (pages or keywords).
+* Returns Gini coefficient, HHI, and top-N concentration metrics.
+*
+* @param items Array of items with key and clicks
+* @param options Configuration options
+*/
+function analyzeConcentration(items, options = {}) {
+	const { topN = 10 } = options;
+	if (items.length === 0) return {
+		giniCoefficient: 0,
+		hhi: 0,
+		topNConcentration: 0,
+		topNItems: [],
+		totalItems: 0,
+		totalClicks: 0,
+		riskLevel: "low"
+	};
+	const sorted = [...items].sort((a, b) => b.clicks - a.clicks);
+	const totalClicks = sorted.reduce((sum, item) => sum + item.clicks, 0);
+	const clickValues = sorted.map((i) => i.clicks);
+	const shares = totalClicks > 0 ? sorted.map((i) => i.clicks / totalClicks) : [];
+	const giniCoefficient = calculateGini(clickValues);
+	const hhi = calculateHHI(shares);
+	const topNItems = sorted.slice(0, topN).map((item) => ({
+		key: item.key,
+		clicks: item.clicks,
+		share: totalClicks > 0 ? item.clicks / totalClicks : 0
+	}));
+	const topNClicks = topNItems.reduce((sum, item) => sum + item.clicks, 0);
+	const topNConcentration = totalClicks > 0 ? topNClicks / totalClicks : 0;
+	let riskLevel = "low";
+	if (hhi > 2500) riskLevel = "high";
+	else if (hhi > 1500) riskLevel = "medium";
+	return {
+		giniCoefficient,
+		hhi,
+		topNConcentration,
+		topNItems,
+		totalItems: items.length,
+		totalClicks,
+		riskLevel
+	};
+}
+/**
+* Convenience wrapper for page concentration analysis.
+*/
+function analyzePageConcentration(pages, options) {
+	return analyzeConcentration(pages.map((p) => ({
+		key: p.page,
+		clicks: num(p.clicks)
+	})), options);
+}
+/**
+* Convenience wrapper for keyword concentration analysis.
+*/
+function analyzeKeywordConcentration(keywords, options) {
+	return analyzeConcentration(keywords.map((k) => ({
+		key: k.keyword,
+		clicks: num(k.clicks)
+	})), options);
+}
+
+//#endregion
+//#region src/analysis/decay.ts
+const SORT_ORDER = {
+	lostClicks: "desc",
+	declinePercent: "desc",
+	currentClicks: "asc"
+};
+const sortResults$2 = createSorter((item, metric) => item[metric], "lostClicks");
+/**
+* Identifies "decaying" content - pages that have lost significant traffic.
+* Useful for finding old content that needs updating.
+*
+* @param input Current and previous period page data
+* @param options Filtering and sorting options
+*/
+function analyzeDecay(input, options = {}) {
+	const { minPreviousClicks = 50, threshold = .2, sortBy = "lostClicks" } = options;
+	const currentMap = /* @__PURE__ */ new Map();
+	for (const row of input.current) currentMap.set(row.page, {
+		clicks: num(row.clicks),
+		position: num(row.position)
+	});
+	const previousMap = /* @__PURE__ */ new Map();
+	for (const row of input.previous) {
+		const clicks = num(row.clicks);
+		if (clicks >= minPreviousClicks) previousMap.set(row.page, {
+			clicks,
+			position: num(row.position)
+		});
+	}
+	const results = [];
+	for (const [page$1, prev] of previousMap) {
+		const curr = currentMap.get(page$1) || {
+			clicks: 0,
+			position: 0
+		};
+		const lostClicks = prev.clicks - curr.clicks;
+		const declinePercent = prev.clicks > 0 ? lostClicks / prev.clicks : 0;
+		if (declinePercent >= threshold && lostClicks > 0) results.push({
+			page: page$1,
+			currentClicks: curr.clicks,
+			previousClicks: prev.clicks,
+			lostClicks,
+			declinePercent,
+			currentPosition: curr.position,
+			previousPosition: prev.position,
+			positionDrop: curr.position - prev.position
+		});
+	}
+	return sortResults$2(results, sortBy, SORT_ORDER[sortBy]);
+}
+
+//#endregion
+//#region src/analysis/movers.ts
+function percentDifference$1(current, previous) {
+	if (previous === 0) return current > 0 ? 100 : 0;
+	return (current - previous) / previous * 100;
+}
+/**
+* Identifies movers and shakers - keywords with significant recent changes.
+* Compares recent period against baseline period.
+*
+* @param input Current and previous keyword data
+* @param options Filtering and sorting options
+*/
+function analyzeMovers(input, options = {}) {
+	const { changeThreshold = .2, minImpressions = 50, sortBy = "clicksChange" } = options;
+	const normFactor = input.normalizationFactor ?? 1;
+	const baselineMap = /* @__PURE__ */ new Map();
+	for (const row of input.previous) baselineMap.set(row.keyword, {
+		clicks: num(row.clicks) / normFactor,
+		impressions: num(row.impressions) / normFactor,
+		position: num(row.position),
+		page: row.page ?? null
+	});
+	const pageMap = /* @__PURE__ */ new Map();
+	for (const row of input.current) if (!pageMap.has(row.keyword) && row.page) pageMap.set(row.keyword, row.page);
+	for (const row of input.previous) if (!pageMap.has(row.keyword) && row.page) pageMap.set(row.keyword, row.page);
+	const rising = [];
+	const declining = [];
+	const stable = [];
+	for (const row of input.current) {
+		const impressions = num(row.impressions);
+		const clicks = num(row.clicks);
+		const position = num(row.position);
+		if (impressions < minImpressions) continue;
+		const baseline = baselineMap.get(row.keyword) || {
+			clicks: 0,
+			impressions: 0,
+			position: 0,
+			page: null
+		};
+		const clicksChangePercent = percentDifference$1(clicks, baseline.clicks);
+		const impressionsChangePercent = percentDifference$1(impressions, baseline.impressions);
+		const data = {
+			keyword: row.keyword,
+			page: pageMap.get(row.keyword) ?? null,
+			recentClicks: clicks,
+			recentImpressions: impressions,
+			recentPosition: position,
+			baselineClicks: Math.round(baseline.clicks),
+			baselineImpressions: Math.round(baseline.impressions),
+			baselinePosition: baseline.position,
+			clicksChange: clicks - Math.round(baseline.clicks),
+			clicksChangePercent,
+			impressionsChangePercent,
+			positionChange: position - baseline.position
+		};
+		const absChange = Math.abs(clicksChangePercent / 100);
+		if (clicksChangePercent > 0 && absChange >= changeThreshold) rising.push(data);
+		else if (clicksChangePercent < 0 && absChange >= changeThreshold) declining.push(data);
+		else stable.push(data);
+	}
+	const sortFn = (a, b) => {
+		switch (sortBy) {
+			case "clicks": return b.recentClicks - a.recentClicks;
+			case "impressions": return b.recentImpressions - a.recentImpressions;
+			case "clicksChange": return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
+			case "impressionsChange": return Math.abs(b.impressionsChangePercent) - Math.abs(a.impressionsChangePercent);
+			case "positionChange": return Math.abs(b.positionChange) - Math.abs(a.positionChange);
+			default: return Math.abs(b.clicksChangePercent) - Math.abs(a.clicksChangePercent);
+		}
+	};
+	rising.sort(sortFn);
+	declining.sort(sortFn);
+	stable.sort((a, b) => b.recentClicks - a.recentClicks);
+	return {
+		rising,
+		declining,
+		stable
+	};
+}
+
+//#endregion
+//#region src/analysis/cannibalization.ts
+const sortResults$1 = createSorter((item, metric) => {
+	switch (metric) {
+		case "clicks": return item.totalClicks;
+		case "impressions": return item.totalImpressions;
+		case "positionSpread": return item.positionSpread;
+		case "pageCount": return item.pages.length;
+	}
+}, "clicks");
+/**
+* Detects keyword cannibalization - queries ranking for multiple pages.
+* Returns queries where multiple pages compete for the same search term.
+*
+* @param rows Query+page data rows
+* @param options Filtering and sorting options
+*/
+function analyzeCannibalization(rows, options = {}) {
+	const { minImpressions = 10, maxPositionSpread = 10, minPages = 2, sortBy = "clicks", sortOrder = "desc" } = options;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions) continue;
+		const pages = queryMap.get(row.query) || [];
+		pages.push({
+			page: row.page,
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
+		});
+		queryMap.set(row.query, pages);
+	}
+	const results = [];
+	for (const [query$1, pages] of queryMap) {
+		if (pages.length < minPages) continue;
+		pages.sort((a, b) => b.clicks - a.clicks);
+		const positions = pages.map((p) => p.position);
+		const positionSpread = Math.max(...positions) - Math.min(...positions);
+		if (positionSpread > maxPositionSpread) continue;
+		results.push({
+			query: query$1,
+			pages,
+			totalClicks: pages.reduce((sum, p) => sum + p.clicks, 0),
+			totalImpressions: pages.reduce((sum, p) => sum + p.impressions, 0),
+			positionSpread
+		});
+	}
+	return sortResults$1(results, sortBy, sortOrder);
+}
+
+//#endregion
+//#region src/analysis/zero-click.ts
+const sortResults = createSorter((item) => item.impressions, "impressions");
+/**
+* Identifies potential "Zero-Click" queries.
+* These are high-volume queries where you rank well but get few clicks,
+* often due to SERP features (Answer Boxes, Knowledge Panels, AI Overviews).
+*
+* @param rows Query+page data rows
+* @param options Filtering options
+*/
+function analyzeZeroClick(rows, options = {}) {
+	const { minImpressions = 1e3, maxCtr = .03, maxPosition = 10 } = options;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions) continue;
+		if (row.position > maxPosition) continue;
+		if (row.ctr > maxCtr) continue;
+		const existing = queryMap.get(row.query);
+		if (!existing || row.position < existing.position) queryMap.set(row.query, {
+			query: row.query,
+			page: row.page,
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
+		});
+	}
+	return sortResults(Array.from(queryMap.values()), "impressions", "desc");
+}
+
+//#endregion
+//#region src/analysis/seasonality.ts
+/**
+* Calculates coefficient of variation (CV) as a seasonality strength measure.
+* CV = std dev / mean, capped at 1 for the result.
+*/
+function calculateCV(values) {
+	if (values.length === 0) return 0;
+	const mean = values.reduce((a, b) => a + b, 0) / values.length;
+	if (mean === 0) return 0;
+	const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+	const stdDev = Math.sqrt(variance);
+	return Math.min(stdDev / mean, 1);
+}
+/**
+* Detects seasonality patterns by analyzing monthly traffic variation.
+* Identifies peaks (>1.5x average) and troughs (<0.5x average).
+*
+* @param dates Array of date metrics (each row is one day)
+* @param options Analysis options
+*/
+function analyzeSeasonality(dates, options = {}) {
+	const { metric = "clicks" } = options;
+	if (dates.length === 0) return {
+		hasSeasonality: false,
+		strength: 0,
+		peakMonths: [],
+		troughMonths: [],
+		monthlyBreakdown: [],
+		insufficientData: true
+	};
+	const monthlyMap = /* @__PURE__ */ new Map();
+	for (const row of dates) {
+		const month = row.date.substring(0, 7);
+		const value = metric === "clicks" ? row.clicks : row.impressions;
+		monthlyMap.set(month, (monthlyMap.get(month) || 0) + value);
+	}
+	const months = Array.from(monthlyMap.keys()).sort();
+	const values = months.map((m) => monthlyMap.get(m) || 0);
+	const insufficientData = months.length < 12;
+	const totalValue = values.reduce((a, b) => a + b, 0);
+	const avgValue = values.length > 0 ? totalValue / values.length : 0;
+	const monthlyBreakdown = months.map((month, i) => {
+		const value = values[i];
+		const vsAverage = avgValue > 0 ? value / avgValue : 0;
+		return {
+			month,
+			value,
+			vsAverage,
+			isPeak: vsAverage > 1.5,
+			isTrough: vsAverage < .5
+		};
+	});
+	const peakMonths = [...new Set(monthlyBreakdown.filter((m) => m.isPeak).map((m) => m.month.substring(5, 7)))];
+	const troughMonths = [...new Set(monthlyBreakdown.filter((m) => m.isTrough).map((m) => m.month.substring(5, 7)))];
+	const strength = calculateCV(values);
+	return {
+		hasSeasonality: peakMonths.length > 0 || troughMonths.length > 0 || strength > .3,
+		strength,
+		peakMonths,
+		troughMonths,
+		monthlyBreakdown,
+		insufficientData
+	};
+}
+
+//#endregion
+//#region src/analysis/clustering.ts
+const INTENT_PREFIXES = [
+	"how to",
+	"what is",
+	"what are",
+	"why is",
+	"why do",
+	"where to",
+	"when to",
+	"best",
+	"top",
+	"vs",
+	"versus",
+	"compare",
+	"review",
+	"buy",
+	"cheap",
+	"free",
+	"near me"
+];
+function extractIntentPrefix(keyword) {
+	const lower = keyword.toLowerCase();
+	for (const prefix of INTENT_PREFIXES) if (lower.startsWith(prefix + " ") || lower.startsWith(prefix)) return prefix;
+	return null;
+}
+function extractWordPrefix(keyword, wordCount = 2) {
+	const words = keyword.toLowerCase().split(/\s+/).filter(Boolean);
+	if (words.length < wordCount + 1) return null;
+	return words.slice(0, wordCount).join(" ");
+}
+/**
+* Clusters keywords by intent prefix or common word prefix.
+* Simple regex/prefix approach - no external NLP dependencies.
+*
+* @param keywords Array of keyword data
+* @param options Clustering options
+*/
+function analyzeClustering(keywords, options = {}) {
+	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
+	const filtered = keywords.filter((k) => num(k.impressions) >= minImpressions);
+	const clusterMap = /* @__PURE__ */ new Map();
+	const clusteredKeywords = /* @__PURE__ */ new Set();
+	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
+		const intent = extractIntentPrefix(kw.keyword);
+		if (intent) {
+			const existing = clusterMap.get(intent);
+			if (existing) existing.keywords.push(kw);
+			else clusterMap.set(intent, {
+				type: "intent",
+				keywords: [kw]
+			});
+			clusteredKeywords.add(kw.keyword);
+		}
+	}
+	if (clusterBy === "prefix" || clusterBy === "both") {
+		const unclustered = filtered.filter((kw) => !clusteredKeywords.has(kw.keyword));
+		const prefixMap = /* @__PURE__ */ new Map();
+		for (const kw of unclustered) {
+			const prefix = extractWordPrefix(kw.keyword);
+			if (prefix) {
+				const existing = prefixMap.get(prefix);
+				if (existing) existing.push(kw);
+				else prefixMap.set(prefix, [kw]);
+			}
+		}
+		for (const [prefix, kws] of prefixMap) if (kws.length >= minClusterSize) {
+			clusterMap.set(prefix, {
+				type: "prefix",
+				keywords: kws
+			});
+			kws.forEach((kw) => clusteredKeywords.add(kw.keyword));
+		}
+	}
+	const clusters = [];
+	for (const [name, data] of clusterMap) {
+		if (data.keywords.length < minClusterSize) continue;
+		const totalClicks = data.keywords.reduce((sum, k) => sum + num(k.clicks), 0);
+		const totalImpressions = data.keywords.reduce((sum, k) => sum + num(k.impressions), 0);
+		const avgPosition = data.keywords.reduce((sum, k) => sum + num(k.position), 0) / data.keywords.length;
+		clusters.push({
+			clusterName: name,
+			clusterType: data.type,
+			keywords: data.keywords,
+			totalClicks,
+			totalImpressions,
+			avgPosition,
+			keywordCount: data.keywords.length
+		});
+	}
+	clusters.sort((a, b) => b.totalClicks - a.totalClicks);
+	return {
+		clusters,
+		unclustered: filtered.filter((kw) => !clusteredKeywords.has(kw.keyword))
+	};
+}
+
+//#endregion
+//#region src/api/indexing.ts
+/**
+* Request Google to index or remove a URL via the Indexing API.
+* Note: The Indexing API officially supports only job posting and livestream content,
+* but can be used for any URL with varying success.
+*/
+async function requestIndexing(client, url, options = {}) {
+	const { type = "URL_UPDATED" } = options;
+	return client.indexing.publish(url, type).then((r) => ({
+		url,
+		type,
+		notifyTime: r.urlNotificationMetadata?.latestUpdate?.notifyTime || void 0
+	}));
+}
+/**
+* Get the indexing notification metadata for a URL.
+* Returns when Google was last notified about updates/removals.
+*/
+async function getIndexingMetadata(client, url) {
+	return client.indexing.getMetadata(url).then((r) => ({
+		url,
+		latestUpdate: r.latestUpdate || void 0,
+		latestRemove: r.latestRemove || void 0
+	}));
+}
+/**
+* Batch request indexing for multiple URLs with rate limiting.
+* Returns results for each URL.
+*/
+async function batchRequestIndexing(client, urls, options = {}) {
+	const { type = "URL_UPDATED", delayMs = 100, onProgress } = options;
+	const results = [];
+	for (let i = 0; i < urls.length; i++) {
+		const result = await requestIndexing(client, urls[i], { type });
+		results.push(result);
+		onProgress?.(result, i, urls.length);
+		if (i < urls.length - 1 && delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+	}
+	return results;
+}
+
+//#endregion
+//#region src/api/inspection.ts
+/**
+* Inspects a URL in Google Search Console to check its indexing status.
+*/
+async function inspectUrl(client, siteUrl, inspectionUrl) {
+	const inspection = (await client.urlInspection.inspect(siteUrl, inspectionUrl)).inspectionResult;
+	return {
+		inspection,
+		isIndexed: inspection?.indexStatusResult?.verdict === "PASS"
+	};
+}
+/**
+* Batch inspect multiple URLs with rate limiting.
+* Returns inspection results for each URL.
+*/
+async function batchInspectUrls(client, siteUrl, urls, options = {}) {
+	const { delayMs = 200, onProgress } = options;
+	const results = [];
+	for (let i = 0; i < urls.length; i++) {
+		const url = urls[i];
+		const { inspection, isIndexed } = await inspectUrl(client, siteUrl, url);
+		const result = {
+			url,
+			inspection,
+			isIndexed
+		};
+		results.push(result);
+		onProgress?.(result, i, urls.length);
+		if (i < urls.length - 1 && delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+	}
+	return results;
+}
+
+//#endregion
+//#region src/api/sites.ts
+/**
+* Fetches all sites the authenticated user has access to in Google Search Console.
+*/
+async function fetchSites(client) {
+	return client.sites.list().then((res) => res?.siteEntry || []);
+}
+/**
+* Fetches sitemaps for a site.
+*/
+async function fetchSitemaps(client, siteUrl) {
+	return client.sitemaps.list(siteUrl).then((res) => res.sitemap || []);
+}
+/**
+* Gets details for a specific sitemap.
+*/
+async function fetchSitemap(client, siteUrl, feedpath) {
+	return client.sitemaps.get(siteUrl, feedpath);
+}
+/**
+* Submits a sitemap to Google Search Console.
+*/
+async function submitSitemap(client, siteUrl, feedpath) {
+	return client.sitemaps.submit(siteUrl, feedpath);
+}
+/**
+* Deletes a sitemap from Google Search Console.
+*/
+async function deleteSitemap(client, siteUrl, feedpath) {
+	return client.sitemaps.delete(siteUrl, feedpath);
+}
+/**
+* Fetches all verified sites with their sitemaps from Google Search Console.
+*/
+async function fetchSitesWithSitemaps(client) {
+	const sites = (await client.sites.list().then((res) => res.siteEntry || [])).filter((s) => !!s.siteUrl && s.permissionLevel !== "siteUnverifiedUser");
+	return Promise.all(sites.map(async (site) => {
+		const sitemaps = site.permissionLevel === "siteOwner" ? await client.sitemaps.list(site.siteUrl).then((res) => res.sitemap || []) : [];
+		return {
+			...site,
+			sitemaps
+		};
+	}));
+}
+
+//#endregion
+//#region src/utils/dayjs.ts
+_dayjs.extend(utc);
+_dayjs.extend(timezone);
+function dayjs(date$1) {
+	return _dayjs(date$1);
+}
+
+//#endregion
+//#region src/utils/format.ts
+/**
+* Formats a date for GSC API queries (YYYY-MM-DD format).
+* @param d - Date object, date string, or null/undefined
+* @returns Formatted date string or null/undefined if input is falsy
+*/
+function formatDateGsc(d) {
+	if (!d) return d;
+	if (typeof d === "string") return d;
+	return `${d.getFullYear()}-${(d.getMonth() + 1).toString().padStart(2, "0")}-${d.getDate().toString().padStart(2, "0")}`;
+}
+/**
+* Calculates the percentage difference between two values.
+* Returns 0 if either value is null, undefined, or 0 (no meaningful comparison).
+* @param a - Current value
+* @param b - Previous/comparison value
+* @returns Percentage difference (positive = increase, negative = decrease), or 0 if either value is falsy
+*/
+function percentDifference(a, b) {
+	if (!b || !a) return 0;
+	return (a - b) / ((a + b) / 2) * 100;
+}
+/**
+* Resolves a period string or object into start/end dates for current and previous periods.
+* @param periodRange - Period string (e.g., '30d', '3mo', 'all') or Period object with start/end dates
+* @returns Resolved period ranges with timestamps and formatted dates for both current and previous periods
+*/
+function userPeriodRange(periodRange = "30d") {
+	let startPeriod;
+	let endPeriod;
+	let startPrevPeriod;
+	let endPrevPeriod;
+	if (typeof periodRange === "string") {
+		endPeriod = dayjs();
+		if (periodRange === "all") {
+			startPeriod = dayjs().subtract(100, "year");
+			startPrevPeriod = dayjs().subtract(200, "year");
+			endPrevPeriod = dayjs().subtract(100, "year").subtract(1, "day");
+		} else if (periodRange === "max") {
+			const maxDays = 480;
+			startPeriod = endPeriod.clone().subtract(maxDays, "day");
+			startPrevPeriod = endPeriod.clone().subtract(maxDays * 2, "day");
+			endPrevPeriod = endPeriod.clone().subtract(maxDays + 1, "day");
+		} else {
+			const periodDays = periodRange.includes("d") ? Number.parseInt(periodRange.replace("d", "")) : Number.parseInt(periodRange.replace("mo", "")) * 30;
+			startPeriod = endPeriod.clone().subtract(periodDays, "day");
+			startPrevPeriod = endPeriod.clone().subtract(periodDays * 2, "day");
+			endPrevPeriod = endPeriod.clone().subtract(periodDays + 1, "day");
+		}
+	} else {
+		startPeriod = dayjs(periodRange.start);
+		endPeriod = dayjs(periodRange.end);
+		const dayDiff = endPeriod.diff(startPeriod, "day");
+		startPrevPeriod = dayjs(periodRange.start).subtract(dayDiff, "day");
+		endPrevPeriod = dayjs(periodRange.end).subtract(dayDiff, "day");
+	}
+	return {
+		period: {
+			startTimestamp: startPeriod.valueOf(),
+			start: startPeriod.toDate(),
+			startDateTime: startPeriod.format("YYYY-MM-DD HH:mm:ss"),
+			startDate: startPeriod.format("YYYY-MM-DD"),
+			end: endPeriod.toDate(),
+			endDate: endPeriod.format("YYYY-MM-DD"),
+			endTimestamp: endPeriod.valueOf(),
+			endDateTime: endPeriod.format("YYYY-MM-DD HH:mm:ss")
+		},
+		prevPeriod: {
+			start: startPrevPeriod.toDate(),
+			startDate: startPrevPeriod.format("YYYY-MM-DD"),
+			end: endPrevPeriod.toDate(),
+			endDate: endPrevPeriod.format("YYYY-MM-DD")
+		}
+	};
+}
+
+//#endregion
+//#region src/api/search-analytics/query.ts
+/**
+* Recursively queries GSC search analytics, automatically handling pagination for large datasets.
+*/
+async function queryRecursive(client, siteUrl, query$1, options = {}) {
+	const rowLimit = query$1.rowLimit || 25e3;
+	const rows = [];
+	let page$1 = 1;
+	const initialRows = (await client.searchAnalytics.query(siteUrl, {
+		...query$1,
+		startRow: 0,
+		rowLimit
+	})).rows || [];
+	rows.push(...initialRows);
+	options.onProgress?.(rows.length);
+	if (initialRows.length === rowLimit) while (true) {
+		page$1++;
+		const nextRows = (await client.searchAnalytics.query(siteUrl, {
+			...query$1,
+			startRow: rows.length,
+			rowLimit
+		})).rows || [];
+		rows.push(...nextRows);
+		options.onProgress?.(rows.length);
+		if (nextRows.length < rowLimit) break;
+	}
+	return {
+		rows,
+		pages: page$1
+	};
+}
+/**
+* Creates a GSC search analytics query request body with standard defaults.
+*/
+function createQueryBody(options = {}) {
+	const { domain, period = {
+		start: dayjs().subtract(30, "day").toDate(),
+		end: dayjs().toDate()
+	}, filters = [], type = "web", dataState = "all", aggregationType = "byPage", rowLimit = 25e3 } = options;
+	const allFilters = [...filters];
+	if (aggregationType === "byPage") {
+		allFilters.unshift({
+			dimension: "page",
+			operator: "excludingRegex",
+			expression: `#`
+		});
+		if (domain) allFilters.unshift({
+			dimension: "page",
+			operator: "includingRegex",
+			expression: `^${withoutTrailingSlash(domain).replace(/\./g, "\\.")}/.*`
+		});
+	}
+	const result = {
+		type,
+		aggregationType,
+		dataState,
+		startDate: formatDateGsc(period.start),
+		endDate: formatDateGsc(period.end),
+		rowLimit
+	};
+	if (allFilters.length > 0) result.dimensionFilterGroups = [{ filters: allFilters }];
+	return result;
+}
+/**
+* Helper to add search appearance dimension filter.
+* Use with spread: createQueryBody({ ...withSearchAppearance('AMP'), period })
+*/
+function withSearchAppearance(appearance) {
+	return { filters: [{
+		dimension: "searchAppearance",
+		operator: "equals",
+		expression: appearance
+	}] };
+}
+/**
+* Helper to set data type (web, image, video, news, discover, googleNews).
+* Use with spread: createQueryBody({ ...withDataType('image'), period })
+*/
+function withDataType(type) {
+	return { type };
+}
+/**
+* Helper to include fresh/unfinalized data (last 3 days).
+* Use with spread: createQueryBody({ ...withFreshData(), period })
+*/
+function withFreshData() {
+	return { dataState: "all" };
+}
+/**
+* Helper to use only finalized data (excludes last 3 days).
+* Use with spread: createQueryBody({ ...withFinalData(), period })
+*/
+function withFinalData() {
+	return { dataState: "final" };
+}
+/**
+* Helper to use byProperty aggregation (domain-level rollup).
+* Use for sc-domain: properties to get true totals.
+* Use with spread: createQueryBody({ ...withPropertyAggregation(), period })
+*/
+function withPropertyAggregation() {
+	return { aggregationType: "byProperty" };
+}
+
+//#endregion
+//#region src/api/search-analytics/analytics.ts
+/**
+* Fetches overall site analytics summary with period comparison and keyword data.
+*/
+async function fetchAnalyticsWithComparison(client, siteUrl, options = {}) {
+	const [currentSummary, previousSummary, currentKeywords, previousKeywords] = await Promise.all([
+		client.searchAnalytics.query(siteUrl, { ...createQueryBody(options) }).then((res) => (res.rows || [])[0] || {}),
+		options.prevPeriod ? client.searchAnalytics.query(siteUrl, { ...createQueryBody({
+			...options,
+			period: options.prevPeriod
+		}) }).then((res) => (res.rows || [])[0] || {}) : Promise.resolve({}),
+		client.searchAnalytics.query(siteUrl, {
+			...createQueryBody(options),
+			dimensions: ["date", "query"]
+		}).then((res) => res.rows || []),
+		options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+			...createQueryBody({
+				...options,
+				period: options.prevPeriod
+			}),
+			dimensions: ["date", "query"]
+		}).then((res) => res.rows || []) : Promise.resolve([])
+	]);
+	return {
+		current: [{
+			...currentSummary,
+			keywords: currentKeywords
+		}],
+		previous: [{
+			...previousSummary,
+			keywords: previousKeywords
+		}],
+		metadata: {
+			currentCount: 1,
+			previousCount: options.prevPeriod ? 1 : 0,
+			currentKeywordCount: currentKeywords.length,
+			previousKeywordCount: previousKeywords.length
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/countries.ts
+var countries_default = [
+	{
+		"name": "Afghanistan",
+		"alpha-2": "AF",
+		"alpha-3": "AFG",
+		"country-code": "004"
+	},
+	{
+		"name": "Åland Islands",
+		"alpha-2": "AX",
+		"alpha-3": "ALA",
+		"country-code": "248"
+	},
+	{
+		"name": "Albania",
+		"alpha-2": "AL",
+		"alpha-3": "ALB",
+		"country-code": "008"
+	},
+	{
+		"name": "Algeria",
+		"alpha-2": "DZ",
+		"alpha-3": "DZA",
+		"country-code": "012"
+	},
+	{
+		"name": "American Samoa",
+		"alpha-2": "AS",
+		"alpha-3": "ASM",
+		"country-code": "016"
+	},
+	{
+		"name": "Andorra",
+		"alpha-2": "AD",
+		"alpha-3": "AND",
+		"country-code": "020"
+	},
+	{
+		"name": "Angola",
+		"alpha-2": "AO",
+		"alpha-3": "AGO",
+		"country-code": "024"
+	},
+	{
+		"name": "Anguilla",
+		"alpha-2": "AI",
+		"alpha-3": "AIA",
+		"country-code": "660"
+	},
+	{
+		"name": "Antarctica",
+		"alpha-2": "AQ",
+		"alpha-3": "ATA",
+		"country-code": "010"
+	},
+	{
+		"name": "Antigua and Barbuda",
+		"alpha-2": "AG",
+		"alpha-3": "ATG",
+		"country-code": "028"
+	},
+	{
+		"name": "Argentina",
+		"alpha-2": "AR",
+		"alpha-3": "ARG",
+		"country-code": "032"
+	},
+	{
+		"name": "Armenia",
+		"alpha-2": "AM",
+		"alpha-3": "ARM",
+		"country-code": "051"
+	},
+	{
+		"name": "Aruba",
+		"alpha-2": "AW",
+		"alpha-3": "ABW",
+		"country-code": "533"
+	},
+	{
+		"name": "Australia",
+		"alpha-2": "AU",
+		"alpha-3": "AUS",
+		"country-code": "036"
+	},
+	{
+		"name": "Austria",
+		"alpha-2": "AT",
+		"alpha-3": "AUT",
+		"country-code": "040"
+	},
+	{
+		"name": "Azerbaijan",
+		"alpha-2": "AZ",
+		"alpha-3": "AZE",
+		"country-code": "031"
+	},
+	{
+		"name": "Bahamas",
+		"alpha-2": "BS",
+		"alpha-3": "BHS",
+		"country-code": "044"
+	},
+	{
+		"name": "Bahrain",
+		"alpha-2": "BH",
+		"alpha-3": "BHR",
+		"country-code": "048"
+	},
+	{
+		"name": "Bangladesh",
+		"alpha-2": "BD",
+		"alpha-3": "BGD",
+		"country-code": "050"
+	},
+	{
+		"name": "Barbados",
+		"alpha-2": "BB",
+		"alpha-3": "BRB",
+		"country-code": "052"
+	},
+	{
+		"name": "Belarus",
+		"alpha-2": "BY",
+		"alpha-3": "BLR",
+		"country-code": "112"
+	},
+	{
+		"name": "Belgium",
+		"alpha-2": "BE",
+		"alpha-3": "BEL",
+		"country-code": "056"
+	},
+	{
+		"name": "Belize",
+		"alpha-2": "BZ",
+		"alpha-3": "BLZ",
+		"country-code": "084"
+	},
+	{
+		"name": "Benin",
+		"alpha-2": "BJ",
+		"alpha-3": "BEN",
+		"country-code": "204"
+	},
+	{
+		"name": "Bermuda",
+		"alpha-2": "BM",
+		"alpha-3": "BMU",
+		"country-code": "060"
+	},
+	{
+		"name": "Bhutan",
+		"alpha-2": "BT",
+		"alpha-3": "BTN",
+		"country-code": "064"
+	},
+	{
+		"name": "Bolivia (Plurinational State of)",
+		"alpha-2": "BO",
+		"alpha-3": "BOL",
+		"country-code": "068"
+	},
+	{
+		"name": "Bonaire, Sint Eustatius and Saba",
+		"alpha-2": "BQ",
+		"alpha-3": "BES",
+		"country-code": "535"
+	},
+	{
+		"name": "Bosnia and Herzegovina",
+		"alpha-2": "BA",
+		"alpha-3": "BIH",
+		"country-code": "070"
+	},
+	{
+		"name": "Botswana",
+		"alpha-2": "BW",
+		"alpha-3": "BWA",
+		"country-code": "072"
+	},
+	{
+		"name": "Bouvet Island",
+		"alpha-2": "BV",
+		"alpha-3": "BVT",
+		"country-code": "074"
+	},
+	{
+		"name": "Brazil",
+		"alpha-2": "BR",
+		"alpha-3": "BRA",
+		"country-code": "076"
+	},
+	{
+		"name": "British Indian Ocean Territory",
+		"alpha-2": "IO",
+		"alpha-3": "IOT",
+		"country-code": "086"
+	},
+	{
+		"name": "Brunei Darussalam",
+		"alpha-2": "BN",
+		"alpha-3": "BRN",
+		"country-code": "096"
+	},
+	{
+		"name": "Bulgaria",
+		"alpha-2": "BG",
+		"alpha-3": "BGR",
+		"country-code": "100"
+	},
+	{
+		"name": "Burkina Faso",
+		"alpha-2": "BF",
+		"alpha-3": "BFA",
+		"country-code": "854"
+	},
+	{
+		"name": "Burundi",
+		"alpha-2": "BI",
+		"alpha-3": "BDI",
+		"country-code": "108"
+	},
+	{
+		"name": "Cabo Verde",
+		"alpha-2": "CV",
+		"alpha-3": "CPV",
+		"country-code": "132"
+	},
+	{
+		"name": "Cambodia",
+		"alpha-2": "KH",
+		"alpha-3": "KHM",
+		"country-code": "116"
+	},
+	{
+		"name": "Cameroon",
+		"alpha-2": "CM",
+		"alpha-3": "CMR",
+		"country-code": "120"
+	},
+	{
+		"name": "Canada",
+		"alpha-2": "CA",
+		"alpha-3": "CAN",
+		"country-code": "124"
+	},
+	{
+		"name": "Cayman Islands",
+		"alpha-2": "KY",
+		"alpha-3": "CYM",
+		"country-code": "136"
+	},
+	{
+		"name": "Central African Republic",
+		"alpha-2": "CF",
+		"alpha-3": "CAF",
+		"country-code": "140"
+	},
+	{
+		"name": "Chad",
+		"alpha-2": "TD",
+		"alpha-3": "TCD",
+		"country-code": "148"
+	},
+	{
+		"name": "Chile",
+		"alpha-2": "CL",
+		"alpha-3": "CHL",
+		"country-code": "152"
+	},
+	{
+		"name": "China",
+		"alpha-2": "CN",
+		"alpha-3": "CHN",
+		"country-code": "156"
+	},
+	{
+		"name": "Christmas Island",
+		"alpha-2": "CX",
+		"alpha-3": "CXR",
+		"country-code": "162"
+	},
+	{
+		"name": "Cocos (Keeling) Islands",
+		"alpha-2": "CC",
+		"alpha-3": "CCK",
+		"country-code": "166"
+	},
+	{
+		"name": "Colombia",
+		"alpha-2": "CO",
+		"alpha-3": "COL",
+		"country-code": "170"
+	},
+	{
+		"name": "Comoros",
+		"alpha-2": "KM",
+		"alpha-3": "COM",
+		"country-code": "174"
+	},
+	{
+		"name": "Congo",
+		"alpha-2": "CG",
+		"alpha-3": "COG",
+		"country-code": "178"
+	},
+	{
+		"name": "Congo, Democratic Republic of the",
+		"alpha-2": "CD",
+		"alpha-3": "COD",
+		"country-code": "180"
+	},
+	{
+		"name": "Cook Islands",
+		"alpha-2": "CK",
+		"alpha-3": "COK",
+		"country-code": "184"
+	},
+	{
+		"name": "Costa Rica",
+		"alpha-2": "CR",
+		"alpha-3": "CRI",
+		"country-code": "188"
+	},
+	{
+		"name": "Côte d'Ivoire",
+		"alpha-2": "CI",
+		"alpha-3": "CIV",
+		"country-code": "384"
+	},
+	{
+		"name": "Croatia",
+		"alpha-2": "HR",
+		"alpha-3": "HRV",
+		"country-code": "191"
+	},
+	{
+		"name": "Cuba",
+		"alpha-2": "CU",
+		"alpha-3": "CUB",
+		"country-code": "192"
+	},
+	{
+		"name": "Curaçao",
+		"alpha-2": "CW",
+		"alpha-3": "CUW",
+		"country-code": "531"
+	},
+	{
+		"name": "Cyprus",
+		"alpha-2": "CY",
+		"alpha-3": "CYP",
+		"country-code": "196"
+	},
+	{
+		"name": "Czechia",
+		"alpha-2": "CZ",
+		"alpha-3": "CZE",
+		"country-code": "203"
+	},
+	{
+		"name": "Denmark",
+		"alpha-2": "DK",
+		"alpha-3": "DNK",
+		"country-code": "208"
+	},
+	{
+		"name": "Djibouti",
+		"alpha-2": "DJ",
+		"alpha-3": "DJI",
+		"country-code": "262"
+	},
+	{
+		"name": "Dominica",
+		"alpha-2": "DM",
+		"alpha-3": "DMA",
+		"country-code": "212"
+	},
+	{
+		"name": "Dominican Republic",
+		"alpha-2": "DO",
+		"alpha-3": "DOM",
+		"country-code": "214"
+	},
+	{
+		"name": "Ecuador",
+		"alpha-2": "EC",
+		"alpha-3": "ECU",
+		"country-code": "218"
+	},
+	{
+		"name": "Egypt",
+		"alpha-2": "EG",
+		"alpha-3": "EGY",
+		"country-code": "818"
+	},
+	{
+		"name": "El Salvador",
+		"alpha-2": "SV",
+		"alpha-3": "SLV",
+		"country-code": "222"
+	},
+	{
+		"name": "Equatorial Guinea",
+		"alpha-2": "GQ",
+		"alpha-3": "GNQ",
+		"country-code": "226"
+	},
+	{
+		"name": "Eritrea",
+		"alpha-2": "ER",
+		"alpha-3": "ERI",
+		"country-code": "232"
+	},
+	{
+		"name": "Estonia",
+		"alpha-2": "EE",
+		"alpha-3": "EST",
+		"country-code": "233"
+	},
+	{
+		"name": "Eswatini",
+		"alpha-2": "SZ",
+		"alpha-3": "SWZ",
+		"country-code": "748"
+	},
+	{
+		"name": "Ethiopia",
+		"alpha-2": "ET",
+		"alpha-3": "ETH",
+		"country-code": "231"
+	},
+	{
+		"name": "Falkland Islands (Malvinas)",
+		"alpha-2": "FK",
+		"alpha-3": "FLK",
+		"country-code": "238"
+	},
+	{
+		"name": "Faroe Islands",
+		"alpha-2": "FO",
+		"alpha-3": "FRO",
+		"country-code": "234"
+	},
+	{
+		"name": "Fiji",
+		"alpha-2": "FJ",
+		"alpha-3": "FJI",
+		"country-code": "242"
+	},
+	{
+		"name": "Finland",
+		"alpha-2": "FI",
+		"alpha-3": "FIN",
+		"country-code": "246"
+	},
+	{
+		"name": "France",
+		"alpha-2": "FR",
+		"alpha-3": "FRA",
+		"country-code": "250"
+	},
+	{
+		"name": "French Guiana",
+		"alpha-2": "GF",
+		"alpha-3": "GUF",
+		"country-code": "254"
+	},
+	{
+		"name": "French Polynesia",
+		"alpha-2": "PF",
+		"alpha-3": "PYF",
+		"country-code": "258"
+	},
+	{
+		"name": "French Southern Territories",
+		"alpha-2": "TF",
+		"alpha-3": "ATF",
+		"country-code": "260"
+	},
+	{
+		"name": "Gabon",
+		"alpha-2": "GA",
+		"alpha-3": "GAB",
+		"country-code": "266"
+	},
+	{
+		"name": "Gambia",
+		"alpha-2": "GM",
+		"alpha-3": "GMB",
+		"country-code": "270"
+	},
+	{
+		"name": "Georgia",
+		"alpha-2": "GE",
+		"alpha-3": "GEO",
+		"country-code": "268"
+	},
+	{
+		"name": "Germany",
+		"alpha-2": "DE",
+		"alpha-3": "DEU",
+		"country-code": "276"
+	},
+	{
+		"name": "Ghana",
+		"alpha-2": "GH",
+		"alpha-3": "GHA",
+		"country-code": "288"
+	},
+	{
+		"name": "Gibraltar",
+		"alpha-2": "GI",
+		"alpha-3": "GIB",
+		"country-code": "292"
+	},
+	{
+		"name": "Greece",
+		"alpha-2": "GR",
+		"alpha-3": "GRC",
+		"country-code": "300"
+	},
+	{
+		"name": "Greenland",
+		"alpha-2": "GL",
+		"alpha-3": "GRL",
+		"country-code": "304"
+	},
+	{
+		"name": "Grenada",
+		"alpha-2": "GD",
+		"alpha-3": "GRD",
+		"country-code": "308"
+	},
+	{
+		"name": "Guadeloupe",
+		"alpha-2": "GP",
+		"alpha-3": "GLP",
+		"country-code": "312"
+	},
+	{
+		"name": "Guam",
+		"alpha-2": "GU",
+		"alpha-3": "GUM",
+		"country-code": "316"
+	},
+	{
+		"name": "Guatemala",
+		"alpha-2": "GT",
+		"alpha-3": "GTM",
+		"country-code": "320"
+	},
+	{
+		"name": "Guernsey",
+		"alpha-2": "GG",
+		"alpha-3": "GGY",
+		"country-code": "831"
+	},
+	{
+		"name": "Guinea",
+		"alpha-2": "GN",
+		"alpha-3": "GIN",
+		"country-code": "324"
+	},
+	{
+		"name": "Guinea-Bissau",
+		"alpha-2": "GW",
+		"alpha-3": "GNB",
+		"country-code": "624"
+	},
+	{
+		"name": "Guyana",
+		"alpha-2": "GY",
+		"alpha-3": "GUY",
+		"country-code": "328"
+	},
+	{
+		"name": "Haiti",
+		"alpha-2": "HT",
+		"alpha-3": "HTI",
+		"country-code": "332"
+	},
+	{
+		"name": "Heard Island and McDonald Islands",
+		"alpha-2": "HM",
+		"alpha-3": "HMD",
+		"country-code": "334"
+	},
+	{
+		"name": "Holy See",
+		"alpha-2": "VA",
+		"alpha-3": "VAT",
+		"country-code": "336"
+	},
+	{
+		"name": "Honduras",
+		"alpha-2": "HN",
+		"alpha-3": "HND",
+		"country-code": "340"
+	},
+	{
+		"name": "Hong Kong",
+		"alpha-2": "HK",
+		"alpha-3": "HKG",
+		"country-code": "344"
+	},
+	{
+		"name": "Hungary",
+		"alpha-2": "HU",
+		"alpha-3": "HUN",
+		"country-code": "348"
+	},
+	{
+		"name": "Iceland",
+		"alpha-2": "IS",
+		"alpha-3": "ISL",
+		"country-code": "352"
+	},
+	{
+		"name": "India",
+		"alpha-2": "IN",
+		"alpha-3": "IND",
+		"country-code": "356"
+	},
+	{
+		"name": "Indonesia",
+		"alpha-2": "ID",
+		"alpha-3": "IDN",
+		"country-code": "360"
+	},
+	{
+		"name": "Iran (Islamic Republic of)",
+		"alpha-2": "IR",
+		"alpha-3": "IRN",
+		"country-code": "364"
+	},
+	{
+		"name": "Iraq",
+		"alpha-2": "IQ",
+		"alpha-3": "IRQ",
+		"country-code": "368"
+	},
+	{
+		"name": "Ireland",
+		"alpha-2": "IE",
+		"alpha-3": "IRL",
+		"country-code": "372"
+	},
+	{
+		"name": "Isle of Man",
+		"alpha-2": "IM",
+		"alpha-3": "IMN",
+		"country-code": "833"
+	},
+	{
+		"name": "Israel",
+		"alpha-2": "IL",
+		"alpha-3": "ISR",
+		"country-code": "376"
+	},
+	{
+		"name": "Italy",
+		"alpha-2": "IT",
+		"alpha-3": "ITA",
+		"country-code": "380"
+	},
+	{
+		"name": "Jamaica",
+		"alpha-2": "JM",
+		"alpha-3": "JAM",
+		"country-code": "388"
+	},
+	{
+		"name": "Japan",
+		"alpha-2": "JP",
+		"alpha-3": "JPN",
+		"country-code": "392"
+	},
+	{
+		"name": "Jersey",
+		"alpha-2": "JE",
+		"alpha-3": "JEY",
+		"country-code": "832"
+	},
+	{
+		"name": "Jordan",
+		"alpha-2": "JO",
+		"alpha-3": "JOR",
+		"country-code": "400"
+	},
+	{
+		"name": "Kazakhstan",
+		"alpha-2": "KZ",
+		"alpha-3": "KAZ",
+		"country-code": "398"
+	},
+	{
+		"name": "Kenya",
+		"alpha-2": "KE",
+		"alpha-3": "KEN",
+		"country-code": "404"
+	},
+	{
+		"name": "Kiribati",
+		"alpha-2": "KI",
+		"alpha-3": "KIR",
+		"country-code": "296"
+	},
+	{
+		"name": "Korea (Democratic People's Republic of)",
+		"alpha-2": "KP",
+		"alpha-3": "PRK",
+		"country-code": "408"
+	},
+	{
+		"name": "Korea, Republic of",
+		"alpha-2": "KR",
+		"alpha-3": "KOR",
+		"country-code": "410"
+	},
+	{
+		"name": "Kuwait",
+		"alpha-2": "KW",
+		"alpha-3": "KWT",
+		"country-code": "414"
+	},
+	{
+		"name": "Kyrgyzstan",
+		"alpha-2": "KG",
+		"alpha-3": "KGZ",
+		"country-code": "417"
+	},
+	{
+		"name": "Lao People's Democratic Republic",
+		"alpha-2": "LA",
+		"alpha-3": "LAO",
+		"country-code": "418"
+	},
+	{
+		"name": "Latvia",
+		"alpha-2": "LV",
+		"alpha-3": "LVA",
+		"country-code": "428"
+	},
+	{
+		"name": "Lebanon",
+		"alpha-2": "LB",
+		"alpha-3": "LBN",
+		"country-code": "422"
+	},
+	{
+		"name": "Lesotho",
+		"alpha-2": "LS",
+		"alpha-3": "LSO",
+		"country-code": "426"
+	},
+	{
+		"name": "Liberia",
+		"alpha-2": "LR",
+		"alpha-3": "LBR",
+		"country-code": "430"
+	},
+	{
+		"name": "Libya",
+		"alpha-2": "LY",
+		"alpha-3": "LBY",
+		"country-code": "434"
+	},
+	{
+		"name": "Liechtenstein",
+		"alpha-2": "LI",
+		"alpha-3": "LIE",
+		"country-code": "438"
+	},
+	{
+		"name": "Lithuania",
+		"alpha-2": "LT",
+		"alpha-3": "LTU",
+		"country-code": "440"
+	},
+	{
+		"name": "Luxembourg",
+		"alpha-2": "LU",
+		"alpha-3": "LUX",
+		"country-code": "442"
+	},
+	{
+		"name": "Macao",
+		"alpha-2": "MO",
+		"alpha-3": "MAC",
+		"country-code": "446"
+	},
+	{
+		"name": "Madagascar",
+		"alpha-2": "MG",
+		"alpha-3": "MDG",
+		"country-code": "450"
+	},
+	{
+		"name": "Malawi",
+		"alpha-2": "MW",
+		"alpha-3": "MWI",
+		"country-code": "454"
+	},
+	{
+		"name": "Malaysia",
+		"alpha-2": "MY",
+		"alpha-3": "MYS",
+		"country-code": "458"
+	},
+	{
+		"name": "Maldives",
+		"alpha-2": "MV",
+		"alpha-3": "MDV",
+		"country-code": "462"
+	},
+	{
+		"name": "Mali",
+		"alpha-2": "ML",
+		"alpha-3": "MLI",
+		"country-code": "466"
+	},
+	{
+		"name": "Malta",
+		"alpha-2": "MT",
+		"alpha-3": "MLT",
+		"country-code": "470"
+	},
+	{
+		"name": "Marshall Islands",
+		"alpha-2": "MH",
+		"alpha-3": "MHL",
+		"country-code": "584"
+	},
+	{
+		"name": "Martinique",
+		"alpha-2": "MQ",
+		"alpha-3": "MTQ",
+		"country-code": "474"
+	},
+	{
+		"name": "Mauritania",
+		"alpha-2": "MR",
+		"alpha-3": "MRT",
+		"country-code": "478"
+	},
+	{
+		"name": "Mauritius",
+		"alpha-2": "MU",
+		"alpha-3": "MUS",
+		"country-code": "480"
+	},
+	{
+		"name": "Mayotte",
+		"alpha-2": "YT",
+		"alpha-3": "MYT",
+		"country-code": "175"
+	},
+	{
+		"name": "Mexico",
+		"alpha-2": "MX",
+		"alpha-3": "MEX",
+		"country-code": "484"
+	},
+	{
+		"name": "Micronesia (Federated States of)",
+		"alpha-2": "FM",
+		"alpha-3": "FSM",
+		"country-code": "583"
+	},
+	{
+		"name": "Moldova, Republic of",
+		"alpha-2": "MD",
+		"alpha-3": "MDA",
+		"country-code": "498"
+	},
+	{
+		"name": "Monaco",
+		"alpha-2": "MC",
+		"alpha-3": "MCO",
+		"country-code": "492"
+	},
+	{
+		"name": "Mongolia",
+		"alpha-2": "MN",
+		"alpha-3": "MNG",
+		"country-code": "496"
+	},
+	{
+		"name": "Montenegro",
+		"alpha-2": "ME",
+		"alpha-3": "MNE",
+		"country-code": "499"
+	},
+	{
+		"name": "Montserrat",
+		"alpha-2": "MS",
+		"alpha-3": "MSR",
+		"country-code": "500"
+	},
+	{
+		"name": "Morocco",
+		"alpha-2": "MA",
+		"alpha-3": "MAR",
+		"country-code": "504"
+	},
+	{
+		"name": "Mozambique",
+		"alpha-2": "MZ",
+		"alpha-3": "MOZ",
+		"country-code": "508"
+	},
+	{
+		"name": "Myanmar",
+		"alpha-2": "MM",
+		"alpha-3": "MMR",
+		"country-code": "104"
+	},
+	{
+		"name": "Namibia",
+		"alpha-2": "NA",
+		"alpha-3": "NAM",
+		"country-code": "516"
+	},
+	{
+		"name": "Nauru",
+		"alpha-2": "NR",
+		"alpha-3": "NRU",
+		"country-code": "520"
+	},
+	{
+		"name": "Nepal",
+		"alpha-2": "NP",
+		"alpha-3": "NPL",
+		"country-code": "524"
+	},
+	{
+		"name": "Netherlands",
+		"alpha-2": "NL",
+		"alpha-3": "NLD",
+		"country-code": "528"
+	},
+	{
+		"name": "New Caledonia",
+		"alpha-2": "NC",
+		"alpha-3": "NCL",
+		"country-code": "540"
+	},
+	{
+		"name": "New Zealand",
+		"alpha-2": "NZ",
+		"alpha-3": "NZL",
+		"country-code": "554"
+	},
+	{
+		"name": "Nicaragua",
+		"alpha-2": "NI",
+		"alpha-3": "NIC",
+		"country-code": "558"
+	},
+	{
+		"name": "Niger",
+		"alpha-2": "NE",
+		"alpha-3": "NER",
+		"country-code": "562"
+	},
+	{
+		"name": "Nigeria",
+		"alpha-2": "NG",
+		"alpha-3": "NGA",
+		"country-code": "566"
+	},
+	{
+		"name": "Niue",
+		"alpha-2": "NU",
+		"alpha-3": "NIU",
+		"country-code": "570"
+	},
+	{
+		"name": "Norfolk Island",
+		"alpha-2": "NF",
+		"alpha-3": "NFK",
+		"country-code": "574"
+	},
+	{
+		"name": "North Macedonia",
+		"alpha-2": "MK",
+		"alpha-3": "MKD",
+		"country-code": "807"
+	},
+	{
+		"name": "Northern Mariana Islands",
+		"alpha-2": "MP",
+		"alpha-3": "MNP",
+		"country-code": "580"
+	},
+	{
+		"name": "Norway",
+		"alpha-2": "NO",
+		"alpha-3": "NOR",
+		"country-code": "578"
+	},
+	{
+		"name": "Oman",
+		"alpha-2": "OM",
+		"alpha-3": "OMN",
+		"country-code": "512"
+	},
+	{
+		"name": "Pakistan",
+		"alpha-2": "PK",
+		"alpha-3": "PAK",
+		"country-code": "586"
+	},
+	{
+		"name": "Palau",
+		"alpha-2": "PW",
+		"alpha-3": "PLW",
+		"country-code": "585"
+	},
+	{
+		"name": "Palestine, State of",
+		"alpha-2": "PS",
+		"alpha-3": "PSE",
+		"country-code": "275"
+	},
+	{
+		"name": "Panama",
+		"alpha-2": "PA",
+		"alpha-3": "PAN",
+		"country-code": "591"
+	},
+	{
+		"name": "Papua New Guinea",
+		"alpha-2": "PG",
+		"alpha-3": "PNG",
+		"country-code": "598"
+	},
+	{
+		"name": "Paraguay",
+		"alpha-2": "PY",
+		"alpha-3": "PRY",
+		"country-code": "600"
+	},
+	{
+		"name": "Peru",
+		"alpha-2": "PE",
+		"alpha-3": "PER",
+		"country-code": "604"
+	},
+	{
+		"name": "Philippines",
+		"alpha-2": "PH",
+		"alpha-3": "PHL",
+		"country-code": "608"
+	},
+	{
+		"name": "Pitcairn",
+		"alpha-2": "PN",
+		"alpha-3": "PCN",
+		"country-code": "612"
+	},
+	{
+		"name": "Poland",
+		"alpha-2": "PL",
+		"alpha-3": "POL",
+		"country-code": "616"
+	},
+	{
+		"name": "Portugal",
+		"alpha-2": "PT",
+		"alpha-3": "PRT",
+		"country-code": "620"
+	},
+	{
+		"name": "Puerto Rico",
+		"alpha-2": "PR",
+		"alpha-3": "PRI",
+		"country-code": "630"
+	},
+	{
+		"name": "Qatar",
+		"alpha-2": "QA",
+		"alpha-3": "QAT",
+		"country-code": "634"
+	},
+	{
+		"name": "Réunion",
+		"alpha-2": "RE",
+		"alpha-3": "REU",
+		"country-code": "638"
+	},
+	{
+		"name": "Romania",
+		"alpha-2": "RO",
+		"alpha-3": "ROU",
+		"country-code": "642"
+	},
+	{
+		"name": "Russian Federation",
+		"alpha-2": "RU",
+		"alpha-3": "RUS",
+		"country-code": "643"
+	},
+	{
+		"name": "Rwanda",
+		"alpha-2": "RW",
+		"alpha-3": "RWA",
+		"country-code": "646"
+	},
+	{
+		"name": "Saint Barthélemy",
+		"alpha-2": "BL",
+		"alpha-3": "BLM",
+		"country-code": "652"
+	},
+	{
+		"name": "Saint Helena, Ascension and Tristan da Cunha",
+		"alpha-2": "SH",
+		"alpha-3": "SHN",
+		"country-code": "654"
+	},
+	{
+		"name": "Saint Kitts and Nevis",
+		"alpha-2": "KN",
+		"alpha-3": "KNA",
+		"country-code": "659"
+	},
+	{
+		"name": "Saint Lucia",
+		"alpha-2": "LC",
+		"alpha-3": "LCA",
+		"country-code": "662"
+	},
+	{
+		"name": "Saint Martin (French part)",
+		"alpha-2": "MF",
+		"alpha-3": "MAF",
+		"country-code": "663"
+	},
+	{
+		"name": "Saint Pierre and Miquelon",
+		"alpha-2": "PM",
+		"alpha-3": "SPM",
+		"country-code": "666"
+	},
+	{
+		"name": "Saint Vincent and the Grenadines",
+		"alpha-2": "VC",
+		"alpha-3": "VCT",
+		"country-code": "670"
+	},
+	{
+		"name": "Samoa",
+		"alpha-2": "WS",
+		"alpha-3": "WSM",
+		"country-code": "882"
+	},
+	{
+		"name": "San Marino",
+		"alpha-2": "SM",
+		"alpha-3": "SMR",
+		"country-code": "674"
+	},
+	{
+		"name": "Sao Tome and Principe",
+		"alpha-2": "ST",
+		"alpha-3": "STP",
+		"country-code": "678"
+	},
+	{
+		"name": "Saudi Arabia",
+		"alpha-2": "SA",
+		"alpha-3": "SAU",
+		"country-code": "682"
+	},
+	{
+		"name": "Senegal",
+		"alpha-2": "SN",
+		"alpha-3": "SEN",
+		"country-code": "686"
+	},
+	{
+		"name": "Serbia",
+		"alpha-2": "RS",
+		"alpha-3": "SRB",
+		"country-code": "688"
+	},
+	{
+		"name": "Seychelles",
+		"alpha-2": "SC",
+		"alpha-3": "SYC",
+		"country-code": "690"
+	},
+	{
+		"name": "Sierra Leone",
+		"alpha-2": "SL",
+		"alpha-3": "SLE",
+		"country-code": "694"
+	},
+	{
+		"name": "Singapore",
+		"alpha-2": "SG",
+		"alpha-3": "SGP",
+		"country-code": "702"
+	},
+	{
+		"name": "Sint Maarten (Dutch part)",
+		"alpha-2": "SX",
+		"alpha-3": "SXM",
+		"country-code": "534"
+	},
+	{
+		"name": "Slovakia",
+		"alpha-2": "SK",
+		"alpha-3": "SVK",
+		"country-code": "703"
+	},
+	{
+		"name": "Slovenia",
+		"alpha-2": "SI",
+		"alpha-3": "SVN",
+		"country-code": "705"
+	},
+	{
+		"name": "Solomon Islands",
+		"alpha-2": "SB",
+		"alpha-3": "SLB",
+		"country-code": "090"
+	},
+	{
+		"name": "Somalia",
+		"alpha-2": "SO",
+		"alpha-3": "SOM",
+		"country-code": "706"
+	},
+	{
+		"name": "South Africa",
+		"alpha-2": "ZA",
+		"alpha-3": "ZAF",
+		"country-code": "710"
+	},
+	{
+		"name": "South Georgia and the South Sandwich Islands",
+		"alpha-2": "GS",
+		"alpha-3": "SGS",
+		"country-code": "239"
+	},
+	{
+		"name": "South Sudan",
+		"alpha-2": "SS",
+		"alpha-3": "SSD",
+		"country-code": "728"
+	},
+	{
+		"name": "Spain",
+		"alpha-2": "ES",
+		"alpha-3": "ESP",
+		"country-code": "724"
+	},
+	{
+		"name": "Sri Lanka",
+		"alpha-2": "LK",
+		"alpha-3": "LKA",
+		"country-code": "144"
+	},
+	{
+		"name": "Sudan",
+		"alpha-2": "SD",
+		"alpha-3": "SDN",
+		"country-code": "729"
+	},
+	{
+		"name": "Suriname",
+		"alpha-2": "SR",
+		"alpha-3": "SUR",
+		"country-code": "740"
+	},
+	{
+		"name": "Svalbard and Jan Mayen",
+		"alpha-2": "SJ",
+		"alpha-3": "SJM",
+		"country-code": "744"
+	},
+	{
+		"name": "Sweden",
+		"alpha-2": "SE",
+		"alpha-3": "SWE",
+		"country-code": "752"
+	},
+	{
+		"name": "Switzerland",
+		"alpha-2": "CH",
+		"alpha-3": "CHE",
+		"country-code": "756"
+	},
+	{
+		"name": "Syrian Arab Republic",
+		"alpha-2": "SY",
+		"alpha-3": "SYR",
+		"country-code": "760"
+	},
+	{
+		"name": "Taiwan",
+		"alpha-2": "TW",
+		"alpha-3": "TWN",
+		"country-code": "158"
+	},
+	{
+		"name": "Tajikistan",
+		"alpha-2": "TJ",
+		"alpha-3": "TJK",
+		"country-code": "762"
+	},
+	{
+		"name": "Tanzania, United Republic of",
+		"alpha-2": "TZ",
+		"alpha-3": "TZA",
+		"country-code": "834"
+	},
+	{
+		"name": "Thailand",
+		"alpha-2": "TH",
+		"alpha-3": "THA",
+		"country-code": "764"
+	},
+	{
+		"name": "Timor-Leste",
+		"alpha-2": "TL",
+		"alpha-3": "TLS",
+		"country-code": "626"
+	},
+	{
+		"name": "Togo",
+		"alpha-2": "TG",
+		"alpha-3": "TGO",
+		"country-code": "768"
+	},
+	{
+		"name": "Tokelau",
+		"alpha-2": "TK",
+		"alpha-3": "TKL",
+		"country-code": "772"
+	},
+	{
+		"name": "Tonga",
+		"alpha-2": "TO",
+		"alpha-3": "TON",
+		"country-code": "776"
+	},
+	{
+		"name": "Trinidad and Tobago",
+		"alpha-2": "TT",
+		"alpha-3": "TTO",
+		"country-code": "780"
+	},
+	{
+		"name": "Tunisia",
+		"alpha-2": "TN",
+		"alpha-3": "TUN",
+		"country-code": "788"
+	},
+	{
+		"name": "Turkey",
+		"alpha-2": "TR",
+		"alpha-3": "TUR",
+		"country-code": "792"
+	},
+	{
+		"name": "Turkmenistan",
+		"alpha-2": "TM",
+		"alpha-3": "TKM",
+		"country-code": "795"
+	},
+	{
+		"name": "Turks and Caicos Islands",
+		"alpha-2": "TC",
+		"alpha-3": "TCA",
+		"country-code": "796"
+	},
+	{
+		"name": "Tuvalu",
+		"alpha-2": "TV",
+		"alpha-3": "TUV",
+		"country-code": "798"
+	},
+	{
+		"name": "Uganda",
+		"alpha-2": "UG",
+		"alpha-3": "UGA",
+		"country-code": "800"
+	},
+	{
+		"name": "Ukraine",
+		"alpha-2": "UA",
+		"alpha-3": "UKR",
+		"country-code": "804"
+	},
+	{
+		"name": "United Arab Emirates",
+		"alpha-2": "AE",
+		"alpha-3": "ARE",
+		"country-code": "784"
+	},
+	{
+		"name": "United Kingdom",
+		"alpha-2": "GB",
+		"alpha-3": "GBR",
+		"country-code": "826"
+	},
+	{
+		"name": "America",
+		"alpha-2": "US",
+		"alpha-3": "USA",
+		"country-code": "840"
+	},
+	{
+		"name": "United States Minor Outlying Islands",
+		"alpha-2": "UM",
+		"alpha-3": "UMI",
+		"country-code": "581"
+	},
+	{
+		"name": "Uruguay",
+		"alpha-2": "UY",
+		"alpha-3": "URY",
+		"country-code": "858"
+	},
+	{
+		"name": "Uzbekistan",
+		"alpha-2": "UZ",
+		"alpha-3": "UZB",
+		"country-code": "860"
+	},
+	{
+		"name": "Vanuatu",
+		"alpha-2": "VU",
+		"alpha-3": "VUT",
+		"country-code": "548"
+	},
+	{
+		"name": "Venezuela (Bolivarian Republic of)",
+		"alpha-2": "VE",
+		"alpha-3": "VEN",
+		"country-code": "862"
+	},
+	{
+		"name": "Vietnam",
+		"alpha-2": "VN",
+		"alpha-3": "VNM",
+		"country-code": "704"
+	},
+	{
+		"name": "Virgin Islands (British)",
+		"alpha-2": "VG",
+		"alpha-3": "VGB",
+		"country-code": "092"
+	},
+	{
+		"name": "Virgin Islands (U.S.)",
+		"alpha-2": "VI",
+		"alpha-3": "VIR",
+		"country-code": "850"
+	},
+	{
+		"name": "Wallis and Futuna",
+		"alpha-2": "WF",
+		"alpha-3": "WLF",
+		"country-code": "876"
+	},
+	{
+		"name": "Western Sahara",
+		"alpha-2": "EH",
+		"alpha-3": "ESH",
+		"country-code": "732"
+	},
+	{
+		"name": "Yemen",
+		"alpha-2": "YE",
+		"alpha-3": "YEM",
+		"country-code": "887"
+	},
+	{
+		"name": "Zambia",
+		"alpha-2": "ZM",
+		"alpha-3": "ZMB",
+		"country-code": "894"
+	},
+	{
+		"name": "Zimbabwe",
+		"alpha-2": "ZW",
+		"alpha-3": "ZWE",
+		"country-code": "716"
+	}
+];
+
+//#endregion
+//#region src/api/search-analytics/breakdowns.ts
+/**
+* Fetches device breakdown (desktop, mobile, tablet) with period comparison.
+*/
+async function fetchDevicesWithComparison(client, siteUrl, options = {}) {
+	const [current, previous] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["device"]
+	}).then((res) => {
+		return (res.rows || []).map((row) => {
+			return {
+				...row,
+				dimension: "device",
+				device: row.keys?.[0] || "unknown",
+				keys: null,
+				clicks: Number(row.clicks) || 0,
+				impressions: Number(row.impressions) || 0,
+				ctr: Number(row.ctr) || 0,
+				position: Number(row.position) || 0
+			};
+		});
+	}), options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...options,
+			period: options.prevPeriod
+		}),
+		dimensions: ["device"]
+	}).then((res) => {
+		return (res.rows || []).map((row) => {
+			return {
+				...row,
+				dimension: "device",
+				device: row.keys?.[0] || "unknown",
+				keys: null,
+				clicks: Number(row.clicks) || 0,
+				impressions: Number(row.impressions) || 0,
+				ctr: Number(row.ctr) || 0,
+				position: Number(row.position) || 0
+			};
+		});
+	}) : Promise.resolve([])]);
+	return {
+		current,
+		previous,
+		metadata: {
+			currentCount: current.length,
+			previousCount: previous.length
+		}
+	};
+}
+/**
+* Fetches device breakdown (desktop, mobile, tablet).
+*/
+async function fetchDevices(client, siteUrl, options = {}) {
+	return client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["device"]
+	}).then((res) => {
+		return (res.rows || []).map((row) => {
+			return {
+				...row,
+				dimension: "device",
+				device: row.keys?.[0] || "unknown",
+				keys: null,
+				clicks: Number(row.clicks) || 0,
+				impressions: Number(row.impressions) || 0,
+				ctr: Number(row.ctr) || 0,
+				position: Number(row.position) || 0
+			};
+		});
+	});
+}
+function fixCountryRows(res) {
+	return (res.rows || []).map((row) => {
+		const alpha3Code = row.keys?.[0] || "";
+		const country$1 = countries_default.find((c) => c["alpha-3"].toLowerCase() === alpha3Code);
+		return {
+			...row,
+			dimension: "country",
+			countryCodeGsc: alpha3Code,
+			country: country$1?.name || alpha3Code,
+			countryCode: country$1?.["alpha-2"] || alpha3Code,
+			keys: null
+		};
+	});
+}
+/**
+* Fetches top countries by traffic with period comparison and keyword counts per country.
+*/
+async function fetchCountriesWithComparison(client, siteUrl, options = {}) {
+	const [current, previous] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["country"],
+		rowLimit: 5
+	}).then(fixCountryRows), options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...options,
+			period: options.prevPeriod
+		}),
+		dimensions: ["country"],
+		rowLimit: 5
+	}).then(fixCountryRows) : Promise.resolve([])]);
+	const keywordCounts = await Promise.all(current.map((row) => {
+		return client.searchAnalytics.query(siteUrl, {
+			...createQueryBody({
+				...options,
+				filters: [{
+					dimension: "country",
+					operator: "equals",
+					expression: row.countryCodeGsc
+				}]
+			}),
+			dimensions: ["query"]
+		}).then((res) => ({
+			countryCodeGsc: row.countryCodeGsc,
+			keywords: res.rows?.length || 0
+		})).catch(() => ({
+			countryCodeGsc: row.countryCodeGsc,
+			keywords: 0
+		}));
+	}));
+	for (const row of current) {
+		const keywordCount = keywordCounts.find((k) => k.countryCodeGsc === row.countryCodeGsc);
+		if (keywordCount) row.keywords = keywordCount.keywords;
+	}
+	return {
+		current,
+		previous,
+		metadata: {
+			currentCount: current.length,
+			previousCount: previous.length,
+			totalKeywords: keywordCounts.reduce((sum, k) => sum + k.keywords, 0)
+		}
+	};
+}
+/**
+* Fetches top countries by traffic.
+*/
+async function fetchCountries(client, siteUrl, options = {}) {
+	return client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["country"],
+		rowLimit: 5
+	}).then(fixCountryRows);
+}
+/**
+* Fetches search appearance breakdown (AMP, rich results, etc.) with period comparison.
+*/
+async function fetchSearchAppearanceWithComparison(client, siteUrl, options = {}) {
+	const [current, previous] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["searchAppearance"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		dimension: "searchAppearance",
+		searchAppearance: row.keys?.[0] || "unknown",
+		keys: null,
+		clicks: Number(row.clicks) || 0,
+		impressions: Number(row.impressions) || 0,
+		ctr: Number(row.ctr) || 0,
+		position: Number(row.position) || 0
+	}))), options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...options,
+			period: options.prevPeriod
+		}),
+		dimensions: ["searchAppearance"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		dimension: "searchAppearance",
+		searchAppearance: row.keys?.[0] || "unknown",
+		keys: null,
+		clicks: Number(row.clicks) || 0,
+		impressions: Number(row.impressions) || 0,
+		ctr: Number(row.ctr) || 0,
+		position: Number(row.position) || 0
+	}))) : Promise.resolve([])]);
+	return {
+		current,
+		previous,
+		metadata: {
+			currentCount: current.length,
+			previousCount: previous.length
+		}
+	};
+}
+/**
+* Fetches search appearance breakdown (AMP, rich results, etc.).
+*/
+async function fetchSearchAppearance(client, siteUrl, options = {}) {
+	return client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["searchAppearance"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		dimension: "searchAppearance",
+		searchAppearance: row.keys?.[0] || "unknown",
+		keys: null,
+		clicks: Number(row.clicks) || 0,
+		impressions: Number(row.impressions) || 0,
+		ctr: Number(row.ctr) || 0,
+		position: Number(row.position) || 0
+	})));
+}
+
+//#endregion
+//#region src/api/search-analytics/dates.ts
+function computeTotals(rows) {
+	if (!rows.length) return {
+		clicks: 0,
+		impressions: 0,
+		ctr: 0,
+		position: 0
+	};
+	return {
+		clicks: rows.reduce((sum, r) => sum + (r.clicks || 0), 0),
+		impressions: rows.reduce((sum, r) => sum + (r.impressions || 0), 0),
+		ctr: rows.reduce((sum, r) => sum + (r.ctr || 0), 0) / rows.length,
+		position: rows.reduce((sum, r) => sum + (r.position || 0), 0) / rows.length
+	};
+}
+/**
+* Fetches daily search analytics data with period-over-period comparison.
+*/
+async function fetchDatesWithComparison(client, siteUrl, options = {}) {
+	const [current, previous] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({ ...options }),
+		dimensions: ["date"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		dimension: "date",
+		date: row.keys?.[0] || "",
+		keys: null
+	}))), options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...options,
+			period: options.prevPeriod
+		}),
+		dimensions: ["date"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		dimension: "date",
+		date: row.keys?.[0] || "",
+		keys: null
+	}))) : Promise.resolve([])]);
+	const currentTotals = computeTotals(current);
+	const previousTotals = computeTotals(previous);
+	return {
+		current,
+		previous,
+		metadata: {
+			currentCount: current.length,
+			previousCount: previous.length,
+			totals: {
+				current: currentTotals,
+				previous: previousTotals,
+				clicksPercent: percentDifference(currentTotals.clicks, previousTotals.clicks),
+				impressionsPercent: percentDifference(currentTotals.impressions, previousTotals.impressions),
+				ctrPercent: percentDifference(currentTotals.ctr, previousTotals.ctr),
+				positionPercent: percentDifference(currentTotals.position, previousTotals.position)
+			}
+		}
+	};
+}
+/**
+* Fetches year-over-year comparison for site metrics.
+* GSC has ~16 months history, so works for periods up to ~4 months.
+*/
+async function fetchYoYComparison(client, siteUrl, options = {}) {
+	const { period = {
+		start: dayjs().subtract(28, "day").toDate(),
+		end: dayjs().toDate()
+	} } = options;
+	const startDate = dayjs(period.start);
+	const endDate = dayjs(period.end);
+	const periodDays = endDate.diff(startDate, "day");
+	const prevStart = startDate.subtract(1, "year");
+	const prevEnd = endDate.subtract(1, "year");
+	const withinLimit = dayjs().diff(prevStart, "day") <= 480;
+	const [currentRes, previousRes] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({ period }),
+		dimensions: ["date"]
+	}), withinLimit ? client.searchAnalytics.query(siteUrl, {
+		startDate: formatDateGsc(prevStart.toDate()) || "",
+		endDate: formatDateGsc(prevEnd.toDate()) || "",
+		dimensions: ["date"],
+		rowLimit: 25e3
+	}) : Promise.resolve({ rows: [] })]);
+	const currentRows = currentRes.rows || [];
+	const previousRows = previousRes.rows || [];
+	const sumMetrics = (rows) => {
+		if (!rows.length) return {
+			clicks: 0,
+			impressions: 0,
+			ctr: 0,
+			position: 0
+		};
+		return {
+			clicks: rows.reduce((sum, r) => sum + (r.clicks || 0), 0),
+			impressions: rows.reduce((sum, r) => sum + (r.impressions || 0), 0),
+			ctr: rows.reduce((sum, r) => sum + (r.ctr || 0), 0) / rows.length,
+			position: rows.reduce((sum, r) => sum + (r.position || 0), 0) / rows.length
+		};
+	};
+	const current = sumMetrics(currentRows);
+	const previous = sumMetrics(previousRows);
+	return {
+		current,
+		previous,
+		change: {
+			clicks: current.clicks - previous.clicks,
+			clicksPercent: percentDifference(current.clicks, previous.clicks),
+			impressions: current.impressions - previous.impressions,
+			impressionsPercent: percentDifference(current.impressions, previous.impressions),
+			ctr: current.ctr - previous.ctr,
+			ctrPercent: percentDifference(current.ctr, previous.ctr),
+			position: current.position - previous.position,
+			positionPercent: percentDifference(current.position, previous.position)
+		},
+		periodDays,
+		withinLimit
+	};
+}
+/**
+* Fetches daily search analytics data for a site.
+*/
+async function fetchDates(client, siteUrl, options = {}) {
+	return await client.searchAnalytics.query(siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["date"]
+	}).then((res) => {
+		return (res.rows || []).map((row) => {
+			return {
+				...row,
+				dimension: "date",
+				date: row.keys?.[0] || "",
+				keys: null
+			};
+		});
+	});
+}
+
+//#endregion
+//#region src/api/search-analytics/utils.ts
+function normalizePagePath(page$1, domain) {
+	if (!page$1) return page$1;
+	return page$1.replace("https://", "").replace(domain, "");
+}
+function extractDomain(siteUrl) {
+	return siteUrl.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function formatPageForQuery(page$1, siteUrl) {
+	let p = withBase(page$1, siteUrl);
+	if (p === extractDomain(siteUrl)) p = `${p}/`;
+	return withHttps(p);
+}
+
+//#endregion
+//#region src/api/search-analytics/keywords.ts
+/**
+* Fetches keyword/query performance data with period comparison and associated pages.
+*/
+async function fetchKeywordsWithComparison(client, siteUrl, options = {}) {
+	const [currentKeywords, previousKeywords, pages] = await Promise.all([
+		client.searchAnalytics.query(siteUrl, {
+			...createQueryBody(options),
+			dimensions: ["query"]
+		}).then((res) => res.rows || []),
+		options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+			...createQueryBody({
+				...options,
+				period: options.prevPeriod
+			}),
+			dimensions: ["query"]
+		}).then((res) => res.rows || []) : Promise.resolve([]),
+		client.searchAnalytics.query(siteUrl, {
+			...createQueryBody(options),
+			dimensions: ["page", "query"]
+		}).then((res) => res.rows || [])
+	]);
+	const current = currentKeywords.map((row) => {
+		const prevRow = previousKeywords.find((r) => r.keys?.[0] === row.keys?.[0]);
+		const pageMatch = pages.find((r) => r.keys?.[1] === row.keys?.[0]);
+		const position = row.position ?? 0;
+		const ctr = row.ctr ?? 0;
+		const prevPosition = prevRow?.position ?? 0;
+		const prevCtr = prevRow?.ctr ?? 0;
+		return {
+			...row,
+			dimension: "query",
+			keyword: row.keys?.[0] || "",
+			page: pageMatch?.keys?.[0] ? normalizePagePath(pageMatch.keys[0], siteUrl) : null,
+			position,
+			positionPercent: percentDifference(position, prevPosition),
+			prevPosition,
+			ctr,
+			ctrPercent: percentDifference(ctr, prevCtr),
+			prevCtr,
+			clicks: row.clicks ?? 0,
+			impressions: row.impressions ?? 0,
+			keys: null
+		};
+	});
+	const previous = previousKeywords.map((prevRow) => {
+		const keywordKey = prevRow.keys?.[0] || "";
+		const currentRow = currentKeywords.find((r) => r.keys?.[0] === keywordKey);
+		const pageMatch = pages.find((r) => r.keys?.[1] === keywordKey);
+		if (!currentRow) return {
+			...prevRow,
+			dimension: "query",
+			keyword: keywordKey,
+			page: pageMatch?.keys?.[0] ? normalizePagePath(pageMatch.keys[0], siteUrl) : null,
+			lost: true,
+			clicks: 0,
+			position: 0,
+			ctr: 0,
+			prevCtr: prevRow.ctr ?? 0,
+			prevPosition: prevRow.position ?? 0,
+			prevClicks: prevRow.clicks ?? 0,
+			prevImpressions: prevRow.impressions ?? 0,
+			keys: null
+		};
+		return {
+			...prevRow,
+			dimension: "query",
+			keyword: keywordKey,
+			page: pageMatch?.keys?.[0] ? normalizePagePath(pageMatch.keys[0], siteUrl) : null,
+			keys: null
+		};
+	});
+	return {
+		current,
+		previous,
+		metadata: {
+			currentCount: current.length,
+			previousCount: previous.length,
+			pageMatches: pages.length
+		}
+	};
+}
+/**
+* Fetches all keywords with their performance data using recursive pagination.
+*/
+async function fetchKeywords(client, siteUrl, options = {}) {
+	const { rows } = await queryRecursive(client, siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["query"]
+	});
+	return rows.map((row) => ({
+		...row,
+		dimension: "query",
+		keyword: row.keys?.[0] || "",
+		keys: null
+	}));
+}
+/**
+* Fetches detailed data for a specific keyword including daily trends and top pages.
+*/
+async function fetchKeyword(client, siteUrl, keyword, options = {}) {
+	const { rowLimit = 5, ...queryOptions } = options;
+	const [dates, pages] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...queryOptions,
+			filters: [{
+				dimension: "query",
+				operator: "equals",
+				expression: keyword
+			}]
+		}),
+		dimensions: ["date"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		date: row.keys?.[0] ?? "",
+		keys: null
+	}))), client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...queryOptions,
+			filters: [{
+				dimension: "query",
+				operator: "equals",
+				expression: keyword
+			}]
+		}),
+		rowLimit,
+		dimensions: ["page"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		page: normalizePagePath(row.keys?.[0] || "", extractDomain(siteUrl)),
+		keys: null
+	})))]);
+	return {
+		dates,
+		pages
+	};
+}
+
+//#endregion
+//#region src/api/search-analytics/pages.ts
+/**
+* Fetches all pages with their performance data using recursive pagination.
+*/
+async function fetchPages(client, siteUrl, options = {}) {
+	return (await queryRecursive(client, siteUrl, {
+		...createQueryBody(options),
+		dimensions: ["page"]
+	}).then((d) => d.rows)).map((row) => ({
+		...row,
+		page: row.keys?.[0] || ""
+	}));
+}
+/**
+* Fetches page performance data with period comparison, including top keyword per page.
+*/
+async function fetchPagesWithComparison(client, siteUrl, options = {}) {
+	const [currentPages, previousPages, keywords] = await Promise.all([
+		client.searchAnalytics.query(siteUrl, {
+			...createQueryBody(options),
+			dimensions: ["page"]
+		}).then((res) => res.rows || []),
+		options.prevPeriod ? client.searchAnalytics.query(siteUrl, {
+			...createQueryBody({
+				...options,
+				period: options.prevPeriod
+			}),
+			dimensions: ["page"]
+		}).then((res) => res.rows || []) : Promise.resolve([]),
+		client.searchAnalytics.query(siteUrl, {
+			...createQueryBody(options),
+			dimensions: ["query", "page"]
+		}).then((res) => res.rows || [])
+	]);
+	const current = currentPages.map((row) => {
+		const prevRow = previousPages.find((r) => r.keys?.[0] === row.keys?.[0]);
+		const keyword = keywords.find((r) => r.keys?.[1] === row.keys?.[0]);
+		const clicks = row.clicks ?? 0;
+		const impressions = row.impressions ?? 0;
+		const prevClicks = prevRow?.clicks ?? 0;
+		const prevImpressions = prevRow?.impressions ?? 0;
+		return {
+			...row,
+			dimension: "page",
+			page: row.keys?.[0] || "",
+			keyword: keyword?.keys?.[0] || void 0,
+			keywordPosition: keyword?.position ?? 0,
+			clicks,
+			prevClicks,
+			clicksPercent: percentDifference(clicks, prevClicks),
+			impressions,
+			impressionsPercent: percentDifference(impressions, prevImpressions),
+			prevImpressions,
+			keys: null
+		};
+	});
+	const previous = previousPages.map((prevRow) => {
+		const pageKey = prevRow.keys?.[0] || "";
+		if (!currentPages.find((r) => r.keys?.[0] === pageKey)) return {
+			...prevRow,
+			dimension: "page",
+			page: pageKey,
+			lost: true,
+			clicks: 0,
+			impressions: 0,
+			prevClicks: prevRow.clicks ?? 0,
+			prevImpressions: prevRow.impressions ?? 0,
+			keys: null
+		};
+		return {
+			...prevRow,
+			dimension: "page",
+			page: pageKey,
+			keys: null
+		};
+	});
+	return {
+		current,
+		previous,
+		metadata: {
+			currentCount: current.length,
+			previousCount: previous.length,
+			keywordMatches: keywords.length
+		}
+	};
+}
+/**
+* Fetches detailed data for a specific page including daily trends and top keywords.
+*/
+async function fetchPage(client, siteUrl, url, options = {}) {
+	const { rowLimit = 5, ...queryOptions } = options;
+	const [dates, keywords] = await Promise.all([client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...queryOptions,
+			filters: [{
+				dimension: "page",
+				operator: "equals",
+				expression: formatPageForQuery(url, extractDomain(siteUrl))
+			}]
+		}),
+		dimensions: ["date"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		date: row.keys?.[0] ?? "",
+		keys: null
+	}))), client.searchAnalytics.query(siteUrl, {
+		...createQueryBody({
+			...queryOptions,
+			filters: [{
+				dimension: "page",
+				operator: "equals",
+				expression: formatPageForQuery(url, extractDomain(siteUrl))
+			}]
+		}),
+		rowLimit,
+		dimensions: ["query"]
+	}).then((res) => (res.rows || []).map((row) => ({
+		...row,
+		keyword: row.keys?.[0] || "",
+		keys: null
+	})))]);
+	return {
+		dates,
+		keywords
+	};
+}
+
+//#endregion
+//#region src/api/search-analytics/stream.ts
+const DIMENSION_TO_FIELD = {
+	query: "keyword",
+	page: "page",
+	date: "date",
+	device: "device",
+	country: "country"
+};
+function mapRowToDimensions(row, dimensions) {
+	const { keys, ...metrics } = row;
+	const fields = {};
+	dimensions.forEach((dim, i) => {
+		fields[DIMENSION_TO_FIELD[dim]] = keys?.[i] || "";
+	});
+	return {
+		...metrics,
+		...fields
+	};
+}
+/**
+* Async generator for memory-efficient pagination of GSC search analytics.
+* Yields batches of typed rows as they're fetched, avoiding accumulation in memory.
+*
+* **Design:** Single generic function with type inference replaces separate
+* `fetchPagesStream`, `fetchKeywordsStream` wrappers. Output type is inferred
+* from the dimensions tuple:
+* - `['query']` → `{ keyword: string, clicks, impressions, ctr, position }`
+* - `['page']` → `{ page: string, clicks, impressions, ctr, position }`
+* - `['query', 'page']` → `{ keyword: string, page: string, ... }`
+*
+* Each yield contains up to 25,000 rows (one API page). Use `collectStream()`
+* to gather all batches if full array is needed.
+*
+* @param client - GSC client instance
+* @param siteUrl - Site URL (e.g., 'https://example.com/' or 'sc-domain:example.com')
+* @param query - Query with dimensions array (requires `as const` for type inference)
+*
+* @example
+* ```ts
+* // Stream keyword+page combinations
+* for await (const batch of queryRecursiveStream(client, url, {
+*   dimensions: ['query', 'page'] as const,
+*   startDate: '2024-01-01',
+*   endDate: '2024-01-31',
+* })) {
+*   // batch: { keyword: string, page: string, clicks, impressions, ctr, position }[]
+*   await db.insert(batch)
+* }
+*
+* // Or collect all at once
+* const allRows = await collectStream(queryRecursiveStream(client, url, {
+*   dimensions: ['page'] as const,
+*   startDate: '2024-01-01',
+*   endDate: '2024-01-31',
+* }))
+* ```
+*
+* @remarks
+* - Requires `as const` on dimensions array for proper type inference
+* - Use for large datasets (>25k rows) where memory is a concern
+* - Non-paginating queries (devices, countries) don't benefit from streaming
+*/
+async function* queryRecursiveStream(client, siteUrl, query$1) {
+	const rowLimit = query$1.rowLimit || 25e3;
+	let startRow = 0;
+	while (true) {
+		const rows = (await client.searchAnalytics.query(siteUrl, {
+			...query$1,
+			dimensions: [...query$1.dimensions],
+			startRow,
+			rowLimit
+		})).rows || [];
+		if (rows.length === 0) break;
+		yield rows.map((row) => mapRowToDimensions(row, query$1.dimensions));
+		startRow += rows.length;
+		if (rows.length < rowLimit) break;
+	}
+}
+/** Collect all batches into single array (for testing / simple cases) */
+async function collectStream(gen) {
+	const all = [];
+	for await (const batch of gen) all.push(...batch);
+	return all;
+}
+
+//#endregion
+//#region src/core/client.ts
+const GSC_API = "https://searchconsole.googleapis.com";
+const INDEXING_API = "https://indexing.googleapis.com";
+function createAuth(options) {
+	let credentials = { refresh_token: options.refreshToken };
+	return {
+		get credentials() {
+			return credentials;
+		},
+		async getAccessToken() {
+			if (credentials?.access_token && credentials.expiry_date && credentials.expiry_date > Date.now()) return { token: credentials.access_token };
+			const response = await ofetch("https://oauth2.googleapis.com/token", {
+				method: "POST",
+				body: {
+					client_id: options.clientId,
+					client_secret: options.clientSecret,
+					refresh_token: options.refreshToken,
+					grant_type: "refresh_token"
+				}
+			});
+			credentials = {
+				...credentials,
+				access_token: response.access_token,
+				expiry_date: Date.now() + response.expires_in * 1e3
+			};
+			return { token: response.access_token };
+		}
+	};
+}
+async function resolveToken(auth) {
+	if (typeof auth === "string") return auth;
+	if ("accessToken" in auth && typeof auth.accessToken === "string") return auth.accessToken;
+	if ("getAccessToken" in auth && typeof auth.getAccessToken === "function") {
+		const { token } = await auth.getAccessToken();
+		return token || "";
+	}
+	if ("credentials" in auth && auth.credentials) return auth.credentials.access_token || "";
+	return "";
+}
+function createFetch(auth, options) {
+	const authState = typeof auth === "object" && auth !== null && "clientId" in auth && "refreshToken" in auth && !("getAccessToken" in auth) ? createAuth(auth) : auth;
+	return ofetch.create({
+		...options,
+		retry: 3,
+		retryDelay: 1e3,
+		retryStatusCodes: [
+			408,
+			409,
+			425,
+			429,
+			500,
+			502,
+			503,
+			504
+		],
+		headers: {
+			...options?.headers,
+			"Accept-Encoding": "gzip",
+			"User-Agent": "gscdump (gzip)"
+		},
+		async onRequest({ options: options$1 }) {
+			const token = await resolveToken(authState);
+			if (token) {
+				options$1.headers = new Headers(options$1.headers);
+				options$1.headers.set("Authorization", `Bearer ${token}`);
+			}
+		},
+		async onResponseError(ctx) {
+			if (ctx.response.status === 403) console.error("[gscdump] Permission denied (403). check your service account permissions being added to the GSC property.");
+			if (options?.onResponseError) if (Array.isArray(options.onResponseError)) for (const handler of options.onResponseError) await handler(ctx);
+			else await options.onResponseError(ctx);
+		}
+	});
+}
+function googleSearchConsole(auth, options = {}) {
+	let fetch;
+	const authState = typeof auth === "object" && auth !== null && "clientId" in auth && "refreshToken" in auth && !("getAccessToken" in auth) ? createAuth(auth) : auth;
+	if (options.fetch) fetch = options.fetch;
+	else {
+		const fetchOptions = options.fetchOptions || {};
+		if (options.onRateLimited) {
+			const originalOnError = fetchOptions.onResponseError;
+			fetchOptions.onResponseError = async (ctx) => {
+				if (ctx.response.status === 429) await options.onRateLimited({ response: ctx.response });
+				if (originalOnError) if (Array.isArray(originalOnError)) for (const handler of originalOnError) await handler(ctx);
+				else await originalOnError(ctx);
+			};
+		}
+		fetch = createFetch(authState, fetchOptions);
+	}
+	return {
+		sites: { list: () => fetch(`${GSC_API}/webmasters/v3/sites`) },
+		sitemaps: {
+			list: (siteUrl) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeURIComponent(siteUrl)}/sitemaps`),
+			get: (siteUrl, feedpath) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeURIComponent(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}`),
+			submit: (siteUrl, feedpath) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeURIComponent(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}`, { method: "PUT" }),
+			delete: (siteUrl, feedpath) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeURIComponent(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}`, { method: "DELETE" })
+		},
+		searchAnalytics: { query: (siteUrl, body) => fetch(`${GSC_API}/webmasters/v3/sites/${encodeURIComponent(siteUrl)}/searchAnalytics/query`, {
+			method: "POST",
+			body
+		}) },
+		urlInspection: { inspect: (siteUrl, inspectionUrl) => fetch(`${GSC_API}/v1/urlInspection/index:inspect`, {
+			method: "POST",
+			body: {
+				inspectionUrl,
+				siteUrl
+			}
+		}) },
+		indexing: {
+			publish: (url, type) => fetch(`${INDEXING_API}/v3/urlNotifications:publish`, {
+				method: "POST",
+				body: {
+					url,
+					type
+				}
+			}),
+			getMetadata: (url) => fetch(`${INDEXING_API}/v3/urlNotifications/metadata`, { query: { url } })
+		}
+	};
+}
+
+//#endregion
+//#region src/core/errors.ts
+/** GSC API quota limits (approximate) */
+const GSC_QUOTAS = {
+	searchAnalytics: 25e3,
+	urlInspection: 2e3,
+	indexing: 200
+};
+/**
+* Detects if an error is a quota exceeded error (403 quotaExceeded).
+*/
+function isQuotaError(error) {
+	const msg = getErrorMessage(error).toLowerCase();
+	return getErrorCode(error) === 403 && (msg.includes("quota") || msg.includes("limit exceeded") || msg.includes("rate limit") || msg.includes("quotaexceeded"));
+}
+/**
+* Detects if an error is a rate limit error (429 Too Many Requests).
+*/
+function isRateLimitError(error) {
+	return getErrorCode(error) === 429;
+}
+/**
+* Detects if an error is an authentication error (401/403 without quota).
+*/
+function isAuthError(error) {
+	const code = getErrorCode(error);
+	const msg = getErrorMessage(error).toLowerCase();
+	if (code === 401) return true;
+	if (code === 403 && !isQuotaError(error)) return msg.includes("access") || msg.includes("permission") || msg.includes("forbidden");
+	return false;
+}
+/**
+* Extracts HTTP status code from various error formats.
+*/
+function getErrorCode(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const e = error;
+	if ("statusCode" in e && typeof e.statusCode === "number") return e.statusCode;
+	if ("status" in e && typeof e.status === "number") return e.status;
+	if ("response" in e && e.response && typeof e.response === "object") {
+		const resp = e.response;
+		if ("status" in resp && typeof resp.status === "number") return resp.status;
+	}
+	if ("code" in e && typeof e.code === "number") return e.code;
+}
+/**
+* Extracts error message from various error formats.
+*/
+function getErrorMessage(error) {
+	if (!error) return "Unknown error";
+	if (typeof error === "string") return error;
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object") {
+		const e = error;
+		if ("message" in e && typeof e.message === "string") return e.message;
+		if ("statusMessage" in e && typeof e.statusMessage === "string") return e.statusMessage;
+		if ("data" in e && e.data && typeof e.data === "object") {
+			const data = e.data;
+			if ("error" in data && data.error && typeof data.error === "object") {
+				const err = data.error;
+				if ("message" in err && typeof err.message === "string") return err.message;
+			}
+		}
+	}
+	return String(error);
+}
+/**
+* Extracts retry-after value from error headers (in seconds).
+*/
+function getRetryAfter(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const e = error;
+	if ("headers" in e && e.headers && typeof e.headers === "object") {
+		const headers = e.headers;
+		const retryAfter = headers["retry-after"] || headers["Retry-After"];
+		if (typeof retryAfter === "string") {
+			const seconds = Number.parseInt(retryAfter, 10);
+			return Number.isNaN(seconds) ? void 0 : seconds;
+		}
+		if (typeof retryAfter === "number") return retryAfter;
+	}
+}
+function formatQuotaSuggestion(message, retryAfter) {
+	if (message.includes("Search Console API")) return `You exceeded the Search Analytics quota (${GSC_QUOTAS.searchAnalytics}/day). Try again tomorrow.`;
+	if (message.includes("Indexing API")) return `You exceeded the Indexing API quota (${GSC_QUOTAS.indexing}/day). Try again tomorrow.`;
+	return `Quota exceeded. Try again in ${retryAfter ? `${retryAfter}s` : "24 hours"}.`;
+}
+function formatRateLimitSuggestion(retryAfter) {
+	return `Rate limited. Slow down requests. Try again in ${retryAfter ? `${retryAfter}s` : "a few minutes"}.`;
+}
+/**
+* Analyzes an error and returns structured information with suggestions.
+*/
+function analyzeError(error) {
+	const code = getErrorCode(error);
+	const message = getErrorMessage(error);
+	const retryAfter = getRetryAfter(error);
+	if (isQuotaError(error)) return {
+		isQuotaError: true,
+		isRateLimitError: false,
+		isAuthError: false,
+		code,
+		message,
+		retryAfter,
+		suggestion: formatQuotaSuggestion(message, retryAfter)
+	};
+	if (isRateLimitError(error)) return {
+		isQuotaError: false,
+		isRateLimitError: true,
+		isAuthError: false,
+		code,
+		message,
+		retryAfter: retryAfter || 60,
+		suggestion: formatRateLimitSuggestion(retryAfter)
+	};
+	if (isAuthError(error)) return {
+		isQuotaError: false,
+		isRateLimitError: false,
+		isAuthError: true,
+		code,
+		message,
+		suggestion: "Run `gscdump auth` to re-authenticate."
+	};
+	return {
+		isQuotaError: false,
+		isRateLimitError: false,
+		isAuthError: false,
+		code,
+		message,
+		suggestion: ""
+	};
+}
+/**
+* Formats an error for CLI display with color codes.
+*/
+function formatErrorForCli(error) {
+	const info = analyzeError(error);
+	const lines = [];
+	lines.push(`\x1B[31m${info.message}\x1B[0m`);
+	if (info.suggestion) {
+		lines.push("");
+		lines.push(info.suggestion);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/query/resolver.ts
+const DATE_OPERATORS = [
+	"gte",
+	"gt",
+	"lte",
+	"lt",
+	"between"
+];
+function isDateOperator(op) {
+	return DATE_OPERATORS.includes(op);
+}
+function addDays(dateStr, days) {
+	const d = new Date(dateStr);
+	d.setDate(d.getDate() + days);
+	return d.toISOString().split("T")[0];
+}
+/**
+* Extract date range from filters. Used by analysis functions to get the period.
+*/
+function extractDateRange(filters) {
+	const { startDate, endDate } = extractDateFilters(filters);
+	return {
+		startDate,
+		endDate
+	};
+}
+function extractDateFilters(filters) {
+	let startDate;
+	let endDate;
+	const nonDateFilters = [];
+	for (const filter of filters) {
+		const dateFilters = [];
+		const otherFilters = [];
+		for (const f of filter._filters) if (f.dimension === "date" && isDateOperator(f.operator)) dateFilters.push(f);
+		else otherFilters.push(f);
+		for (const df of dateFilters) switch (df.operator) {
+			case "gte":
+				startDate = df.expression;
+				break;
+			case "gt":
+				startDate = addDays(df.expression, 1);
+				break;
+			case "lte":
+				endDate = df.expression;
+				break;
+			case "lt":
+				endDate = addDays(df.expression, -1);
+				break;
+			case "between":
+				startDate = df.expression;
+				endDate = df.expression2;
+				break;
+		}
+		if (otherFilters.length > 0) nonDateFilters.push({
+			...filter,
+			_filters: otherFilters
+		});
+	}
+	return {
+		startDate,
+		endDate,
+		nonDateFilters
+	};
+}
+function resolveToBody(state) {
+	const { startDate, endDate, nonDateFilters } = extractDateFilters(state.filters);
+	if (!startDate || !endDate) throw new Error("Date range required: use .where(between(date, start, end)) or .where(gte(date, start)).where(lte(date, end))");
+	const body = {
+		dimensions: state.dimensions,
+		startDate,
+		endDate
+	};
+	if (state.rowLimit) body.rowLimit = state.rowLimit;
+	const filterGroups = resolveFilters(nonDateFilters);
+	if (filterGroups.length > 0) body.dimensionFilterGroups = filterGroups;
+	return body;
+}
+function resolveFilters(filters) {
+	const groups = [];
+	for (const filter of filters) if ((filter._groupType ?? "and") === "or" && filter._filters.length > 1) groups.push({
+		groupType: "or",
+		filters: filter._filters.map((f) => ({
+			dimension: f.dimension,
+			operator: f.operator,
+			expression: f.expression
+		}))
+	});
+	else if (filter._filters.length > 0) groups.push({ filters: filter._filters.map((f) => ({
+		dimension: f.dimension,
+		operator: f.operator,
+		expression: f.expression
+	})) });
+	return groups;
+}
+
+//#endregion
+//#region src/query/builder.ts
+function transformResponse(response, dimensions) {
+	return { rows: (response.rows ?? []).map((row) => {
+		const result = {
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
+		};
+		dimensions.forEach((dim, i) => {
+			result[dim] = row.keys?.[i];
+		});
+		return result;
+	}) };
+}
+function createBuilder(state) {
+	return {
+		select(...dims) {
+			return createBuilder({
+				...state,
+				dimensions: dims
+			});
+		},
+		where(filter) {
+			return createBuilder({
+				...state,
+				filters: [...state.filters, filter]
+			});
+		},
+		siteUrl(url) {
+			return createBuilder({
+				...state,
+				siteUrl: url
+			});
+		},
+		limit(n) {
+			return createBuilder({
+				...state,
+				rowLimit: n
+			});
+		},
+		async execute(client) {
+			const body = resolveToBody(state);
+			return transformResponse(await client.searchAnalytics.query(state.siteUrl, body), state.dimensions);
+		},
+		toBody() {
+			return resolveToBody(state);
+		},
+		getState() {
+			return { ...state };
+		}
+	};
+}
+const gsc = createBuilder({
+	dimensions: [],
+	filters: []
+});
+
+//#endregion
+//#region src/query/columns.ts
+function createColumn(dimension) {
+	return { dimension };
+}
+const page = createColumn("page");
+const query = createColumn("query");
+const device = createColumn("device");
+const country = createColumn("country");
+const searchAppearance = createColumn("searchAppearance");
+const date = createColumn("date");
+
+//#endregion
+//#region src/query/operators.ts
+function eq(column, value) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "equals",
+			expression: String(value)
+		}]
+	};
+}
+function ne(column, value) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "notEquals",
+			expression: String(value)
+		}]
+	};
+}
+function inArray(column, values) {
+	return {
+		_constraints: {},
+		_filters: values.map((v) => ({
+			dimension: column.dimension,
+			operator: "equals",
+			expression: String(v)
+		})),
+		_groupType: "or"
+	};
+}
+function contains(column, pattern) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "contains",
+			expression: pattern
+		}]
+	};
+}
+function like(column, pattern) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "contains",
+			expression: pattern.replace(/%/g, "")
+		}]
+	};
+}
+function regex(column, pattern) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "includingRegex",
+			expression: typeof pattern === "string" ? pattern : pattern.source
+		}]
+	};
+}
+function notRegex(column, pattern) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "excludingRegex",
+			expression: typeof pattern === "string" ? pattern : pattern.source
+		}]
+	};
+}
+function and(...filters) {
+	return {
+		_constraints: {},
+		_filters: filters.flatMap((f) => f._filters),
+		_groupType: "and"
+	};
+}
+function or(...filters) {
+	return {
+		_constraints: {},
+		_filters: filters.flatMap((f) => f._filters),
+		_groupType: "or"
+	};
+}
+const DATE_OPS = [
+	"gte",
+	"gt",
+	"lte",
+	"lt",
+	"between"
+];
+function not(filter) {
+	return {
+		_constraints: {},
+		_filters: filter._filters.filter((f) => !DATE_OPS.includes(f.operator)).map((f) => ({
+			...f,
+			operator: invertOperator(f.operator)
+		}))
+	};
+}
+function invertOperator(op) {
+	return {
+		equals: "notEquals",
+		notEquals: "equals",
+		contains: "notContains",
+		notContains: "contains",
+		includingRegex: "excludingRegex",
+		excludingRegex: "includingRegex"
+	}[op];
+}
+function gte(column, value) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "gte",
+			expression: String(value)
+		}]
+	};
+}
+function gt(column, value) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "gt",
+			expression: String(value)
+		}]
+	};
+}
+function lte(column, value) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "lte",
+			expression: String(value)
+		}]
+	};
+}
+function lt(column, value) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "lt",
+			expression: String(value)
+		}]
+	};
+}
+function between(column, start, end) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "between",
+			expression: String(start),
+			expression2: String(end)
+		}]
+	};
+}
+
+//#endregion
+//#region src/query/constants.ts
+const Device = {
+	MOBILE: "MOBILE",
+	DESKTOP: "DESKTOP",
+	TABLET: "TABLET"
+};
+const Country = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
+
+//#endregion
+export { Country, Device, GSC_QUOTAS, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeError, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, and, batchInspectUrls, batchRequestIndexing, between, collectStream, contains, countries_default as countries, country, createAuth, createFetch, createQueryBody, createSorter, date, dayjs, deleteSitemap, device, eq, extractDateRange, fetchAnalyticsWithComparison, fetchCountries, fetchCountriesWithComparison, fetchDates, fetchDatesWithComparison, fetchDevices, fetchDevicesWithComparison, fetchKeyword, fetchKeywords, fetchKeywordsWithComparison, fetchPage, fetchPages, fetchPagesWithComparison, fetchSearchAppearance, fetchSearchAppearanceWithComparison, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, fetchYoYComparison, formatDateGsc, formatErrorForCli, getErrorCode, getErrorMessage, getIndexingMetadata, getRetryAfter, googleSearchConsole, gsc, gt, gte, inArray, inspectUrl, isAuthError, isQuotaError, isRateLimitError, like, lt, lte, ne, not, notRegex, num, or, page, percentDifference, query, queryRecursive, queryRecursiveStream, regex, requestIndexing, searchAppearance, submitSitemap, userPeriodRange, withDataType, withFinalData, withFreshData, withPropertyAggregation, withSearchAppearance };