@case-framework/survey-core 0.7.0 → 0.9.0

package/build/localization-1lzNpyFX.mjs

@@ -0,0 +1,1373 @@
+import { UTCDate } from "@date-fns/utc";
+import { addDays } from "date-fns/addDays";
+import { addMonths } from "date-fns/addMonths";
+import { addYears } from "date-fns/addYears";
+import { differenceInCalendarDays } from "date-fns/differenceInCalendarDays";
+import { differenceInMonths } from "date-fns/differenceInMonths";
+import { differenceInYears } from "date-fns/differenceInYears";
+import { format } from "date-fns/format";
+import { z } from "zod";
+//#region src/calendar-date.ts
+const CALENDAR_DATE_UNITS = [
+	"years",
+	"months",
+	"days"
+];
+const isCalendarDateUnit = (value) => CALENDAR_DATE_UNITS.includes(value);
+const pad = (n, width = 2) => String(n).padStart(width, "0");
+const daysInMonth = (year, month) => month === 2 ? year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28 : [
+	4,
+	6,
+	9,
+	11
+].includes(month) ? 30 : 31;
+function isCalendarDate(value) {
+	if (typeof value !== "string" || !/^\d{4}(?:-\d{2}(?:-\d{2})?)?$/.test(value)) return false;
+	const [year, month, day] = value.split("-").map(Number);
+	return year >= 1 && year <= 9999 && (month === void 0 || month >= 1 && month <= 12 && (day === void 0 || day >= 1 && day <= daysInMonth(year, month)));
+}
+/** A calendar date with day precision, as used for the session's current date. */
+const calendarDaySchema = z.string().refine((value) => isCalendarDate(value) && value.length === 10, "Expected a YYYY-MM-DD date");
+function calendarDatePrecision(value) {
+	if (!isCalendarDate(value)) throw new Error(`Invalid calendar date: ${value}`);
+	return value.length === 4 ? "year" : value.length === 7 ? "year-month" : "year-month-day";
+}
+function calendarDateFromLocalDate(date, precision = "year-month-day") {
+	const value = [
+		pad(date.getFullYear(), 4),
+		pad(date.getMonth() + 1),
+		pad(date.getDate())
+	].slice(0, precision === "year" ? 1 : precision === "year-month" ? 2 : 3).join("-");
+	if (!isCalendarDate(value)) throw new Error("Invalid calendar date");
+	return value;
+}
+/** Adapter for calendar widgets only. Never serialize this Date as an instant. */
+function calendarDateToLocalDate(value) {
+	calendarDatePrecision(value);
+	const [year, month = 1, day = 1] = value.split("-").map(Number);
+	const date = /* @__PURE__ */ new Date(0);
+	date.setFullYear(year, month - 1, day);
+	date.setHours(12, 0, 0, 0);
+	return date;
+}
+function calendarDateBounds(value) {
+	calendarDatePrecision(value);
+	const [year, month] = value.split("-").map(Number);
+	if (value.length === 4) return [`${value}-01-01`, `${value}-12-31`];
+	if (value.length === 7) return [`${value}-01`, `${value}-${pad(daysInMonth(year, month))}`];
+	return [value, value];
+}
+/** Ordering requires equal precision; callers must explicitly choose interval semantics otherwise. */
+function compareCalendarDates(a, b) {
+	if (!isCalendarDate(a) || !isCalendarDate(b) || a.length !== b.length) return void 0;
+	return a === b ? 0 : a < b ? -1 : 1;
+}
+function utcDate(value) {
+	const [year, month = 1, day = 1] = value.split("-").map(Number);
+	const date = new UTCDate(0);
+	date.setFullYear(year, month - 1, day);
+	return date;
+}
+function fromUtcDate(date, precision) {
+	const result = `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`.slice(0, precision === "year" ? 4 : precision === "year-month" ? 7 : 10);
+	return isCalendarDate(result) ? result : void 0;
+}
+const unitLength = {
+	years: 4,
+	months: 7,
+	days: 10
+};
+function addCalendarDate(value, amount, unit) {
+	if (!isCalendarDate(value) || !Number.isSafeInteger(amount)) return void 0;
+	if (amount === 0) return value;
+	if (value.length < unitLength[unit]) return void 0;
+	return fromUtcDate((unit === "days" ? addDays : unit === "months" ? addMonths : addYears)(utcDate(value), amount), calendarDatePrecision(value));
+}
+/**
+* Signed number of completed units in a - b. Mixed precisions are compared at the coarser
+* one; a unit finer than that precision is unavailable.
+*/
+function differenceCalendarDates(a, b, unit) {
+	if (!isCalendarDate(a) || !isCalendarDate(b)) return void 0;
+	const length = Math.min(a.length, b.length);
+	if (length < unitLength[unit]) return void 0;
+	const later = utcDate(a.slice(0, length)), earlier = utcDate(b.slice(0, length));
+	return unit === "days" ? differenceInCalendarDays(later, earlier) : unit === "months" ? differenceInMonths(later, earlier) : differenceInYears(later, earlier);
+}
+/** Partial dates retain their precision even if a display pattern requests absent components. */
+function formatCalendarDate(value, pattern) {
+	calendarDatePrecision(value);
+	if (value.length !== 10) return value;
+	return format(utcDate(value), pattern);
+}
+//#endregion
+//#region src/expressions/tree.ts
+/** Fail an exhaustive node or function switch if a new variant is not handled. */
+function unreachable(value) {
+	throw new Error(`Unsupported expression node: ${JSON.stringify(value)}`);
+}
+/** Convert unfinished editor operands to serializable null gaps, including sparse array indexes. */
+function expressionArguments(args) {
+	return Array.from(args, (arg) => arg ?? null);
+}
+/** Read an operand, treating a missing or null argument as undefined. */
+function operand(args, index) {
+	return args?.[index] ?? void 0;
+}
+/** Dispatch one node to its typed handler; use transformExpression to recurse into children. */
+function visitExpression(node, handlers, path = []) {
+	switch (node.type) {
+		case "const": return handlers.const(node, path);
+		case "responseVariable": return handlers.responseVariable(node, path);
+		case "ownerState": return handlers.ownerState(node, path);
+		case "contextVariable": return handlers.contextVariable(node, path);
+		case "function": return handlers.function(node, path);
+		default: return unreachable(node);
+	}
+}
+/**
+* Rewrite every node after its children. The path points to the node in the original tree;
+* argument positions and null editor gaps are preserved for diagnostics and remapping.
+*/
+function transformExpression(node, handlers, path = []) {
+	const args = (items) => Array.from(items, (_, index) => {
+		const child = operand(items, index);
+		return child ? transformExpression(child, handlers, [
+			...path,
+			"arguments",
+			index
+		]) : null;
+	});
+	switch (node.type) {
+		case "const":
+		case "responseVariable":
+		case "ownerState": return visitExpression(node, handlers, path);
+		case "function": return visitExpression({
+			...node,
+			arguments: args(node.arguments)
+		}, handlers, path);
+		case "contextVariable": return visitExpression({
+			...node,
+			...node.key ? { key: transformExpression(node.key, handlers, [...path, "key"]) } : {},
+			...node.arguments ? { arguments: args(node.arguments) } : {}
+		}, handlers, path);
+		default: return unreachable(node);
+	}
+}
+//#endregion
+//#region src/expressions/references.ts
+/** Collect response and owner state reads so the graph can validate and order dependencies. */
+function collectExpressionDependencies(node) {
+	const references = [];
+	transformExpression(node, {
+		const: (value) => value,
+		contextVariable: (value) => value,
+		function: (value) => value,
+		responseVariable: (value, path) => {
+			references.push({
+				kind: "answer",
+				...value.variableRef,
+				path
+			});
+			return value;
+		},
+		ownerState: (value, path) => {
+			references.push({
+				kind: "state",
+				state: value.state,
+				targetRef: value.targetRef,
+				path
+			});
+			return value;
+		}
+	});
+	return references;
+}
+/**
+* Rewrite slot IDs, owner IDs, and constant reference values when survey content is copied.
+* IDs absent from the map are left as they are.
+*/
+function remapExpression(node, ids) {
+	const id = (value) => ids.get(value) ?? value;
+	return transformExpression(node, {
+		const: (value) => {
+			if (value.value?.type === "reference") return {
+				...value,
+				value: {
+					...value.value,
+					value: id(value.value.value)
+				}
+			};
+			if (value.value?.type === "reference[]") return {
+				...value,
+				value: {
+					...value.value,
+					value: value.value.value.map(id)
+				}
+			};
+			return value;
+		},
+		contextVariable: (value) => value,
+		function: (value) => value,
+		responseVariable: (value) => ({
+			...value,
+			variableRef: {
+				...value.variableRef,
+				slotId: id(value.variableRef.slotId)
+			}
+		}),
+		ownerState: (value) => ({
+			...value,
+			targetRef: { ownerId: id(value.targetRef.ownerId) }
+		})
+	});
+}
+//#endregion
+//#region src/survey/responses/value-schema.ts
+const precision = z.enum(["int", "float"]).optional();
+const number = z.number().finite();
+const date = z.string().refine(isCalendarDate, "Expected a calendar year, month, or date");
+const unit = z.enum([
+	"seconds",
+	"minutes",
+	"hours",
+	"days",
+	"weeks",
+	"months",
+	"years"
+]);
+/** The same JSON value grammar is used by expressions, retained answers, and submissions. */
+const responseValueSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("string"),
+		value: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("reference"),
+		value: z.string().min(1)
+	}),
+	z.strictObject({
+		type: z.literal("number"),
+		value: number,
+		precision
+	}),
+	z.strictObject({
+		type: z.literal("boolean"),
+		value: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("date"),
+		value: date
+	}),
+	z.strictObject({
+		type: z.literal("duration"),
+		value: number,
+		unit,
+		precision
+	}),
+	z.strictObject({
+		type: z.literal("string[]"),
+		value: z.array(z.string())
+	}),
+	z.strictObject({
+		type: z.literal("reference[]"),
+		value: z.array(z.string().min(1))
+	}),
+	z.strictObject({
+		type: z.literal("number[]"),
+		value: z.array(number),
+		precision
+	}),
+	z.strictObject({
+		type: z.literal("date[]"),
+		value: z.array(date)
+	}),
+	z.strictObject({
+		type: z.literal("duration[]"),
+		value: z.array(number),
+		unit,
+		precision
+	})
+]);
+const valueTypeSchema = z.enum([
+	"string",
+	"reference",
+	"number",
+	"boolean",
+	"date",
+	"duration",
+	"string[]",
+	"reference[]",
+	"number[]",
+	"date[]",
+	"duration[]"
+]);
+//#endregion
+//#region src/expressions/schema.ts
+/** Serialized expression nodes and their Zod validation contract. Other expression modules operate on these nodes. */
+/** Optional authoring metadata carried by a node without affecting evaluation. */
+const expressionEditorConfigSchema = z.strictObject({
+	usedTemplate: z.string().optional(),
+	label: z.string().optional(),
+	description: z.string().optional()
+});
+/** Function names accepted in serialized expression trees. */
+const functionNameSchema = z.enum([
+	"and",
+	"or",
+	"not",
+	"list_contains",
+	"list_count",
+	"if",
+	"eq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in_range",
+	"sum",
+	"min",
+	"max",
+	"str_eq",
+	"date_eq",
+	"date_gt",
+	"date_gte",
+	"date_lt",
+	"date_lte",
+	"date_add_days",
+	"date_add_months",
+	"date_add_years",
+	"date_diff",
+	"date_min",
+	"date_max"
+]);
+const editorConfig = expressionEditorConfigSchema.optional();
+const constantSchema = z.strictObject({
+	type: z.literal("const"),
+	value: responseValueSchema.optional(),
+	editorConfig
+});
+const answerSchema = z.strictObject({
+	type: z.literal("responseVariable"),
+	variableRef: z.strictObject({
+		slotId: z.string().min(1),
+		method: z.enum(["get", "isDefined"])
+	}),
+	editorConfig
+});
+const ownerStateSchema = z.strictObject({
+	type: z.literal("ownerState"),
+	state: z.literal("disabled"),
+	targetRef: z.strictObject({ ownerId: z.string().min(1) }),
+	editorConfig
+});
+const contextSchema = z.strictObject({
+	type: z.literal("contextVariable"),
+	contextType: z.enum([
+		"locale",
+		"currentDate",
+		"participantFlag",
+		"customValue"
+	]),
+	get key() {
+		return expressionSchema.optional();
+	},
+	get arguments() {
+		return z.array(expressionSchema.nullable()).optional();
+	},
+	asType: valueTypeSchema.optional(),
+	editorConfig
+});
+const functionSchema = z.strictObject({
+	type: z.literal("function"),
+	functionName: functionNameSchema,
+	get arguments() {
+		return z.array(expressionSchema.nullable());
+	},
+	editorConfig
+});
+/** Parse a complete recursive expression tree, including owner state reads. */
+const expressionSchema = z.discriminatedUnion("type", [
+	constantSchema,
+	answerSchema,
+	contextSchema,
+	functionSchema,
+	ownerStateSchema
+]);
+//#endregion
+//#region src/schema/annotations.ts
+const annotations = z.registry();
+/** Clone before annotating: shared primitive schemas must not acquire another field's meaning. */
+function annotated(schema, annotation) {
+	const result = schema.clone();
+	const base = result;
+	annotations.add(base, annotation);
+	return result;
+}
+function schemaAnnotation(schema) {
+	return annotations.get(schema);
+}
+const ownedId = (identity, slotAlias = false) => annotated(z.string().min(1), {
+	kind: "identity",
+	identity,
+	...slotAlias ? { slotAlias } : {}
+});
+const referenceId = (target, external = false) => annotated(z.string().min(1), {
+	kind: "reference",
+	target,
+	...external ? { external } : {}
+});
+const expressionField = (expectedReturnType) => annotated(expressionSchema, {
+	kind: "expression",
+	...expectedReturnType ? { expectedReturnType } : {}
+});
+/**
+* A literal, or `{ expression, fallback? }` whose fallback applies when the expression has no
+* value. The annotation lets tools tell a bound from other config that also holds an expression.
+*/
+const boundField = (value, expectedReturnType) => annotated(z.union([value, z.strictObject({
+	expression: expressionField(expectedReturnType),
+	fallback: value.optional()
+})]), { kind: "bound" });
+const contentOwner = (schema, roles) => annotated(schema, {
+	kind: "owner",
+	roles
+});
+/** Object extension changes schema identity, so carry the toolkit metadata explicitly. */
+function extendObject(schema, extension) {
+	const result = schema.extend(extension);
+	const annotation = annotations.get(schema);
+	return annotation ? annotated(result, annotation) : result;
+}
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const unionDispatch = /* @__PURE__ */ new WeakMap();
+/** Disjoint literal discriminants select a branch without reparsing its recursive subtree. */
+function discriminatedVariant(schema, value) {
+	let dispatch = unionDispatch.get(schema);
+	if (dispatch === void 0) {
+		dispatch = null;
+		const objects = schema.options.filter((option) => option instanceof z.ZodObject);
+		if (objects.length === schema.options.length && objects.length > 0) for (const key of Object.keys(objects[0].shape)) {
+			const variants = /* @__PURE__ */ new Map();
+			if (objects.every((option) => {
+				const discriminator = option.shape[key];
+				if (!(discriminator instanceof z.ZodLiteral)) return false;
+				for (const literal of discriminator.values) {
+					if (variants.has(literal)) return false;
+					variants.set(literal, option);
+				}
+				return true;
+			})) {
+				dispatch = {
+					key,
+					variants
+				};
+				break;
+			}
+		}
+		unionDispatch.set(schema, dispatch);
+	}
+	if (!dispatch) return void 0;
+	const branch = record(value) ? dispatch.variants.get(value[dispatch.key]) : void 0;
+	if (!branch) throw new Error(`Unknown '${dispatch.key}' schema variant`);
+	return branch;
+}
+/**
+* A schema-guided walk of validated data. Values and record keys share one traversal.
+* Expressions are opaque here: their canonical visitor owns the recursive AST grammar.
+*/
+function walkAnnotated(schema, input, transform) {
+	const walk = (current, value, path, key = false) => {
+		const annotation = annotations.get(current);
+		if (annotation) {
+			value = transform({
+				schema: current,
+				value,
+				path,
+				key,
+				annotation
+			});
+			if (annotation.kind === "expression" || annotation.kind === "responseValue") return value;
+		}
+		if (value === void 0 || value === null) return value;
+		if (current instanceof z.ZodOptional || current instanceof z.ZodExactOptional || current instanceof z.ZodNullable || current instanceof z.ZodReadonly || current instanceof z.ZodNonOptional || current instanceof z.ZodDefault || current instanceof z.ZodPrefault || current instanceof z.ZodCatch) return walk(current.unwrap(), value, path, key);
+		if (current instanceof z.ZodLazy) return walk(current.unwrap(), value, path, key);
+		if (current instanceof z.ZodObject) {
+			if (!record(value)) throw new Error(`Expected object at ${JSON.stringify(path)}`);
+			return Object.fromEntries(Object.entries(value).map(([name, child]) => {
+				const childSchema = Object.hasOwn(current.shape, name) ? current.shape[name] : current._zod.def.catchall;
+				return [name, childSchema ? walk(childSchema, child, [...path, name]) : child];
+			}));
+		}
+		if (current instanceof z.ZodArray) {
+			if (!Array.isArray(value)) throw new Error(`Expected array at ${JSON.stringify(path)}`);
+			return value.map((child, index) => walk(current.element, child, [...path, index]));
+		}
+		if (current instanceof z.ZodTuple) {
+			if (!Array.isArray(value)) throw new Error(`Expected tuple at ${JSON.stringify(path)}`);
+			return value.map((child, index) => {
+				const childSchema = current._zod.def.items[index] ?? current._zod.def.rest;
+				if (!childSchema) throw new Error(`Unexpected tuple member at ${JSON.stringify(path)}`);
+				return walk(childSchema, child, [...path, index]);
+			});
+		}
+		if (current instanceof z.ZodRecord) {
+			if (!record(value)) throw new Error(`Expected record at ${JSON.stringify(path)}`);
+			const entries = Object.entries(value).map(([name, child]) => {
+				const nextKey = walk(current.keyType, name, [...path, name], true);
+				if (typeof nextKey !== "string") throw new Error("A record key must remain a string");
+				return [nextKey, walk(current.valueType, child, [...path, name])];
+			});
+			if (new Set(entries.map(([name]) => name)).size !== entries.length) throw new Error("Remapping collides record keys");
+			return Object.fromEntries(entries);
+		}
+		if (current instanceof z.ZodUnion) {
+			const variant = discriminatedVariant(current, value);
+			if (variant) return walk(variant, value, path, key);
+			for (const candidate of current.options) if (candidate instanceof z.ZodType && candidate.safeParse(value).success) return walk(candidate, value, path, key);
+			throw new Error(`No schema variant at ${JSON.stringify(path)}`);
+		}
+		switch (current._zod.def.type) {
+			case "string":
+			case "number":
+			case "boolean":
+			case "bigint":
+			case "symbol":
+			case "undefined":
+			case "null":
+			case "any":
+			case "unknown":
+			case "never":
+			case "void":
+			case "date":
+			case "nan":
+			case "enum":
+			case "literal":
+			case "template_literal":
+			case "custom":
+			case "file": return value;
+			default: throw new Error(`Unsupported schema container '${current._zod.def.type}' at ${JSON.stringify(path)}`);
+		}
+	};
+	return walk(schema, input, []);
+}
+function transformAnnotated(schema, input, transform) {
+	return schema.parse(walkAnnotated(schema, input, transform));
+}
+function inspectAnnotated(schema, input) {
+	const visits = [];
+	walkAnnotated(schema, input, (visit) => {
+		visits.push(visit);
+		return visit.value;
+	});
+	return visits;
+}
+function remapAnnotated(schema, input, ids) {
+	const remap = (id) => ids.get(id) ?? id;
+	return transformAnnotated(schema, input, ({ value, annotation }) => {
+		if (annotation.kind === "identity" || annotation.kind === "reference" && !annotation.external) {
+			if (typeof value !== "string") throw new Error("An identity must be a string");
+			return remap(value);
+		}
+		if (annotation.kind === "expression") return remapExpression(expressionSchema.parse(value), ids);
+		if (annotation.kind === "responseValue" && record(value)) {
+			if (value.type === "reference" && typeof value.value === "string") return {
+				...value,
+				value: remap(value.value)
+			};
+			if (value.type === "reference[]" && Array.isArray(value.value)) return {
+				...value,
+				value: value.value.map((entry) => typeof entry === "string" ? remap(entry) : entry)
+			};
+		}
+		return value;
+	});
+}
+function annotatedReferences(visits) {
+	return visits.flatMap((visit) => {
+		if (visit.annotation.kind === "reference" && !visit.annotation.external && typeof visit.value === "string") return [{
+			target: visit.annotation.target,
+			id: visit.value,
+			path: visit.path
+		}];
+		if (visit.annotation.kind === "expression") return collectExpressionDependencies(expressionSchema.parse(visit.value)).map((ref) => ({
+			target: ref.kind === "answer" ? "slot" : "state",
+			id: ref.kind === "answer" ? ref.slotId : ref.targetRef.ownerId,
+			path: [...visit.path, ...ref.path]
+		}));
+		return [];
+	});
+}
+/** Declared content owners in a validated subtree, including nested custom bodies. */
+function contentOwnerIds(schema, input) {
+	return new Set(inspectAnnotated(schema, input).flatMap((visit) => visit.annotation.kind === "owner" && record(visit.value) && typeof visit.value.id === "string" ? [visit.value.id] : []));
+}
+//#endregion
+//#region src/schema/string-record.ts
+/**
+* JSON dictionaries use opaque string keys, including `__proto__`. Zod's record
+* parser deliberately drops that key. Extend its record type at one boundary so
+* schema introspection, annotations, cloning and JSON Schema still see a record.
+* Define the exceptional property as data; never invoke Object.prototype's setter.
+* On Zod upgrades, run string-record.test.ts (clone/check/async/JSON Schema canaries).
+*/
+function stringRecord(keyType, valueType) {
+	return new (z.core.$constructor("StringRecord", (schema, def) => {
+		if (def.keyType._zod.def.checks?.some((check) => check._zod.def.check === "overwrite")) throw new Error("Dictionary key schemas must not rewrite opaque keys");
+		z.ZodRecord.init(schema, def);
+		const parse = schema._zod.parse;
+		schema._zod.parse = (payload, context) => {
+			const input = payload.value;
+			const parsed = parse(payload, context);
+			if (!z.core.util.isPlainObject(input) || !Object.prototype.propertyIsEnumerable.call(input, "__proto__")) return parsed;
+			const finish = (result) => {
+				const key = def.keyType._zod.run({
+					value: "__proto__",
+					issues: []
+				}, context);
+				if (key instanceof Promise) throw new Error("Async dictionary keys are unsupported");
+				if (key.issues.length) {
+					result.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: key.issues.map((issue) => z.core.util.finalizeIssue(issue, context, z.config())),
+						input: "__proto__",
+						path: ["__proto__"],
+						inst: schema
+					});
+					return result;
+				}
+				if (typeof key.value !== "string") throw new Error("Dictionary keys must remain strings");
+				const outputKey = key.value;
+				const value = def.valueType._zod.run({
+					value: input.__proto__,
+					issues: []
+				}, context);
+				const assign = (child) => {
+					result.issues.push(...z.core.util.prefixIssues("__proto__", child.issues));
+					Object.defineProperty(result.value, outputKey, {
+						value: child.value,
+						enumerable: true,
+						writable: true,
+						configurable: true
+					});
+					return result;
+				};
+				return value instanceof Promise ? value.then(assign) : assign(value);
+			};
+			return parsed instanceof Promise ? parsed.then(finish) : finish(parsed);
+		};
+	}))({
+		type: "record",
+		keyType,
+		valueType
+	});
+}
+/** JSON dictionary lookups must not fall through to Object.prototype. */
+function ownValue(record, key) {
+	return record && Object.hasOwn(record, key) ? record[key] : void 0;
+}
+function setOwnValue(record, key, value) {
+	Object.defineProperty(record, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+//#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"
+};
+/** Use the canonical codec at every boundary, including custom registry declarations. */
+function isResponseValue(value) {
+	return responseValueSchema.safeParse(value).success;
+}
+function assertResponseValue(value, path) {
+	if (!isResponseValue(value)) throw new Error(`Invalid response value at '${path}'`);
+}
+//#endregion
+//#region src/survey/composition/content-schema.ts
+const jsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(jsonValueSchema),
+	stringRecord(z.string(), jsonValueSchema)
+]));
+const contentAttributesSchema = stringRecord(z.string(), jsonValueSchema);
+const richTextStyleSchema = z.strictObject({
+	weight: z.enum(["strong", "normal"]).optional(),
+	italic: z.enum(["italic", "normal"]).optional(),
+	underline: z.enum(["underline", "none"]).optional(),
+	color: z.enum([
+		"primary",
+		"accent",
+		"default"
+	]).optional()
+});
+const richTextTextInlineSchema = z.strictObject({
+	type: z.literal("text"),
+	text: z.string(),
+	style: richTextStyleSchema.optional(),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextTemplateInlineSchema = z.strictObject({
+	type: z.literal("template"),
+	key: z.string().min(1),
+	style: richTextStyleSchema.optional(),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextLineBreakInlineSchema = z.strictObject({
+	type: z.literal("lineBreak"),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextLinkChildInlineSchema = z.discriminatedUnion("type", [
+	richTextTextInlineSchema,
+	richTextTemplateInlineSchema,
+	richTextLineBreakInlineSchema
+]);
+const richTextLinkInlineSchema = z.strictObject({
+	type: z.literal("link"),
+	href: z.string().min(1),
+	target: z.string().nullable().optional(),
+	rel: z.string().nullable().optional(),
+	title: z.string().nullable().optional(),
+	attrs: contentAttributesSchema.optional(),
+	children: z.array(richTextLinkChildInlineSchema)
+});
+const richTextInlineExtensionSchema = z.strictObject({
+	type: z.literal("inlineExtension"),
+	name: z.string().min(1),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextInlineSchema = z.discriminatedUnion("type", [
+	richTextTextInlineSchema,
+	richTextTemplateInlineSchema,
+	richTextLinkInlineSchema,
+	richTextLineBreakInlineSchema,
+	richTextInlineExtensionSchema
+]);
+const textAlignmentSchema = z.enum([
+	"left",
+	"center",
+	"right",
+	"justify"
+]);
+const richTextParagraphBlockSchema = z.strictObject({
+	type: z.literal("paragraph"),
+	children: z.array(richTextInlineSchema),
+	alignment: textAlignmentSchema.optional(),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextHeadingBlockSchema = z.strictObject({
+	type: z.literal("heading"),
+	level: z.union([
+		z.literal(1),
+		z.literal(2),
+		z.literal(3),
+		z.literal(4),
+		z.literal(5),
+		z.literal(6)
+	]),
+	children: z.array(richTextInlineSchema),
+	alignment: textAlignmentSchema.optional(),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextListItemBlockSchema = z.strictObject({
+	type: z.literal("listItem"),
+	children: z.array(richTextParagraphBlockSchema),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextBulletListBlockSchema = z.strictObject({
+	type: z.literal("bulletList"),
+	items: z.array(richTextListItemBlockSchema),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextImageDimensionSchema = z.union([z.strictObject({
+	unit: z.literal("px"),
+	value: z.number().finite().nonnegative()
+}), z.strictObject({
+	unit: z.literal("%"),
+	value: z.number().finite().nonnegative()
+})]);
+const richTextImageSourceSchema = z.discriminatedUnion("type", [z.strictObject({
+	type: z.literal("asset"),
+	assetId: referenceId("asset")
+}), z.strictObject({
+	type: z.literal("external"),
+	url: z.string()
+})]);
+const richTextImageBlockSchema = z.strictObject({
+	type: z.literal("image"),
+	source: richTextImageSourceSchema,
+	alt: z.string().optional(),
+	caption: z.array(richTextParagraphBlockSchema).optional(),
+	size: z.strictObject({
+		width: richTextImageDimensionSchema.optional(),
+		height: richTextImageDimensionSchema.optional(),
+		maxWidth: richTextImageDimensionSchema.optional(),
+		maxHeight: richTextImageDimensionSchema.optional()
+	}).optional(),
+	alignment: textAlignmentSchema.optional(),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextInfoBoxBlockSchema = z.strictObject({
+	type: z.literal("infoBox"),
+	tone: z.enum(["info", "warning"]).optional(),
+	title: z.array(richTextInlineSchema).optional(),
+	collapsible: z.boolean().optional(),
+	defaultOpen: z.boolean().optional(),
+	children: z.array(richTextParagraphBlockSchema),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextSeparatorBlockSchema = z.strictObject({
+	type: z.literal("separator"),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextBlockExtensionSchema = z.strictObject({
+	type: z.literal("blockExtension"),
+	name: z.string().min(1),
+	attrs: contentAttributesSchema.optional()
+});
+const richTextBlockSchema = z.discriminatedUnion("type", [
+	richTextParagraphBlockSchema,
+	richTextHeadingBlockSchema,
+	richTextBulletListBlockSchema,
+	richTextImageBlockSchema,
+	richTextInfoBoxBlockSchema,
+	richTextSeparatorBlockSchema,
+	richTextBlockExtensionSchema
+]);
+/** Survey roles use two document levels; general rich editors can represent all HTML levels. */
+const surveyContentSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("md"),
+		content: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("plain"),
+		content: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("richText"),
+		version: z.literal(1),
+		doc: z.strictObject({
+			type: z.literal("doc"),
+			blocks: z.array(richTextBlockSchema)
+		})
+	})
+]).superRefine((content, context) => {
+	if (content.type !== "richText") return;
+	content.doc.blocks.forEach((block, index) => {
+		if (block.type === "heading" && block.level > 2) context.addIssue({
+			code: "custom",
+			path: [
+				"doc",
+				"blocks",
+				index,
+				"level"
+			],
+			message: "Survey headings use level 1 or 2"
+		});
+	});
+});
+//#endregion
+//#region src/survey/composition/schema.ts
+const localizedContent = surveyContentSchema;
+const CURRENT_SURVEY_SCHEMA_VERSION = 3;
+const CURRENT_SURVEY_SCHEMA = "https://github.com/case-framework/case-survey-toolkit/packages/survey-core/schemas/survey-schema.json";
+const conditionsShape = {
+	visibility: expressionField().optional(),
+	disabled: expressionField().optional()
+};
+const layoutPolicySchema = z.discriminatedUnion("mode", [z.strictObject({
+	mode: z.literal("automatic"),
+	maxColumns: z.number().int().min(1).max(12)
+}), z.strictObject({
+	mode: z.literal("advanced"),
+	columns: z.strictObject({
+		base: z.number().int().min(1).max(12),
+		xs: z.number().int().min(1).max(12),
+		sm: z.number().int().min(1).max(12),
+		md: z.number().int().min(1).max(12),
+		xl: z.number().int().min(1).max(12)
+	})
+})]);
+const slotTransformSchema = z.strictObject({
+	mode: z.string(),
+	include: z.boolean().optional(),
+	categorical: z.enum([
+		"codes",
+		"labels",
+		"ids"
+	]).optional(),
+	multiple: z.enum([
+		"json",
+		"delimited",
+		"indicators"
+	]).optional(),
+	delimiter: z.string().optional(),
+	locale: z.string().optional(),
+	optionCodes: stringRecord(referenceId("option"), z.string()).optional(),
+	optionLabels: stringRecord(referenceId("option"), z.string()).optional(),
+	booleanValues: z.strictObject({
+		true: z.string(),
+		false: z.string()
+	}).optional(),
+	precision: z.number().int().nonnegative().optional(),
+	durationUnit: z.enum([
+		"seconds",
+		"minutes",
+		"hours",
+		"days",
+		"weeks",
+		"months",
+		"years"
+	]).optional(),
+	dateFormat: z.strictObject({ pattern: z.string() }).optional(),
+	maskText: z.string().optional()
+});
+const slotPrefillSchema = z.strictObject({
+	id: ownedId("prefill"),
+	when: expressionField().optional(),
+	apply: z.literal("ifEmpty").optional(),
+	source: z.discriminatedUnion("type", [
+		z.strictObject({
+			type: z.literal("static"),
+			value: annotated(responseValueSchema, { kind: "responseValue" })
+		}),
+		z.strictObject({
+			type: z.literal("expression"),
+			expression: expressionField()
+		}),
+		z.strictObject({
+			type: z.literal("templateValue"),
+			key: z.string().min(1)
+		}),
+		z.strictObject({
+			type: z.literal("previousResponse"),
+			ref: z.strictObject({
+				surveyKey: z.string().optional(),
+				slotId: referenceId("slot", true)
+			}),
+			ifUnsupported: z.literal("skip").optional()
+		})
+	])
+});
+const elementShape = {
+	id: ownedId("element"),
+	kind: z.literal("element"),
+	...conditionsShape,
+	placement: z.strictObject({
+		width: z.enum(["auto", "full"]).optional(),
+		minWidthRem: z.number().positive().optional()
+	}).optional(),
+	exportSettings: stringRecord(referenceId("slot"), slotTransformSchema).optional(),
+	prefills: stringRecord(referenceId("slot"), z.array(slotPrefillSchema)).optional()
+};
+const validationRuleSchema = contentOwner(z.strictObject({
+	id: ownedId("rule"),
+	targets: z.array(referenceId("slot")).min(1),
+	expression: expressionField(),
+	when: expressionField().optional(),
+	phase: z.enum(["page", "submit"]).optional()
+}), [{
+	role: "message",
+	policy: "inline"
+}]);
+function createCompositionSchema(element) {
+	const body = annotated(z.strictObject({ blocks: z.array(z.discriminatedUnion("kind", [z.strictObject({
+		id: ownedId("layout"),
+		kind: z.literal("layout"),
+		layout: layoutPolicySchema,
+		elements: z.array(element)
+	}), contentOwner(z.strictObject({
+		id: ownedId("section"),
+		kind: z.literal("section"),
+		...conditionsShape,
+		get body() {
+			return body;
+		}
+	}), [{
+		role: "title",
+		policy: "inline",
+		recommended: true
+	}, {
+		role: "description",
+		policy: "block"
+	}])])) }), {
+		kind: "body",
+		followUp: false
+	});
+	return body;
+}
+const followUpBody = (body) => annotated(body, {
+	kind: "body",
+	followUp: true
+});
+const metadata = stringRecord(z.string(), z.string()).optional();
+const itemEditorMetadataSchema = z.strictObject({
+	createdAt: z.string().optional(),
+	updatedAt: z.string().optional()
+});
+const editorMetadata = itemEditorMetadataSchema.optional();
+const itemShape = {
+	id: ownedId("item"),
+	metadata,
+	editorMetadata,
+	...conditionsShape
+};
+const groupSchema = contentOwner(z.strictObject({
+	...itemShape,
+	itemType: z.literal("group"),
+	config: z.strictObject({
+		isRoot: z.boolean().optional(),
+		items: z.array(referenceId("item")),
+		shuffleItems: z.boolean().optional()
+	})
+}), []);
+const pageBreakSchema = contentOwner(z.strictObject({
+	...itemShape,
+	itemType: z.literal("page-break"),
+	config: z.strictObject({})
+}), []);
+function createContentItemSchema(body) {
+	return contentOwner(z.strictObject({
+		...itemShape,
+		itemType: z.literal("content"),
+		config: z.strictObject({
+			body,
+			validationRules: z.array(validationRuleSchema).optional()
+		})
+	}), [
+		{
+			role: "title",
+			policy: "inline"
+		},
+		{
+			role: "subtitle",
+			policy: "block"
+		},
+		{
+			role: "footer",
+			policy: "block"
+		}
+	]);
+}
+function createFlowItemSchema(body) {
+	return z.discriminatedUnion("itemType", [
+		createContentItemSchema(body),
+		groupSchema,
+		pageBreakSchema
+	]);
+}
+const surveyLocaleContentSchema = z.strictObject({
+	surveyCardContent: z.strictObject({
+		name: localizedContent.optional(),
+		description: localizedContent.optional(),
+		typicalDuration: localizedContent.optional()
+	}).optional(),
+	navigationContent: z.strictObject({
+		previousButtonText: localizedContent.optional(),
+		nextButtonText: localizedContent.optional(),
+		submitButtonText: localizedContent.optional(),
+		pageIndicatorText: localizedContent.optional(),
+		submitBoxMessage: localizedContent.optional()
+	}).optional(),
+	validationMessages: z.strictObject({ invalidResponse: localizedContent.optional() }).optional(),
+	content: stringRecord(referenceId("owner"), stringRecord(z.string(), localizedContent))
+});
+const templateValueSchema = z.discriminatedUnion("type", [z.strictObject({
+	type: z.literal("default"),
+	returnType: valueTypeSchema,
+	expression: expressionField().optional()
+}), z.strictObject({
+	type: z.literal("formatDate"),
+	returnType: z.literal("string"),
+	expression: expressionField().optional(),
+	dateFormat: z.string()
+})]);
+const surveyShape = {
+	$schema: z.literal(CURRENT_SURVEY_SCHEMA),
+	schemaVersion: z.literal(3),
+	metadata,
+	/** The source language; exports and hosts fall back to it. Must be a key of `translations`. */
+	defaultLocale: z.string().min(1).optional(),
+	translations: stringRecord(z.string().min(1), surveyLocaleContentSchema).optional(),
+	maxItemsPerPage: z.strictObject({
+		large: z.number().int().positive(),
+		small: z.number().int().positive()
+	}).optional(),
+	assets: stringRecord(ownedId("asset"), z.strictObject({
+		kind: z.literal("image"),
+		source: z.strictObject({
+			type: z.literal("embedded"),
+			mediaType: z.string(),
+			encoding: z.literal("base64"),
+			data: z.string()
+		}),
+		metadata: z.strictObject({
+			name: z.string().optional(),
+			filename: z.string().optional(),
+			alt: z.string().optional(),
+			width: z.number().positive().optional(),
+			height: z.number().positive().optional()
+		}).optional()
+	})).optional(),
+	templateValues: stringRecord(z.string(), templateValueSchema).optional()
+};
+function createSurveySchema(body) {
+	return z.strictObject({
+		...surveyShape,
+		surveyItems: z.array(createFlowItemSchema(body)).min(1)
+	});
+}
+//#endregion
+//#region src/survey/utils/content.ts
+const ContentType = {
+	richText: "richText",
+	plain: "plain",
+	md: "md"
+};
+function hasRenderableRichTextBlock(block) {
+	switch (block.type) {
+		case "paragraph": return block.children.length > 0;
+		case "heading": return block.children.length > 0;
+		case "bulletList": return block.items.some((item) => item.children.some((paragraph) => paragraph.children.length > 0));
+		case "image": return true;
+		case "infoBox": return true;
+		case "separator": return true;
+		case "blockExtension": return true;
+	}
+}
+function hasRenderableRichTextContent(content) {
+	return content.doc.blocks.some((block) => hasRenderableRichTextBlock(block));
+}
+function createRichTextContent(text = "") {
+	return {
+		type: ContentType.richText,
+		version: 1,
+		doc: {
+			type: "doc",
+			blocks: [{
+				type: "paragraph",
+				children: text.length > 0 ? text.split("\n").flatMap((line, index) => {
+					const parts = [];
+					if (index > 0) parts.push({ type: "lineBreak" });
+					if (line.length > 0) parts.push({
+						type: "text",
+						text: line
+					});
+					return parts;
+				}) : []
+			}]
+		}
+	};
+}
+function getPlainTextFromLinkChildren(children) {
+	return children.map((inline) => {
+		switch (inline.type) {
+			case "text": return inline.text;
+			case "template": return `{${inline.key}}`;
+			case "lineBreak": return "\n";
+		}
+	}).join("");
+}
+function getPlainTextFromInlineNodes(inlines) {
+	return inlines.map((inline) => {
+		switch (inline.type) {
+			case "text": return inline.text;
+			case "template": return `{${inline.key}}`;
+			case "link": return getPlainTextFromLinkChildren(inline.children);
+			case "lineBreak": return "\n";
+			case "inlineExtension": return "";
+		}
+	}).join("");
+}
+function getPlainTextFromParagraphs(paragraphs) {
+	return paragraphs.map((paragraph) => getPlainTextFromInlineNodes(paragraph.children)).join("\n");
+}
+function getPlainTextFromBlock(block) {
+	switch (block.type) {
+		case "paragraph": return getPlainTextFromInlineNodes(block.children);
+		case "heading": return getPlainTextFromInlineNodes(block.children);
+		case "bulletList": return block.items.map((item) => getPlainTextFromParagraphs(item.children)).join("\n");
+		case "image": {
+			const captionText = block.caption ? getPlainTextFromParagraphs(block.caption) : "";
+			return [block.alt ?? "", captionText].filter(Boolean).join("\n");
+		}
+		case "infoBox": return [block.title ? getPlainTextFromInlineNodes(block.title) : "", getPlainTextFromParagraphs(block.children)].filter(Boolean).join("\n");
+		case "separator": return "";
+		case "blockExtension": return "";
+	}
+}
+function getPlainTextFromRichTextContent(content) {
+	return content.doc.blocks.map((block) => getPlainTextFromBlock(block)).filter((text) => text.length > 0).join("\n").trim();
+}
+function getContentPlainText(content) {
+	if (!content) return "";
+	if (content.type !== ContentType.richText) return content.content ?? "";
+	return getPlainTextFromRichTextContent(content);
+}
+function isContentEmpty(content) {
+	if (!content) return true;
+	if (content.type !== ContentType.richText) return content.content.trim().length === 0;
+	return !hasRenderableRichTextContent(content);
+}
+function getAssetUsagesFromContent(content) {
+	if (!content || content.type !== ContentType.richText) return [];
+	const usages = [];
+	content.doc.blocks.forEach((block, blockIndex) => {
+		if (block.type === "image" && block.source.type === "asset") usages.push({
+			assetId: block.source.assetId,
+			blockIndex
+		});
+	});
+	return usages;
+}
+//#endregion
+//#region src/survey/utils/localization.ts
+const SURVEY_LOCALIZATION_SURFACES = [
+	"surveyCardContent",
+	"navigationContent",
+	"validationMessages"
+];
+const SURVEY_LOCALIZATION_FIELDS = {
+	surveyCardContent: {
+		name: true,
+		description: true,
+		typicalDuration: true
+	},
+	navigationContent: {
+		previousButtonText: true,
+		nextButtonText: true,
+		submitButtonText: true,
+		pageIndicatorText: true,
+		submitBoxMessage: true
+	},
+	validationMessages: { invalidResponse: true }
+};
+const hasLocalizationText = (content) => Boolean(content && getContentPlainText(content).trim());
+const getLocalizationEntryKey = (ref) => ref.scope === "content" ? JSON.stringify([
+	ref.scope,
+	ref.ownerId,
+	ref.role
+]) : JSON.stringify([
+	ref.scope,
+	ref.surface,
+	ref.contentKey
+]);
+const getLocalizationCellKey = (ref, locale) => JSON.stringify([locale, getLocalizationEntryKey(ref)]);
+/** Accepts parsed draft data too, so disconnected items remain discoverable once. */
+function getLocalizationItems(survey, itemIds) {
+	const byId = new Map(survey.surveyItems.map((item) => [item.id, item]));
+	const visited = /* @__PURE__ */ new Set();
+	const ordered = [];
+	const visit = (id) => {
+		if (visited.has(id)) return;
+		visited.add(id);
+		const item = byId.get(id);
+		if (!item) return;
+		ordered.push(item);
+		if (item.itemType === "group") item.config.items.forEach(visit);
+	};
+	if (itemIds) itemIds.forEach((id) => {
+		if (!byId.has(id)) throw new Error(`Unknown localization item '${id}'`);
+		visit(id);
+	});
+	else {
+		survey.surveyItems.filter((item) => item.itemType === "group" && item.config.isRoot).forEach((item) => visit(item.id));
+		survey.surveyItems.forEach((item) => visit(item.id));
+	}
+	return ordered;
+}
+function validateLocalizationRef(survey, ref) {
+	if (ref.scope === "content") {
+		if (!survey.owners.get(ref.ownerId)?.roles.some((entry) => entry.role === ref.role)) throw new Error(`Unavailable localized content '${ref.ownerId}/${ref.role}'`);
+	} else if (!Object.hasOwn(SURVEY_LOCALIZATION_FIELDS[ref.surface], ref.contentKey)) throw new Error(`Unknown survey content field '${ref.surface}/${ref.contentKey}'`);
+}
+function readLocalizationContent(survey, ref, locale) {
+	validateLocalizationRef(survey, ref);
+	const translation = ownValue(survey.data.translations, locale);
+	if (ref.scope === "content") return ownValue(ownValue(translation?.content, ref.ownerId), ref.role);
+	const values = translation?.[ref.surface];
+	return ownValue(values, ref.contentKey);
+}
+function listLocalizationEntries(survey, options = {}) {
+	const locales = Object.keys(survey.data.translations ?? {}), entries = [];
+	const add = (ref) => {
+		const contents = Object.fromEntries(locales.map((locale) => [locale, readLocalizationContent(survey, ref, locale)]));
+		const includeEmpty = ref.scope === "survey" && options.includeEmptySurveyFields && !options.sourceLocale;
+		if (options.sourceLocale ? !hasLocalizationText(ownValue(contents, options.sourceLocale)) : !includeEmpty && !Object.values(contents).some(hasLocalizationText)) return;
+		entries.push({
+			key: getLocalizationEntryKey(ref),
+			ref,
+			contents
+		});
+	};
+	if (!options.itemIds) for (const surface of SURVEY_LOCALIZATION_SURFACES) for (const contentKey of Object.keys(SURVEY_LOCALIZATION_FIELDS[surface])) add({
+		scope: "survey",
+		surface,
+		contentKey
+	});
+	for (const item of getLocalizationItems(survey.data, options.itemIds)) for (const owner of survey.owners.values()) if (owner.itemId === item.id) for (const role of owner.roles) add({
+		scope: "content",
+		ownerId: owner.id,
+		role: role.role
+	});
+	return entries;
+}
+const isEmptySurveyLocalizationEntry = (entry) => entry.ref.scope === "survey" && !Object.values(entry.contents).some(hasLocalizationText);
+function getLocalizationCoverage(entries, locale) {
+	const required = entries.filter((entry) => !isEmptySurveyLocalizationEntry(entry));
+	const present = required.filter((entry) => hasLocalizationText(ownValue(entry.contents, locale))).length;
+	return {
+		total: required.length,
+		present,
+		missing: required.length - present
+	};
+}
+/** Fallback is a participant concern only; inventory and authoring readiness use exact locales. */
+function resolveParticipantContent(survey, ownerId, role, locales) {
+	for (const locale of locales) {
+		const content = readLocalizationContent(survey, {
+			scope: "content",
+			ownerId,
+			role
+		}, locale);
+		if (content && (hasLocalizationText(content) || content.type === "richText" && content.doc.blocks.some((block) => block.type !== "paragraph" && block.type !== "heading" && block.type !== "bulletList" && hasRenderableRichTextBlock(block)))) return {
+			locale,
+			content
+		};
+	}
+}
+//#endregion
+export { inspectAnnotated as $, slotPrefillSchema as A, ValueType as B, createCompositionSchema as C, calendarDaySchema as Ct, followUpBody as D, isCalendarDate as Dt, elementShape as E, formatCalendarDate as Et, richTextImageDimensionSchema as F, stringRecord as G, isResponseValue as H, richTextImageSourceSchema as I, boundField as J, annotated as K, surveyContentSchema as L, templateValueSchema as M, validationRuleSchema as N, itemEditorMetadataSchema as O, isCalendarDateUnit as Ot, jsonValueSchema as P, extendObject as Q, DurationUnits as R, conditionsShape as S, calendarDateToLocalDate as St, createSurveySchema as T, differenceCalendarDates as Tt, ownValue as U, assertResponseValue as V, setOwnValue as W, contentOwnerIds as X, contentOwner as Y, expressionField as Z, hasRenderableRichTextBlock as _, CALENDAR_DATE_UNITS as _t, getLocalizationItems as a, expressionEditorConfigSchema as at, CURRENT_SURVEY_SCHEMA as b, calendarDateFromLocalDate as bt, listLocalizationEntries as c, responseValueSchema as ct, validateLocalizationRef as d, remapExpression as dt, ownedId as et, ContentType as f, expressionArguments as ft, getPlainTextFromRichTextContent as g, visitExpression as gt, getContentPlainText as h, unreachable as ht, getLocalizationEntryKey as i, transformAnnotated as it, slotTransformSchema as j, layoutPolicySchema as k, readLocalizationContent as l, valueTypeSchema as lt, getAssetUsagesFromContent as m, transformExpression as mt, getLocalizationCellKey as n, remapAnnotated as nt, hasLocalizationText as o, expressionSchema as ot, createRichTextContent as p, operand as pt, annotatedReferences as q, getLocalizationCoverage as r, schemaAnnotation as rt, isEmptySurveyLocalizationEntry as s, functionNameSchema as st, SURVEY_LOCALIZATION_SURFACES as t, referenceId as tt, resolveParticipantContent as u, collectExpressionDependencies as ut, hasRenderableRichTextContent as v, addCalendarDate as vt, createFlowItemSchema as w, compareCalendarDates as wt, CURRENT_SURVEY_SCHEMA_VERSION as x, calendarDatePrecision as xt, isContentEmpty as y, calendarDateBounds as yt, NumberPrecision as z };
+
+//# sourceMappingURL=localization-1lzNpyFX.mjs.map