@reform-society/agera-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1122 @@
+import { atom } from "nanostores";
+import log from "loglevel";
+//#region src/stores.ts
+function createSessionStore(initial) {
+	return atom({
+		id: typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}`,
+		answers: {},
+		startedAt: /* @__PURE__ */ new Date(),
+		...initial
+	});
+}
+function createStepsStore(initial) {
+	return atom({
+		current: "",
+		path: [],
+		...initial
+	});
+}
+//#endregion
+//#region src/resolve.ts
+function traverseDotPath(obj, dotPath) {
+	const parts = dotPath.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current == null || typeof current !== "object") return void 0;
+		current = current[part];
+	}
+	return current;
+}
+function resolveQuizPath(dotPath, quizResults) {
+	const directValue = traverseDotPath(quizResults, dotPath);
+	if (directValue !== void 0) return directValue;
+	if (dotPath === "winner") return traverseDotPath(quizResults, "weighted.winner");
+	if (dotPath === "winner.score") return quizResults.winnerScore ?? traverseDotPath(quizResults, "weighted.winnerScore");
+	if (dotPath.startsWith("scores.")) return traverseDotPath(quizResults, `weighted.${dotPath}`);
+	if (dotPath.startsWith("weighted.")) return traverseDotPath(quizResults, dotPath.slice(9));
+}
+function resolveValue(field, answers, sources) {
+	if (field.startsWith("storage.")) {
+		const key = field.slice(8);
+		return sources?.storage?.[key];
+	}
+	if (field.startsWith("crm_response.")) {
+		const dotPath = field.slice(13);
+		if (!sources?.crmResponse) return void 0;
+		return traverseDotPath(sources.crmResponse, dotPath);
+	}
+	if (field === "env.device") return sources?.env?.device;
+	if (field.startsWith("env.")) {
+		const path = field.slice(4).split(".");
+		if (path[0] === "utm" && path[1]) {
+			const fromEnv = sources?.env?.utm?.[path[1]];
+			if (fromEnv !== void 0) return fromEnv;
+			return (sources?.queryParams ?? new URLSearchParams()).get(`utm_${path[1]}`);
+		}
+		if (path[0]) return answers[path[0]];
+	}
+	if (field.startsWith("query.")) {
+		const paramName = field.slice(6);
+		return (sources?.queryParams ?? new URLSearchParams()).get(paramName);
+	}
+	if (field.startsWith("quiz.")) {
+		const quizResults = answers["__quiz__"];
+		if (!quizResults) return void 0;
+		return resolveQuizPath(field.slice(5), quizResults);
+	}
+	return answers[field];
+}
+//#endregion
+//#region src/answers.ts
+const PRESERVED_ANSWER_KEYS = new Set(["__quiz__"]);
+function mergeAnswers(previous, dom, preserveKeys) {
+	const merged = { ...dom };
+	const keysToPreserve = preserveKeys ?? PRESERVED_ANSWER_KEYS;
+	for (const [key, value] of Object.entries(previous)) if (!(key in merged) || keysToPreserve.has(key)) merged[key] = value;
+	return merged;
+}
+function answersChanged(previous, next) {
+	const prevKeys = Object.keys(previous);
+	const nextKeys = Object.keys(next);
+	if (prevKeys.length !== nextKeys.length) return true;
+	for (const key of nextKeys) if (previous[key] !== next[key]) return true;
+	return false;
+}
+//#endregion
+//#region src/predicates.ts
+function evaluatePredicate(predicate, answers, sources) {
+	if ("all" in predicate) return predicate.all.every((p) => evaluatePredicate(p, answers, sources));
+	if ("any" in predicate) return predicate.any.some((p) => evaluatePredicate(p, answers, sources));
+	if ("not" in predicate) return !evaluatePredicate(predicate.not, answers, sources);
+	if ("field" in predicate && "op" in predicate) {
+		const { field, op, value } = predicate;
+		const fieldValue = resolveValue(field, answers, sources);
+		switch (op) {
+			case "eq": return fieldValue === value;
+			case "neq": return fieldValue !== value;
+			case "in": return Array.isArray(value) && value.includes(fieldValue);
+			case "nin": return Array.isArray(value) && !value.includes(fieldValue);
+			case "gt": return Number(fieldValue) > Number(value);
+			case "gte": return Number(fieldValue) >= Number(value);
+			case "lt": return Number(fieldValue) < Number(value);
+			case "lte": return Number(fieldValue) <= Number(value);
+			case "exists": return fieldValue !== void 0 && fieldValue !== null;
+			case "truthy": return Boolean(fieldValue);
+			case "falsy": return !fieldValue;
+			case "contains": return String(fieldValue).includes(String(value));
+			case "starts_with": return String(fieldValue).startsWith(String(value));
+			case "ends_with": return String(fieldValue).endsWith(String(value));
+			default: return false;
+		}
+	}
+	return false;
+}
+function evaluateShowIf(predicateJson, answers, sources) {
+	try {
+		return evaluatePredicate(JSON.parse(predicateJson), answers, sources);
+	} catch (error) {
+		log.error("[conditions] Invalid predicate JSON:", error);
+		return false;
+	}
+}
+function evaluateNextMap(nextMapJson, answers, sources) {
+	try {
+		const nextMap = JSON.parse(nextMapJson);
+		for (const rule of nextMap) if (evaluatePredicate(rule.if, answers, sources)) return rule.then;
+		return null;
+	} catch (error) {
+		log.error("[conditions] Invalid next-map JSON:", error);
+		return null;
+	}
+}
+//#endregion
+//#region src/validators.ts
+/**
+* Parse value as number if it looks numeric, otherwise return null for length comparison.
+*/
+function parseNumericValue(val) {
+	const trimmed = val.trim();
+	if (trimmed === "") return null;
+	const num = Number(trimmed);
+	return !isNaN(num) && isFinite(num) ? num : null;
+}
+/** Must start with a letter (Unicode), allows letters, hyphens, apostrophes, dots, spaces */
+const NAME_RE = /^[\p{L}\p{M}][\p{L}\p{M}'\-.\s]*$/u;
+const validators = {
+	required: (val) => val.trim() !== "",
+	email: (val) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val),
+	name: (val) => NAME_RE.test(val.trim()),
+	pattern: (val, re) => {
+		try {
+			return new RegExp(re).test(val);
+		} catch {
+			return false;
+		}
+	},
+	min: (val, n) => {
+		const num = parseNumericValue(val);
+		const threshold = Number(n);
+		return num !== null ? num >= threshold : val.length >= threshold;
+	},
+	max: (val, n) => {
+		const num = parseNumericValue(val);
+		const threshold = Number(n);
+		return num !== null ? num <= threshold : val.length <= threshold;
+	}
+};
+//#endregion
+//#region src/validation-messages.ts
+const errorMessages = {
+	"sv-SE": {
+		required: "Fyll i det här fältet för att gå vidare",
+		email: "Skriv en e-postadress i formatet namn@exempel.se",
+		name: "Kontrollera att namnet är rättstavat",
+		phone: "Ange ett giltigt telefonnummer, till exempel {example}",
+		pattern: "Formatet ser inte rätt ut, kontrollera en gång till",
+		min: "Skriv minst {min} tecken",
+		max: "Skriv högst {max} tecken",
+		minValue: "Ange ett värde på minst {minValue}",
+		maxValue: "Ange ett värde på högst {maxValue}"
+	},
+	"nb-NO": {
+		required: "Fyll ut dette feltet for å gå videre",
+		email: "Skriv inn en e-postadresse i formatet navn@eksempel.no",
+		name: "Kontroller at navnet er riktig stavet",
+		phone: "Oppgi et gyldig telefonnummer, for eksempel {example}",
+		pattern: "Formatet ser ikke riktig ut, sjekk en gang til",
+		min: "Skriv minst {min} tegn",
+		max: "Skriv maks {max} tegn",
+		minValue: "Oppgi en verdi på minst {minValue}",
+		maxValue: "Oppgi en verdi på maks {maxValue}"
+	},
+	"da-DK": {
+		required: "Udfyld feltet for at gå videre",
+		email: "Skriv en e-mailadresse i formatet navn@eksempel.dk",
+		name: "Kontroller at navnet er stavet korrekt",
+		phone: "Angiv et gyldigt telefonnummer, for eksempel {example}",
+		pattern: "Formatet ser ikke rigtigt ud, tjek en ekstra gang",
+		min: "Skriv mindst {min} tegn",
+		max: "Skriv højst {max} tegn",
+		minValue: "Angiv en værdi på mindst {minValue}",
+		maxValue: "Angiv en værdi på højst {maxValue}"
+	},
+	"en-US": {
+		required: "Fill in this field to continue",
+		email: "Enter an email address in the format name@example.com",
+		name: "Check that the name is spelled correctly",
+		phone: "Enter a valid phone number, for example {example}",
+		pattern: "The format does not look right, please check again",
+		min: "Enter at least {min} characters",
+		max: "Enter no more than {max} characters",
+		minValue: "Enter a value of at least {minValue}",
+		maxValue: "Enter a value of at most {maxValue}"
+	},
+	en: {
+		required: "Fill in this field to continue",
+		email: "Enter an email address in the format name@example.com",
+		name: "Check that the name is spelled correctly",
+		phone: "Enter a valid phone number, for example {example}",
+		pattern: "The format does not look right, please check again",
+		min: "Enter at least {min} characters",
+		max: "Enter no more than {max} characters",
+		minValue: "Enter a value of at least {minValue}",
+		maxValue: "Enter a value of at most {maxValue}"
+	},
+	"de-DE": {
+		required: "Dieses Feld ausfüllen, um fortzufahren",
+		email: "Eine E-Mail-Adresse im Format name@beispiel.de eingeben",
+		name: "Prüfen, ob der Name richtig geschrieben ist",
+		phone: "Geben Sie eine gültige Telefonnummer ein, zum Beispiel {example}",
+		pattern: "Das Format sieht nicht richtig aus, bitte noch einmal prüfen",
+		min: "Mindestens {min} Zeichen eingeben",
+		max: "Höchstens {max} Zeichen eingeben",
+		minValue: "Einen Wert von mindestens {minValue} eingeben",
+		maxValue: "Einen Wert von höchstens {maxValue} eingeben"
+	},
+	"es-ES": {
+		required: "Rellena este campo para continuar",
+		email: "Escribe un correo en formato nombre@ejemplo.es",
+		name: "Comprueba que el nombre esté bien escrito",
+		phone: "Introduce un número de teléfono válido, por ejemplo {example}",
+		pattern: "El formato no parece correcto, revísalo de nuevo",
+		min: "Escribe al menos {min} caracteres",
+		max: "Escribe como máximo {max} caracteres",
+		minValue: "Indica un valor de al menos {minValue}",
+		maxValue: "Indica un valor de como máximo {maxValue}"
+	},
+	"fi-FI": {
+		required: "Täytä tämä kenttä jatkaaksesi",
+		email: "Kirjoita sähköpostiosoite muodossa nimi@esimerkki.fi",
+		name: "Tarkista, että nimi on kirjoitettu oikein",
+		phone: "Syötä kelvollinen puhelinnumero, esimerkiksi {example}",
+		pattern: "Muoto ei näytä oikealta, tarkista vielä kerran",
+		min: "Kirjoita vähintään {min} merkkiä",
+		max: "Kirjoita enintään {max} merkkiä",
+		minValue: "Anna arvo, joka on vähintään {minValue}",
+		maxValue: "Anna arvo, joka on enintään {maxValue}"
+	},
+	"fr-FR": {
+		required: "Renseignez ce champ pour continuer",
+		email: "Saisissez une adresse e-mail au format nom@exemple.fr",
+		name: "Vérifiez que le nom est correctement orthographié",
+		phone: "Saisissez un numéro de téléphone valide, par exemple {example}",
+		pattern: "Le format ne semble pas correct, vérifiez une nouvelle fois",
+		min: "Saisissez au moins {min} caractères",
+		max: "Saisissez au plus {max} caractères",
+		minValue: "Saisissez une valeur d'au moins {minValue}",
+		maxValue: "Saisissez une valeur d'au plus {maxValue}"
+	}
+};
+errorMessages.sv = errorMessages["sv-SE"];
+errorMessages.nb = errorMessages["nb-NO"];
+errorMessages.no = errorMessages["nb-NO"];
+errorMessages.da = errorMessages["da-DK"];
+errorMessages.de = errorMessages["de-DE"];
+errorMessages.es = errorMessages["es-ES"];
+errorMessages.fi = errorMessages["fi-FI"];
+errorMessages.fr = errorMessages["fr-FR"];
+const PHONE_EXAMPLES = {
+	SE: {
+		national: "070-123 45 67",
+		international: "+46 70 123 45 67",
+		e164: "+46701234567"
+	},
+	NO: {
+		national: "912 34 567",
+		international: "+47 912 34 567",
+		e164: "+4791234567"
+	},
+	DK: {
+		national: "20 12 34 56",
+		international: "+45 20 12 34 56",
+		e164: "+4520123456"
+	},
+	US: {
+		national: "(555) 123-4567",
+		international: "+1 555 123 4567",
+		e164: "+15551234567"
+	},
+	GB: {
+		national: "07911 123456",
+		international: "+44 7911 123456",
+		e164: "+447911123456"
+	},
+	DE: {
+		national: "0151 12345678",
+		international: "+49 151 12345678",
+		e164: "+4915112345678"
+	},
+	ES: {
+		national: "612 34 56 78",
+		international: "+34 612 34 56 78",
+		e164: "+34612345678"
+	},
+	FI: {
+		national: "040 1234567",
+		international: "+358 40 1234567",
+		e164: "+358401234567"
+	},
+	FR: {
+		national: "06 12 34 56 78",
+		international: "+33 6 12 34 56 78",
+		e164: "+33612345678"
+	}
+};
+function getPhoneExample(region, format) {
+	const key = region?.toUpperCase();
+	const fmt = format?.toUpperCase();
+	const selected = (key ? PHONE_EXAMPLES[key] : void 0) ?? {
+		national: "070-123 45 67",
+		international: "+46 70 123 45 67",
+		e164: "+46701234567"
+	};
+	if (fmt === "E164") return selected.e164;
+	if (fmt === "NATIONAL") return selected.national;
+	return selected.international;
+}
+const placesMessages = {
+	"sv-SE": {
+		hint: "Välj gata, fyll sedan i husnummer",
+		noResults: "Inga adresser hittades",
+		validate: "Välj en adress från listan",
+		manual: "Fyll i adress manuellt",
+		backToSearch: "Tillbaka till sökningen",
+		manualValidate: "Fyll i alla adressfält",
+		postalErr: "Postnummer måste följa formatet {example}"
+	},
+	"nb-NO": {
+		hint: "Velg gate, fyll deretter inn husnummer",
+		noResults: "Ingen adresser funnet",
+		validate: "Velg en adresse fra listen",
+		manual: "Fyll inn adresse manuelt",
+		backToSearch: "Tilbake til søk",
+		manualValidate: "Fyll inn alle adressefelt",
+		postalErr: "Postnummer må følge formatet {example}"
+	},
+	"da-DK": {
+		hint: "Vælg vej, og udfyld derefter husnummer",
+		noResults: "Ingen adresser fundet",
+		validate: "Vælg en adresse fra listen",
+		manual: "Indtast adresse manuelt",
+		backToSearch: "Tilbage til søgning",
+		manualValidate: "Udfyld alle adressefelter",
+		postalErr: "Postnummer skal have formatet {example}"
+	},
+	"en-US": {
+		hint: "Select street, then add house number",
+		noResults: "No addresses found",
+		validate: "Select an address from the list",
+		manual: "Enter address manually",
+		backToSearch: "Back to search",
+		manualValidate: "Fill in all address fields",
+		postalErr: "Postal code must match format {example}"
+	},
+	en: {
+		hint: "Select street, then add house number",
+		noResults: "No addresses found",
+		validate: "Select an address from the list",
+		manual: "Enter address manually",
+		backToSearch: "Back to search",
+		manualValidate: "Fill in all address fields",
+		postalErr: "Postal code must match format {example}"
+	},
+	"de-DE": {
+		hint: "Straße auswählen, dann Hausnummer ergänzen",
+		noResults: "Keine Adressen gefunden",
+		validate: "Wählen Sie eine Adresse aus der Liste",
+		manual: "Adresse manuell eingeben",
+		backToSearch: "Zurück zur Suche",
+		manualValidate: "Füllen Sie alle Adressfelder aus",
+		postalErr: "Postleitzahl muss dem Format {example} entsprechen"
+	},
+	"es-ES": {
+		hint: "Selecciona calle y luego añade número",
+		noResults: "No se encontraron direcciones",
+		validate: "Selecciona una dirección de la lista",
+		manual: "Introducir dirección manualmente",
+		backToSearch: "Volver a la búsqueda",
+		manualValidate: "Rellena todos los campos de dirección",
+		postalErr: "El código postal debe tener el formato {example}"
+	},
+	"fi-FI": {
+		hint: "Valitse katu ja lisää sitten talon numero",
+		noResults: "Osoitteita ei löytynyt",
+		validate: "Valitse osoite listalta",
+		manual: "Syötä osoite manuaalisesti",
+		backToSearch: "Takaisin hakuun",
+		manualValidate: "Täytä kaikki osoitekentät",
+		postalErr: "Postinumeron pitää olla muodossa {example}"
+	},
+	"fr-FR": {
+		hint: "Sélectionnez la rue, puis ajoutez le numéro",
+		noResults: "Aucune adresse trouvée",
+		validate: "Sélectionnez une adresse dans la liste",
+		manual: "Saisir l'adresse manuellement",
+		backToSearch: "Retour à la recherche",
+		manualValidate: "Renseignez tous les champs d'adresse",
+		postalErr: "Le code postal doit suivre le format {example}"
+	}
+};
+placesMessages.sv = placesMessages["sv-SE"];
+placesMessages.nb = placesMessages["nb-NO"];
+placesMessages.no = placesMessages["nb-NO"];
+placesMessages.da = placesMessages["da-DK"];
+placesMessages.de = placesMessages["de-DE"];
+placesMessages.es = placesMessages["es-ES"];
+placesMessages.fi = placesMessages["fi-FI"];
+placesMessages.fr = placesMessages["fr-FR"];
+const POSTAL_EXAMPLES = {
+	SE: "123 45",
+	NO: "0123",
+	DK: "1234",
+	US: "12345 or 12345-6789",
+	GB: "SW1A 1AA",
+	DE: "10115",
+	ES: "28013",
+	FI: "00100",
+	FR: "75001"
+};
+function getPostalExample(region) {
+	const key = region?.toUpperCase();
+	if (!key) return POSTAL_EXAMPLES.US;
+	return POSTAL_EXAMPLES[key] ?? POSTAL_EXAMPLES.US;
+}
+function getPlacesMessagesForLanguage(lang, region) {
+	const messages = (!lang ? void 0 : placesMessages[lang] ?? placesMessages[lang.split("-")[0]]) ?? placesMessages.en;
+	return {
+		...messages,
+		postalErr: messages.postalErr.replace("{example}", getPostalExample(region))
+	};
+}
+/**
+* Gets error messages for a given language tag.
+* Falls back to English if language is not found.
+*/
+function getErrorMessagesForLanguage(lang) {
+	if (!lang) return errorMessages.en;
+	return errorMessages[lang] ?? errorMessages[lang.split("-")[0]] ?? errorMessages.en;
+}
+//#endregion
+//#region src/quiz.ts
+function uniqueStrings(values) {
+	const seen = /* @__PURE__ */ new Set();
+	return values.filter((value) => {
+		if (seen.has(value)) return false;
+		seen.add(value);
+		return true;
+	});
+}
+function normalizeWeightedScores(scores) {
+	const normalized = {};
+	for (const [category, weight] of Object.entries(scores)) if (Number.isFinite(weight) && weight > 0) normalized[category] = weight;
+	return normalized;
+}
+function normalizeQuestionInput(question) {
+	return {
+		...question,
+		answeredValues: uniqueStrings(question.answeredValues),
+		answeredLabels: uniqueStrings(question.answeredLabels),
+		expectedValues: question.expectedValues ? uniqueStrings(question.expectedValues) : null,
+		expectedLabels: question.expectedLabels ? uniqueStrings(question.expectedLabels) : null,
+		weightedScores: normalizeWeightedScores(question.weightedScores)
+	};
+}
+function areSameAnswerSet(left, right) {
+	if (left.length !== right.length) return false;
+	const rightSet = new Set(right);
+	return left.every((value) => rightSet.has(value));
+}
+function isSupportedCorrectnessQuestion(question) {
+	if (question.invalid || question.scoringModel == null || question.expectedValues == null) return false;
+	if (question.scoringModel === "partial") return question.model === "multi_select" && question.expectedValues.length > 0;
+	return question.expectedValues.length > 0;
+}
+function getEligibleQuestionResults(questionResults) {
+	return Object.values(questionResults).filter((question) => question.eligible);
+}
+function getUniqueScoringModels(questions) {
+	const active = /* @__PURE__ */ new Set();
+	for (const question of questions) {
+		if (question.usesWeightedScoring) active.add("weighted");
+		if (question.scoringModel != null && isSupportedCorrectnessQuestion(question)) active.add(question.scoringModel);
+	}
+	return Array.from(active);
+}
+function buildQuestionResult(question, earnedPoints, possiblePoints) {
+	return {
+		key: question.key,
+		model: question.model,
+		section: question.section,
+		eligible: question.eligible,
+		answeredValues: question.answeredValues,
+		answeredLabels: question.answeredLabels,
+		expectedValues: question.expectedValues,
+		expectedLabels: question.expectedLabels,
+		state: deriveQuestionState(question.answeredValues, earnedPoints, possiblePoints),
+		earnedPoints,
+		possiblePoints
+	};
+}
+/**
+* Calculate the winner from scores, handling ties
+*/
+function calculateWinner(scores) {
+	const categories = Object.keys(scores);
+	if (categories.length === 0) return {
+		scores: {},
+		winner: null,
+		winnerScore: 0,
+		ties: []
+	};
+	const maxScore = Math.max(...Object.values(scores));
+	const winners = categories.filter((cat) => scores[cat] === maxScore);
+	if (winners.length === 1) return {
+		scores,
+		winner: winners[0],
+		winnerScore: maxScore,
+		ties: []
+	};
+	return {
+		scores,
+		winner: winners[0],
+		winnerScore: maxScore,
+		ties: winners
+	};
+}
+function deriveQuestionState(answeredValues, earnedPoints, possiblePoints) {
+	if (answeredValues.length === 0) return "unanswered";
+	if (possiblePoints <= 0 || earnedPoints <= 0) return "incorrect";
+	if (earnedPoints >= possiblePoints) return "correct";
+	return "partial";
+}
+function scoreExactQuestion(question) {
+	const normalizedQuestion = normalizeQuestionInput(question);
+	if (normalizedQuestion.invalid || normalizedQuestion.scoringModel !== "exact" || normalizedQuestion.expectedValues == null || normalizedQuestion.expectedValues.length === 0) return null;
+	return buildQuestionResult(normalizedQuestion, normalizedQuestion.answeredValues.length > 0 && areSameAnswerSet(normalizedQuestion.answeredValues, normalizedQuestion.expectedValues) ? 1 : 0, 1);
+}
+function scorePartialQuestion(question) {
+	const normalizedQuestion = normalizeQuestionInput(question);
+	if (normalizedQuestion.invalid || normalizedQuestion.scoringModel !== "partial" || normalizedQuestion.model !== "multi_select" || normalizedQuestion.expectedValues == null || normalizedQuestion.expectedValues.length === 0) return null;
+	const expectedValues = new Set(normalizedQuestion.expectedValues);
+	const correctSelections = normalizedQuestion.answeredValues.filter((value) => expectedValues.has(value)).length;
+	const incorrectSelections = normalizedQuestion.answeredValues.filter((value) => !expectedValues.has(value)).length;
+	const pointShare = 1 / normalizedQuestion.expectedValues.length;
+	return buildQuestionResult(normalizedQuestion, Math.max(0, Math.min(1, correctSelections * pointShare - incorrectSelections * pointShare)), 1);
+}
+function scoreQuizQuestions(questions) {
+	const questionResults = {};
+	for (const question of questions.map(normalizeQuestionInput)) {
+		if (!isSupportedCorrectnessQuestion(question)) continue;
+		const result = question.scoringModel === "partial" ? scorePartialQuestion(question) : scoreExactQuestion(question);
+		if (result) questionResults[result.key] = result;
+	}
+	return questionResults;
+}
+function calculateScoreResults(questionResults) {
+	const eligibleQuestions = questionResults.filter((question) => question.eligible);
+	if (eligibleQuestions.length === 0) return null;
+	const earnedPoints = eligibleQuestions.reduce((total, question) => total + question.earnedPoints, 0);
+	const possiblePoints = eligibleQuestions.reduce((total, question) => total + question.possiblePoints, 0);
+	if (possiblePoints === 0) return null;
+	return {
+		earnedPoints,
+		possiblePoints,
+		percent: Math.round(earnedPoints / possiblePoints * 100),
+		eligibleCount: eligibleQuestions.length,
+		correctCount: eligibleQuestions.filter((question) => question.state === "correct").length,
+		partialCount: eligibleQuestions.filter((question) => question.state === "partial").length,
+		incorrectCount: eligibleQuestions.filter((question) => question.state === "incorrect").length,
+		unansweredCount: eligibleQuestions.filter((question) => question.state === "unanswered").length
+	};
+}
+function aggregateWeightedScores(questions) {
+	const eligibleWeightedQuestions = questions.map(normalizeQuestionInput).filter((question) => !question.invalid && question.eligible && question.usesWeightedScoring);
+	if (eligibleWeightedQuestions.length === 0) return null;
+	const scores = {};
+	for (const question of eligibleWeightedQuestions) for (const [category, weight] of Object.entries(question.weightedScores)) scores[category] = (scores[category] ?? 0) + weight;
+	return calculateWinner(scores);
+}
+function derivePassResults(scoreResults, config) {
+	if (!scoreResults || !config) return null;
+	const passed = scoreResults.percent >= config.percentGte;
+	return {
+		passed,
+		label: passed ? "pass" : "fail"
+	};
+}
+function deriveBandResults(scoreResults, bands) {
+	if (!scoreResults || !bands || bands.length === 0) return null;
+	const match = bands.find((band) => {
+		const meetsMin = band.minPercent == null || scoreResults.percent >= band.minPercent;
+		const meetsMax = band.maxPercent == null || scoreResults.percent <= band.maxPercent;
+		return meetsMin && meetsMax;
+	});
+	return {
+		id: match?.id ?? null,
+		label: match?.label ?? null
+	};
+}
+function buildOutcomeBundle(questions, questionResults, config) {
+	const score = calculateScoreResults(getEligibleQuestionResults(questionResults));
+	return {
+		score,
+		weighted: aggregateWeightedScores(questions),
+		pass: derivePassResults(score, config.passFail),
+		band: deriveBandResults(score, config.bands)
+	};
+}
+function calculateSectionResults(questions, questionResults, config = {}) {
+	const sections = {};
+	const sectionIds = Array.from(new Set(questions.filter((question) => !question.invalid && question.section != null).map((question) => question.section)));
+	for (const sectionId of sectionIds) {
+		const sectionQuestions = questions.filter((question) => !question.invalid && question.section === sectionId);
+		const sectionQuestionResults = Object.fromEntries(Object.entries(questionResults).filter(([, question]) => question.section === sectionId));
+		const sectionConfig = config.sections?.[sectionId];
+		sections[sectionId] = buildOutcomeBundle(sectionQuestions, sectionQuestionResults, {
+			passFail: sectionConfig?.passFail ?? config.passFail,
+			bands: sectionConfig?.bands ?? config.bands
+		});
+	}
+	return sections;
+}
+function scoreQuiz(questions, config = {}) {
+	const normalizedQuestions = questions.map(normalizeQuestionInput).filter((question) => !question.invalid);
+	const questionResults = scoreQuizQuestions(normalizedQuestions);
+	const { score, weighted, pass, band } = buildOutcomeBundle(normalizedQuestions, questionResults, config);
+	const sections = calculateSectionResults(normalizedQuestions, questionResults, config);
+	return {
+		activeQuestionModels: Array.from(new Set(normalizedQuestions.filter((question) => question.eligible).map((question) => question.model))),
+		activeScoringModels: getUniqueScoringModels(normalizedQuestions.filter((question) => question.eligible)),
+		activeOutcomes: [
+			...score ? ["score"] : [],
+			...weighted ? ["weighted"] : [],
+			...pass ? ["pass"] : [],
+			...band ? ["band"] : [],
+			...Object.keys(sections).length > 0 ? ["sections"] : []
+		],
+		questions: questionResults,
+		score,
+		weighted,
+		pass,
+		band,
+		sections
+	};
+}
+//#endregion
+//#region src/basin-client.ts
+/** Check if JWT is expired (with 60s buffer) */
+function isJwtExpired(jwt) {
+	try {
+		const payload = jwt.split(".")[1];
+		if (!payload) return true;
+		const { exp } = JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
+		return typeof exp === "number" && exp <= Date.now() / 1e3 + 60;
+	} catch {
+		return true;
+	}
+}
+async function fetchBasinJWT(endpoint, storage, storageKey) {
+	const cached = storage.getItem(storageKey);
+	if (cached && !isJwtExpired(cached)) return cached;
+	if (cached) storage.removeItem(storageKey);
+	try {
+		const res = await fetch(`${endpoint}/generate_jwt`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		if (!res.ok) {
+			log.warn("[basin] JWT endpoint returned", res.status, "- multistep may not be supported");
+			return "";
+		}
+		const data = await res.json();
+		if (data.jwt) {
+			storage.setItem(storageKey, data.jwt);
+			return data.jwt;
+		}
+		return "";
+	} catch (error) {
+		log.warn("[basin] Failed to fetch JWT (multistep may not be supported):", error);
+		return "";
+	}
+}
+//#endregion
+//#region src/utm.ts
+const UTM_KEYS = [
+	"source",
+	"campaign",
+	"medium",
+	"content",
+	"term",
+	"wec"
+];
+function extractUtms(search) {
+	const params = new URLSearchParams(search);
+	const utms = {};
+	for (const key of UTM_KEYS) {
+		const matchingKey = [...params.keys()].find((k) => {
+			const lower = k.toLowerCase();
+			return lower === key || lower.endsWith(`_${key}`) || lower.endsWith(`-${key}`);
+		});
+		if (matchingKey) {
+			const val = params.get(matchingKey)?.toLowerCase();
+			if (val) utms[key] = val;
+		}
+	}
+	return utms;
+}
+function buildFcrmUtms(utms) {
+	const result = {};
+	for (const key of UTM_KEYS) if (utms[key]) result[`utm_${key}`] = utms[key];
+	return result;
+}
+//#endregion
+//#region src/url-utils.ts
+/** Appends query params to a URL without overriding existing ones. */
+function updateUrlWithParams(url, params, base) {
+	function appendParamsToParsedUrl(parsed) {
+		params.forEach((value, param) => {
+			if (!parsed.searchParams.has(param)) parsed.searchParams.set(param, value);
+		});
+		return parsed.toString();
+	}
+	function appendParamsToRelativeUrl(relativeUrl) {
+		const hashIndex = relativeUrl.indexOf("#");
+		const beforeHash = hashIndex >= 0 ? relativeUrl.slice(0, hashIndex) : relativeUrl;
+		const hash = hashIndex >= 0 ? relativeUrl.slice(hashIndex) : "";
+		const queryIndex = beforeHash.indexOf("?");
+		const path = queryIndex >= 0 ? beforeHash.slice(0, queryIndex) : beforeHash;
+		const query = queryIndex >= 0 ? beforeHash.slice(queryIndex + 1) : "";
+		const searchParams = new URLSearchParams(query);
+		params.forEach((value, param) => {
+			if (!searchParams.has(param)) searchParams.set(param, value);
+		});
+		const nextQuery = searchParams.toString();
+		return nextQuery ? `${path}?${nextQuery}${hash}` : `${path}${hash}`;
+	}
+	function isAbsoluteLikeUrl(value) {
+		const trimmed = value.trim();
+		return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(trimmed) || trimmed.startsWith("//");
+	}
+	try {
+		if (base) return appendParamsToParsedUrl(new URL(url, base));
+		try {
+			return appendParamsToParsedUrl(new URL(url));
+		} catch {
+			if (isAbsoluteLikeUrl(url)) return url;
+			return appendParamsToRelativeUrl(url);
+		}
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region src/memory-cache.ts
+function createMemoryCache(options = {}) {
+	const entries = /* @__PURE__ */ new Map();
+	const max = options.max ?? 0;
+	const defaultTtlMs = options.ttlMs ?? 0;
+	const now = options.now ?? Date.now;
+	function isExpired(entry) {
+		return entry.expiresAt != null && entry.expiresAt <= now();
+	}
+	function touch(key, entry) {
+		entries.delete(key);
+		entries.set(key, entry);
+	}
+	function pruneExpired() {
+		for (const [key, entry] of entries) {
+			if (!isExpired(entry)) continue;
+			entries.delete(key);
+		}
+	}
+	function enforceMaxSize() {
+		if (max <= 0) return;
+		while (entries.size > max) {
+			const oldestKey = entries.keys().next().value;
+			if (oldestKey === void 0) return;
+			entries.delete(oldestKey);
+		}
+	}
+	function resolveExpiresAt(ttlMs) {
+		const effectiveTtlMs = ttlMs ?? defaultTtlMs;
+		if (effectiveTtlMs <= 0) return null;
+		return now() + effectiveTtlMs;
+	}
+	return {
+		get(key) {
+			const entry = entries.get(key);
+			if (!entry) return void 0;
+			if (isExpired(entry)) {
+				entries.delete(key);
+				return;
+			}
+			touch(key, entry);
+			return entry.value;
+		},
+		set(key, value, setOptions = {}) {
+			pruneExpired();
+			touch(key, {
+				value,
+				expiresAt: resolveExpiresAt(setOptions.ttlMs)
+			});
+			enforceMaxSize();
+			return value;
+		},
+		has(key) {
+			const entry = entries.get(key);
+			if (!entry) return false;
+			if (isExpired(entry)) {
+				entries.delete(key);
+				return false;
+			}
+			return true;
+		},
+		delete(key) {
+			return entries.delete(key);
+		},
+		clear() {
+			entries.clear();
+		},
+		size() {
+			pruneExpired();
+			return entries.size;
+		}
+	};
+}
+//#endregion
+//#region src/flatten.ts
+function flattenObject(obj, prefix = "") {
+	const result = {};
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		const flatKey = prefix ? `${prefix}.${key}` : key;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) Object.assign(result, flattenObject(value, flatKey));
+		else result[flatKey] = value;
+	}
+	return result;
+}
+//#endregion
+//#region src/counter.ts
+/** djb2 hash → 6-char hex string */
+function djb2(str) {
+	let hash = 5381;
+	for (let i = 0; i < str.length; i++) hash = hash * 33 ^ str.charCodeAt(i);
+	return (hash >>> 0).toString(16).slice(0, 6);
+}
+function inferCounterName(client, pathname) {
+	return `${client}-${djb2(pathname)}`;
+}
+function parseCounterUpdateAttr(value, client, pathname) {
+	if (!value || value === "false") return [];
+	if (value === "true" || value === "auto") return [{ name: inferCounterName(client, pathname) }];
+	const trimmed = value.trim();
+	if (trimmed.startsWith("[") || trimmed.startsWith("{")) try {
+		const parsed = JSON.parse(trimmed);
+		return (Array.isArray(parsed) ? parsed : [parsed]).filter((item) => typeof item === "object" && item !== null && typeof item.name === "string");
+	} catch (err) {
+		log.warn("[counter] Failed to parse counter update config:", value, err);
+		return [];
+	}
+	return [{ name: trimmed }];
+}
+function buildCounterPayload(config, context) {
+	const body = {};
+	if (config.add_amount != null) body.add_amount = config.add_amount;
+	if (config.add_amount_field) body.add_amount_field = config.add_amount_field;
+	if (context?.source_url) body.source = context.source_url;
+	return {
+		name: config.name,
+		body
+	};
+}
+//#endregion
+//#region src/counter-display.ts
+const TIERS = [
+	{
+		threshold: 5e5,
+		step: 1e5
+	},
+	{
+		threshold: 2e5,
+		step: 5e4
+	},
+	{
+		threshold: 1e5,
+		step: 25e3
+	},
+	{
+		threshold: 5e4,
+		step: 1e4
+	},
+	{
+		threshold: 2e4,
+		step: 5e3
+	},
+	{
+		threshold: 5e3,
+		step: 2500
+	},
+	{
+		threshold: 2e3,
+		step: 500
+	},
+	{
+		threshold: 500,
+		step: 250
+	},
+	{
+		threshold: 350,
+		step: 100
+	},
+	{
+		threshold: 0,
+		step: 50
+	}
+];
+function computeAutoTarget(current) {
+	const raw = current * 1.05;
+	const step = TIERS.find((t) => raw >= t.threshold)?.step ?? 50;
+	return Math.ceil(raw / step) * step;
+}
+function formatCounterValue(value, locale, notation, useGrouping) {
+	try {
+		return new Intl.NumberFormat(locale ?? "en", {
+			notation: notation ?? "standard",
+			useGrouping: useGrouping ?? true
+		}).format(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/insert.ts
+function parseInsertDirective(value) {
+	if (!value) return null;
+	const colonIndex = value.indexOf(":");
+	if (colonIndex <= 0 || colonIndex === value.length - 1) return null;
+	return {
+		source: value.slice(0, colonIndex),
+		key: value.slice(colonIndex + 1)
+	};
+}
+function parseInsertDirectives(value) {
+	if (!value) return [];
+	return value.split("|").map((segment) => parseInsertDirective(segment.trim())).filter((d) => d !== null);
+}
+//#endregion
+//#region src/crm-context.ts
+function buildContext(config, frontendKeys, counters) {
+	const ctx = {};
+	for (const [key, value] of Object.entries(config)) if (!frontendKeys.has(key) && value !== void 0) ctx[key] = typeof value === "number" || typeof value === "boolean" ? String(value) : value;
+	if (counters && counters.length > 0) ctx.counters = counters;
+	return ctx;
+}
+//#endregion
+//#region src/crm-utils.ts
+const BLOCKED_REDIRECT_PROTOCOLS = /^(javascript|data|vbscript):/i;
+function isCounterResponse(data) {
+	return typeof data.count === "number" && typeof data.name === "string";
+}
+function isSafeRedirectUrl(url) {
+	const trimmed = url.trim();
+	if (!trimmed) return false;
+	if (trimmed.startsWith("//")) return false;
+	if (BLOCKED_REDIRECT_PROTOCOLS.test(trimmed)) return false;
+	return true;
+}
+//#endregion
+//#region src/counter-fetch.ts
+const FALLBACK = (name) => ({
+	count: 0,
+	name
+});
+async function fetchCounter(name, siteId, apiBaseUrl, sourceUrl) {
+	const url = `${apiBaseUrl}counter/${encodeURIComponent(name)}?site_id=${encodeURIComponent(siteId)}`;
+	let res;
+	try {
+		res = await fetch(url, { headers: { "x-source": sourceUrl } });
+	} catch {
+		return FALLBACK(name);
+	}
+	if (!res.ok) return FALLBACK(name);
+	let data;
+	try {
+		data = await res.json();
+	} catch {
+		return FALLBACK(name);
+	}
+	return {
+		count: Number(data.count) || 0,
+		name
+	};
+}
+//#endregion
+//#region src/device.ts
+function detectDeviceType(input) {
+	const { userAgent: ua = "", maxTouchPoints: maxTouch = 0, screenWidth, uaDataMobile } = input;
+	if (uaDataMobile === true) return "mobile";
+	if (maxTouch > 0 && /iPad|Macintosh/i.test(ua) && !/iPhone/i.test(ua)) return "tablet";
+	if (maxTouch > 0 && /Android/i.test(ua) && !/Mobile/i.test(ua)) return "tablet";
+	if (/iPhone|iPod|Android.*Mobile|webOS|BlackBerry|Opera Mini|IEMobile/i.test(ua)) return "mobile";
+	if (maxTouch > 0) {
+		const width = screenWidth ?? 1920;
+		if (width <= 480) return "mobile";
+		if (width <= 1024) return "tablet";
+	}
+	return "desktop";
+}
+//#endregion
+//#region src/crm-fetch.ts
+const noop = () => {};
+async function crmFetch(url, payload, options = {}) {
+	const { waitForResponse = true, sourceUrl, deviceType, method = "POST" } = options;
+	const body = JSON.stringify(payload);
+	const headers = { "Content-Type": "application/json" };
+	if (sourceUrl) headers["x-source"] = sourceUrl;
+	if (deviceType !== void 0) headers["x-device-type"] = deviceType;
+	if (!waitForResponse) {
+		try {
+			fetch(url, {
+				method,
+				headers,
+				body,
+				keepalive: true
+			}).catch(noop);
+		} catch {}
+		return {
+			ok: true,
+			status: 0,
+			data: null
+		};
+	}
+	try {
+		const response = await fetch(url, {
+			method,
+			headers,
+			body
+		});
+		let data = null;
+		try {
+			data = await response.json();
+		} catch {}
+		return {
+			ok: response.ok,
+			status: response.status,
+			data
+		};
+	} catch {
+		return {
+			ok: false,
+			status: 0,
+			data: null
+		};
+	}
+}
+//#endregion
+//#region src/crm-request.ts
+function assembleCrmRequest({ body: rawBody, config, frontendKeys, utms, queryParams, sourceUrl, counters, jsonGroups }) {
+	const configuredCounters = Array.isArray(config.counter_update) ? config.counter_update : void 0;
+	const resolvedCounters = counters ?? configuredCounters;
+	const body = { ...rawBody };
+	if (jsonGroups) {
+		const groupEntries = Object.entries(jsonGroups);
+		if (groupEntries.length > 0) body["json-groups"] = JSON.stringify(groupEntries.map(([key, fields]) => ({ [key]: fields })));
+	}
+	return {
+		body,
+		source: sourceUrl,
+		utms: buildFcrmUtms(utms),
+		query_params: queryParams,
+		context: buildContext(config, frontendKeys, resolvedCounters)
+	};
+}
+//#endregion
+//#region src/polling.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function matchesFormat(example, value) {
+	if (example === null || example === void 0) return value === example;
+	if (value === null || value === void 0) return false;
+	if (typeof example !== typeof value) return false;
+	if (Array.isArray(example)) {
+		if (!Array.isArray(value)) return false;
+		if (example.length === 0) return true;
+		if (example.length === 1) return value.every((entry) => matchesFormat(example[0], entry));
+		if (value.length < example.length) return false;
+		return example.every((entry, index) => matchesFormat(entry, value[index]));
+	}
+	if (isRecord(example)) {
+		if (!isRecord(value)) return false;
+		return Object.entries(example).every(([key, nestedExample]) => key in value && matchesFormat(nestedExample, value[key]));
+	}
+	if (example === "") return typeof value === "string";
+	return example === value;
+}
+//#endregion
+export { aggregateWeightedScores, answersChanged, assembleCrmRequest, buildContext, buildCounterPayload, buildFcrmUtms, calculateScoreResults, calculateSectionResults, calculateWinner, computeAutoTarget, createMemoryCache, createSessionStore, createStepsStore, crmFetch, deriveBandResults, derivePassResults, deriveQuestionState, detectDeviceType, errorMessages, evaluateNextMap, evaluatePredicate, evaluateShowIf, extractUtms, fetchBasinJWT, fetchCounter, flattenObject, formatCounterValue, getErrorMessagesForLanguage, getPhoneExample, getPlacesMessagesForLanguage, getPostalExample, inferCounterName, isCounterResponse, isJwtExpired, isSafeRedirectUrl, matchesFormat, mergeAnswers, parseCounterUpdateAttr, parseInsertDirective, parseInsertDirectives, resolveValue, scoreExactQuestion, scorePartialQuestion, scoreQuiz, scoreQuizQuestions, updateUrlWithParams, validators };
+
+//# sourceMappingURL=index.js.map