gscdump 0.1.3 → 0.2.0

package/dist/analysis/index.mjs

@@ -0,0 +1,810 @@
+//#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/brand.ts
+/**
+* Segments keywords into brand and non-brand based on provided brand terms.
+*/
+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.query.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/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.
+*/
+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.query);
+		if (intent) {
+			const existing = clusterMap.get(intent);
+			if (existing) existing.keywords.push(kw);
+			else clusterMap.set(intent, {
+				type: "intent",
+				keywords: [kw]
+			});
+			clusteredKeywords.add(kw.query);
+		}
+	}
+	if (clusterBy === "prefix" || clusterBy === "both") {
+		const unclustered = filtered.filter((kw) => !clusteredKeywords.has(kw.query));
+		const prefixMap = /* @__PURE__ */ new Map();
+		for (const kw of unclustered) {
+			const prefix = extractWordPrefix(kw.query);
+			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.query));
+		}
+	}
+	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.query))
+	};
+}
+
+//#endregion
+//#region src/analysis/concentration.ts
+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);
+}
+function calculateHHI(shares) {
+	return shares.reduce((sum, share) => sum + (share * 100) ** 2, 0);
+}
+/**
+* Analyzes traffic concentration across items (pages or keywords).
+*/
+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
+	};
+}
+/**
+* Page concentration analysis.
+*/
+function analyzePageConcentration(pages, options) {
+	return analyzeConcentration(pages.map((p) => ({
+		key: p.page,
+		clicks: num(p.clicks)
+	})), options);
+}
+/**
+* Keyword concentration analysis.
+*/
+function analyzeKeywordConcentration(keywords, options) {
+	return analyzeConcentration(keywords.map((k) => ({
+		key: k.query,
+		clicks: num(k.clicks)
+	})), options);
+}
+
+//#endregion
+//#region src/analysis/decay.ts
+const SORT_ORDER$1 = {
+	lostClicks: "desc",
+	declinePercent: "desc",
+	currentClicks: "asc"
+};
+const sortResults$2 = createSorter((item, metric) => item[metric], "lostClicks");
+/**
+* Identifies "decaying" content - pages that have lost significant traffic.
+*/
+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$1[sortBy]);
+}
+
+//#endregion
+//#region src/query/resolver.ts
+const DATE_OPERATORS = [
+	"gte",
+	"gt",
+	"lte",
+	"lt",
+	"between"
+];
+const QUERY_PARAMS = ["searchType"];
+function isDateOperator(op) {
+	return DATE_OPERATORS.includes(op);
+}
+function isQueryParam(dim) {
+	return QUERY_PARAMS.includes(dim);
+}
+function addDays(dateStr, days) {
+	const d = new Date(dateStr);
+	d.setDate(d.getDate() + days);
+	return d.toISOString().split("T")[0];
+}
+function extractSpecialFilters(filter) {
+	if (!filter) return {};
+	let startDate;
+	let endDate;
+	let searchType$1;
+	const otherFilters = [];
+	const cleanedNestedGroups = [];
+	for (const f of filter._filters) if (f.dimension === "date" && isDateOperator(f.operator)) switch (f.operator) {
+		case "gte":
+			startDate = f.expression;
+			break;
+		case "gt":
+			startDate = addDays(f.expression, 1);
+			break;
+		case "lte":
+			endDate = f.expression;
+			break;
+		case "lt":
+			endDate = addDays(f.expression, -1);
+			break;
+		case "between":
+			startDate = f.expression;
+			endDate = f.expression2;
+			break;
+	}
+	else if (isQueryParam(f.dimension)) {
+		if (f.dimension === "searchType") searchType$1 = f.expression;
+	} else otherFilters.push(f);
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) {
+		const extracted = extractSpecialFilters(nested);
+		if (extracted.startDate) startDate = extracted.startDate;
+		if (extracted.endDate) endDate = extracted.endDate;
+		if (extracted.searchType) searchType$1 = extracted.searchType;
+		if (extracted.dimensionFilter) cleanedNestedGroups.push(extracted.dimensionFilter);
+	}
+	const dimensionFilter = otherFilters.length > 0 || cleanedNestedGroups.length > 0 ? {
+		...filter,
+		_filters: otherFilters,
+		_nestedGroups: cleanedNestedGroups.length > 0 ? cleanedNestedGroups : void 0
+	} : void 0;
+	return {
+		startDate,
+		endDate,
+		searchType: searchType$1,
+		dimensionFilter
+	};
+}
+function resolveToBody(state) {
+	const { startDate, endDate, searchType: searchType$1, dimensionFilter } = extractSpecialFilters(state.filter);
+	if (!startDate || !endDate) throw new Error("Date range required: use .where(between(date, start, end)) or .where(and(gte(date, start), lte(date, end)))");
+	const body = {
+		dimensions: state.dimensions,
+		startDate,
+		endDate
+	};
+	if (searchType$1) body.searchType = searchType$1;
+	if (state.rowLimit) body.rowLimit = state.rowLimit;
+	if (state.startRow) body.startRow = state.startRow;
+	const filterGroups = resolveFilter(dimensionFilter);
+	if (filterGroups.length > 0) body.dimensionFilterGroups = filterGroups;
+	return body;
+}
+function resolveFilter(filter) {
+	if (!filter) return [];
+	const groups = [];
+	if ((filter._groupType ?? "and") === "or") {
+		if (filter._filters.length > 0) 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
+	})) });
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) groups.push(...resolveFilter(nested));
+	return groups;
+}
+
+//#endregion
+//#region src/query/builder.ts
+function createBuilder(state) {
+	return {
+		select(...dims) {
+			return createBuilder({
+				...state,
+				dimensions: dims
+			});
+		},
+		where(filter) {
+			return createBuilder({
+				...state,
+				filter
+			});
+		},
+		limit(n) {
+			return createBuilder({
+				...state,
+				rowLimit: n
+			});
+		},
+		offset(n) {
+			return createBuilder({
+				...state,
+				startRow: n
+			});
+		},
+		toBody() {
+			return resolveToBody(state);
+		},
+		getState() {
+			return { ...state };
+		}
+	};
+}
+const gsc = createBuilder({ dimensions: [] });
+
+//#endregion
+//#region src/query/columns.ts
+function createColumn(dimension) {
+	return { dimension };
+}
+function createQueryParam(param) {
+	return { param };
+}
+const page = createColumn("page");
+const query = createColumn("query");
+const device = createColumn("device");
+const country = createColumn("country");
+const searchAppearance = createColumn("searchAppearance");
+const date = createColumn("date");
+const searchType = createQueryParam("searchType");
+
+//#endregion
+//#region src/query/operators.ts
+function between(column, start, end) {
+	return {
+		_constraints: {},
+		_filters: [{
+			dimension: column.dimension,
+			operator: "between",
+			expression: String(start),
+			expression2: String(end)
+		}]
+	};
+}
+
+//#endregion
+//#region src/analysis/movers.ts
+function percentDifference(current, previous) {
+	if (previous === 0) return current > 0 ? 100 : 0;
+	return (current - previous) / previous * 100;
+}
+/**
+* Identifies movers and shakers - keywords with significant recent changes.
+*/
+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.query, {
+		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.query) && row.page) pageMap.set(row.query, row.page);
+	for (const row of input.previous) if (!pageMap.has(row.query) && row.page) pageMap.set(row.query, 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.query) || {
+			clicks: 0,
+			impressions: 0,
+			position: 0,
+			page: null
+		};
+		const clicksChangePercent = percentDifference(clicks, baseline.clicks);
+		const impressionsChangePercent = percentDifference(impressions, baseline.impressions);
+		const data = {
+			keyword: row.query,
+			page: pageMap.get(row.query) ?? 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/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;
+}
+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);
+}
+function calculateImpressionScore(impressions) {
+	if (impressions <= 0) return 0;
+	return Math.min(Math.log10(impressions) / 5, 1);
+}
+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 = {
+	opportunityScore: "desc",
+	potentialClicks: "desc",
+	impressions: "desc",
+	position: "asc"
+};
+const sortResults$1 = 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 geometricMean = (positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight) ** (1 / (positionWeight + impressionsWeight + ctrGapWeight));
+		const opportunityScore = Math.round(geometricMean * 100);
+		const targetCtr = getExpectedCtr(Math.min(3, position));
+		const potentialClicks = Math.round(impressions * targetCtr);
+		results.push({
+			keyword: row.query,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			opportunityScore,
+			potentialClicks,
+			factors: {
+				positionScore,
+				impressionScore,
+				ctrGapScore
+			}
+		});
+	}
+	return sortResults$1(results, sortBy, SORT_ORDER[sortBy]);
+}
+
+//#endregion
+//#region src/analysis/seasonality.ts
+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.
+*/
+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/striking-distance.ts
+const sortResults = 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.query,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			potentialClicks
+		});
+	}
+	return sortResults(results, sortBy, sortOrder);
+}
+
+//#endregion
+//#region src/analysis/fetch.ts
+/** Collect all rows from async generator */
+async function collectRows(generator) {
+	const rows = [];
+	for await (const batch of generator) rows.push(...batch);
+	return rows;
+}
+/** Fetch keywords (query+page dimensions) for a period */
+async function fetchKeywordsInternal(client, siteUrl, period, limit = 25e3) {
+	const builder = gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit);
+	return collectRows(client.query(siteUrl, builder));
+}
+/** Fetch pages (page dimension) for a period */
+async function fetchPagesInternal(client, siteUrl, period, limit = 25e3) {
+	const builder = gsc.select(page).where(between(date, period.startDate, period.endDate)).limit(limit);
+	return collectRows(client.query(siteUrl, builder));
+}
+/** Fetch dates (date dimension) for a period */
+async function fetchDatesInternal(client, siteUrl, period, limit = 25e3) {
+	const builder = gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit);
+	return collectRows(client.query(siteUrl, builder));
+}
+/**
+* Query search analytics data for a single period.
+* Returns keywords, pages, and dates data.
+* API calls: 3 (one per dimension)
+*/
+async function queryAnalytics(client, siteUrl, period, options = {}) {
+	const limit = options.limit ?? 25e3;
+	const [keywords, pages, dates] = await Promise.all([
+		fetchKeywordsInternal(client, siteUrl, period, limit),
+		fetchPagesInternal(client, siteUrl, period, limit),
+		fetchDatesInternal(client, siteUrl, period, limit)
+	]);
+	return {
+		keywords,
+		pages,
+		dates
+	};
+}
+/**
+* Query search analytics data for current and previous periods.
+* Returns comparison data for all dimensions.
+* API calls: 6 (3 per period)
+*/
+async function queryComparison(client, siteUrl, periods, options = {}) {
+	const [current, previous] = await Promise.all([queryAnalytics(client, siteUrl, periods.current, options), queryAnalytics(client, siteUrl, periods.previous, options)]);
+	return {
+		current,
+		previous
+	};
+}
+const fetchKeywords = fetchKeywordsInternal;
+const fetchPages = fetchPagesInternal;
+const fetchDates = fetchDatesInternal;
+/**
+* Fetch keywords and analyze striking distance opportunities.
+* API calls: 1
+*/
+async function fetchStrikingDistance(client, siteUrl, period, options) {
+	return analyzeStrikingDistance(await fetchKeywords(client, siteUrl, period), options);
+}
+/**
+* Fetch keywords and analyze optimization opportunities.
+* API calls: 1
+*/
+async function fetchOpportunity(client, siteUrl, period, options) {
+	return analyzeOpportunity(await fetchKeywords(client, siteUrl, period), options);
+}
+/**
+* Fetch keywords and analyze brand vs non-brand segmentation.
+* API calls: 1
+*/
+async function fetchBrandSegmentation(client, siteUrl, period, options) {
+	return analyzeBrandSegmentation(await fetchKeywords(client, siteUrl, period), options);
+}
+/**
+* Fetch pages and analyze traffic concentration.
+* API calls: 1
+*/
+async function fetchPageConcentration(client, siteUrl, period, options) {
+	return analyzePageConcentration(await fetchPages(client, siteUrl, period), options);
+}
+/**
+* Fetch keywords and analyze traffic concentration.
+* API calls: 1
+*/
+async function fetchKeywordConcentration(client, siteUrl, period, options) {
+	return analyzeKeywordConcentration(await fetchKeywords(client, siteUrl, period), options);
+}
+/**
+* Fetch keywords and analyze clusters.
+* API calls: 1
+*/
+async function fetchClustering(client, siteUrl, period, options) {
+	return analyzeClustering(await fetchKeywords(client, siteUrl, period), options);
+}
+/**
+* Fetch dates and analyze seasonality patterns.
+* API calls: 1
+*/
+async function fetchSeasonality(client, siteUrl, period, options) {
+	return analyzeSeasonality(await fetchDates(client, siteUrl, period), options);
+}
+/**
+* Fetch pages for both periods and analyze content decay.
+* API calls: 2
+*/
+async function fetchDecay(client, siteUrl, periods, options) {
+	const [current, previous] = await Promise.all([fetchPages(client, siteUrl, periods.current), fetchPages(client, siteUrl, periods.previous)]);
+	return analyzeDecay({
+		current,
+		previous
+	}, options);
+}
+/**
+* Fetch keywords for both periods and analyze movers/shakers.
+* API calls: 2
+*/
+async function fetchMovers(client, siteUrl, periods, options) {
+	const [current, previous] = await Promise.all([fetchKeywords(client, siteUrl, periods.current), fetchKeywords(client, siteUrl, periods.previous)]);
+	return analyzeMovers({
+		current,
+		previous
+	}, options);
+}
+
+//#endregion
+export { analyzeBrandSegmentation, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, createSorter, fetchBrandSegmentation, fetchClustering, fetchDecay, fetchKeywordConcentration, fetchMovers, fetchOpportunity, fetchPageConcentration, fetchSeasonality, fetchStrikingDistance, num, queryAnalytics, queryComparison };