survey-expression 0.0.0-stage → 4.4.0

package/dist/index.js

@@ -0,0 +1,1176 @@
+import { MILLISECONDS_PER_SECOND, exhaustiveGuard, getOrCreate, padWithZeros, takeOne } from "@esposter/shared";
+import { err, ok } from "neverthrow";
+// src/models/SurveyExpressionBinaryOperator.ts
+let SurveyExpressionBinaryOperator = /* @__PURE__ */ function(SurveyExpressionBinaryOperator) {
+	SurveyExpressionBinaryOperator["Add"] = "add";
+	SurveyExpressionBinaryOperator["AllOf"] = "allOf";
+	SurveyExpressionBinaryOperator["And"] = "and";
+	SurveyExpressionBinaryOperator["AnyOf"] = "anyOf";
+	SurveyExpressionBinaryOperator["Contains"] = "contains";
+	SurveyExpressionBinaryOperator["Divide"] = "divide";
+	SurveyExpressionBinaryOperator["Equal"] = "equal";
+	SurveyExpressionBinaryOperator["Greater"] = "greater";
+	SurveyExpressionBinaryOperator["GreaterOrEqual"] = "greaterOrEqual";
+	SurveyExpressionBinaryOperator["Less"] = "less";
+	SurveyExpressionBinaryOperator["LessOrEqual"] = "lessOrEqual";
+	SurveyExpressionBinaryOperator["Modulo"] = "modulo";
+	SurveyExpressionBinaryOperator["Multiply"] = "multiply";
+	SurveyExpressionBinaryOperator["NotContains"] = "notContains";
+	SurveyExpressionBinaryOperator["NotEqual"] = "notEqual";
+	SurveyExpressionBinaryOperator["Or"] = "or";
+	SurveyExpressionBinaryOperator["Power"] = "power";
+	SurveyExpressionBinaryOperator["Subtract"] = "subtract";
+	return SurveyExpressionBinaryOperator;
+}({});
+// src/models/SurveyExpressionNodeType.ts
+let SurveyExpressionNodeType = /* @__PURE__ */ function(SurveyExpressionNodeType) {
+	SurveyExpressionNodeType["Binary"] = "binary";
+	SurveyExpressionNodeType["Call"] = "call";
+	SurveyExpressionNodeType["List"] = "list";
+	SurveyExpressionNodeType["Literal"] = "literal";
+	SurveyExpressionNodeType["Reference"] = "reference";
+	SurveyExpressionNodeType["Unary"] = "unary";
+	return SurveyExpressionNodeType;
+}({});
+// src/models/SurveyExpressionTokenType.ts
+let SurveyExpressionTokenType = /* @__PURE__ */ function(SurveyExpressionTokenType) {
+	SurveyExpressionTokenType["Boolean"] = "boolean";
+	SurveyExpressionTokenType["End"] = "end";
+	SurveyExpressionTokenType["Identifier"] = "identifier";
+	SurveyExpressionTokenType["Number"] = "number";
+	SurveyExpressionTokenType["Operator"] = "operator";
+	SurveyExpressionTokenType["Punctuation"] = "punctuation";
+	SurveyExpressionTokenType["Reference"] = "reference";
+	SurveyExpressionTokenType["String"] = "string";
+	return SurveyExpressionTokenType;
+}({});
+// src/models/SurveyExpressionUnaryOperator.ts
+let SurveyExpressionUnaryOperator = /* @__PURE__ */ function(SurveyExpressionUnaryOperator) {
+	SurveyExpressionUnaryOperator["Empty"] = "empty";
+	SurveyExpressionUnaryOperator["Negate"] = "negate";
+	SurveyExpressionUnaryOperator["Not"] = "not";
+	SurveyExpressionUnaryOperator["NotEmpty"] = "notEmpty";
+	return SurveyExpressionUnaryOperator;
+}({});
+// src/services/shared/checkIsSurveyFieldName.ts
+const checkIsSurveyFieldName = (text) => !/[{}><=!]/u.test(text);
+// src/services/shared/getOwnValue.ts
+const getOwnValue = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
+// src/services/shared/getSurveyArrayItems.ts
+const getSurveyArrayItems = (data) => {
+	if (Array.isArray(data)) return data;
+	if (typeof data === "object") return Object.values(data);
+	return [];
+};
+// src/services/shared/toSurveyLogicNumber.ts
+const NUMBER_TEXT_REGEX = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/iu;
+const toSurveyLogicNumber = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value !== "string") return void 0;
+	const text = value.trim();
+	if (!NUMBER_TEXT_REGEX.test(text)) return void 0;
+	const number = Number(text);
+	return Number.isFinite(number) ? number : void 0;
+};
+// src/services/shared/getSurveyArrayParams.ts
+const getSurveyArrayParams = (args) => {
+	const [data, name, returnCandidate] = args;
+	if (args.length < 2 || args.length > 4 || typeof name !== "string") return void 0;
+	const hasReturnField = args.length > 2 && typeof returnCandidate === "string" && checkIsSurveyFieldName(returnCandidate);
+	const filterIndex = hasReturnField ? 3 : 2;
+	if (args.length > filterIndex) return void 0;
+	const rows = [];
+	for (const item of getSurveyArrayItems(data)) {
+		if (typeof item !== "object" || Array.isArray(item)) continue;
+		const field = toSurveyLogicNumber(getOwnValue(item, name));
+		if (field !== void 0) rows.push({
+			field,
+			item
+		});
+	}
+	return {
+		returnField: hasReturnField && returnCandidate !== name ? returnCandidate : void 0,
+		rows
+	};
+};
+// src/services/shared/countSurveyLogicDecimals.ts
+const countSurveyLogicDecimals = (number) => {
+	const [mantissa = "", exponent = "0"] = number.toExponential().split("e");
+	const fraction = mantissa.split(".")[1] ?? "";
+	return Math.max(fraction.length - Number(exponent), 0);
+};
+// src/services/SurveyExpressionBinaryOperatorMap.ts
+const SurveyExpressionBinaryOperatorMap = {
+	"!=": {
+		operator: "notEqual",
+		power: 3
+	},
+	"%": {
+		operator: "modulo",
+		power: 5
+	},
+	"*": {
+		operator: "multiply",
+		power: 5
+	},
+	"+": {
+		operator: "add",
+		power: 4
+	},
+	"-": {
+		operator: "subtract",
+		power: 4
+	},
+	"/": {
+		operator: "divide",
+		power: 5
+	},
+	"<": {
+		operator: "less",
+		power: 3
+	},
+	"<=": {
+		operator: "lessOrEqual",
+		power: 3
+	},
+	"=": {
+		operator: "equal",
+		power: 3
+	},
+	">": {
+		operator: "greater",
+		power: 3
+	},
+	">=": {
+		operator: "greaterOrEqual",
+		power: 3
+	},
+	"^": {
+		operator: "power",
+		power: 6,
+		rightAssociative: true
+	},
+	allof: {
+		operator: "allOf",
+		power: 3
+	},
+	and: {
+		operator: "and",
+		power: 2
+	},
+	anyof: {
+		operator: "anyOf",
+		power: 3
+	},
+	contains: {
+		operator: "contains",
+		power: 3
+	},
+	notcontains: {
+		operator: "notContains",
+		power: 3
+	},
+	or: {
+		operator: "or",
+		power: 1
+	}
+};
+// src/services/SurveyExpressionPrefixOperatorMap.ts
+const SurveyExpressionPrefixOperatorMap = {
+	"-": {
+		operator: "negate",
+		power: 6
+	},
+	not: {
+		operator: "not",
+		power: 3
+	}
+};
+// src/services/tokenizer/checkIsSurveyExpressionWordStart.ts
+const checkIsSurveyExpressionWordStart = (character) => /[A-Za-z_]/u.test(character);
+// src/services/constants.ts
+const LOWEST_POWER = 0;
+const MAX_DECIMAL_PLACES = 100;
+const MAX_SURVEY_EXPRESSION_LENGTH = 2e3;
+const PUNCTUATION_CHARACTERS = [
+	"(",
+	")",
+	"[",
+	"]",
+	","
+];
+const STRING_QUOTES = ["'", "\""];
+const SYMBOL_OPERATOR_TEXTS = [...Object.keys(SurveyExpressionBinaryOperatorMap), ...Object.keys(SurveyExpressionPrefixOperatorMap)].filter((operatorText) => !checkIsSurveyExpressionWordStart(operatorText.charAt(0))).toSorted((firstText, secondText) => secondText.length - firstText.length);
+// src/services/shared/roundSurveyLogicResult.ts
+const roundSurveyLogicResult = (result, digits) => digits > 0 ? Number(result.toFixed(Math.min(digits, 100))) : result;
+// src/services/shared/roundSurveyLogicSum.ts
+const roundSurveyLogicSum = (left, right, sum) => roundSurveyLogicResult(sum, Math.max(countSurveyLogicDecimals(left), countSurveyLogicDecimals(right)));
+// src/services/shared/toSurveyLogicResult.ts
+const toSurveyLogicResult = (result) => Number.isFinite(result) ? result : void 0;
+// src/services/shared/sumSurveyNumbers.ts
+const sumSurveyNumbers = (numbers) => {
+	let total = 0;
+	for (const number of numbers) total = roundSurveyLogicSum(total, number, total + number);
+	return toSurveyLogicResult(total);
+};
+// src/services/functions/avgInArrayFunction.ts
+const avgInArrayFunction = (args) => {
+	const params = getSurveyArrayParams(args);
+	if (params === void 0 || params.rows.length === 0) return void 0;
+	const total = sumSurveyNumbers(params.rows.map((row) => row.field));
+	return total === void 0 ? void 0 : total / params.rows.length;
+};
+// src/services/functions/countInArrayFunction.ts
+const countInArrayFunction = (args) => {
+	const params = getSurveyArrayParams(args);
+	if (params === void 0) return void 0;
+	return params.rows.length;
+};
+// src/services/shared/getSurveyExtreme.ts
+const getSurveyExtreme = (candidates, checkReplaces) => {
+	let best;
+	for (const candidate of candidates) if (best === void 0 || checkReplaces(best, candidate)) best = candidate;
+	return best;
+};
+// src/services/shared/getSurveyArrayExtreme.ts
+const getSurveyArrayExtreme = (params, checkReplaces) => {
+	const best = getSurveyExtreme(params.rows, (bestRow, candidateRow) => checkReplaces(bestRow.field, candidateRow.field));
+	if (best === void 0) return void 0;
+	return params.returnField === void 0 ? best.field : getOwnValue(best.item, params.returnField);
+};
+// src/services/functions/maxInArrayFunction.ts
+const maxInArrayFunction = (args) => {
+	const params = getSurveyArrayParams(args);
+	if (params === void 0) return void 0;
+	return getSurveyArrayExtreme(params, (best, candidate) => candidate > best);
+};
+// src/services/functions/minInArrayFunction.ts
+const minInArrayFunction = (args) => {
+	const params = getSurveyArrayParams(args);
+	if (params === void 0) return void 0;
+	return getSurveyArrayExtreme(params, (best, candidate) => candidate < best);
+};
+// src/services/functions/sumInArrayFunction.ts
+const sumInArrayFunction = (args) => {
+	const params = getSurveyArrayParams(args);
+	if (params === void 0) return void 0;
+	return sumSurveyNumbers(params.rows.map((row) => row.field));
+};
+// src/services/functions/ArrayFunctionMap.ts
+const ArrayFunctionMap = {
+	avginarray: avgInArrayFunction,
+	countinarray: countInArrayFunction,
+	maxinarray: maxInArrayFunction,
+	mininarray: minInArrayFunction,
+	suminarray: sumInArrayFunction
+};
+// src/services/shared/createSurveyLogicWallClock.ts
+const createSurveyLogicWallClock = (year, monthIndex, day, { hour = 0, millisecond = 0, minute = 0, second = 0 } = {}) => {
+	const wallClock = /* @__PURE__ */ new Date(0);
+	wallClock.setUTCFullYear(year, monthIndex, day);
+	wallClock.setUTCHours(hour, minute, second, millisecond);
+	return wallClock;
+};
+// src/services/shared/addSurveyLogicMonths.ts
+const addSurveyLogicMonths = (wallClock, months) => {
+	const monthIndex = wallClock.getUTCFullYear() * 12 + wallClock.getUTCMonth() + months;
+	const year = Math.floor(monthIndex / 12);
+	const month = monthIndex - year * 12;
+	const lastDay = createSurveyLogicWallClock(year, month + 1, 0);
+	wallClock.setUTCFullYear(year, month, Math.min(wallClock.getUTCDate(), lastDay.getUTCDate()));
+};
+// src/services/shared/getSurveyLogicDayNumber.ts
+const MILLISECONDS_PER_DAY = 864e5;
+const getSurveyLogicDayNumber = (wallClock) => Math.floor(wallClock.getTime() / MILLISECONDS_PER_DAY);
+// src/services/shared/getDateDifference.ts
+const millisecondsPerUnitMap = {
+	hours: 36e5,
+	minutes: 6e4,
+	seconds: MILLISECONDS_PER_SECOND
+};
+const getDateDifference = (first, second, unit) => {
+	const [from, to] = first.getTime() <= second.getTime() ? [first, second] : [second, first];
+	if (unit === "days") return getSurveyLogicDayNumber(to) - getSurveyLogicDayNumber(from);
+	const milliseconds = getOwnValue(millisecondsPerUnitMap, unit);
+	if (milliseconds !== void 0) return Math.ceil((to.getTime() - from.getTime()) / milliseconds);
+	if (unit !== "months" && unit !== "years") return void 0;
+	const monthsApart = (to.getUTCFullYear() - from.getUTCFullYear()) * 12 + to.getUTCMonth() - from.getUTCMonth();
+	const anchor = new Date(from);
+	addSurveyLogicMonths(anchor, monthsApart);
+	const wholeMonths = anchor.getTime() > to.getTime() ? monthsApart - 1 : monthsApart;
+	return unit === "months" ? wholeMonths : Math.trunc(wholeMonths / 12);
+};
+// src/services/shared/checkIsSurveyLogicValueEmpty.ts
+const checkIsSurveyLogicValueEmpty = (value) => {
+	if (Array.isArray(value)) return value.length === 0;
+	if (typeof value === "object") return Object.values(value).every((field) => checkIsSurveyLogicValueEmpty(field));
+	return !value && value !== 0 && value !== false;
+};
+// src/services/shared/getSurveyOptionalArgument.ts
+const getSurveyOptionalArgument = (value, defaultValue, readArgument) => checkIsSurveyLogicValueEmpty(value) ? defaultValue : readArgument(value);
+// src/services/shared/getSurveyDateUnit.ts
+const getSurveyDateUnit = (value, defaultUnit) => getSurveyOptionalArgument(value, defaultUnit, (text) => typeof text === "string" ? text : void 0);
+// src/services/shared/checkIsCalendarDay.ts
+const checkIsCalendarDay = (year, month, day) => {
+	const date = createSurveyLogicWallClock(year, month - 1, day);
+	return date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+};
+// src/services/shared/toSurveyLogicWallClock.ts
+const toSurveyLogicWallClock = (instant) => createSurveyLogicWallClock(instant.getFullYear(), instant.getMonth(), instant.getDate(), {
+	hour: instant.getHours(),
+	millisecond: instant.getMilliseconds(),
+	minute: instant.getMinutes(),
+	second: instant.getSeconds()
+});
+// src/services/shared/parseSurveyLogicDate.ts
+const DATE_TEXT_REGEX = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})(?:[T ](?<hour>\d{2}):(?<minute>\d{2})(?::(?<second>\d{2})(?:\.(?<fraction>\d+))?)?(?<zone>Z|[+-]\d{2}:\d{2})?)?$/u;
+const parseSurveyLogicDate = (value) => {
+	if (typeof value !== "string") return void 0;
+	const groups = DATE_TEXT_REGEX.exec(value)?.groups;
+	if (groups === void 0) return void 0;
+	const { day: dayText, fraction: fractionText = "", hour: hourText = "0", minute: minuteText = "0", month: monthText, second: secondText = "0", year: yearText, zone } = groups;
+	const year = Number(yearText);
+	const month = Number(monthText);
+	const day = Number(dayText);
+	const hour = Number(hourText);
+	const minute = Number(minuteText);
+	const second = Number(secondText);
+	if (!checkIsCalendarDay(year, month, day) || hour > 23 || minute > 59 || second > 59) return void 0;
+	const millisecond = Number(`${fractionText}00`.slice(0, 3));
+	if (zone !== void 0) {
+		const instant = /* @__PURE__ */ new Date(`${yearText}-${monthText}-${dayText}T${hourText}:${minuteText}:${secondText}.${padWithZeros(millisecond, 3)}${zone}`);
+		return Number.isNaN(instant.getTime()) ? void 0 : toSurveyLogicWallClock(instant);
+	}
+	return createSurveyLogicWallClock(year, month - 1, day, {
+		hour,
+		millisecond,
+		minute,
+		second
+	});
+};
+// src/services/functions/ageFunction.ts
+const ageFunction = ([birthdateValue, intervalValue], context) => {
+	const birthdate = parseSurveyLogicDate(birthdateValue);
+	const now = toSurveyLogicWallClock(context.now);
+	const unit = getSurveyDateUnit(intervalValue, "years");
+	if (birthdate === void 0 || birthdate.getTime() > now.getTime() || unit === void 0) return void 0;
+	return getDateDifference(birthdate, now, unit);
+};
+// src/services/shared/toSurveyLogicDate.ts
+const toSurveyLogicDate = (wallClock) => {
+	if (Number.isNaN(wallClock.getTime())) return void 0;
+	const year = wallClock.getUTCFullYear();
+	if (year < 0 || year > 9999) return void 0;
+	const datePart = `${padWithZeros(year, 4)}-${padWithZeros(wallClock.getUTCMonth() + 1, 2)}-${padWithZeros(wallClock.getUTCDate(), 2)}`;
+	if (wallClock.getUTCHours() === 0 && wallClock.getUTCMinutes() === 0 && wallClock.getUTCSeconds() === 0 && wallClock.getUTCMilliseconds() === 0) return datePart;
+	return `${datePart}T${padWithZeros(wallClock.getUTCHours(), 2)}:${padWithZeros(wallClock.getUTCMinutes(), 2)}:${padWithZeros(wallClock.getUTCSeconds(), 2)}.${padWithZeros(wallClock.getUTCMilliseconds(), 3)}`;
+};
+// src/services/functions/dateAddFunction.ts
+const unitAdditionMap = {
+	days: (date, amount) => {
+		date.setUTCDate(date.getUTCDate() + amount);
+	},
+	hours: (date, amount) => {
+		date.setUTCHours(date.getUTCHours() + amount);
+	},
+	minutes: (date, amount) => {
+		date.setUTCMinutes(date.getUTCMinutes() + amount);
+	},
+	months: (date, amount) => {
+		addSurveyLogicMonths(date, amount);
+	},
+	seconds: (date, amount) => {
+		date.setUTCSeconds(date.getUTCSeconds() + amount);
+	},
+	years: (date, amount) => {
+		addSurveyLogicMonths(date, amount * 12);
+	}
+};
+const dateAddFunction = ([dateValue, amountValue, intervalValue]) => {
+	const date = parseSurveyLogicDate(dateValue);
+	const amount = toSurveyLogicNumber(amountValue);
+	const unit = getSurveyDateUnit(intervalValue, "days");
+	const addToDate = unit === void 0 ? void 0 : getOwnValue(unitAdditionMap, unit);
+	if (date === void 0 || amount === void 0 || addToDate === void 0) return void 0;
+	addToDate(date, Math.trunc(amount));
+	return toSurveyLogicDate(date);
+};
+// src/services/functions/dateDiffFunction.ts
+const dateDiffFunction = ([fromValue, toValue, intervalValue]) => {
+	const from = parseSurveyLogicDate(fromValue);
+	const to = parseSurveyLogicDate(toValue);
+	const unit = getSurveyDateUnit(intervalValue, "days");
+	if (from === void 0 || to === void 0 || unit === void 0) return void 0;
+	return getDateDifference(from, to, unit);
+};
+// src/services/shared/getDateOrNow.ts
+const getDateOrNow = (value, now) => getSurveyOptionalArgument(value, toSurveyLogicWallClock(now), parseSurveyLogicDate);
+// src/services/functions/dayFunction.ts
+const dayFunction = (args, context) => getDateOrNow(args[0], context.now)?.getUTCDate();
+// src/services/functions/monthFunction.ts
+const monthFunction = (args, context) => {
+	const date = getDateOrNow(args[0], context.now);
+	return date === void 0 ? void 0 : date.getUTCMonth() + 1;
+};
+// src/services/shared/getSurveyNumberWithPrecision.ts
+const getSurveyNumberWithPrecision = (args) => {
+	const [value, precisionValue] = args;
+	const number = toSurveyLogicNumber(value);
+	const precision = getSurveyOptionalArgument(precisionValue, 0, toSurveyLogicNumber);
+	if (number === void 0 || precision === void 0) return void 0;
+	if (!Number.isInteger(precision) || precision < 0 || precision > 100) return void 0;
+	return [number, precision];
+};
+// src/services/functions/roundFunction.ts
+const roundFunction = (args) => {
+	const numberWithPrecision = getSurveyNumberWithPrecision(args);
+	if (numberWithPrecision === void 0) return void 0;
+	const [number, precision] = numberWithPrecision;
+	const scale = 10 ** precision;
+	return toSurveyLogicResult(Math.round(number * scale * (1 + Number.EPSILON)) / scale);
+};
+// src/services/functions/todayFunction.ts
+const todayFunction = (args, context) => {
+	const date = toSurveyLogicWallClock(context.now);
+	date.setUTCHours(0, 0, 0, 0);
+	if (args.length === 1) {
+		const days = getSurveyOptionalArgument(args[0], 0, toSurveyLogicNumber);
+		if (days === void 0) return void 0;
+		date.setUTCDate(date.getUTCDate() + Math.trunc(days));
+	}
+	return toSurveyLogicDate(date);
+};
+// src/services/functions/truncFunction.ts
+const PRODUCT_DIGITS = 15;
+const truncFunction = (args) => {
+	const numberWithPrecision = getSurveyNumberWithPrecision(args);
+	if (numberWithPrecision === void 0) return void 0;
+	const [number, precision] = numberWithPrecision;
+	if (precision === 0) return Math.trunc(number);
+	if (countSurveyLogicDecimals(number) <= precision) return number;
+	const scale = 10 ** precision;
+	return Math.trunc(Number((number * scale).toPrecision(PRODUCT_DIGITS))) / scale;
+};
+// src/services/functions/weekdayFunction.ts
+const weekdayFunction = (args, context) => getDateOrNow(args[0], context.now)?.getUTCDay();
+// src/services/functions/yearFunction.ts
+const yearFunction = (args, context) => getDateOrNow(args[0], context.now)?.getUTCFullYear();
+// src/services/functions/DateFunctionMap.ts
+const DateFunctionMap = {
+	age: ageFunction,
+	dateadd: dateAddFunction,
+	datediff: dateDiffFunction,
+	day: dayFunction,
+	month: monthFunction,
+	round: roundFunction,
+	today: todayFunction,
+	trunc: truncFunction,
+	weekday: weekdayFunction,
+	year: yearFunction
+};
+// src/services/shared/flattenSurveyNumbers.ts
+const flattenSurveyNumbers = (values) => values.flatMap((value) => {
+	if (Array.isArray(value)) return flattenSurveyNumbers(value);
+	const number = toSurveyLogicNumber(value);
+	return number === void 0 ? [] : [number];
+});
+// src/services/functions/avgFunction.ts
+const avgFunction = (args) => {
+	const numbers = flattenSurveyNumbers(args);
+	if (numbers.length === 0) return void 0;
+	const total = sumSurveyNumbers(numbers);
+	return total === void 0 ? void 0 : total / numbers.length;
+};
+// src/services/functions/countFunction.ts
+const countFunction = (args) => {
+	return flattenSurveyNumbers(args).length;
+};
+// src/services/functions/iifFunction.ts
+const iifFunction = (args) => {
+	if (args.length < 2) return void 0;
+	const [condition, valueIfTrue, valueIfFalse] = args;
+	return condition === true ? valueIfTrue : valueIfFalse;
+};
+// src/services/functions/maxFunction.ts
+const maxFunction = (args) => getSurveyExtreme(flattenSurveyNumbers(args), (best, candidate) => candidate > best);
+// src/services/functions/minFunction.ts
+const minFunction = (args) => getSurveyExtreme(flattenSurveyNumbers(args), (best, candidate) => candidate < best);
+// src/services/shared/getSurveyTextIndex.ts
+const getSurveyTextIndex = (index, length) => Math.min(Math.max(Math.trunc(index), 0), length);
+// src/services/shared/toSurveyLogicText.ts
+const toSurveyLogicText = (value) => {
+	if (value === void 0) return "";
+	if (Array.isArray(value)) return value.map((item) => toSurveyLogicText(item)).join(",");
+	if (typeof value === "object") return "";
+	return String(value);
+};
+// src/services/functions/substringFunction.ts
+const substringFunction = (args) => {
+	const [textValue, start, end] = args;
+	const startNumber = toSurveyLogicNumber(start);
+	if (textValue === void 0 || startNumber === void 0) return void 0;
+	const text = toSurveyLogicText(textValue);
+	const endNumber = getSurveyOptionalArgument(end, text.length, toSurveyLogicNumber);
+	if (endNumber === void 0) return void 0;
+	const startIndex = getSurveyTextIndex(startNumber, text.length);
+	const endIndex = getSurveyTextIndex(endNumber, text.length);
+	return text.slice(Math.min(startIndex, endIndex), Math.max(startIndex, endIndex));
+};
+// src/services/functions/sumFunction.ts
+const sumFunction = (args) => sumSurveyNumbers(flattenSurveyNumbers(args));
+// src/services/functions/GeneralFunctionMap.ts
+const GeneralFunctionMap = {
+	avg: avgFunction,
+	count: countFunction,
+	iif: iifFunction,
+	max: maxFunction,
+	min: minFunction,
+	substring: substringFunction,
+	sum: sumFunction
+};
+// src/services/functions/SurveyLogicFunctionMap.ts
+const SurveyLogicFunctionMap = {
+	...ArrayFunctionMap,
+	...DateFunctionMap,
+	...GeneralFunctionMap
+};
+// src/services/getCallRefusal.ts
+const getCallRefusal = (node) => {
+	const name = node.name.toLowerCase();
+	if (getOwnValue(SurveyLogicFunctionMap, name) === void 0) return `Unknown function "${node.name}"`;
+	if (getOwnValue(ArrayFunctionMap, name) === void 0 || node.args.length < 3) return void 0;
+	const third = node.args.at(2);
+	return node.args.length === 3 && third?.type === "literal" && typeof third.value === "string" && checkIsSurveyFieldName(third.value) ? void 0 : `The filter form of "${node.name}" is not supported`;
+};
+// src/services/getSurveyExpressionChildren.ts
+const getSurveyExpressionChildren = (node) => {
+	switch (node.type) {
+		case "binary": return [node.left, node.right];
+		case "call": return node.args;
+		case "list": return node.items;
+		case "literal":
+		case "reference": return [];
+		case "unary": return [node.operand];
+		default: return exhaustiveGuard(node);
+	}
+};
+// src/services/findSurveyExpressionRefusal.ts
+const findSurveyExpressionRefusal = (node) => {
+	if (node.type === "call") {
+		const refusal = getCallRefusal(node);
+		if (refusal !== void 0) return {
+			message: refusal,
+			position: node.position
+		};
+	}
+	for (const child of getSurveyExpressionChildren(node)) {
+		const refusal = findSurveyExpressionRefusal(child);
+		if (refusal !== void 0) return refusal;
+	}
+};
+// src/services/SurveyExpressionPostfixOperatorMap.ts
+const SurveyExpressionPostfixOperatorMap = {
+	empty: {
+		operator: "empty",
+		power: 3
+	},
+	notempty: {
+		operator: "notEmpty",
+		power: 3
+	}
+};
+// src/services/parser/parseBinaryOperators.ts
+const parseBinaryOperators = (state, left, minimumPower, parse) => {
+	const token = takeOne(state.tokens, state.index);
+	if (token.type !== "operator") return ok(left);
+	const postfix = getOwnValue(SurveyExpressionPostfixOperatorMap, token.text);
+	if (postfix !== void 0 && postfix.power >= minimumPower) {
+		state.index++;
+		const unary = {
+			operand: left,
+			operator: postfix.operator,
+			position: token.position,
+			type: "unary"
+		};
+		return parseBinaryOperators(state, unary, minimumPower, parse);
+	}
+	const binary = getOwnValue(SurveyExpressionBinaryOperatorMap, token.text);
+	if (binary === void 0 || binary.power < minimumPower) return ok(left);
+	state.index++;
+	return parse(state, binary.rightAssociative ? binary.power : binary.power + 1).andThen((right) => {
+		const node = {
+			left,
+			operator: binary.operator,
+			position: token.position,
+			right,
+			type: "binary"
+		};
+		return parseBinaryOperators(state, node, minimumPower, parse);
+	});
+};
+// src/services/parser/checkIsPunctuation.ts
+const checkIsPunctuation = (token, text) => token.type === "punctuation" && token.text === text;
+// src/services/parser/parseSequenceItems.ts
+const parseSequenceItems = (state, closing, message, parse, items) => parse(state, 0).andThen((item) => {
+	items.push(item);
+	const token = takeOne(state.tokens, state.index);
+	if (checkIsPunctuation(token, ",")) {
+		state.index++;
+		return parseSequenceItems(state, closing, message, parse, items);
+	}
+	if (checkIsPunctuation(token, closing)) {
+		state.index++;
+		return ok(items);
+	}
+	return err({
+		message,
+		position: token.position
+	});
+});
+// src/services/parser/parseSequence.ts
+const parseSequence = (state, closing, message, parse) => {
+	if (checkIsPunctuation(takeOne(state.tokens, state.index), closing)) {
+		state.index++;
+		return ok([]);
+	}
+	return parseSequenceItems(state, closing, message, parse, []);
+};
+// src/services/parser/parseCall.ts
+const parseCall = (state, parse) => {
+	const name = takeOne(state.tokens, state.index);
+	state.index++;
+	const opening = takeOne(state.tokens, state.index);
+	const message = `Expected ( after ${name.text}`;
+	if (!checkIsPunctuation(opening, "(")) return err({
+		message,
+		position: opening.position
+	});
+	state.index++;
+	return parseSequence(state, ")", "Expected , or ) to close the call opened here", parse).map((args) => ({
+		args,
+		name: name.text,
+		position: name.position,
+		type: "call"
+	}));
+};
+// src/services/parser/parseGroup.ts
+const parseGroup = (state, parse) => {
+	state.index++;
+	return parse(state, 0).andThen((node) => {
+		const token = takeOne(state.tokens, state.index);
+		if (checkIsPunctuation(token, ")")) {
+			state.index++;
+			return ok(node);
+		}
+		return err({
+			message: "Expected ) to close the parenthesis opened here",
+			position: token.position
+		});
+	});
+};
+// src/services/parser/parseList.ts
+const parseList = (state, parse) => {
+	const opening = takeOne(state.tokens, state.index);
+	state.index++;
+	return parseSequence(state, "]", "Expected , or ] to close the list opened here", parse).map((items) => ({
+		items,
+		position: opening.position,
+		type: "list"
+	}));
+};
+// src/services/parser/parsePrefixOperator.ts
+const parsePrefixOperator = (state, parse) => {
+	const token = takeOne(state.tokens, state.index);
+	const prefix = getOwnValue(SurveyExpressionPrefixOperatorMap, token.text);
+	if (prefix === void 0) return err({
+		message: "Expected an expression",
+		position: token.position
+	});
+	state.index++;
+	return parse(state, prefix.power).map((operand) => ({
+		operand,
+		operator: prefix.operator,
+		position: token.position,
+		type: "unary"
+	}));
+};
+// src/services/parser/parseOperand.ts
+const parseOperand = (state, parse) => {
+	const token = takeOne(state.tokens, state.index);
+	switch (token.type) {
+		case "boolean":
+			state.index++;
+			return ok({
+				position: token.position,
+				type: "literal",
+				value: token.text === "true"
+			});
+		case "end": break;
+		case "identifier": return parseCall(state, parse);
+		case "number":
+			state.index++;
+			return ok({
+				position: token.position,
+				type: "literal",
+				value: Number(token.text)
+			});
+		case "operator": return parsePrefixOperator(state, parse);
+		case "punctuation":
+			if (checkIsPunctuation(token, "(")) return parseGroup(state, parse);
+			if (checkIsPunctuation(token, "[")) return parseList(state, parse);
+			break;
+		case "reference":
+			state.index++;
+			return ok({
+				name: token.text,
+				position: token.position,
+				type: "reference"
+			});
+		case "string":
+			state.index++;
+			return ok({
+				position: token.position,
+				type: "literal",
+				value: token.text
+			});
+		default: return exhaustiveGuard(token.type);
+	}
+	return err({
+		message: "Expected an expression",
+		position: token.position
+	});
+};
+// src/services/parser/parseBinary.ts
+const parseBinary = (state, minimumPower) => parseOperand(state, parseBinary).andThen((left) => parseBinaryOperators(state, left, minimumPower, parseBinary));
+// src/services/tokenizer/advanceSurveyExpressionWhile.ts
+const advanceSurveyExpressionWhile = (state, checkCharacter) => {
+	while (state.index < state.source.length && checkCharacter(state.source.charAt(state.index))) state.index++;
+};
+// src/services/tokenizer/checkIsSurveyExpressionWhitespace.ts
+const checkIsSurveyExpressionWhitespace = (character) => /\s/u.test(character);
+// src/services/tokenizer/checkIsSurveyExpressionDigit.ts
+const checkIsSurveyExpressionDigit = (character) => /\d/u.test(character);
+// src/services/tokenizer/readSurveyExpressionNumber.ts
+const readSurveyExpressionNumber = (state) => {
+	const start = state.index;
+	advanceSurveyExpressionWhile(state, checkIsSurveyExpressionDigit);
+	if (state.source.charAt(state.index) === "." && checkIsSurveyExpressionDigit(state.source.charAt(state.index + 1))) {
+		state.index++;
+		advanceSurveyExpressionWhile(state, checkIsSurveyExpressionDigit);
+	}
+	state.tokens.push({
+		position: start,
+		text: state.source.slice(start, state.index),
+		type: "number"
+	});
+};
+// src/services/tokenizer/readSurveyExpressionReference.ts
+const readSurveyExpressionReference = (state) => {
+	const start = state.index;
+	const closing = state.source.indexOf("}", start);
+	if (closing === -1) {
+		state.error = {
+			message: "Expected } to close the reference opened here",
+			position: state.source.length
+		};
+		return;
+	}
+	const name = state.source.slice(start + 1, closing);
+	if (name.trim() === "") {
+		state.error = {
+			message: "Expected a question name between { and }",
+			position: closing
+		};
+		return;
+	}
+	state.index = closing + 1;
+	state.tokens.push({
+		position: start,
+		text: name,
+		type: "reference"
+	});
+};
+// src/services/tokenizer/readSurveyExpressionString.ts
+const readSurveyExpressionString = (state) => {
+	const start = state.index;
+	const quote = state.source.charAt(start);
+	let text = "";
+	state.index++;
+	while (state.index < state.source.length && state.source.charAt(state.index) !== quote) {
+		const character = state.source.charAt(state.index);
+		const nextCharacter = state.source.charAt(state.index + 1);
+		if (character === "\\" && ["\\", quote].includes(nextCharacter)) {
+			text += nextCharacter;
+			state.index += 2;
+		} else {
+			text += character;
+			state.index++;
+		}
+	}
+	if (state.index >= state.source.length) {
+		state.error = {
+			message: `Expected ${quote} to close the string opened here`,
+			position: state.source.length
+		};
+		return;
+	}
+	state.index++;
+	state.tokens.push({
+		position: start,
+		text,
+		type: "string"
+	});
+};
+// src/services/tokenizer/readSurveyExpressionSymbol.ts
+const readSurveyExpressionSymbol = (state) => {
+	const character = state.source.charAt(state.index);
+	if (PUNCTUATION_CHARACTERS.includes(character)) {
+		state.tokens.push({
+			position: state.index,
+			text: character,
+			type: "punctuation"
+		});
+		state.index++;
+		return;
+	}
+	const symbol = SYMBOL_OPERATOR_TEXTS.find((symbolText) => state.source.startsWith(symbolText, state.index));
+	if (symbol === void 0) {
+		state.error = {
+			message: `Unexpected character ${character}`,
+			position: state.index
+		};
+		return;
+	}
+	state.tokens.push({
+		position: state.index,
+		text: symbol,
+		type: "operator"
+	});
+	state.index += symbol.length;
+};
+// src/services/tokenizer/checkIsSurveyExpressionKeyword.ts
+const checkIsSurveyExpressionKeyword = (lowercasedWord) => getOwnValue(SurveyExpressionBinaryOperatorMap, lowercasedWord) !== void 0 || getOwnValue(SurveyExpressionPostfixOperatorMap, lowercasedWord) !== void 0 || getOwnValue(SurveyExpressionPrefixOperatorMap, lowercasedWord) !== void 0;
+// src/services/tokenizer/checkIsSurveyExpressionWordCharacter.ts
+const checkIsSurveyExpressionWordCharacter = (character) => /[\dA-Za-z_]/u.test(character);
+// src/services/tokenizer/readSurveyExpressionWord.ts
+const readSurveyExpressionWord = (state) => {
+	const start = state.index;
+	advanceSurveyExpressionWhile(state, checkIsSurveyExpressionWordCharacter);
+	const word = state.source.slice(start, state.index);
+	const lowercasedWord = word.toLowerCase();
+	if (["false", "true"].includes(lowercasedWord)) state.tokens.push({
+		position: start,
+		text: lowercasedWord,
+		type: "boolean"
+	});
+	else if (checkIsSurveyExpressionKeyword(lowercasedWord)) state.tokens.push({
+		position: start,
+		text: lowercasedWord,
+		type: "operator"
+	});
+	else state.tokens.push({
+		position: start,
+		text: word,
+		type: "identifier"
+	});
+};
+// src/services/tokenizer/readSurveyExpressionToken.ts
+const readSurveyExpressionToken = (state) => {
+	const character = state.source.charAt(state.index);
+	const nextCharacter = state.source.charAt(state.index + 1);
+	if (checkIsSurveyExpressionDigit(character) || character === "." && checkIsSurveyExpressionDigit(nextCharacter)) readSurveyExpressionNumber(state);
+	else if (STRING_QUOTES.includes(character)) readSurveyExpressionString(state);
+	else if (character === "{") readSurveyExpressionReference(state);
+	else if (checkIsSurveyExpressionWordStart(character)) readSurveyExpressionWord(state);
+	else readSurveyExpressionSymbol(state);
+};
+// src/services/tokenizeSurveyExpression.ts
+const tokenizeSurveyExpression = (source) => {
+	const state = {
+		index: 0,
+		source,
+		tokens: []
+	};
+	advanceSurveyExpressionWhile(state, checkIsSurveyExpressionWhitespace);
+	while (state.error === void 0 && state.index < source.length) {
+		readSurveyExpressionToken(state);
+		advanceSurveyExpressionWhile(state, checkIsSurveyExpressionWhitespace);
+	}
+	if (state.error !== void 0) return err(state.error);
+	state.tokens.push({
+		position: source.length,
+		text: "",
+		type: "end"
+	});
+	return ok(state.tokens);
+};
+// src/services/parseSurveyExpression.ts
+const parseSurveyExpression = (source) => {
+	if (source.length > 2e3) return err({
+		message: "The expression is too long",
+		position: MAX_SURVEY_EXPRESSION_LENGTH
+	});
+	return tokenizeSurveyExpression(source).andThen((tokens) => {
+		const state = {
+			index: 0,
+			tokens
+		};
+		return parseBinary(state, 0).andThen((node) => {
+			const token = takeOne(tokens, state.index);
+			return token.type === "end" ? ok(node) : err({
+				message: "Expected the end of the expression",
+				position: token.position
+			});
+		});
+	});
+};
+// src/services/checkSurveyExpression.ts
+const checkSurveyExpression = (source) => parseSurveyExpression(source).match(findSurveyExpressionRefusal, (error) => error);
+// src/services/shared/roundSurveyLogicProduct.ts
+const roundSurveyLogicProduct = (left, right, product) => roundSurveyLogicResult(product, countSurveyLogicDecimals(left) + countSurveyLogicDecimals(right));
+// src/services/evaluator/operators/evaluateArithmeticOperator.ts
+const evaluateArithmeticOperator = (operator, left, right) => {
+	const leftNumber = toSurveyLogicNumber(left);
+	const rightNumber = toSurveyLogicNumber(right);
+	if (leftNumber === void 0 || rightNumber === void 0) return operator === "add" && leftNumber === void 0 && rightNumber === void 0 && typeof left === "string" && typeof right === "string" && left !== "" && right !== "" ? left + right : void 0;
+	switch (operator) {
+		case "add": return toSurveyLogicResult(roundSurveyLogicSum(leftNumber, rightNumber, leftNumber + rightNumber));
+		case "divide": return rightNumber === 0 ? void 0 : toSurveyLogicResult(leftNumber / rightNumber);
+		case "modulo": return rightNumber === 0 ? void 0 : toSurveyLogicResult(leftNumber % rightNumber);
+		case "multiply": return toSurveyLogicResult(roundSurveyLogicProduct(leftNumber, rightNumber, leftNumber * rightNumber));
+		case "power": return toSurveyLogicResult(leftNumber ** rightNumber);
+		case "subtract": return toSurveyLogicResult(roundSurveyLogicSum(leftNumber, rightNumber, leftNumber - rightNumber));
+		default: return exhaustiveGuard(operator);
+	}
+};
+// src/services/shared/compareSurveyLogicTexts.ts
+const BASIC_PLANE_LAST_CODE_POINT = 65535;
+const compareSurveyLogicTexts = (first, second) => {
+	let firstIndex = 0;
+	let secondIndex = 0;
+	while (firstIndex < first.length && secondIndex < second.length) {
+		const firstPoint = first.codePointAt(firstIndex) ?? 0;
+		const secondPoint = second.codePointAt(secondIndex) ?? 0;
+		if (firstPoint !== secondPoint) return firstPoint < secondPoint ? -1 : 1;
+		firstIndex += firstPoint > BASIC_PLANE_LAST_CODE_POINT ? 2 : 1;
+		secondIndex += secondPoint > BASIC_PLANE_LAST_CODE_POINT ? 2 : 1;
+	}
+	if (firstIndex < first.length) return 1;
+	return secondIndex < second.length ? -1 : 0;
+};
+// src/services/shared/toSurveyLogicPrimitive.ts
+const toSurveyLogicPrimitive = (value) => Array.isArray(value) ? toSurveyLogicText(value) : value;
+// src/services/shared/checkIsSurveyLogicLess.ts
+const checkIsSurveyLogicLess = (left, right) => {
+	const leftPrimitive = toSurveyLogicPrimitive(left);
+	const rightPrimitive = toSurveyLogicPrimitive(right);
+	if (checkIsSurveyLogicValueEmpty(leftPrimitive) || checkIsSurveyLogicValueEmpty(rightPrimitive)) return false;
+	const leftNumber = toSurveyLogicNumber(leftPrimitive);
+	const rightNumber = toSurveyLogicNumber(rightPrimitive);
+	if (leftNumber !== void 0 && rightNumber !== void 0) return leftNumber < rightNumber;
+	if (leftNumber !== void 0 && typeof rightPrimitive === "string") return false;
+	if (rightNumber !== void 0 && typeof leftPrimitive === "string") return false;
+	if (typeof leftPrimitive === "string" && typeof rightPrimitive === "string") return compareSurveyLogicTexts(leftPrimitive, rightPrimitive) < 0;
+	return false;
+};
+// src/services/shared/checkIsSurveyLogicPrimitiveEqual.ts
+const checkIsSurveyLogicPrimitiveEqual = (left, right) => {
+	if (typeof left === "boolean" || typeof right === "boolean") return left === right;
+	const leftNumber = toSurveyLogicNumber(left);
+	const rightNumber = toSurveyLogicNumber(right);
+	if (leftNumber !== void 0 || rightNumber !== void 0) return leftNumber === rightNumber;
+	return left === right;
+};
+// src/services/shared/checkIsSurveyLogicValueEqual.ts
+const checkIsSurveyLogicValueEqual = (left, right) => {
+	const isLeftEmpty = checkIsSurveyLogicValueEmpty(left);
+	if (isLeftEmpty || checkIsSurveyLogicValueEmpty(right)) return isLeftEmpty && checkIsSurveyLogicValueEmpty(right);
+	if (Array.isArray(left) && Array.isArray(right)) {
+		if (left.length !== right.length) return false;
+		let unpairedItems = right;
+		for (const item of left) {
+			const index = unpairedItems.findIndex((rightItem) => checkIsSurveyLogicValueEqual(item, rightItem));
+			if (index === -1) return false;
+			unpairedItems = unpairedItems.toSpliced(index, 1);
+		}
+		return true;
+	}
+	if (Array.isArray(left) || Array.isArray(right)) return false;
+	if (typeof left === "object" && typeof right === "object") return Object.keys({
+		...left,
+		...right
+	}).every((key) => checkIsSurveyLogicValueEqual(getOwnValue(left, key), getOwnValue(right, key)));
+	if (typeof left === "object" || typeof right === "object") return false;
+	return checkIsSurveyLogicPrimitiveEqual(left, right);
+};
+// src/services/evaluator/operators/evaluateComparisonOperator.ts
+const evaluateComparisonOperator = (operator, left, right) => {
+	switch (operator) {
+		case "equal": return checkIsSurveyLogicValueEqual(left, right);
+		case "greater": return checkIsSurveyLogicLess(right, left);
+		case "greaterOrEqual": return checkIsSurveyLogicValueEqual(left, right) || checkIsSurveyLogicLess(right, left);
+		case "less": return checkIsSurveyLogicLess(left, right);
+		case "lessOrEqual": return checkIsSurveyLogicValueEqual(left, right) || checkIsSurveyLogicLess(left, right);
+		case "notEqual": return !checkIsSurveyLogicValueEqual(left, right);
+		default: return exhaustiveGuard(operator);
+	}
+};
+// src/services/evaluator/operators/evaluateLogicOperator.ts
+const evaluateLogicOperator = (operator, left, right) => {
+	switch (operator) {
+		case "and": return left === true && right === true;
+		case "or": return left === true || right === true;
+		default: return exhaustiveGuard(operator);
+	}
+};
+// src/services/shared/checkIsSurveyLogicItemHeld.ts
+const checkIsSurveyLogicItemHeld = (haystack, item) => {
+	if (checkIsSurveyLogicValueEmpty(item) || checkIsSurveyLogicValueEmpty(haystack)) return false;
+	if (Array.isArray(haystack)) return haystack.some((haystackItem) => checkIsSurveyLogicValueEqual(haystackItem, item));
+	if (typeof haystack === "object" || typeof item === "object") return false;
+	return toSurveyLogicText(haystack).includes(toSurveyLogicText(item));
+};
+// src/services/shared/checkIsSurveyLogicContaining.ts
+const checkIsSurveyLogicContaining = (left, right) => {
+	if (checkIsSurveyLogicValueEmpty(right)) return false;
+	return (Array.isArray(right) ? right : [right]).every((item) => checkIsSurveyLogicItemHeld(left, item));
+};
+// src/services/shared/checkIsSurveyLogicAllOf.ts
+const checkIsSurveyLogicAllOf = (left, right) => checkIsSurveyLogicValueEmpty(right) || checkIsSurveyLogicContaining(left, right);
+// src/services/shared/checkIsSurveyLogicAnyOf.ts
+const checkIsSurveyLogicAnyOf = (left, right) => {
+	if (checkIsSurveyLogicValueEmpty(right)) return false;
+	return (Array.isArray(right) ? right : [right]).some((item) => checkIsSurveyLogicItemHeld(left, item));
+};
+// src/services/evaluator/operators/evaluateMembershipOperator.ts
+const evaluateMembershipOperator = (operator, left, right) => {
+	switch (operator) {
+		case "allOf": return checkIsSurveyLogicAllOf(left, right);
+		case "anyOf": return checkIsSurveyLogicAnyOf(left, right);
+		case "contains": return checkIsSurveyLogicContaining(left, right);
+		case "notContains": return !checkIsSurveyLogicContaining(left, right);
+		default: return exhaustiveGuard(operator);
+	}
+};
+// src/services/evaluator/evaluateBinary.ts
+const evaluateBinary = (node, context, evaluate) => {
+	const left = evaluate(node.left, context);
+	const right = evaluate(node.right, context);
+	switch (node.operator) {
+		case "add":
+		case "divide":
+		case "modulo":
+		case "multiply":
+		case "power":
+		case "subtract": return evaluateArithmeticOperator(node.operator, left, right);
+		case "allOf":
+		case "anyOf":
+		case "contains":
+		case "notContains": return evaluateMembershipOperator(node.operator, left, right);
+		case "and":
+		case "or": return evaluateLogicOperator(node.operator, left, right);
+		case "equal":
+		case "greater":
+		case "greaterOrEqual":
+		case "less":
+		case "lessOrEqual":
+		case "notEqual": return evaluateComparisonOperator(node.operator, left, right);
+		default: return exhaustiveGuard(node.operator);
+	}
+};
+// src/services/evaluator/evaluateCall.ts
+const evaluateCall = (node, context, evaluate) => {
+	const surveyLogicFunction = getOwnValue(SurveyLogicFunctionMap, node.name.toLowerCase());
+	if (surveyLogicFunction === void 0) return void 0;
+	return surveyLogicFunction(node.args.map((argument) => evaluate(argument, context)), context);
+};
+// src/services/evaluator/evaluateList.ts
+const evaluateList = (node, context, evaluate) => node.items.map((item) => evaluate(item, context));
+// src/services/evaluator/readSurveyLogicLength.ts
+const readSurveyLogicLength = (value) => Array.isArray(value) || typeof value === "string" ? value.length : 0;
+// src/services/evaluator/readSurveyLogicKey.ts
+const DIGITS_ONLY_REGEX = /^\d+$/u;
+const readSurveyLogicKey = (container, key) => {
+	if (Array.isArray(container)) return DIGITS_ONLY_REGEX.test(key) ? container.at(Number(key)) : void 0;
+	if (typeof container === "object") return getOwnValue(container, key);
+};
+// src/services/evaluator/readSurveyLogicPart.ts
+const PART_REGEX = /^(?<key>[^[]*)(?:\[(?<index>\d+)\])?$/u;
+const readSurveyLogicPart = (container, part) => {
+	const match = PART_REGEX.exec(part);
+	if (match === null) return void 0;
+	const { index, key = "" } = match.groups ?? {};
+	const value = readSurveyLogicKey(container, key);
+	if (index === void 0) return value;
+	return Array.isArray(value) ? value.at(Number(index)) : void 0;
+};
+// src/services/evaluator/readSurveyLogicPathUncached.ts
+const readSurveyLogicPathUncached = (container, name, readTail) => {
+	const whole = readSurveyLogicPart(container, name);
+	if (whole !== void 0) return whole;
+	for (let separatorIndex = name.indexOf("."); separatorIndex !== -1; separatorIndex = name.indexOf(".", separatorIndex + 1)) {
+		const head = readSurveyLogicPart(container, name.slice(0, separatorIndex));
+		const tail = name.slice(separatorIndex + 1);
+		const value = readTail(head, tail);
+		if (value !== void 0) return value;
+		if (tail === "length") return readSurveyLogicLength(head);
+	}
+};
+// src/services/evaluator/readMemoizedSurveyLogicPath.ts
+const readMemoizedSurveyLogicPath = (container, name, memo) => {
+	const namesRead = getOrCreate(memo, container, () => /* @__PURE__ */ new Map());
+	if (namesRead.has(name)) return namesRead.get(name);
+	const value = readSurveyLogicPathUncached(container, name, (head, tail) => readMemoizedSurveyLogicPath(head, tail, memo));
+	namesRead.set(name, value);
+	return value;
+};
+// src/services/evaluator/readSurveyLogicPath.ts
+const readSurveyLogicPath = (container, name) => readMemoizedSurveyLogicPath(container, name, /* @__PURE__ */ new Map());
+// src/services/evaluator/readSurveyLogicReference.ts
+const readSurveyLogicReference = (name, context) => {
+	const answer = getOwnValue(context.values, name);
+	if (answer !== void 0) return answer;
+	const separatorIndex = name.indexOf(".");
+	const scope = separatorIndex === -1 ? void 0 : getOwnValue(context.scopes, name.slice(0, separatorIndex));
+	if (scope !== void 0) {
+		const scopedName = name.slice(separatorIndex + 1);
+		return getOwnValue(scope, scopedName) ?? readSurveyLogicPath(scope, scopedName);
+	}
+	return readSurveyLogicPath(context.values, name);
+};
+// src/services/evaluator/evaluateReference.ts
+const evaluateReference = (node, context) => readSurveyLogicReference(node.name, context);
+// src/services/evaluator/evaluateUnary.ts
+const evaluateUnary = (node, context, evaluate) => {
+	const operand = evaluate(node.operand, context);
+	switch (node.operator) {
+		case "empty": return checkIsSurveyLogicValueEmpty(operand);
+		case "negate": return evaluateArithmeticOperator("subtract", 0, operand);
+		case "not": return operand !== true;
+		case "notEmpty": return !checkIsSurveyLogicValueEmpty(operand);
+		default: return exhaustiveGuard(node.operator);
+	}
+};
+// src/services/evaluateSurveyExpression.ts
+const evaluateSurveyExpression = (node, context) => {
+	switch (node.type) {
+		case "binary": return evaluateBinary(node, context, evaluateSurveyExpression);
+		case "call": return evaluateCall(node, context, evaluateSurveyExpression);
+		case "list": return evaluateList(node, context, evaluateSurveyExpression);
+		case "literal": return node.value;
+		case "reference": return evaluateReference(node, context);
+		case "unary": return evaluateUnary(node, context, evaluateSurveyExpression);
+		default: return exhaustiveGuard(node);
+	}
+};
+// src/services/runSurveyExpression.ts
+const runSurveyExpression = (source, context) => parseSurveyExpression(source).map((node) => evaluateSurveyExpression(node, context));
+// src/services/shared/toSurveyLogicAnswer.ts
+const toSurveyLogicAnswers = (record) => Object.fromEntries(Object.entries(record).map(([name, answer]) => [name, toSurveyLogicAnswer(answer)]));
+const toSurveyLogicAnswer = (value) => {
+	if (value === null) return void 0;
+	if (Array.isArray(value)) return value.map((item) => toSurveyLogicAnswer(item));
+	if (typeof value === "object") return toSurveyLogicAnswers(value);
+	return value;
+};
+export { ArrayFunctionMap, DateFunctionMap, GeneralFunctionMap, LOWEST_POWER, MAX_DECIMAL_PLACES, MAX_SURVEY_EXPRESSION_LENGTH, PUNCTUATION_CHARACTERS, STRING_QUOTES, SYMBOL_OPERATOR_TEXTS, SurveyExpressionBinaryOperator, SurveyExpressionBinaryOperatorMap, SurveyExpressionNodeType, SurveyExpressionPostfixOperatorMap, SurveyExpressionPrefixOperatorMap, SurveyExpressionTokenType, SurveyExpressionUnaryOperator, SurveyLogicFunctionMap, addSurveyLogicMonths, advanceSurveyExpressionWhile, ageFunction, avgFunction, avgInArrayFunction, checkIsCalendarDay, checkIsPunctuation, checkIsSurveyExpressionDigit, checkIsSurveyExpressionKeyword, checkIsSurveyExpressionWhitespace, checkIsSurveyExpressionWordCharacter, checkIsSurveyExpressionWordStart, checkIsSurveyFieldName, checkIsSurveyLogicAllOf, checkIsSurveyLogicAnyOf, checkIsSurveyLogicContaining, checkIsSurveyLogicItemHeld, checkIsSurveyLogicLess, checkIsSurveyLogicPrimitiveEqual, checkIsSurveyLogicValueEmpty, checkIsSurveyLogicValueEqual, checkSurveyExpression, compareSurveyLogicTexts, countFunction, countInArrayFunction, countSurveyLogicDecimals, createSurveyLogicWallClock, dateAddFunction, dateDiffFunction, dayFunction, evaluateArithmeticOperator, evaluateBinary, evaluateCall, evaluateComparisonOperator, evaluateList, evaluateLogicOperator, evaluateMembershipOperator, evaluateReference, evaluateSurveyExpression, evaluateUnary, findSurveyExpressionRefusal, flattenSurveyNumbers, getCallRefusal, getDateDifference, getDateOrNow, getOwnValue, getSurveyArrayExtreme, getSurveyArrayItems, getSurveyArrayParams, getSurveyDateUnit, getSurveyExpressionChildren, getSurveyExtreme, getSurveyLogicDayNumber, getSurveyNumberWithPrecision, getSurveyOptionalArgument, getSurveyTextIndex, iifFunction, maxFunction, maxInArrayFunction, minFunction, minInArrayFunction, monthFunction, parseBinary, parseBinaryOperators, parseCall, parseGroup, parseList, parseOperand, parsePrefixOperator, parseSequence, parseSequenceItems, parseSurveyExpression, parseSurveyLogicDate, readMemoizedSurveyLogicPath, readSurveyExpressionNumber, readSurveyExpressionReference, readSurveyExpressionString, readSurveyExpressionSymbol, readSurveyExpressionToken, readSurveyExpressionWord, readSurveyLogicKey, readSurveyLogicLength, readSurveyLogicPart, readSurveyLogicPath, readSurveyLogicPathUncached, readSurveyLogicReference, roundFunction, roundSurveyLogicProduct, roundSurveyLogicResult, roundSurveyLogicSum, runSurveyExpression, substringFunction, sumFunction, sumInArrayFunction, sumSurveyNumbers, toSurveyLogicAnswer, toSurveyLogicAnswers, toSurveyLogicDate, toSurveyLogicNumber, toSurveyLogicPrimitive, toSurveyLogicResult, toSurveyLogicText, toSurveyLogicWallClock, todayFunction, tokenizeSurveyExpression, truncFunction, weekdayFunction, yearFunction };