@case-framework/survey-core 0.1.0

package/build/index.mjs

@@ -0,0 +1,1586 @@
+import { C as ValueReference, D as structuredCloneMethod, E as shuffleIndices, S as ReferenceUsageType, T as generateId, _ as Expression, a as validateLocale, b as FunctionExpressionNames, c as SurveyItemCore, d as deserializeTemplateValues, f as serializeTemplateValue, g as ContextVariableType, h as ContextVariableExpression, i as SurveyTranslations, l as TemplateDefTypes, m as ConstExpression, o as SurveyItemKey, p as serializeTemplateValues, r as SurveyItemTranslations, s as ReservedSurveyItemTypes, t as Survey, u as deserializeTemplateValue, v as ExpressionType, w as ValueReferenceMethod, x as ResponseVariableExpression, y as FunctionExpression } from "./survey-C3ZHI-5z.mjs";
+import { format } from "date-fns";
+import { enUS } from "date-fns/locale";
+
+//#region src/to_mirgrate/data_types/legacy-types.ts
+const isLegacyItemGroupComponent = (item) => {
+	const items = item.items;
+	return items !== void 0 && items.length > 0;
+};
+const isLegacySurveyGroupItem = (item) => {
+	const items = item.items;
+	return items !== void 0 && items.length > 0;
+};
+
+//#endregion
+//#region src/survey/responses/item-response.ts
+/**
+* SurveyItemResponse to store the response of a survey item.
+*/
+var SurveyItemResponse = class SurveyItemResponse {
+	itemId;
+	meta;
+	response;
+	itemType;
+	constructor(itemDef, response) {
+		this.itemId = itemDef.itemId;
+		this.response = response;
+		this.itemType = itemDef.itemType;
+	}
+	serialize() {
+		return {
+			itemId: this.itemId,
+			itemType: this.itemType,
+			meta: this.meta,
+			response: this.response?.serialize()
+		};
+	}
+	static deserialize(json) {
+		const newResponse = new SurveyItemResponse({
+			itemId: json.itemId,
+			itemType: json.itemType
+		}, json.response ? ResponseItem.deserialize(json.response) : void 0);
+		newResponse.meta = json.meta;
+		return newResponse;
+	}
+};
+var ResponseItem = class ResponseItem {
+	_slots;
+	constructor(initialValues) {
+		this._slots = new Map(initialValues ?? []);
+	}
+	get(slotId) {
+		return this._slots.get(slotId);
+	}
+	setSlotValue(slotId, slotResponse) {
+		if (slotResponse) this._slots.set(slotId, slotResponse);
+		else this._slots.delete(slotId);
+	}
+	serialize() {
+		return { slotValues: Array.from(this._slots.entries()) };
+	}
+	clone() {
+		return new ResponseItem(Array.from(this._slots.entries()));
+	}
+	static deserialize(json) {
+		return new ResponseItem(json.slotValues);
+	}
+};
+
+//#endregion
+//#region src/survey/responses/response-meta.ts
+const SurveyEventTypes = {
+	openSurvey: "openSurvey",
+	pageChanged: "pageChanged",
+	responeChanged: "responeChanged",
+	languageChanged: "languageChanged"
+};
+
+//#endregion
+//#region src/survey/responses/survey-response.ts
+/**
+* SurveyResponse to store the responses of a survey.
+*/
+var SurveyResponse = class SurveyResponse {
+	key;
+	participantId;
+	submittedAt;
+	versionId;
+	responses;
+	events;
+	context;
+	constructor(key, versionId) {
+		this.key = key;
+		this.participantId = "";
+		this.submittedAt = 0;
+		this.versionId = versionId;
+		this.responses = /* @__PURE__ */ new Map();
+		this.events = [];
+	}
+	serialize() {
+		return {
+			key: this.key,
+			participantId: this.participantId,
+			submittedAt: this.submittedAt,
+			versionId: this.versionId,
+			responses: Array.from(this.responses.values()).map((r) => r.serialize()),
+			events: this.events,
+			context: this.context
+		};
+	}
+	static deserialize(json) {
+		const response = new SurveyResponse(json.key, json.versionId);
+		response.participantId = json.participantId;
+		response.submittedAt = json.submittedAt;
+		response.responses = new Map(json.responses.map((r) => [r.itemId, SurveyItemResponse.deserialize(r)]));
+		response.context = json.context;
+		return response;
+	}
+};
+
+//#endregion
+//#region src/survey/responses/value-types.ts
+const ValueType = {
+	string: "string",
+	duration: "duration",
+	reference: "reference",
+	number: "number",
+	boolean: "boolean",
+	date: "date",
+	stringArray: "string[]",
+	durationArray: "duration[]",
+	referenceArray: "reference[]",
+	numberArray: "number[]",
+	dateArray: "date[]"
+};
+const DurationUnits = {
+	seconds: "seconds",
+	minutes: "minutes",
+	hours: "hours",
+	days: "days",
+	weeks: "weeks",
+	months: "months",
+	years: "years"
+};
+const NumberPrecision = {
+	int: "int",
+	float: "float"
+};
+
+//#endregion
+//#region src/survey/responses/utils.ts
+const initValueForType = (returnType) => {
+	switch (returnType) {
+		case ValueType.string: return {
+			type: ValueType.string,
+			value: ""
+		};
+		case ValueType.number: return {
+			type: ValueType.number,
+			value: 0
+		};
+		case ValueType.boolean: return {
+			type: ValueType.boolean,
+			value: false
+		};
+		case ValueType.date: return {
+			type: ValueType.date,
+			value: Math.floor(Date.now() / 1e3)
+		};
+		case ValueType.stringArray: return {
+			type: ValueType.stringArray,
+			value: []
+		};
+		case ValueType.numberArray: return {
+			type: ValueType.numberArray,
+			value: []
+		};
+		case ValueType.dateArray: return {
+			type: ValueType.dateArray,
+			value: []
+		};
+		case ValueType.duration: return {
+			type: ValueType.duration,
+			value: 0,
+			unit: DurationUnits.seconds
+		};
+		case ValueType.reference: return {
+			type: ValueType.reference,
+			value: ""
+		};
+		case ValueType.durationArray: return {
+			type: ValueType.durationArray,
+			value: [],
+			unit: DurationUnits.seconds
+		};
+		case ValueType.referenceArray: return {
+			type: ValueType.referenceArray,
+			value: []
+		};
+		default: throw new Error("Invalid return type: " + returnType);
+	}
+};
+
+//#endregion
+//#region src/expressions/expression-evaluator.ts
+var ExpressionEvaluator = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	eval(expression) {
+		if (expression === void 0) return;
+		switch (expression.type) {
+			case ExpressionType.Const: return this.evaluateConst(expression);
+			case ExpressionType.Function: return this.evaluateFunction(expression);
+			case ExpressionType.ResponseVariable: return this.evaluateResponseVariable(expression);
+			case ExpressionType.ContextVariable: return this.evaluateContextVariable(expression);
+			default: throw new Error(`Unsupported expression type: ${expression.type}`);
+		}
+	}
+	setContext(context) {
+		this.context = context;
+	}
+	evaluateConst(expression) {
+		return expression.value;
+	}
+	evaluateResponseVariable(expression) {
+		const varRef = expression.responseVariableRef;
+		switch (varRef.name) {
+			case ValueReferenceMethod.get: return this.context?.responses[varRef.itemId]?.response?.get(varRef.slotId);
+			case ValueReferenceMethod.isDefined: return {
+				type: ValueType.boolean,
+				value: this.context?.responses[varRef.itemId]?.response?.get(varRef.slotId) !== void 0
+			};
+			default: throw new Error(`Unsupported value reference method: ${varRef.name}`);
+		}
+	}
+	evaluateFunction(expression) {
+		switch (expression.functionName) {
+			case FunctionExpressionNames.and: return this.evaluateAnd(expression);
+			case FunctionExpressionNames.or: return this.evaluateOr(expression);
+			case FunctionExpressionNames.not: return this.evaluateNot(expression);
+			case FunctionExpressionNames.str_eq: return this.evaluateStrEq(expression);
+			case FunctionExpressionNames.eq: return this.evaluateEq(expression);
+			case FunctionExpressionNames.gt: return this.evaluateGt(expression);
+			case FunctionExpressionNames.gte: return this.evaluateGte(expression);
+			case FunctionExpressionNames.lt: return this.evaluateLt(expression);
+			case FunctionExpressionNames.lte: return this.evaluateLte(expression);
+			case FunctionExpressionNames.in_range: return this.evaluateInRange(expression);
+			case FunctionExpressionNames.sum: return this.evaluateSum(expression);
+			case FunctionExpressionNames.min: return this.evaluateMin(expression);
+			case FunctionExpressionNames.max: return this.evaluateMax(expression);
+			case FunctionExpressionNames.list_contains: return this.evaluateListContains(expression);
+			default: throw new Error(`Unsupported function: ${expression.functionName}`);
+		}
+	}
+	evaluateContextVariable(expression) {
+		if (!this.context?.surveyContext) return;
+		const surveyContext = this.context.surveyContext;
+		switch (expression.contextType) {
+			case ContextVariableType.Locale: return {
+				type: ValueType.string,
+				value: surveyContext.locale
+			};
+			case ContextVariableType.ParticipantFlag: {
+				if (!expression.key) return;
+				const flagKey = this.eval(expression.key);
+				if (flagKey?.type !== ValueType.string || flagKey.value === void 0) return;
+				const flagValue = surveyContext.participantFlags?.[flagKey.value];
+				switch (expression.asType) {
+					case ValueType.boolean: return {
+						type: ValueType.boolean,
+						value: flagValue !== void 0
+					};
+					case ValueType.string:
+						if (flagValue === void 0) return;
+						return {
+							type: ValueType.string,
+							value: flagValue
+						};
+					case ValueType.number: {
+						if (flagValue === void 0) return;
+						const numValue = parseFloat(flagValue);
+						return isNaN(numValue) ? void 0 : {
+							type: ValueType.number,
+							value: numValue
+						};
+					}
+					case ValueType.date: {
+						if (flagValue === void 0) return;
+						const timestamp = parseFloat(flagValue);
+						return isNaN(timestamp) ? void 0 : {
+							type: ValueType.date,
+							value: timestamp
+						};
+					}
+					default:
+						if (flagValue === void 0) return;
+						return {
+							type: ValueType.string,
+							value: flagValue
+						};
+				}
+			}
+			case ContextVariableType.CustomValue: {
+				if (!expression.key) return;
+				const customKey = this.eval(expression.key);
+				if (customKey?.type !== ValueType.string || customKey.value === void 0) return;
+				const customValue = surveyContext.customValues?.[customKey.value];
+				if (customValue === void 0) return;
+				if (expression.asType !== void 0) {
+					if (customValue?.type !== expression.asType) throw new Error(`Custom value type does not match expected type, got ${customValue?.type} and expected ${expression.asType}`);
+				}
+				return customValue;
+			}
+			case ContextVariableType.CustomExpression: {
+				if (!expression.key) return;
+				const expressionKey = this.eval(expression.key);
+				if (expressionKey?.type !== ValueType.string || expressionKey.value === void 0) return;
+				const customExpression = surveyContext.customExpressions?.[expressionKey.value];
+				if (typeof customExpression !== ExpressionType.Function || customExpression === void 0) return;
+				try {
+					const args = expression.arguments;
+					const result = customExpression(args);
+					if (expression.asType !== void 0) {
+						if (result?.type !== expression.asType) throw new Error(`Custom expression result type does not match expected type, got ${result?.type} and expected ${expression.asType}`);
+					}
+					return result;
+				} catch (error) {
+					throw new Error(`Error evaluating custom expression: ${error}`);
+				}
+			}
+		}
+	}
+	evaluateAnd(expression) {
+		return {
+			type: ValueType.boolean,
+			value: expression.arguments.every((arg) => this.eval(arg)?.value === true)
+		};
+	}
+	evaluateOr(expression) {
+		return {
+			type: ValueType.boolean,
+			value: expression.arguments.some((arg) => this.eval(arg)?.value === true)
+		};
+	}
+	evaluateNot(expression) {
+		if (expression.arguments.length !== 1 || expression.arguments[0] === void 0) throw new Error(`Not function expects 1 argument, got ${expression.arguments.length}`);
+		const resolvedValue = this.eval(expression.arguments[0]);
+		if (resolvedValue?.type !== ValueType.boolean) throw new Error(`Not function expects a boolean argument, got ${resolvedValue?.type}`);
+		if (resolvedValue === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		return {
+			type: ValueType.boolean,
+			value: !resolvedValue.value
+		};
+	}
+	evaluateListContains(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`List contains function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedList = this.eval(expression.arguments[0]);
+		const resolvedItem = this.eval(expression.arguments[1]);
+		if (resolvedList === void 0 || resolvedItem === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		const allowedListTypes = [ValueType.stringArray, ValueType.referenceArray];
+		const allowedItemTypes = [ValueType.string, ValueType.reference];
+		const resolvedListType = resolvedList.type;
+		const resolvedItemType = resolvedItem.type;
+		if (!allowedListTypes.includes(resolvedListType) || !allowedItemTypes.includes(resolvedItemType)) throw new Error(`List contains function expects a string array list and a string item, got ${resolvedList?.type} and ${resolvedItem?.type}`);
+		const list = resolvedList.value;
+		const item = resolvedItem.value;
+		return {
+			type: ValueType.boolean,
+			value: list.includes(item)
+		};
+	}
+	evaluateStrEq(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`String equals function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== ValueType.string || resolvedB?.type !== ValueType.string) throw new Error(`String equals function expects strings for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value === resolvedB.value
+		};
+	}
+	evaluateEq(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Equals function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Equals function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value === resolvedB.value
+		};
+	}
+	evaluateGt(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Greater than function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Greater than function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value > resolvedB.value
+		};
+	}
+	evaluateGte(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Greater than or equal to function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Greater than or equal to function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value >= resolvedB.value
+		};
+	}
+	evaluateLt(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Less than function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Less than function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value < resolvedB.value
+		};
+	}
+	evaluateLte(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Less than or equal to function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Less than or equal to function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value <= resolvedB.value
+		};
+	}
+	evaluateInRange(expression) {
+		if (expression.arguments.length !== 4) throw new Error(`In range function expects 4 arguments, got ${expression.arguments.length}`);
+		const resolvedValue = this.eval(expression.arguments[0]);
+		const resolvedMin = this.eval(expression.arguments[1]);
+		const resolvedMax = this.eval(expression.arguments[2]);
+		const resolvedInclusive = this.eval(expression.arguments[3])?.value === true;
+		if (resolvedValue === void 0 || resolvedMin === void 0 || resolvedMax === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedValue?.type !== ValueType.number || resolvedMin?.type !== ValueType.number || resolvedMax?.type !== ValueType.number) throw new Error(`In range function expects numbers for all arguments, got ${resolvedValue?.type} and ${resolvedMin?.type} and ${resolvedMax?.type}`);
+		if (resolvedInclusive) return {
+			type: ValueType.boolean,
+			value: resolvedValue.value >= resolvedMin.value && resolvedValue.value <= resolvedMax.value
+		};
+		return {
+			type: ValueType.boolean,
+			value: resolvedValue.value > resolvedMin.value && resolvedValue.value < resolvedMax.value
+		};
+	}
+	evaluateSum(expression) {
+		if (expression.arguments.length < 1) throw new Error(`Sum function expects at least 1 argument, got ${expression.arguments.length}`);
+		return expression.arguments.reduce((sum, arg) => {
+			if (arg === void 0) return sum;
+			const resolvedValue = this.eval(arg);
+			if (resolvedValue === void 0) return sum;
+			if (resolvedValue?.type === ValueType.number) return {
+				type: ValueType.number,
+				value: sum.value + resolvedValue.value
+			};
+			throw new Error(`Sum function expects all arguments to be numbers, got ${resolvedValue?.type}`);
+		}, {
+			type: ValueType.number,
+			value: 0
+		});
+	}
+	evaluateMin(expression) {
+		if (expression.arguments.length < 1) throw new Error(`Min function expects at least 1 argument, got ${expression.arguments.length}`);
+		return expression.arguments.reduce((min, arg) => {
+			if (arg === void 0) return min;
+			const resolvedValue = this.eval(arg);
+			if (resolvedValue === void 0) return min;
+			if (resolvedValue?.type === ValueType.number) return {
+				type: ValueType.number,
+				value: Math.min(min.value, resolvedValue.value)
+			};
+			throw new Error(`Min function expects all arguments to be numbers, got ${typeof resolvedValue}`);
+		}, {
+			type: ValueType.number,
+			value: Infinity
+		});
+	}
+	evaluateMax(expression) {
+		if (expression.arguments.length < 1) throw new Error(`Max function expects at least 1 argument, got ${expression.arguments.length}`);
+		return expression.arguments.reduce((max, arg) => {
+			if (arg === void 0) return max;
+			const resolvedValue = this.eval(arg);
+			if (resolvedValue === void 0) return max;
+			if (resolvedValue?.type === ValueType.number) return {
+				type: ValueType.number,
+				value: Math.max(max.value, resolvedValue.value)
+			};
+			throw new Error(`Max function expects all arguments to be numbers, got ${typeof resolvedValue}`);
+		}, {
+			type: ValueType.number,
+			value: -Infinity
+		});
+	}
+};
+
+//#endregion
+//#region src/expressions/editors/expression-editor.ts
+var ExpressionEditor = class {
+	returnType;
+	_editorConfig;
+	get editorConfig() {
+		return this._editorConfig;
+	}
+	withEditorConfig(editorConfig) {
+		this._editorConfig = editorConfig;
+		return this;
+	}
+};
+var ConstStringArrayEditor = class extends ExpressionEditor {
+	returnType = ValueType.stringArray;
+	_values;
+	constructor(values, editorConfig) {
+		super();
+		this._values = values;
+		this._editorConfig = editorConfig;
+	}
+	get values() {
+		return this._values;
+	}
+	set values(values) {
+		this._values = values;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.stringArray,
+			value: this._values
+		}, this._editorConfig);
+	}
+};
+var ConstStringEditor = class extends ExpressionEditor {
+	returnType = ValueType.string;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.string,
+			value: this._value
+		}, this._editorConfig);
+	}
+};
+var ConstNumberEditor = class extends ExpressionEditor {
+	returnType = ValueType.number;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.number,
+			value: this._value
+		}, this._editorConfig);
+	}
+};
+var ConstBooleanEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.boolean,
+			value: this._value
+		}, this._editorConfig);
+	}
+};
+var ConstDateEditor = class extends ExpressionEditor {
+	returnType = ValueType.date;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		const value = Math.floor(this._value.getTime() / 1e3);
+		return new ConstExpression({
+			type: ValueType.date,
+			value
+		}, this._editorConfig);
+	}
+};
+var ConstNumberArrayEditor = class extends ExpressionEditor {
+	returnType = ValueType.numberArray;
+	_values;
+	constructor(values, editorConfig) {
+		super();
+		this._values = values;
+		this._editorConfig = editorConfig;
+	}
+	get values() {
+		return this._values;
+	}
+	set values(values) {
+		this._values = values;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.numberArray,
+			value: this._values
+		}, this._editorConfig);
+	}
+};
+var ConstDateArrayEditor = class extends ExpressionEditor {
+	returnType = ValueType.dateArray;
+	_values;
+	constructor(values, editorConfig) {
+		super();
+		this._values = values;
+		this._editorConfig = editorConfig;
+	}
+	get values() {
+		return this._values;
+	}
+	set values(values) {
+		this._values = values;
+	}
+	getExpression() {
+		const value = this._values.map((date) => Math.floor(date.getTime() / 1e3));
+		return new ConstExpression({
+			type: ValueType.dateArray,
+			value
+		}, this._editorConfig);
+	}
+};
+var ResponseVariableEditor = class extends ExpressionEditor {
+	_variableName;
+	_variableRef;
+	constructor(variableName, variableType, editorConfig) {
+		super();
+		this._variableName = variableName;
+		this._variableRef = new ValueReference(variableName);
+		this._editorConfig = editorConfig;
+		this.returnType = variableType;
+	}
+	get variableName() {
+		return this._variableName;
+	}
+	get variableRef() {
+		return this._variableRef;
+	}
+	getExpression() {
+		return new ResponseVariableExpression(this._variableName, this._editorConfig);
+	}
+};
+var ContextVariableEditor = class extends ExpressionEditor {
+	_contextType;
+	_key;
+	_args;
+	_asType;
+	constructor(contextType, key, args, asType, editorConfig) {
+		super();
+		this._contextType = contextType;
+		this._key = key;
+		this._args = args;
+		this._asType = asType;
+		this._editorConfig = editorConfig;
+	}
+	getExpression() {
+		return new ContextVariableExpression(this._contextType, this._key?.getExpression(), this._args?.map((arg) => arg.getExpression()), this._asType, this._editorConfig);
+	}
+};
+var CtxLocaleEditor = class extends ContextVariableEditor {
+	returnType = ValueType.string;
+	constructor(editorConfig) {
+		super(ContextVariableType.Locale, void 0, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxPFlagIsDefinedEditor = class extends ContextVariableEditor {
+	returnType = ValueType.boolean;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.boolean, editorConfig);
+	}
+};
+var CtxPFlagStringEditor = class extends ContextVariableEditor {
+	returnType = ValueType.string;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxPFlagNumEditor = class extends ContextVariableEditor {
+	returnType = ValueType.number;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.number, editorConfig);
+	}
+};
+var CtxPFlagDateEditor = class extends ContextVariableEditor {
+	returnType = ValueType.date;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.date, editorConfig);
+	}
+};
+var CtxCustomValueEditor = class extends ContextVariableEditor {
+	constructor(key, asType, editorConfig) {
+		super(ContextVariableType.CustomValue, key, void 0, asType, editorConfig);
+		this.returnType = asType;
+	}
+};
+var CtxCustomExpressionEditor = class extends ContextVariableEditor {
+	constructor(key, args, asType, editorConfig) {
+		super(ContextVariableType.CustomExpression, key, args, asType, editorConfig);
+		this.returnType = asType;
+	}
+};
+var GroupExpressionEditor = class extends ExpressionEditor {
+	_args;
+	constructor(args, editorConfig) {
+		super();
+		this._args = args;
+		this._editorConfig = editorConfig;
+	}
+	get args() {
+		return this._args;
+	}
+	addArg(arg, position) {
+		if (position === void 0) this._args.push(arg);
+		else this._args.splice(position, 0, arg);
+	}
+	removeArg(position) {
+		this._args.splice(position, 1);
+	}
+	replaceArg(position, arg) {
+		this._args[position] = arg;
+	}
+	swapArgs(activeIndex, overIndex) {
+		const newOrder = [...this._args];
+		newOrder.splice(activeIndex, 1);
+		newOrder.splice(overIndex, 0, this._args[activeIndex]);
+		this._args = newOrder;
+	}
+};
+var AndExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.boolean;
+	constructor(args, editorConfig) {
+		if (args.some((arg) => arg.returnType !== ValueType.boolean)) throw new Error("And expression editor must have boolean arguments");
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.and, this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var OrExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.boolean;
+	constructor(args, editorConfig) {
+		if (args.some((arg) => arg.returnType !== ValueType.boolean)) throw new Error("Or expression editor must have boolean arguments");
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.or, this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var StrListContainsExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_list;
+	_item;
+	constructor(list, item, editorConfig) {
+		super();
+		if (list.returnType !== ValueType.stringArray) throw new Error("List contains expression editor must have a string array list");
+		if (item.returnType !== ValueType.string) throw new Error("List contains expression editor must have a string item");
+		this._list = list;
+		this._item = item;
+		this._editorConfig = editorConfig;
+	}
+	get list() {
+		return this._list;
+	}
+	get item() {
+		return this._item;
+	}
+	set list(list) {
+		this._list = list;
+	}
+	set item(item) {
+		this._item = item;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.list_contains, [this._list?.getExpression(), this._item?.getExpression()], this._editorConfig);
+	}
+};
+var StrEqExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.str_eq, [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var EqExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.eq, [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var GtExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.gt, [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var GteExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.gte, [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var LtExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.lt, [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var LteExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.lte, [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var InRangeExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	value;
+	min;
+	max;
+	inclusive;
+	constructor(value, min, max, inclusive, editorConfig) {
+		super();
+		this.value = value;
+		this.min = min;
+		this.max = max;
+		this.inclusive = inclusive;
+		this._editorConfig = editorConfig;
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.in_range, [
+			this.value?.getExpression(),
+			this.min?.getExpression(),
+			this.max?.getExpression(),
+			this.inclusive?.getExpression()
+		], this._editorConfig);
+	}
+};
+var SumExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.number;
+	constructor(args, editorConfig) {
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.sum, this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var MinExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.number;
+	constructor(args, editorConfig) {
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.min, this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var MaxExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.number;
+	constructor(args, editorConfig) {
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression(FunctionExpressionNames.max, this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+
+//#endregion
+//#region src/expressions/editors/expression-editor-generators.ts
+const const_string_array = (...values) => {
+	return new ConstStringArrayEditor(values);
+};
+const const_string = (value) => {
+	return new ConstStringEditor(value);
+};
+const const_number_array = (...values) => {
+	return new ConstNumberArrayEditor(values);
+};
+const const_number = (value) => {
+	return new ConstNumberEditor(value);
+};
+const const_boolean = (value) => {
+	return new ConstBooleanEditor(value);
+};
+const const_date = (value) => {
+	return new ConstDateEditor(value);
+};
+const const_date_array = (...values) => {
+	return new ConstDateArrayEditor(values);
+};
+const response_string = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.string);
+};
+const response_string_array = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.stringArray);
+};
+const response_number = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.number);
+};
+const response_boolean = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.boolean);
+};
+const response_date = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.date);
+};
+const response_number_array = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.numberArray);
+};
+const response_date_array = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.dateArray);
+};
+const ctx_locale = () => {
+	return new CtxLocaleEditor();
+};
+const ctx_pflag_is_defined = (key) => {
+	return new CtxPFlagIsDefinedEditor(key);
+};
+const ctx_pflag_string = (key) => {
+	return new CtxPFlagStringEditor(key);
+};
+const ctx_pflag_num = (key) => {
+	return new CtxPFlagNumEditor(key);
+};
+const ctx_pflag_date = (key) => {
+	return new CtxPFlagDateEditor(key);
+};
+const ctx_custom_value = (key, dType) => {
+	return new CtxCustomValueEditor(key, dType);
+};
+const ctx_custom_expression = (key, args, returnType) => {
+	return new CtxCustomExpressionEditor(key, args, returnType);
+};
+const and = (...args) => {
+	return new AndExpressionEditor(args);
+};
+const or = (...args) => {
+	return new OrExpressionEditor(args);
+};
+const str_list_contains = (list, item) => {
+	return new StrListContainsExpressionEditor(list, item);
+};
+const str_eq = (a, b) => {
+	return new StrEqExpressionEditor(a, b);
+};
+const eq = (a, b) => {
+	return new EqExpressionEditor(a, b);
+};
+const gt = (a, b) => {
+	return new GtExpressionEditor(a, b);
+};
+const gte = (a, b) => {
+	return new GteExpressionEditor(a, b);
+};
+const lt = (a, b) => {
+	return new LtExpressionEditor(a, b);
+};
+const lte = (a, b) => {
+	return new LteExpressionEditor(a, b);
+};
+const in_range = (value, min, max, inclusive) => {
+	return new InRangeExpressionEditor(value, min, max, inclusive);
+};
+const sum = (...args) => {
+	return new SumExpressionEditor(args);
+};
+const min = (...args) => {
+	return new MinExpressionEditor(args);
+};
+const max = (...args) => {
+	return new MaxExpressionEditor(args);
+};
+
+//#endregion
+//#region src/survey/utils/content.ts
+let ContentType = /* @__PURE__ */ function(ContentType) {
+	ContentType["CQM"] = "CQM";
+	ContentType["md"] = "md";
+	return ContentType;
+}({});
+let AttributionType = /* @__PURE__ */ function(AttributionType) {
+	AttributionType["style"] = "style";
+	AttributionType["template"] = "template";
+	return AttributionType;
+}({});
+
+//#endregion
+//#region src/engine/engine.ts
+var SurveyEngineCore = class {
+	surveyDef;
+	renderedSurveyTree;
+	context;
+	locale;
+	responses;
+	prefills;
+	_events;
+	_openedAt;
+	dateLocales;
+	cache;
+	constructor(survey, context, prefills, dateLocales) {
+		this._openedAt = this._getTimestamp();
+		this.surveyDef = survey;
+		this.context = context ? context : { locale: "en" };
+		this.locale = this.context.locale;
+		this.prefills = prefills ? prefills.reduce((acc, p) => {
+			acc[p.itemId] = SurveyItemResponse.deserialize(p);
+			return acc;
+		}, {}) : void 0;
+		this.dateLocales = dateLocales || [{
+			code: "en",
+			locale: enUS
+		}];
+		this.responses = this.initResponseObject(this.surveyDef.surveyItems);
+		this.initCache();
+		this.evalExpressions();
+		if (!survey.rootItem) throw new Error("constructor: root item not found");
+		this.renderedSurveyTree = this.renderGroup(survey.rootItem);
+		this._events = [{
+			type: SurveyEventTypes.openSurvey,
+			timestamp: this._getTimestamp(),
+			value: this.context.locale
+		}];
+	}
+	setContext(context) {
+		this.context = context;
+	}
+	getDateLocales() {
+		return this.dateLocales.slice();
+	}
+	getCurrentDateLocale() {
+		const found = this.dateLocales.find((dl) => dl.code === this.locale);
+		if (!found) {
+			console.warn(`Locale '${this.locale}' is not available. Using default locale.`);
+			if (this.dateLocales.length > 0) return this.dateLocales[0].locale;
+			return enUS;
+		}
+		return found?.locale;
+	}
+	updateContext(context) {
+		this.context = context;
+		this.locale = context.locale;
+		this._registerSurveyEvent({
+			type: SurveyEventTypes.languageChanged,
+			timestamp: this._getTimestamp(),
+			value: context.locale
+		});
+		this.evalExpressions();
+		this.reRenderSurveyTree();
+	}
+	setResponse(targetKey, response) {
+		const target = this.getResponseItem(targetKey);
+		if (!target) throw new Error("setResponse: target not found for key: " + targetKey);
+		target.response = response;
+		this._registerSurveyEvent({
+			type: SurveyEventTypes.responeChanged,
+			timestamp: this._getTimestamp(),
+			itemId: targetKey
+		});
+		this.evalExpressions();
+		this.reRenderSurveyTree();
+	}
+	get openedAt() {
+		return this._openedAt;
+	}
+	get survey() {
+		return this.surveyDef;
+	}
+	getSurveyPages(size) {
+		const renderedSurvey = flattenTree(this.renderedSurveyTree);
+		const pages = new Array();
+		if (!size) size = "large";
+		let currentPage = [];
+		renderedSurvey.forEach((item) => {
+			if (item.type === ReservedSurveyItemTypes.PageBreak) {
+				if (currentPage.length > 0) {
+					pages.push([...currentPage]);
+					currentPage = [];
+				}
+				return;
+			}
+			currentPage.push(item);
+			if (!this.surveyDef.maxItemsPerPage) return;
+			let max = 0;
+			switch (size) {
+				case "large":
+					max = this.surveyDef.maxItemsPerPage.large;
+					break;
+				case "small":
+					max = this.surveyDef.maxItemsPerPage.small;
+					break;
+			}
+			if (currentPage.length >= max) {
+				pages.push([...currentPage]);
+				currentPage = [];
+			}
+		});
+		if (currentPage.length > 0) pages.push([...currentPage]);
+		return pages;
+	}
+	getRenderedSurveyItem(itemId) {
+		return flattenTree(this.renderedSurveyTree).find((item) => item.id === itemId);
+	}
+	onPageChanged(pageIndex) {
+		this._registerSurveyEvent({
+			type: SurveyEventTypes.pageChanged,
+			timestamp: this._getTimestamp(),
+			value: pageIndex
+		});
+	}
+	getEvents() {
+		return this._events.slice();
+	}
+	getResponses() {
+		const renderedSurvey = flattenTree(this.renderedSurveyTree).filter((item) => item.type !== ReservedSurveyItemTypes.PageBreak);
+		const responses = [];
+		renderedSurvey.forEach((item, index) => {
+			const response = this.getResponseItem(item.id);
+			if (!response) return;
+			response.meta = { position: index };
+			responses.push(response);
+		});
+		return responses;
+	}
+	getDisplayConditionValue(itemKey, componentKey) {
+		if (componentKey) return this.cache.displayConditions[itemKey]?.components?.[componentKey]?.result;
+		return this.cache.displayConditions[itemKey]?.root?.result;
+	}
+	getDisabledConditionValue(itemKey, componentKey) {
+		return this.cache.disabledConditions[itemKey]?.components?.[componentKey]?.result;
+	}
+	getTemplateValue(templateValueKey) {
+		return this.cache.templateValues[templateValueKey]?.value;
+	}
+	getValidationValues(itemKey) {
+		const validations = this.cache.validations[itemKey];
+		if (!validations) return;
+		return Object.keys(validations).reduce((acc, validationKey) => {
+			acc[validationKey] = validations[validationKey].result;
+			return acc;
+		}, {});
+	}
+	initCache() {
+		this.cache = {
+			validations: {},
+			displayConditions: {},
+			templateValues: {},
+			disabledConditions: {}
+		};
+		this.surveyDef.getTemplateValueKeys().forEach((templateKey) => {
+			this.cache.templateValues[templateKey] = {
+				value: void 0,
+				templateDef: this.surveyDef.getTemplateValue(templateKey)
+			};
+		});
+		this.surveyDef.surveyItems.forEach((item, itemId) => {
+			if (item.validations && Object.keys(item.validations).length > 0) {
+				this.cache.validations[itemId] = {};
+				Object.keys(item.validations).forEach((validationKey) => {
+					const valExp = item.validations[validationKey];
+					if (!valExp) {
+						console.warn("initCache: validation expression not found: " + itemId + " " + validationKey);
+						return;
+					}
+					this.cache.validations[itemId][validationKey] = {
+						expression: valExp,
+						result: false
+					};
+				});
+			}
+			if (item.displayConditions !== void 0 && (item.displayConditions.root || item.displayConditions.components)) {
+				this.cache.displayConditions[itemId] = {};
+				if (item.displayConditions.root) this.cache.displayConditions[itemId].root = {
+					expression: item.displayConditions.root,
+					result: false
+				};
+				if (item.displayConditions.components) {
+					this.cache.displayConditions[itemId].components = {};
+					Object.keys(item.displayConditions.components).forEach((componentKey) => {
+						const compExp = item.displayConditions?.components?.[componentKey];
+						if (!compExp) {
+							console.warn("initCache: display condition component expression not found: " + itemId + " " + componentKey);
+							return;
+						}
+						this.cache.displayConditions[itemId].components[componentKey] = {
+							expression: compExp,
+							result: false
+						};
+					});
+				}
+			}
+			if (item.disabledConditions !== void 0 && item.disabledConditions.components !== void 0) {
+				this.cache.disabledConditions[itemId] = { components: {} };
+				Object.keys(item.disabledConditions.components).forEach((componentKey) => {
+					const compExp = item.disabledConditions?.components?.[componentKey];
+					if (!compExp) {
+						console.warn("initCache: disabled condition component expression not found: " + itemId + " " + componentKey);
+						return;
+					}
+					this.cache.disabledConditions[itemId].components[componentKey] = {
+						expression: compExp,
+						result: false
+					};
+				});
+			}
+		});
+	}
+	initResponseObject(items) {
+		const respGroup = {};
+		items.forEach((item, itemId) => {
+			if (!item.isInteractive) return;
+			else {
+				const prefill = this.prefills?.[itemId];
+				const applyPrefill = prefill && prefill.itemType === item.type;
+				respGroup[itemId] = new SurveyItemResponse({
+					itemId,
+					itemType: item.type
+				}, applyPrefill ? prefill.response : void 0);
+			}
+		});
+		return respGroup;
+	}
+	shouldRender(itemId, componentId) {
+		const displayConditionResult = this.getDisplayConditionValue(itemId, componentId);
+		if (displayConditionResult !== void 0) return displayConditionResult;
+		return true;
+	}
+	sequentialRender(groupDef) {
+		const newItems = [];
+		for (const itemId of groupDef.items || []) {
+			if (!this.shouldRender(itemId)) continue;
+			const itemDef = this.surveyDef.surveyItems.get(itemId);
+			if (!itemDef) {
+				console.warn("sequentialRender: item not found: " + itemId);
+				continue;
+			}
+			if (itemDef.type === ReservedSurveyItemTypes.Group) {
+				newItems.push(this.renderGroup(itemDef));
+				continue;
+			}
+			newItems.push({
+				id: itemId,
+				type: itemDef.type
+			});
+		}
+		return {
+			id: groupDef.id,
+			type: ReservedSurveyItemTypes.Group,
+			items: newItems
+		};
+	}
+	randomizedItemRender(groupDef, parent) {
+		const newItems = parent.items?.filter((rItem) => this.shouldRender(rItem.id)) || [];
+		const itemIds = groupDef.items || [];
+		const shuffledIndices = shuffleIndices(itemIds.length);
+		for (const index of shuffledIndices) {
+			const itemId = itemIds[index];
+			if (parent.items?.find((rItem) => rItem.id === itemId)) continue;
+			if (!this.shouldRender(itemId)) continue;
+			const itemDef = this.surveyDef.surveyItems.get(itemId);
+			if (!itemDef) {
+				console.warn("randomizedItemRender: item not found: " + itemId);
+				continue;
+			}
+			if (itemDef.type === ReservedSurveyItemTypes.Group) {
+				newItems.push(this.renderGroup(itemDef, parent));
+				continue;
+			}
+			newItems.push({
+				id: itemId,
+				type: itemDef.type
+			});
+		}
+		return {
+			id: groupDef.id,
+			type: ReservedSurveyItemTypes.Group,
+			items: newItems
+		};
+	}
+	renderGroup(groupDef, parent) {
+		if (!parent) parent = {
+			id: groupDef.id,
+			type: ReservedSurveyItemTypes.Group,
+			items: []
+		};
+		if (groupDef.config.shuffleItems) return this.randomizedItemRender(groupDef, parent);
+		return this.sequentialRender(groupDef);
+	}
+	reRenderSurveyTree() {
+		if (!this.surveyDef.rootItem) throw new Error("reRenderSurveyTree: root item not found");
+		this.renderedSurveyTree = this.renderGroup(this.surveyDef.rootItem);
+	}
+	_registerSurveyEvent(event) {
+		this._events.push(event);
+	}
+	_getTimestamp() {
+		return Math.floor(Date.now() / 1e3);
+	}
+	getResponseItem(itemId) {
+		return this.responses[itemId];
+	}
+	evalExpressions() {
+		const evalEngine = new ExpressionEvaluator({
+			responses: this.responses,
+			surveyContext: this.context
+		});
+		this.evalTemplateValues(evalEngine);
+		this.evalDisplayConditions(evalEngine);
+		this.evalDisableConditions(evalEngine);
+		this.evalValidations(evalEngine);
+	}
+	evalTemplateValues(evalEngine) {
+		Object.keys(this.cache.templateValues).forEach((templateValueKey) => {
+			const templateValue = this.cache.templateValues[templateValueKey];
+			if (!templateValue.templateDef?.expression) {
+				console.warn("evalTemplateValues: template value expression not found: " + templateValueKey);
+				return;
+			}
+			let evaluatedValue = evalEngine.eval(templateValue.templateDef.expression);
+			if (evaluatedValue === void 0) {
+				console.warn("evalTemplateValues: template value expression returned undefined: " + templateValueKey);
+				return;
+			}
+			switch (templateValue.templateDef.type) {
+				case TemplateDefTypes.Date2String:
+					if (evaluatedValue.type !== ValueType.date) {
+						console.warn("evalTemplateValues: template value expression returned non-date value: " + templateValueKey);
+						return;
+					}
+					evaluatedValue = {
+						type: ValueType.string,
+						value: format(/* @__PURE__ */ new Date(evaluatedValue.value * 1e3), templateValue.templateDef.dateFormat)
+					};
+					break;
+				default: break;
+			}
+			this.cache.templateValues[templateValueKey].value = evaluatedValue;
+		});
+	}
+	evalDisplayConditions(evalEngine) {
+		Object.keys(this.cache.displayConditions).forEach((itemKey) => {
+			const displayCondition = this.cache.displayConditions[itemKey];
+			if (displayCondition.root) {
+				const resolvedValue = evalEngine.eval(displayCondition.root.expression);
+				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
+					console.warn("evalDisplayConditions: display condition expression returned undefined: " + itemKey);
+					return;
+				}
+				this.cache.displayConditions[itemKey].root.result = resolvedValue.value;
+			}
+			if (displayCondition.components) Object.keys(displayCondition.components).forEach((componentKey) => {
+				const resolvedValue = evalEngine.eval(displayCondition.components[componentKey].expression);
+				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
+					console.warn("evalDisplayConditions: display condition component expression returned undefined: " + itemKey + "." + componentKey);
+					return;
+				}
+				this.cache.displayConditions[itemKey].components[componentKey].result = resolvedValue.value;
+			});
+		});
+	}
+	evalDisableConditions(evalEngine) {
+		Object.keys(this.cache.disabledConditions).forEach((itemKey) => {
+			const disableCondition = this.cache.disabledConditions[itemKey];
+			if (disableCondition.components) Object.keys(disableCondition.components).forEach((componentKey) => {
+				const resolvedValue = evalEngine.eval(disableCondition.components[componentKey].expression);
+				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
+					console.warn("evalDisableConditions: disable condition component expression returned undefined: " + itemKey + "." + componentKey);
+					return;
+				}
+				this.cache.disabledConditions[itemKey].components[componentKey].result = resolvedValue.value;
+			});
+		});
+	}
+	evalValidations(evalEngine) {
+		Object.keys(this.cache.validations).forEach((itemId) => {
+			const validation = this.cache.validations[itemId];
+			Object.keys(validation).forEach((validationKey) => {
+				const resolvedValue = evalEngine.eval(validation[validationKey].expression);
+				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
+					console.warn("evalValidations: validation expression returned undefined: " + itemId + "." + validationKey);
+					return;
+				}
+				this.cache.validations[itemId][validationKey].result = resolvedValue.value;
+			});
+		});
+	}
+};
+const flattenTree = (itemTree) => {
+	const flatTree = new Array();
+	itemTree.items?.forEach((item) => {
+		if (item.type === ReservedSurveyItemTypes.Group) flatTree.push(...flattenTree(item));
+		else flatTree.push({ ...item });
+	});
+	return flatTree;
+};
+
+//#endregion
+export { AndExpressionEditor, AttributionType, ConstBooleanEditor, ConstDateArrayEditor, ConstDateEditor, ConstExpression, ConstNumberArrayEditor, ConstNumberEditor, ConstStringArrayEditor, ConstStringEditor, ContentType, ContextVariableExpression, ContextVariableType, CtxCustomExpressionEditor, CtxCustomValueEditor, CtxLocaleEditor, CtxPFlagDateEditor, CtxPFlagIsDefinedEditor, CtxPFlagNumEditor, CtxPFlagStringEditor, DurationUnits, EqExpressionEditor, Expression, ExpressionEditor, ExpressionEvaluator, ExpressionType, FunctionExpression, FunctionExpressionNames, GtExpressionEditor, GteExpressionEditor, InRangeExpressionEditor, LtExpressionEditor, LteExpressionEditor, MaxExpressionEditor, MinExpressionEditor, NumberPrecision, OrExpressionEditor, ReferenceUsageType, ReservedSurveyItemTypes, ResponseItem, ResponseVariableEditor, ResponseVariableExpression, StrEqExpressionEditor, StrListContainsExpressionEditor, SumExpressionEditor, Survey, SurveyEngineCore, SurveyEventTypes, SurveyItemCore, SurveyItemKey, SurveyItemResponse, SurveyItemTranslations, SurveyResponse, SurveyTranslations, TemplateDefTypes, ValueReference, ValueReferenceMethod, ValueType, and, const_boolean, const_date, const_date_array, const_number, const_number_array, const_string, const_string_array, ctx_custom_expression, ctx_custom_value, ctx_locale, ctx_pflag_date, ctx_pflag_is_defined, ctx_pflag_num, ctx_pflag_string, deserializeTemplateValue, deserializeTemplateValues, eq, flattenTree, generateId, gt, gte, in_range, initValueForType, isLegacyItemGroupComponent, isLegacySurveyGroupItem, lt, lte, max, min, or, response_boolean, response_date, response_date_array, response_number, response_number_array, response_string, response_string_array, serializeTemplateValue, serializeTemplateValues, shuffleIndices, str_eq, str_list_contains, structuredCloneMethod, sum, validateLocale };
+//# sourceMappingURL=index.mjs.map