@memizy/oqse 0.1.1 → 0.1.3

package/dist/index.js

@@ -15,58 +15,58 @@ function i(e) {
 function a(e) {
 	return e.type === "mcq-multi";
 }
-function ee(e) {
+function o(e) {
 	return e.type === "short-answer";
 }
-function te(e) {
+function ee(e) {
 	return e.type === "fill-in-blanks";
 }
-function ne(e) {
+function te(e) {
 	return e.type === "fill-in-select";
 }
-function re(e) {
+function ne(e) {
 	return e.type === "match-pairs";
 }
-function ie(e) {
+function re(e) {
 	return e.type === "match-complex";
 }
-function ae(e) {
+function ie(e) {
 	return e.type === "sort-items";
 }
-function oe(e) {
+function ae(e) {
 	return e.type === "slider";
 }
-function se(e) {
+function oe(e) {
 	return e.type === "pin-on-image";
 }
-function ce(e) {
+function se(e) {
 	return e.type === "categorize";
 }
-function le(e) {
+function ce(e) {
 	return e.type === "timeline";
 }
-function ue(e) {
+function le(e) {
 	return e.type === "matrix";
 }
-function de(e) {
+function ue(e) {
 	return e.type === "math-input";
 }
-function fe(e) {
+function de(e) {
 	return e.type === "diagram-label";
 }
-function pe(e) {
+function fe(e) {
 	return e.type === "open-ended";
 }
-function me(e) {
+function pe(e) {
 	return e.type === "numeric-input";
 }
-function he(e) {
+function me(e) {
 	return e.type === "pin-on-model";
 }
-function ge(e) {
+function he(e) {
 	return e.type === "chess-puzzle";
 }
-function o(e) {
+function s(e) {
 	return [
 		"note",
 		"flashcard",
@@ -74,53 +74,180 @@ function o(e) {
 		"short-answer"
 	].includes(e.type);
 }
+function ge(e) {
+	return !s(e);
+}
+//#endregion
+//#region src/manifest.ts
+var c = [
+	"render",
+	"edit",
+	"validate",
+	"import",
+	"export"
+], l = [
+	"markdown",
+	"math",
+	"rtl",
+	"html",
+	"syntax-highlighting",
+	"mermaid",
+	"smiles",
+	"abc-notation",
+	"text-to-speech",
+	"voice-input",
+	"handwriting-recognition"
+], u = [
+	"hints",
+	"explanation",
+	"incorrectFeedback",
+	"sources",
+	"relatedItems",
+	"dependencyItems",
+	"timeLimit",
+	"lang",
+	"topic",
+	"pedagogy"
+], d = [
+	"description",
+	"thumbnail",
+	"subject",
+	"language",
+	"author",
+	"contributors",
+	"license",
+	"ageRestriction",
+	"tags",
+	"tagDefinitions",
+	"sourceMaterials",
+	"estimatedTime",
+	"prerequisites",
+	"translations",
+	"relatedSets"
+];
+function f(e) {
+	return /^\d+\.\d+$/.test(e);
+}
 function _e(e) {
-	return !o(e);
+	return /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/.test(e);
+}
+function p(e, t) {
+	let [n = 0, r = 0] = e.split(".").map(Number), [i = 0, a = 0] = t.split(".").map(Number);
+	return n === i ? r - a : n - i;
+}
+function ve(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e, n = t.author;
+	return typeof t.version == "string" && typeof t.id == "string" && typeof t.appName == "string" && t.appName !== "" && (n === void 0 || typeof n == "object" && !!n) && typeof t.capabilities == "object" && t.capabilities !== null && Array.isArray(t.capabilities.actions);
+}
+function ye(e, t) {
+	return !(!f(e) || t.minOqseVersion && f(t.minOqseVersion) && p(e, t.minOqseVersion) < 0 || t.maxOqseVersion && f(t.maxOqseVersion) && p(e, t.maxOqseVersion) > 0);
+}
+//#endregion
+//#region node_modules/uuid/dist/regex.js
+var be = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+//#endregion
+//#region node_modules/uuid/dist/validate.js
+function xe(e) {
+	return typeof e == "string" && be.test(e);
+}
+//#endregion
+//#region node_modules/uuid/dist/stringify.js
+var m = [];
+for (let e = 0; e < 256; ++e) m.push((e + 256).toString(16).slice(1));
+function Se(e, t = 0) {
+	return (m[e[t + 0]] + m[e[t + 1]] + m[e[t + 2]] + m[e[t + 3]] + "-" + m[e[t + 4]] + m[e[t + 5]] + "-" + m[e[t + 6]] + m[e[t + 7]] + "-" + m[e[t + 8]] + m[e[t + 9]] + "-" + m[e[t + 10]] + m[e[t + 11]] + m[e[t + 12]] + m[e[t + 13]] + m[e[t + 14]] + m[e[t + 15]]).toLowerCase();
+}
+//#endregion
+//#region node_modules/uuid/dist/rng.js
+var h, Ce = new Uint8Array(16);
+function we() {
+	if (!h) {
+		if (typeof crypto > "u" || !crypto.getRandomValues) throw Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+		h = crypto.getRandomValues.bind(crypto);
+	}
+	return h(Ce);
+}
+//#endregion
+//#region node_modules/uuid/dist/v7.js
+var g = {};
+function Te(e, t, n) {
+	let r;
+	if (e) r = De(e.random ?? e.rng?.() ?? we(), e.msecs, e.seq, t, n);
+	else {
+		let e = Date.now(), i = we();
+		Ee(g, e, i), r = De(i, g.msecs, g.seq, t, n);
+	}
+	return t ?? Se(r);
+}
+function Ee(e, t, n) {
+	return e.msecs ??= -Infinity, e.seq ??= 0, t > e.msecs ? (e.seq = n[6] << 23 | n[7] << 16 | n[8] << 8 | n[9], e.msecs = t) : (e.seq = e.seq + 1 | 0, e.seq === 0 && e.msecs++), e;
+}
+function De(e, t, n, r, i = 0) {
+	if (e.length < 16) throw Error("Random bytes length must be >= 16");
+	if (!r) r = new Uint8Array(16), i = 0;
+	else if (i < 0 || i + 16 > r.length) throw RangeError(`UUID byte range ${i}:${i + 15} is out of buffer bounds`);
+	return t ??= Date.now(), n ??= e[6] * 127 << 24 | e[7] << 16 | e[8] << 8 | e[9], r[i++] = t / 1099511627776 & 255, r[i++] = t / 4294967296 & 255, r[i++] = t / 16777216 & 255, r[i++] = t / 65536 & 255, r[i++] = t / 256 & 255, r[i++] = t & 255, r[i++] = 112 | n >>> 28 & 15, r[i++] = n >>> 20 & 255, r[i++] = 128 | n >>> 14 & 63, r[i++] = n >>> 6 & 255, r[i++] = n << 2 & 255 | e[10] & 3, r[i++] = e[11], r[i++] = e[12], r[i++] = e[13], r[i++] = e[14], r[i++] = e[15], r;
+}
+//#endregion
+//#region src/utils.ts
+function Oe(e) {
+	return xe(e);
+}
+function ke() {
+	return Te();
+}
+function _(e, t = 10, n = 0) {
+	if (n > t) throw Error(`OQSE Security Error: Maximum nesting depth exceeded limit of ${t} levels.`);
+	if (typeof e == "object" && e) {
+		let r = Array.isArray(e) ? e : Object.values(e);
+		for (let e of r) _(e, t, n + 1);
+	}
 }
 //#endregion
 //#region src/oqseValidation.ts
-var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string().min(2, "K+-d jazyka mus+� m+�t alespo+� 2 znaky").regex(/^[a-z]{2,3}(-[A-Z][a-z]{3})?(-[A-Z]{2})?$/, "Neplatn+� form+�t BCP 47 (nap+�. \"cs\", \"en-US\")"), l = e.string().min(1, "Identifik+�tor licence nesm+� b+�t pr+�zdn+�"), u = e.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/, "Neplatn+� form+�t ISO 8601 (nap+�. \"2025-11-21T14:30:00Z\")"), d = e.string().url({ message: "Mus+� b+�t platn+� absolutn+� URL adresa" }), f = e.string().regex(/^[a-z0-9_-]+$/, "Kl+��� assetu mus+� obsahovat pouze mal+� p+�smena, ��+�sla, poml��ky a podtr+�+�tka"), p = e.string().min(1, "Text nesm+� b+�t pr+�zdn+�"), m = e.string().min(1, "Obsah nesm+� b+�t pr+�zdn+�"), h = e.string().optional(), g = e.object({
-	lang: c,
-	value: e.string().min(1, "URI titulk+� nesm+� b+�t pr+�zdn+�"),
+var v = e.string().uuid({ message: "Invalid UUID format" }), y = e.string().min(2, "Language code must have at least 2 characters").regex(/^[a-z]{2,3}(-[A-Z][a-z]{3})?(-[A-Z]{2})?$/, "Invalid BCP 47 format (e.g. \"cs\", \"en-US\")"), b = e.string().min(1, "License identifier must not be empty"), x = e.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/, "Invalid ISO 8601 format (e.g. \"2025-11-21T14:30:00Z\")"), S = e.string().url({ message: "Must be a valid absolute URL" }), C = e.string().regex(/^[a-z0-9_-]+$/, "Asset key must contain only lowercase letters, numbers, hyphens and underscores"), w = e.string().min(1, "Text must not be empty"), T = e.string().min(1, "Content must not be empty"), E = e.string().max(1e4, "Question must not be longer than 10000 characters").optional(), D = e.string().regex(/^[a-zA-Z0-9_-]{1,64}$/, "Token must be alphanumeric, max 64 chars"), O = e.object({
+	lang: y,
+	value: e.string().min(1, "Subtitle URI must not be empty").regex(/\.(vtt|srt)(\?.*)?$/i, "Subtitle URI must end with .vtt or .srt"),
 	label: e.string().optional(),
 	kind: e.enum([
 		"captions",
 		"subtitles",
 		"descriptions"
 	]).optional()
-}), ve = e.object({
+}), k = e.object({
 	type: e.enum([
 		"image",
 		"audio",
 		"video",
 		"model"
 	]),
-	value: e.string().min(1, "URI m+�dia nesm+� b+�t pr+�zdn+�"),
+	value: e.string().min(1, "Media URI must not be empty"),
 	mimeType: e.string().optional(),
 	altText: e.string().optional(),
-	transcript: m.optional(),
-	caption: m.optional(),
+	transcript: T.optional(),
+	caption: T.optional(),
 	width: e.number().int().positive().optional(),
 	height: e.number().int().positive().optional(),
 	start: e.number().nonnegative().optional(),
 	end: e.number().positive().optional(),
 	loop: e.boolean().optional(),
-	subtitles: e.array(g).optional(),
-	license: l.optional(),
+	subtitles: e.array(O).optional(),
+	license: b.optional(),
 	attribution: e.string().optional(),
 	checksums: e.record(e.string(), e.string()).optional()
 }).refine((e) => e.start !== void 0 && e.end !== void 0 ? e.start < e.end : !0, {
-	message: "Po��+�te��n+� ��as mus+� b+�t men+�+� ne+� koncov+� ��as",
+	message: "Start time must be less than end time",
 	path: ["end"]
 }).refine((e) => !(e.type === "image" && !e.altText), {
-	message: "Obr+�zky mus+� m+�t definovan+� alternativn+� text (altText) pro p+�+�stupnost",
+	message: "Images must have alternative text (altText) defined for accessibility",
 	path: ["altText"]
-}), _ = e.record(f, ve), v = e.object({
-	name: p,
+}), A = e.record(C, k), j = e.object({
+	name: w,
 	role: e.string().optional(),
-	email: e.string().email("Neplatn+� form+�t e-mailov+� adresy").optional(),
-	url: d.optional()
-}), y = e.enum([
+	email: e.string().email("Invalid email format").optional(),
+	url: S.optional()
+}), M = e.enum([
 	"url",
 	"doi",
 	"isbn",
@@ -131,16 +258,16 @@ var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string
 	"image",
 	"model",
 	"other"
-]), b = e.object({
-	id: p,
-	type: y,
-	value: p,
-	title: p,
+]), N = e.object({
+	id: w,
+	type: M,
+	value: w,
+	title: w,
 	description: e.string().optional(),
-	authors: e.array(p).optional(),
-	publishedDate: u.optional(),
-	retrievedAt: u.optional(),
-	license: l.optional()
+	authors: e.array(w).optional(),
+	publishedDate: x.optional(),
+	retrievedAt: x.optional(),
+	license: b.optional()
 }).refine((e) => {
 	if ([
 		"url",
@@ -155,261 +282,252 @@ var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string
 	}
 	return !0;
 }, {
-	message: "Pro typy url, pdf, video, audio a image mus+� b+�t value platn+� URL adresa",
+	message: "For url, pdf, video, audio and image types, value must be a valid URL",
 	path: ["value"]
-}), x = e.object({
-	id: p,
+}), P = e.object({
+	id: w,
 	location: e.string().optional(),
-	quote: m.optional()
-}), S = e.object({
-	wikidataId: e.string().regex(/^Q\d+$/, "Wikidata ID mus+� m+�t form+�t Q n+�sledovan+� ��+�slem").optional(),
+	quote: T.optional()
+}), Ae = e.object({
+	wikidataId: e.string().regex(/^Q\d+$/, "Wikidata ID must have format Q followed by number").optional(),
 	description: e.string().optional()
-}), C = e.record(e.string(), S), w = e.object({
-	features: e.array(e.string().min(1, "Kl+��� funkce nesm+� b+�t pr+�zdn+�")).optional(),
-	latexPackages: e.array(e.string().min(1, "N+�zev bal+���ku nesm+� b+�t pr+�zdn+�")).optional(),
-	itemProperties: e.array(e.string().min(1, "Kl+��� vlastnosti nesm+� b+�t pr+�zdn+�")).optional(),
-	metaProperties: e.array(e.string().min(1, "Kl+��� vlastnosti nesm+� b+�t pr+�zdn+�")).optional()
-}), T = e.enum([
-	"official",
-	"experimental",
-	"proprietary"
-]), ye = e.enum([
-	"math",
-	"media-image",
-	"media-audio",
-	"media-video",
-	"hotspots",
-	"complex-pairing",
-	"open-text"
-]), E = e.object({
-	name: p,
-	type: T,
-	vendor: e.string().optional()
-}).refine((e) => !(e.type === "proprietary" && !e.vendor), {
-	message: "Propriet+�rn+� funkce mus+� m+�t definovan+� vendor (nap+�. \"memizy.com\")",
-	path: ["vendor"]
-}), D = e.object({
-	lang: c,
-	id: s,
-	title: p,
-	downloadUrl: d.optional()
-}), O = e.object({
-	id: s,
-	title: p,
-	downloadUrl: d.optional()
-}), k = e.enum([
+}), je = e.record(e.string(), Ae), F = e.object({
+	features: e.array(e.string().refine((e) => l.includes(e) || e.startsWith("x-"), { message: "Feature must be an official key or have prefix \"x-\"" })).optional(),
+	latexPackages: e.array(e.string().min(1, "Package name must not be empty")).optional(),
+	itemProperties: e.array(e.string().refine((e) => u.includes(e) || e.startsWith("x-"), { message: "Item property must be an official key or have prefix \"x-\"" })).optional(),
+	metaProperties: e.array(e.string().refine((e) => d.includes(e) || e.startsWith("x-"), { message: "Meta property must be an official key or have prefix \"x-\"" })).optional()
+}), Me = e.object({
+	lang: y,
+	id: v,
+	title: w,
+	downloadUrl: S.optional()
+}), I = e.object({
+	id: v,
+	title: w,
+	downloadUrl: S.optional()
+}), Ne = e.enum([
 	"remember",
 	"understand",
 	"apply",
 	"analyze",
 	"evaluate",
 	"create"
-]), A = e.enum([
+]), Pe = e.enum([
 	"low",
 	"medium",
 	"high"
-]), j = e.object({
-	bloomLevel: k.optional(),
+]), Fe = e.object({
+	bloomLevel: Ne.optional(),
 	irtDifficulty: e.number().optional(),
 	irtDiscrimination: e.number().optional(),
-	irtGuessing: e.number().min(0).max(1, "IRT guessing mus+� b+�t mezi 0 a 1").optional(),
+	irtGuessing: e.number().min(0).max(1, "IRT guessing must be between 0 and 1").optional(),
 	avgTime: e.number().positive().optional(),
-	cognitiveLoad: A.optional(),
+	cognitiveLoad: Pe.optional(),
 	partialCredit: e.boolean().optional(),
-	penaltyPerWrong: e.number().min(0).max(1, "Penalizace mus+� b+�t mezi 0 a 1").optional()
-}), M = e.enum(["katex", "mathjax"]), N = e.object({
-	renderer: M.optional(),
-	packages: e.array(e.string()).optional()
-}), P = e.object({
-	id: s,
-	language: c,
-	title: p.max(500, "Titulek nesm+� b+�t del+�+� ne+� 500 znak+�"),
-	description: m.max(5e3, "Popis nesm+� b+�t del+�+� ne+� 5000 znak+�").optional(),
-	thumbnail: f.optional(),
-	assets: _.optional(),
+	penaltyPerWrong: e.number().min(0).max(1, "Penalty must be between 0 and 1").optional()
+}), L = e.object({
+	id: v,
+	language: y,
+	title: w.max(500, "Title must not be longer than 500 characters"),
+	description: T.max(5e3, "Description must not be longer than 5000 characters").optional(),
+	thumbnail: C.optional(),
+	assets: A.optional(),
 	ageMin: e.number().int().nonnegative().optional(),
 	ageMax: e.number().int().nonnegative().optional(),
 	subject: e.string().optional(),
-	createdAt: u,
-	updatedAt: u,
-	author: v.optional(),
-	contributors: e.array(v).optional(),
-	license: l.optional(),
-	licenseUrl: d.optional(),
-	requirements: w.optional(),
-	requiredFeatures: e.array(E).optional(),
-	tags: e.array(p).optional(),
-	tagDefinitions: C.optional(),
-	translations: e.array(D).optional(),
-	sourceMaterials: e.array(b).optional(),
+	createdAt: x,
+	updatedAt: x,
+	author: j.optional(),
+	contributors: e.array(j).optional(),
+	license: b.optional(),
+	licenseUrl: S.optional(),
+	requirements: F.optional(),
+	tags: e.array(w).optional(),
+	tagDefinitions: je.optional(),
+	translations: e.array(Me).optional(),
+	sourceMaterials: e.array(N).optional(),
 	estimatedTime: e.number().positive().optional(),
-	prerequisites: e.array(O).optional(),
-	relatedSets: e.array(O).optional(),
-	mathSettings: N.optional(),
+	prerequisites: e.array(I).optional(),
+	relatedSets: e.array(I).optional(),
 	customData: e.record(e.string(), e.unknown()).optional(),
 	appSpecific: e.record(e.string(), e.unknown()).optional()
 }).refine((e) => e.ageMin !== void 0 && e.ageMax !== void 0 ? e.ageMin <= e.ageMax : !0, {
-	message: "Minim+�ln+� v��k (ageMin) mus+� b+�t men+�+� nebo roven maxim+�ln+�mu v��ku (ageMax)",
+	message: "Minimum age (ageMin) must be less than or equal to maximum age (ageMax)",
 	path: ["ageMax"]
 }).refine((e) => new Date(e.createdAt) <= new Date(e.updatedAt), {
-	message: "Datum vytvo+�en+� (createdAt) mus+� b+�t p+�ed nebo stejn+� jako datum aktualizace (updatedAt)",
+	message: "Creation date (createdAt) must be before or equal to update date (updatedAt)",
 	path: ["updatedAt"]
-}), F = e.object({
-	id: s,
+}), R = e.object({
+	id: v,
 	type: e.string(),
-	assets: _.optional(),
-	lang: c.optional(),
-	tags: e.array(p).optional(),
-	difficulty: e.number().int().min(1, "Obt+�+�nost mus+� b+�t minim+�ln�� 1").max(5, "Obt+�+�nost mus+� b+�t maxim+�ln�� 5").optional(),
-	timeLimit: e.number().positive("��asov+� limit mus+� b+�t kladn+� ��+�slo").optional(),
-	hints: e.array(m.max(2e3, "N+�pov��da nesm+� b+�t del+�+� ne+� 2000 znak+�")).max(20, "Maxim+�ln�� 20 n+�pov��d na polo+�ku").optional(),
-	explanation: m.max(1e4, "Vysv��tlen+� nesm+� b+�t del+�+� ne+� 10000 znak+�").optional(),
-	incorrectFeedback: m.optional(),
-	sources: e.array(x).optional(),
-	relatedItems: e.array(s).optional(),
-	dependencyItems: e.array(s).optional(),
-	pedagogy: j.optional(),
+	assets: A.optional(),
+	lang: y.optional(),
+	tags: e.array(w).optional(),
+	topic: w.optional(),
+	difficulty: e.number().int().min(1, "Difficulty must be at least 1").max(5, "Difficulty must be at most 5").optional(),
+	timeLimit: e.number().positive("Time limit must be a positive number").optional(),
+	hints: e.array(T.max(2e3, "Hint must not be longer than 2000 characters")).max(20, "Maximum 20 hints per item").optional(),
+	explanation: T.max(1e4, "Explanation must not be longer than 10000 characters").optional(),
+	incorrectFeedback: T.optional(),
+	sources: e.array(P).optional(),
+	relatedItems: e.array(v).optional(),
+	dependencyItems: e.array(v).optional(),
+	pedagogy: Fe.optional(),
 	customData: e.record(e.string(), e.unknown()).optional(),
 	appSpecific: e.record(e.string(), e.unknown()).optional()
-}), I = e.object({
-	options: e.array(m).min(1, "Mus+� b+�t alespo+� 1 mo+�nost"),
+}), Ie = e.object({
+	options: e.array(T).min(1, "Must have at least 1 option"),
 	correctIndex: e.number().int().nonnegative()
 }).refine((e) => e.correctIndex < e.options.length, {
-	message: "Index spr+�vn+� odpov��di odkazuje na neexistuj+�c+� mo+�nost",
+	message: "Correct answer index references non-existent option",
 	path: ["correctIndex"]
-}), L = e.object({
+}), z = e.object({
 	type: e.literal("rect"),
 	label: e.string().optional(),
-	x: e.number().min(0).max(100, "X mus+� b+�t v rozmez+� 0-100%"),
-	y: e.number().min(0).max(100, "Y mus+� b+�t v rozmez+� 0-100%"),
-	width: e.number().min(0).max(100, "+�+�+�ka mus+� b+�t v rozmez+� 0-100%"),
-	height: e.number().min(0).max(100, "V+�+�ka mus+� b+�t v rozmez+� 0-100%")
-}), R = e.object({
+	x: e.number().min(0).max(100, "X must be in range 0-100%"),
+	y: e.number().min(0).max(100, "Y must be in range 0-100%"),
+	width: e.number().min(0).max(100, "Width must be in range 0-100%"),
+	height: e.number().min(0).max(100, "Height must be in range 0-100%")
+}), B = e.object({
 	type: e.literal("circle"),
 	label: e.string().optional(),
-	x: e.number().min(0).max(100, "X mus+� b+�t v rozmez+� 0-100%"),
-	y: e.number().min(0).max(100, "Y mus+� b+�t v rozmez+� 0-100%"),
-	radius: e.number().min(0).max(100, "Polom��r mus+� b+�t v rozmez+� 0-100%")
-}), z = e.object({
+	x: e.number().min(0).max(100, "X must be in range 0-100%"),
+	y: e.number().min(0).max(100, "Y must be in range 0-100%"),
+	radius: e.number().min(0).max(100, "Radius must be in range 0-100%")
+}), V = e.object({
 	type: e.literal("polygon"),
 	label: e.string().optional(),
 	points: e.array(e.object({
 		x: e.number().min(0).max(100),
 		y: e.number().min(0).max(100)
-	})).min(3, "Polygon mus+� m+�t alespo+� 3 body")
-}), B = e.object({
+	})).min(3, "Polygon must have at least 3 points")
+}), H = e.object({
 	type: e.literal("mesh"),
 	label: e.string().optional(),
-	targetName: p
-}), V = e.discriminatedUnion("type", [
-	L,
-	R,
+	targetName: w
+}), Le = e.discriminatedUnion("type", [
 	z,
-	B
-]), H = e.object({
+	B,
+	V,
+	H
+]), Re = e.discriminatedUnion("type", [
+	z,
+	B,
+	V
+]), U = e.object({
 	x: e.number(),
 	y: e.number(),
 	z: e.number()
-}), U = e.object({
-	position: H.optional(),
-	target: H.optional()
-}), be = e.object({
-	id: p,
-	text: m,
+}), ze = e.object({
+	position: U.optional(),
+	target: U.optional()
+}), Be = e.object({
+	id: w,
+	text: T,
 	correctCategoryIndex: e.number().int().nonnegative()
-}), xe = e.enum([
+}), Ve = e.enum([
 	"year",
 	"month",
 	"day",
 	"datetime"
-]), Se = e.object({
-	id: p,
-	text: m,
-	date: u,
-	precision: xe.optional()
-}), Ce = e.union([
-	L.extend({ correctLabelIndex: e.number().int().nonnegative() }),
-	R.extend({ correctLabelIndex: e.number().int().nonnegative() }),
-	z.extend({ correctLabelIndex: e.number().int().nonnegative() })
-]), we = e.object({
-	label: p,
-	percentage: e.number().min(0, "Procenta mus+� b+�t nez+�porn+�").max(100, "Procenta nesm+� p+�es+�hnout 100"),
+]), He = e.object({
+	id: w,
+	text: T,
+	date: x,
+	precision: Ve.optional()
+}), Ue = e.union([
+	z.extend({ correctLabelIndex: e.number().int().nonnegative() }),
+	B.extend({ correctLabelIndex: e.number().int().nonnegative() }),
+	V.extend({ correctLabelIndex: e.number().int().nonnegative() })
+]), W = e.object({
+	label: w,
+	percentage: e.number().min(0, "Percentage must be non-negative").max(100, "Percentage must not exceed 100"),
 	description: e.string().optional()
-}), Te = e.object({ criteria: e.array(we).min(1, "Rubrika mus+� m+�t alespo+� 1 krit+�rium") }).refine((e) => e.criteria.reduce((e, t) => e + t.percentage, 0) > 0, {
-	message: "Sou��et procent v+�ech krit+�ri+� mus+� b+�t v��t+�+� ne+� 0",
+}), We = e.object({ criteria: e.array(W).min(1, "Rubric must have at least 1 criterion") }).refine((e) => e.criteria.reduce((e, t) => e + t.percentage, 0) > 0, {
+	message: "Sum of percentages of all criteria must be greater than 0",
 	path: ["criteria"]
-}), Ee = e.object({
+}), Ge = e.object({
 	min: e.number(),
 	max: e.number()
 }).refine((e) => e.min <= e.max, {
-	message: "Minim+�ln+� hodnota mus+� b+�t men+�+� nebo rovna maxim+�ln+� hodnot��",
+	message: "Minimum value must be less than or equal to maximum value",
 	path: ["max"]
-}), De = F.extend({
+}), Ke = R.extend({
 	type: e.literal("note"),
 	title: e.string().optional(),
-	content: m.max(1e4, "Obsah nesm+� b+�t del+�+� ne+� 10000 znak+�")
-}), Oe = F.extend({
+	content: T.max(1e4, "Content must not be longer than 10000 characters"),
+	hiddenContent: T.max(1e4, "Content must not be longer than 10000 characters").optional()
+}), qe = R.extend({
 	type: e.literal("flashcard"),
-	front: m.max(1e4, "P+�edn+� strana nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	back: m.max(1e4, "Zadn+� strana nesm+� b+�t del+�+� ne+� 10000 znak+�")
-}), ke = F.extend({
+	front: T.max(1e4, "Front side must not be longer than 10000 characters"),
+	back: T.max(1e4, "Back side must not be longer than 10000 characters")
+}), Je = R.extend({
 	type: e.literal("true-false"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
 	answer: e.boolean()
-}), Ae = F.extend({
+}), Ye = R.extend({
 	type: e.literal("mcq-single"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	options: e.array(m.max(2e3, "Mo+�nost nesm+� b+�t del+�+� ne+� 2000 znak+�")).min(2, "Ot+�zka mus+� m+�t alespo+� 2 mo+�nosti").max(100, "Maxim+�ln�� 100 mo+�nost+�"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	options: e.array(T.max(2e3, "Option must not be longer than 2000 characters")).min(2, "Question must have at least 2 options").max(100, "Maximum 100 options"),
 	correctIndex: e.number().int().nonnegative(),
 	shuffleOptions: e.boolean().optional(),
-	optionExplanations: e.array(e.union([m, e.null()])).optional()
+	optionExplanations: e.array(e.union([T, e.null()])).optional()
 }).refine((e) => e.correctIndex < e.options.length, {
-	message: "Index spr+�vn+� odpov��di odkazuje na neexistuj+�c+� mo+�nost",
+	message: "Correct answer index references non-existent option",
 	path: ["correctIndex"]
 }).refine((e) => e.optionExplanations ? e.optionExplanations.length === e.options.length : !0, {
-	message: "Po��et vysv��tlen+� mo+�nost+� mus+� b+�t stejn+� jako po��et mo+�nost+�",
+	message: "Number of option explanations must match number of options",
 	path: ["optionExplanations"]
-}), je = F.extend({
+}).refine((e) => new Set(e.options.map((e) => e.toLowerCase())).size === e.options.length, {
+	message: "Options must not contain duplicates (case-insensitive)",
+	path: ["options"]
+}), Xe = R.extend({
 	type: e.literal("mcq-multi"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	options: e.array(m.max(2e3, "Mo+�nost nesm+� b+�t del+�+� ne+� 2000 znak+�")).min(2, "Ot+�zka mus+� m+�t alespo+� 2 mo+�nosti").max(100, "Maxim+�ln�� 100 mo+�nost+�"),
-	correctIndices: e.array(e.number().int().nonnegative()).min(1, "Mus+� b+�t alespo+� 1 spr+�vn+� odpov����"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	options: e.array(T.max(2e3, "Option must not be longer than 2000 characters")).min(2, "Question must have at least 2 options").max(100, "Maximum 100 options"),
+	correctIndices: e.array(e.number().int().nonnegative()).min(1, "Must have at least 1 correct answer"),
 	minSelections: e.number().int().positive().optional(),
 	maxSelections: e.number().int().positive().optional(),
 	shuffleOptions: e.boolean().optional(),
-	optionExplanations: e.array(e.union([m, e.null()])).optional()
+	optionExplanations: e.array(e.union([T, e.null()])).optional()
 }).refine((e) => e.correctIndices.every((t) => t < e.options.length), {
-	message: "N��kter+� z index+� spr+�vn+�ch odpov��d+� odkazuje na neexistuj+�c+� mo+�nost",
+	message: "Some of correct answer indices reference non-existent option",
 	path: ["correctIndices"]
 }).refine((e) => new Set(e.correctIndices).size === e.correctIndices.length, {
-	message: "Indexy spr+�vn+�ch odpov��d+� obsahuj+� duplicity",
+	message: "Correct answer indices contain duplicates",
 	path: ["correctIndices"]
 }).refine((e) => e.minSelections && e.maxSelections ? e.minSelections <= e.maxSelections : !0, {
-	message: "Minim+�ln+� po��et v+�b��r+� mus+� b+�t men+�+� nebo roven maxim+�ln+�mu po��tu",
+	message: "Minimum number of selections must be less than or equal to maximum",
 	path: ["maxSelections"]
 }).refine((e) => e.maxSelections ? e.maxSelections <= e.options.length : !0, {
-	message: "Maxim+�ln+� po��et v+�b��r+� nesm+� p+�es+�hnout po��et mo+�nost+�",
+	message: "Maximum number of selections must not exceed number of options",
 	path: ["maxSelections"]
+}).refine((e) => e.minSelections ? e.minSelections <= e.options.length : !0, {
+	message: "minSelections cannot be greater than the number of options",
+	path: ["minSelections"]
 }).refine((e) => e.optionExplanations ? e.optionExplanations.length === e.options.length : !0, {
-	message: "Po��et vysv��tlen+� mo+�nost+� mus+� b+�t stejn+� jako po��et mo+�nost+�",
+	message: "Number of option explanations must match number of options",
 	path: ["optionExplanations"]
-}), W = F.extend({
+}).refine((e) => new Set(e.options.map((e) => e.toLowerCase())).size === e.options.length, {
+	message: "Options must not contain duplicates (case-insensitive)",
+	path: ["options"]
+}), Ze = R.extend({
 	type: e.literal("short-answer"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	answers: e.array(p).min(1, "Mus+� b+�t alespo+� 1 spr+�vn+� odpov����"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	answers: e.array(w).min(1, "Must have at least 1 correct answer"),
 	caseSensitive: e.boolean().optional(),
 	trimWhitespace: e.boolean().optional(),
 	acceptPartial: e.boolean().optional(),
 	ignoreDiacritics: e.boolean().optional()
-}), Me = F.extend({
+}), Qe = R.extend({
 	type: e.literal("fill-in-blanks"),
-	question: h,
-	text: m.max(1e4, "Text nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	blanks: e.record(e.string(), e.array(p).min(1, "Ka+�d+� mezera mus+� m+�t alespo+� 1 spr+�vnou odpov����")),
+	question: E,
+	text: T.max(1e4, "Text must not be longer than 10000 characters"),
+	blanks: e.record(D, e.array(w).min(1, "Each blank must have at least 1 correct answer")),
 	caseSensitive: e.boolean().optional(),
 	trimWhitespace: e.boolean().optional()
 }).refine((e) => Object.keys(e.blanks).length > 0, {
-	message: "Text mus+� obsahovat alespo+� 1 mezeru k dopln��n+�",
+	message: "Text must contain at least 1 blank to fill",
 	path: ["blanks"]
 }).refine((e) => {
 	let t = /<blank:([a-zA-Z0-9_-]{1,64})\s*\/>/g, n = /* @__PURE__ */ new Set(), r;
@@ -419,15 +537,15 @@ var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string
 	for (let e of i) if (!n.has(e)) return !1;
 	return !0;
 }, {
-	message: "V+�echny tokeny v textu mus+� m+�t definici v blanks a v+�echny definice mus+� b+�t pou+�ity v textu",
+	message: "All tokens in text must have definition in blanks and all definitions must be used in text",
 	path: ["blanks"]
-}), Ne = F.extend({
+}), $e = R.extend({
 	type: e.literal("fill-in-select"),
-	question: h,
-	text: m.max(1e4, "Text nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	blanks: e.record(e.string(), I)
+	question: E,
+	text: T.max(1e4, "Text must not be longer than 10000 characters"),
+	blanks: e.record(D, Ie)
 }).refine((e) => Object.keys(e.blanks).length > 0, {
-	message: "Text mus+� obsahovat alespo+� 1 mezeru k v+�b��ru",
+	message: "Text must contain at least 1 blank to select",
 	path: ["blanks"]
 }).refine((e) => {
 	let t = /<blank:([a-zA-Z0-9_-]{1,64})\s*\/>/g, n = /* @__PURE__ */ new Set(), r;
@@ -437,95 +555,98 @@ var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string
 	for (let e of i) if (!n.has(e)) return !1;
 	return !0;
 }, {
-	message: "V+�echny tokeny v textu mus+� m+�t definici v blanks a v+�echny definice mus+� b+�t pou+�ity v textu",
+	message: "All tokens in text must have definition in blanks and all definitions must be used in text",
 	path: ["blanks"]
-}), Pe = F.extend({
+}), et = R.extend({
 	type: e.literal("match-pairs"),
-	question: h,
-	prompts: e.array(m).min(2, "Mus+� b+�t alespo+� 2 p+�ry k p+�i+�azen+�"),
-	matches: e.array(m).min(2, "Mus+� b+�t alespo+� 2 p+�ry k p+�i+�azen+�")
+	question: E,
+	prompts: e.array(T).min(2, "Must have at least 2 pairs to match").max(100, "Maximum 100 pairs"),
+	matches: e.array(T).min(2, "Must have at least 2 pairs to match").max(100, "Maximum 100 pairs")
 }).refine((e) => e.prompts.length === e.matches.length, {
-	message: "Po��et ot+�zek (prompts) mus+� b+�t stejn+� jako po��et odpov��d+� (matches)",
+	message: "Number of prompts must match number of matches",
 	path: ["matches"]
-}), Fe = F.extend({
+}), tt = R.extend({
 	type: e.literal("match-complex"),
-	question: h,
-	leftItems: e.array(m).min(1, "Mus+� b+�t alespo+� 1 polo+�ka vlevo"),
-	rightItems: e.array(m).min(1, "Mus+� b+�t alespo+� 1 polo+�ka vpravo"),
-	connections: e.array(e.tuple([e.number().int().nonnegative(), e.number().int().nonnegative()])).min(1, "Mus+� b+�t alespo+� 1 propojen+�"),
+	question: E,
+	leftItems: e.array(T).min(1, "Must have at least 1 item on left"),
+	rightItems: e.array(T).min(1, "Must have at least 1 item on right"),
+	connections: e.array(e.tuple([e.number().int().nonnegative(), e.number().int().nonnegative()])).min(1, "Must have at least 1 connection"),
 	minCorrect: e.number().int().positive().optional()
 }).refine((e) => e.connections.every(([t, n]) => t < e.leftItems.length && n < e.rightItems.length), {
-	message: "N��kter+� propojen+� odkazuje na neexistuj+�c+� polo+�ku",
+	message: "Some connection references non-existent item",
 	path: ["connections"]
 }).refine((e) => new Set(e.connections.map((e) => `${e[0]}-${e[1]}`)).size === e.connections.length, {
-	message: "Propojen+� obsahuj+� duplicity",
+	message: "Connections contain duplicates",
 	path: ["connections"]
 }).refine((e) => e.minCorrect ? e.minCorrect <= e.connections.length : !0, {
-	message: "Minim+�ln+� po��et spr+�vn+�ch odpov��d+� nesm+� p+�es+�hnout celkov+� po��et propojen+�",
+	message: "Minimum correct answers must not exceed total number of connections",
 	path: ["minCorrect"]
-}), Ie = F.extend({
+}), nt = R.extend({
 	type: e.literal("sort-items"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	items: e.array(m).min(2, "Mus+� b+�t alespo+� 2 polo+�ky k se+�azen+�")
-}), Le = F.extend({
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	items: e.array(T).min(2, "Must have at least 2 items to sort")
+}), rt = R.extend({
 	type: e.literal("slider"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
 	min: e.number(),
 	max: e.number(),
-	step: e.number().positive("Krok mus+� b+�t kladn+� ��+�slo"),
+	step: e.number().positive("Step must be a positive number"),
 	correctAnswer: e.number(),
-	tolerance: e.number().nonnegative("Tolerance mus+� b+�t nez+�porn+�"),
+	tolerance: e.number().nonnegative("Tolerance must be non-negative"),
 	unit: e.string().optional()
 }).refine((e) => e.min < e.max, {
-	message: "Minim+�ln+� hodnota mus+� b+�t men+�+� ne+� maxim+�ln+� hodnota",
+	message: "Minimum value must be less than maximum value",
 	path: ["max"]
 }).refine((e) => e.correctAnswer >= e.min && e.correctAnswer <= e.max, {
-	message: "Spr+�vn+� odpov���� mus+� b+�t v rozmez+� min-max",
+	message: "Correct answer must be in range min-max",
 	path: ["correctAnswer"]
 }).refine((e) => {
 	let t = (e.correctAnswer - e.min) / e.step;
 	return Math.abs(t - Math.round(t)) < 1e-4;
 }, {
-	message: "Spr+�vn+� odpov���� mus+� b+�t dosa+�iteln+� pomoc+� definovan+�ho kroku",
+	message: "Correct answer must be reachable by defined step",
 	path: ["correctAnswer"]
 }).refine((e) => e.tolerance <= (e.max - e.min) / 2, {
-	message: "Tolerance nesm+� b+�t v��t+�+� ne+� polovina rozsahu hodnot",
+	message: "Tolerance must not be greater than half of value range",
 	path: ["tolerance"]
-}), Re = F.extend({
+}), it = R.extend({
 	type: e.literal("pin-on-image"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	targetAsset: f,
-	hotspots: e.array(V).min(1, "Mus+� b+�t alespo+� 1 hotspot"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	targetAsset: C,
+	hotspots: e.array(Re).min(1, "Must have at least 1 hotspot"),
 	multipleCorrect: e.boolean().optional(),
 	minCorrect: e.number().int().positive().optional()
 }).refine((e) => e.minCorrect ? e.minCorrect <= e.hotspots.length : !0, {
-	message: "Minim+�ln+� po��et spr+�vn+�ch odpov��d+� nesm+� p+�es+�hnout po��et hotspot+�",
+	message: "Minimum correct answers must not exceed number of hotspots",
 	path: ["minCorrect"]
-}), ze = F.extend({
+}), at = R.extend({
 	type: e.literal("categorize"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	categories: e.array(p).min(2, "Mus+� b+�t alespo+� 2 kategorie"),
-	items: e.array(be).min(1, "Mus+� b+�t alespo+� 1 polo+�ka ke kategorizaci")
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	categories: e.array(w).min(2, "Must have at least 2 categories"),
+	items: e.array(Be).min(1, "Must have at least 1 item to categorize")
+}).refine((e) => new Set(e.categories.map((e) => e.toLowerCase())).size === e.categories.length, {
+	message: "Categories must not contain duplicates (case-insensitive)",
+	path: ["categories"]
 }).refine((e) => e.items.every((t) => t.correctCategoryIndex < e.categories.length), {
-	message: "N��kter+� polo+�ka odkazuje na neexistuj+�c+� kategorii",
+	message: "Some item references non-existent category",
 	path: ["items"]
-}), Be = F.extend({
+}), ot = R.extend({
 	type: e.literal("timeline"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	events: e.array(Se).min(2, "Mus+� b+�t alespo+� 2 ud+�losti"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	events: e.array(He).min(2, "Must have at least 2 events"),
 	randomize: e.boolean().optional()
-}), Ve = F.extend({
+}), st = R.extend({
 	type: e.literal("matrix"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	rows: e.array(p).min(1, "Mus+� b+�t alespo+� 1 +�+�dek"),
-	columns: e.array(p).min(1, "Mus+� b+�t alespo+� 1 sloupec"),
-	correctCells: e.array(e.tuple([e.number().int().nonnegative(), e.number().int().nonnegative()])).min(1, "Mus+� b+�t alespo+� 1 spr+�vn+� bu+�ka"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	rows: e.array(w).min(1, "Must have at least 1 row"),
+	columns: e.array(w).min(1, "Must have at least 1 column"),
+	correctCells: e.array(e.tuple([e.number().int().nonnegative(), e.number().int().nonnegative()])).min(1, "Must have at least 1 correct cell"),
 	multiplePerRow: e.boolean().optional()
 }).refine((e) => e.correctCells.every(([t, n]) => t < e.rows.length && n < e.columns.length), {
-	message: "N��kter+� sou+�adnice bu+�ky odkazuj+� na neexistuj+�c+� +�+�dek nebo sloupec",
+	message: "Some cell coordinates reference non-existent row or column",
 	path: ["correctCells"]
 }).refine((e) => new Set(e.correctCells.map((e) => `${e[0]}-${e[1]}`)).size === e.correctCells.length, {
-	message: "Spr+�vn+� bu+�ky obsahuj+� duplicity",
+	message: "Correct cells contain duplicates",
 	path: ["correctCells"]
 }).refine((e) => {
 	if (!e.multiplePerRow) {
@@ -535,103 +656,103 @@ var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string
 	}
 	return !0;
 }, {
-	message: "Pokud multiplePerRow je false, ka+�d+� +�+�dek sm+� m+�t maxim+�ln�� 1 spr+�vnou bu+�ku",
+	message: "If multiplePerRow is false, each row may have maximum 1 correct cell",
 	path: ["correctCells"]
-}), He = F.extend({
+}), ct = R.extend({
 	type: e.literal("math-input"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	correctAnswer: p,
-	alternativeAnswers: e.array(p).optional(),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	correctAnswer: w,
+	alternativeAnswers: e.array(w).optional(),
 	tolerance: e.number().nonnegative().optional()
-}), Ue = F.extend({
+}), lt = R.extend({
 	type: e.literal("diagram-label"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	targetAsset: f,
-	labels: e.array(m).min(1, "Mus+� b+�t alespo+� 1 +�t+�tek"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	targetAsset: C,
+	labels: e.array(T).min(1, "Must have at least 1 label"),
 	caseSensitive: e.boolean().optional(),
 	requireTyping: e.boolean().optional(),
-	zones: e.array(Ce).min(1, "Mus+� b+�t alespo+� 1 z+-na")
+	zones: e.array(Ue).min(1, "Must have at least 1 zone")
 }).refine((e) => e.zones.every((t) => t.correctLabelIndex < e.labels.length), {
-	message: "N��kter+� z+-na odkazuje na neexistuj+�c+� +�t+�tek",
+	message: "Some zone references non-existent label",
 	path: ["zones"]
-}), We = F.extend({
+}), ut = R.extend({
 	type: e.literal("open-ended"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
 	minWords: e.number().int().positive().optional(),
 	maxWords: e.number().int().positive().optional(),
-	sampleAnswer: m.optional(),
-	rubric: Te.optional()
+	sampleAnswer: T.optional(),
+	rubric: We.optional()
 }).refine((e) => e.minWords && e.maxWords ? e.minWords <= e.maxWords : !0, {
-	message: "Minim+�ln+� po��et slov mus+� b+�t men+�+� nebo roven maxim+�ln+�mu po��tu",
+	message: "Minimum word count must be less than or equal to maximum",
 	path: ["maxWords"]
-}), Ge = F.extend({
+}), dt = R.extend({
 	type: e.literal("numeric-input"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
 	value: e.number(),
 	tolerance: e.number().nonnegative().optional(),
-	range: Ee.optional(),
+	range: Ge.optional(),
 	unit: e.string().optional()
-}), Ke = F.extend({
+}), ft = R.extend({
 	type: e.literal("pin-on-model"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	targetAsset: f,
-	hotspots: e.array(B).min(1, "Mus+� b+�t alespo+� 1 hotspot"),
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	targetAsset: C,
+	hotspots: e.array(H).min(1, "Must have at least 1 hotspot"),
 	multipleCorrect: e.boolean().optional(),
 	minCorrect: e.number().int().positive().optional(),
-	camera: U.optional()
+	camera: ze.optional()
 }).refine((e) => e.minCorrect ? e.minCorrect <= e.hotspots.length : !0, {
-	message: "Minim+�ln+� po��et spr+�vn+�ch odpov��d+� nesm+� p+�es+�hnout po��et hotspot+�",
+	message: "Minimum correct answers must not exceed number of hotspots",
 	path: ["minCorrect"]
-}), qe = F.extend({
+}), pt = R.extend({
 	type: e.literal("chess-puzzle"),
-	question: m.max(1e4, "Ot+�zka nesm+� b+�t del+�+� ne+� 10000 znak+�"),
-	fen: p,
-	answers: e.array(e.array(p).min(1, "Sekvence tah+� nesm+� b+�t pr+�zdn+�")).min(1, "Mus+� b+�t alespo+� 1 spr+�vn+� sekvence tah+�"),
-	elo: e.number().int().nonnegative("ELO mus+� b+�t nez+�porn+� cel+� ��+�slo").optional()
+	question: T.max(1e4, "Question must not be longer than 10000 characters"),
+	fen: w,
+	answers: e.array(e.array(w).min(1, "Move sequence must not be empty")).min(1, "Must have at least 1 correct move sequence"),
+	elo: e.number().int().nonnegative("ELO must be non-negative integer").optional()
 }), G = e.discriminatedUnion("type", [
-	De,
-	Oe,
-	ke,
-	Ae,
-	je,
-	W,
-	Me,
-	Ne,
-	Pe,
-	Fe,
-	Ie,
-	Le,
-	Re,
-	ze,
-	Be,
-	Ve,
-	He,
-	Ue,
-	We,
-	Ge,
 	Ke,
-	qe
+	qe,
+	Je,
+	Ye,
+	Xe,
+	Ze,
+	Qe,
+	$e,
+	et,
+	tt,
+	nt,
+	rt,
+	it,
+	at,
+	ot,
+	st,
+	ct,
+	lt,
+	ut,
+	dt,
+	ft,
+	pt
 ]), K = e.object({
 	$schema: e.string().url().optional(),
-	version: e.string().regex(/^\d+\.\d+$/, "Verze musi byt ve formatu \"X.Y\" (napr. \"0.1\")"),
-	meta: P,
-	items: e.array(G).max(1e4, "Maxim+�ln�� 10000 polo+�ek na sadu")
+	version: e.string().regex(/^\d+\.\d+$/, "Version must be in MAJOR.MINOR format (e.g. \"0.1\")"),
+	meta: L,
+	items: e.array(G).max(1e4, "Maximum 10000 items per set")
 }).refine((e) => {
 	let t = new Set(e.items.map((e) => e.id));
 	for (let n of e.items) {
 		if (n.relatedItems) {
-			for (let e of n.relatedItems) if (!t.has(e)) return !1;
+			for (let e of n.relatedItems) if (!t.has(e) || n.id === e) return !1;
 		}
 		if (n.dependencyItems) {
-			for (let e of n.dependencyItems) if (!t.has(e)) return !1;
+			for (let e of n.dependencyItems) if (!t.has(e) || n.id === e) return !1;
 		}
 	}
 	return !0;
 }, {
-	message: "N��kter+� polo+�ka odkazuje na neexistuj+�c+� relatedItems nebo dependencyItems",
+	message: "Some item references non-existent relatedItems, dependencyItems, or references itself",
 	path: ["items"]
 }).refine((e) => e.meta.thumbnail && e.meta.assets ? e.meta.thumbnail in e.meta.assets : !0, {
-	message: "Thumbnail odkazuje na neexistuj+�c+� asset",
+	message: "Thumbnail references non-existent asset",
 	path: ["meta", "thumbnail"]
 }).refine((e) => {
 	let t = new Set((e.meta.sourceMaterials || []).map((e) => e.id));
@@ -640,13 +761,29 @@ var s = e.string().uuid({ message: "Neplatn+� form+�t UUID" }), c = e.string
 	}
 	return !0;
 }, {
-	message: "N��kter+� polo+�ka odkazuje na neexistuj+�c+� source material",
+	message: "Some item references non-existent source material",
 	path: ["items"]
 });
-function Je(e) {
-	return K.parse(e);
+function mt(t) {
+	let n = t instanceof Error ? t.message : "OQSE Security Error: Maximum nesting depth exceeded limit of 10 levels.";
+	return new e.ZodError([{
+		code: e.ZodIssueCode.custom,
+		message: n,
+		path: []
+	}]);
+}
+function ht(e) {
+	return _(e, 10), K.parse(e);
 }
-function Ye(e) {
+function gt(e) {
+	try {
+		_(e, 10);
+	} catch (e) {
+		return {
+			success: !1,
+			error: mt(e)
+		};
+	}
 	let t = K.safeParse(e);
 	return t.success ? {
 		success: !0,
@@ -656,10 +793,18 @@ function Ye(e) {
 		error: t.error
 	};
 }
-function Xe(e) {
-	return G.parse(e);
+function _t(e) {
+	return _(e, 10), G.parse(e);
 }
-function Ze(e) {
+function vt(e) {
+	try {
+		_(e, 10);
+	} catch (e) {
+		return {
+			success: !1,
+			error: mt(e)
+		};
+	}
 	let t = G.safeParse(e);
 	return t.success ? {
 		success: !0,
@@ -669,128 +814,127 @@ function Ze(e) {
 		error: t.error
 	};
 }
-function Qe(e) {
+function yt(e) {
 	return e.issues.map((e) => {
-		let t = e.path.join(" ��� ");
-		return t ? `${t}: ${e.message}` : e.message;
+		let t = "";
+		return e.path.forEach((n, r) => {
+			if (typeof n == "number") t += `[${n}]`;
+			else {
+				let i = r === 0 || typeof e.path[r - 1] == "number";
+				t += (i ? "" : ".") + String(n);
+			}
+		}), t ? `${t}: ${e.message}` : e.message;
 	});
 }
 //#endregion
-//#region src/manifest.ts
-function q(e) {
-	return /^\d+\.\d+$/.test(e);
-}
-function $e(e) {
-	return /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/.test(e);
-}
-function J(e, t) {
-	let [n = 0, r = 0] = e.split(".").map(Number), [i = 0, a = 0] = t.split(".").map(Number);
-	return n === i ? r - a : n - i;
-}
-function et(e) {
-	if (typeof e != "object" || !e) return !1;
-	let t = e;
-	return typeof t.version == "string" && typeof t.id == "string" && typeof t.appName == "string" && t.appName !== "" && typeof t.capabilities == "object" && t.capabilities !== null && Array.isArray(t.capabilities.actions);
-}
-function tt(e, t) {
-	return !(!q(e) || t.minOqseVersion && q(t.minOqseVersion) && J(e, t.minOqseVersion) < 0 || t.maxOqseVersion && q(t.maxOqseVersion) && J(e, t.maxOqseVersion) > 0);
-}
-//#endregion
 //#region src/manifestValidation.ts
-var Y = e.string().min(1, "Hodnota nesm+� b+�t pr+�zdn+�").trim(), nt = e.string().url("Mus+� b+�t platn+� absolutn+� URL").refine((e) => e.startsWith("http://") || e.startsWith("https://"), { message: "URL mus+� pou+�+�vat sch+�ma http nebo https" }), X = e.string().regex(/^\d+\.\d+$/, "Verze mus+� b+�t ve form+�tu MAJOR.MINOR (nap+�. \"0.1\")"), rt = e.string().regex(/^\d+\.\d+\.\d+$/, "Verze mus+� b+�t ve form+�tu MAJOR.MINOR.PATCH (nap+�. \"1.2.3\")"), it = [
-	"render",
-	"edit",
-	"validate",
-	"import",
-	"export"
-], at = e.string().refine((e) => it.includes(e) || e.startsWith("x-"), { message: "Akce mus+� b+�t jedna z [render, edit, validate, import, export] nebo m+�t prefix \"x-\"" }), ot = e.enum([
+var q = e.string().min(1, "Value must not be empty").trim(), bt = e.string().regex(/^[a-zA-Z]{2,8}(-[a-zA-Z0-9\-]+)*$/, "Must be a valid BCP 47 locale (e.g., \"en\", \"cs\")"), J = e.string().url("Must be a valid absolute URL").refine((e) => e.startsWith("http://") || e.startsWith("https://"), { message: "URL must use http or https scheme" }), xt = e.string().regex(/^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Must be a valid URN UUID (urn:uuid:...)"), Y = e.string().regex(/^\d+\.\d+$/, "Version must be in MAJOR.MINOR format (e.g. \"0.1\")"), St = [
+	"note",
+	"flashcard",
+	"true-false",
+	"mcq-single",
+	"mcq-multi",
+	"short-answer",
+	"fill-in-blanks",
+	"fill-in-select",
+	"match-pairs",
+	"match-complex",
+	"sort-items",
+	"slider",
+	"pin-on-image",
+	"categorize",
+	"timeline",
+	"matrix",
+	"math-input",
+	"diagram-label",
+	"open-ended",
+	"numeric-input",
+	"pin-on-model",
+	"chess-puzzle"
+], Ct = q.refine((e) => St.includes(e) || e.startsWith("x-"), { message: "Custom types MUST use the \"x-\" prefix" }), wt = e.string().refine((e) => c.includes(e) || e.startsWith("x-"), { message: "Action must be one of [render, edit, validate, import, export] or have prefix \"x-\"" }), Tt = e.enum([
 	"game",
 	"fun",
 	"drill"
-]), st = e.enum([
+]), Et = e.enum([
 	"low",
 	"medium",
 	"high"
-]), ct = [
-	"math",
-	"media",
-	"media-image",
-	"media-audio",
-	"media-video",
-	"media-model",
-	"hotspots",
-	"hotspots-3d",
-	"complex-pairing",
-	"open-text",
-	"chess"
-], lt = e.string().refine((e) => ct.includes(e) || e.startsWith("x-"), { message: "Funkce mus+� b+�t jedna z ofici+�ln+�ch kl+���+� nebo m+�t prefix \"x-\"" }), ut = e.string().min(1, "Kl+��� vlastnosti polo+�ky nesm+� b+�t pr+�zdn+�"), dt = e.string().min(1, "Kl+��� vlastnosti metadat nesm+� b+�t pr+�zdn+�");
-function Z(t) {
+]), Dt = e.string().refine((e) => l.includes(e) || e.startsWith("x-"), { message: "Feature must be one of official keys or have prefix \"x-\"" }), Ot = e.string().refine((e) => u.includes(e) || e.startsWith("x-"), { message: "Item property must be an official key or have prefix \"x-\"" }), kt = e.string().refine((e) => d.includes(e) || e.startsWith("x-"), { message: "Meta property must be an official key or have prefix \"x-\"" });
+function X(t) {
 	return e.union([
 		e.tuple([e.literal("*")]),
 		e.array(t),
 		e.null()
 	]);
 }
-var ft = e.string().refine((e) => e.startsWith("image/"), { message: "Mus+� b+�t platn+� MIME typ obr+�zku (image/...)" }), pt = e.string().refine((e) => e.startsWith("audio/"), { message: "Mus+� b+�t platn+� MIME typ zvuku (audio/...)" }), mt = e.string().refine((e) => e.startsWith("video/"), { message: "Mus+� b+�t platn+� MIME typ videa (video/...)" }), ht = e.string().refine((e) => e.startsWith("model/") || e === "application/octet-stream", { message: "Mus+� b+�t platn+� MIME typ 3D modelu (model/... nebo application/octet-stream)" }), gt = e.object({
-	image: Z(ft).optional(),
-	audio: Z(pt).optional(),
-	video: Z(mt).optional(),
-	model: Z(ht).optional()
-}), _t = w.extend({
-	actions: e.array(at).min(1, "Aplikace mus+� podporovat alespo+� jednu akci"),
-	types: Z(Y).optional(),
-	assets: gt.optional()
-}), Q = e.object({
-	$schema: nt.optional(),
-	id: Y.regex(/^[a-z0-9-]+(\.[a-z0-9-]+)*$/, "ID mus+� b+�t ve tvaru reverse-domain (nap+�. \"com.acme.app\")"),
-	appName: Y.max(100, "N+�zev nesm+� b+�t del+�+� ne+� 100 znak+�"),
-	version: X,
-	pluginVersion: rt.optional(),
-	minOqseVersion: X.optional(),
-	maxOqseVersion: X.optional(),
-	capabilities: _t,
-	author: e.string().max(100, "N+�zev autora nesm+� b+�t del+�+� ne+� 100 znak+�").optional(),
-	authorUrl: nt.optional(),
-	locales: e.array(Y).optional(),
-	description: e.string().max(500, "Popis nesm+� b+�t del+�+� ne+� 500 znak+�").optional(),
+var At = e.string().refine((e) => e.startsWith("image/"), { message: "Must be a valid image MIME type (image/...)" }), jt = e.string().refine((e) => e.startsWith("audio/"), { message: "Must be a valid audio MIME type (audio/...)" }), Mt = e.string().refine((e) => e.startsWith("video/"), { message: "Must be a valid video MIME type (video/...)" }), Nt = e.string().refine((e) => e.startsWith("model/") || e === "application/octet-stream", { message: "Must be a valid 3D model MIME type (model/... or application/octet-stream)" }), Pt = e.object({
+	image: X(At).optional(),
+	audio: X(jt).optional(),
+	video: X(Mt).optional(),
+	model: X(Nt).optional()
+}), Ft = F.extend({
+	actions: e.array(wt).min(1, "Application must support at least one action"),
+	types: X(Ct).optional(),
+	assets: Pt.optional()
+}).superRefine((t, n) => {
+	(t.actions.includes("render") || t.actions.includes("edit")) && (!Array.isArray(t.types) || t.types.length === 0) && n.addIssue({
+		code: e.ZodIssueCode.custom,
+		message: "types array MUST be declared and non-empty when actions include \"render\" or \"edit\"",
+		path: ["types"]
+	});
+}), Z = e.object({
+	$schema: J.optional(),
+	id: e.union([J, xt]),
+	appName: q.max(200, "Name must not be longer than 200 characters"),
+	version: Y,
+	pluginVersion: e.string().optional(),
+	minOqseVersion: Y.optional(),
+	maxOqseVersion: Y.optional(),
+	capabilities: Ft,
+	author: j.optional(),
+	contributors: e.array(j).optional(),
+	license: e.string().max(100, "License must not be longer than 100 characters").optional(),
+	licenseUrl: J.optional(),
+	locales: e.array(bt).optional(),
+	description: e.string().max(5e3, "Description must not be longer than 5000 characters").optional(),
 	emoji: e.string().optional(),
-	tags: e.array(Y).optional(),
-	studyMode: ot.optional(),
-	questionDensity: st.optional(),
+	tags: e.array(q).optional(),
+	studyMode: Tt.optional(),
+	questionDensity: Et.optional(),
 	appSpecific: e.record(e.string(), e.unknown()).optional()
 }).refine((e) => {
 	if (!e.minOqseVersion || !e.maxOqseVersion) return !0;
-	let t = e.minOqseVersion.split("."), n = e.maxOqseVersion.split("."), r = Number(t[0]), i = Number(t[1]), a = Number(n[0]), ee = Number(n[1]);
-	return r === a ? i <= ee : r < a;
+	let t = e.minOqseVersion.split("."), n = e.maxOqseVersion.split("."), r = Number(t[0]), i = Number(t[1]), a = Number(n[0]), o = Number(n[1]);
+	return r === a ? i <= o : r < a;
 }, {
-	message: "minOqseVersion nesm+� b+�t vy+�+�+� ne+� maxOqseVersion",
+	message: "minOqseVersion must not be greater than maxOqseVersion",
 	path: ["minOqseVersion"]
 });
-function vt(e) {
-	return Q.parse(e);
+function It(e) {
+	return Z.parse(e);
 }
-function yt(e) {
-	return Q.safeParse(e);
+function Lt(e) {
+	return Z.safeParse(e);
 }
-function bt(e) {
+function Rt(e) {
 	return e.issues.map((e) => {
 		let t = e.path.map((e) => String(e)).join(".");
 		return t ? `${t}: ${e.message}` : e.message;
 	}).join("\n");
 }
-function xt(e) {
-	return Q.safeParse(e).success;
+function zt(e) {
+	return Z.safeParse(e).success;
 }
 //#endregion
 //#region src/progressValidation.ts
-var St = e.object({
+var Bt = e.object({
 	attempts: e.number().int().nonnegative(),
 	incorrect: e.number().int().nonnegative(),
 	streak: e.number().int().nonnegative()
 }).refine((e) => e.incorrect <= e.attempts, {
-	message: "incorrect nesmí být vyšší než attempts",
+	message: "incorrect cannot be higher than attempts",
 	path: ["incorrect"]
-}), Ct = e.object({
+}), Vt = e.object({
 	isCorrect: e.boolean(),
 	confidence: e.union([
 		e.literal(1),
@@ -798,14 +942,11 @@ var St = e.object({
 		e.literal(3),
 		e.literal(4)
 	]).optional(),
-	answeredAt: u,
+	answeredAt: x,
 	timeSpent: e.number().int().nonnegative().optional(),
-	hintsUsed: e.number().int().nonnegative().optional(),
+	hintsUsed: e.number().int().nonnegative().default(0),
 	isSkipped: e.boolean().optional()
-}).refine((e) => !e.isSkipped || e.isCorrect === !1, {
-	message: "Pokud je isSkipped=true, isCorrect má být false",
-	path: ["isCorrect"]
-}), wt = e.object({
+}), Ht = e.object({
 	bucket: e.union([
 		e.literal(0),
 		e.literal(1),
@@ -813,34 +954,86 @@ var St = e.object({
 		e.literal(3),
 		e.literal(4)
 	]),
-	nextReviewAt: u.optional(),
-	stats: St,
-	lastAnswer: Ct.optional(),
+	nextReviewAt: x.optional(),
+	stats: Bt,
+	lastAnswer: Vt.optional(),
 	appSpecific: e.record(e.string(), e.unknown()).optional()
-}), Tt = e.object({
-	setId: s,
-	exportedAt: u,
-	algorithm: e.string().regex(/^[a-z0-9-]+$/, "algorithm musí mít formát lowercase alphanumeric s pomlčkami").optional()
-}), $ = e.object({
-	$schema: e.string().url().optional(),
-	version: e.string().regex(/^\d+\.\d+$/, "Verze musí být ve formátu MAJOR.MINOR"),
-	meta: Tt,
-	records: e.record(s, wt)
+}), Ut = e.object({
+	setId: v,
+	exportedAt: x,
+	algorithm: e.string().regex(/^[a-z0-9-]+$/, "algorithm must be lowercase alphanumeric with hyphens format").optional()
+}), Q = e.object({
+	$schema: e.url().optional(),
+	version: e.string().regex(/^\d+\.\d+$/, "Version must be in MAJOR.MINOR format"),
+	meta: Ut,
+	records: e.record(v, Ht)
+});
+function Wt(e) {
+	return Q.parse(e);
+}
+function Gt(e) {
+	return Q.safeParse(e);
+}
+var $ = e.object(L.shape).pick({
+	id: !0,
+	title: !0,
+	language: !0,
+	updatedAt: !0,
+	description: !0,
+	author: !0,
+	subject: !0,
+	tags: !0,
+	createdAt: !0,
+	estimatedTime: !0,
+	requirements: !0
+}).partial({ createdAt: !0 }).extend({
+	url: S,
+	$schema: e.string().url().optional()
 });
-function Et(e) {
+function Kt(e) {
 	return $.parse(e);
 }
-function Dt(e) {
+function qt(e) {
 	return $.safeParse(e);
 }
 //#endregion
-//#region src/utils.ts
-var Ot = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function kt(e) {
-	return Ot.test(e);
+//#region src/richTextProcessor.ts
+function Jt(e) {
+	let t = {};
+	return {
+		text: e.replace(/<(asset|blank):([a-zA-Z0-9_-]+)\s*\/>/gi, (e, n, r) => {
+			let i = `[[__OQSE_TOKEN_${Math.random().toString(36).substring(2, 15)}__]]`;
+			return t[i] = {
+				type: n.toLowerCase(),
+				key: r.toLowerCase(),
+				originalTag: e
+			}, i;
+		}),
+		tokens: t
+	};
 }
-function At() {
-	return crypto.randomUUID();
+function Yt(e) {
+	let t = e.replace(/`{1,}[^`]*`{1,}/g, "").replace(/~{3,}[\s\S]*?~{3,}/g, "");
+	if (/<[a-zA-Z\/][^>]*>/.test(t)) throw Error("OQSE Security Error: Raw HTML tags are not allowed in Tier 1 (Pure Markdown). If the set requires HTML formatting, it MUST declare the 'html' feature in meta.requirements.");
+}
+function Xt(e, t, n) {
+	let r = e;
+	for (let [e, i] of Object.entries(t)) {
+		let t = i.originalTag;
+		i.type === "asset" && n.assetReplacer ? t = n.assetReplacer(i.key) : i.type === "blank" && n.blankReplacer && (t = n.blankReplacer(i.key)), r = r.replace(e, t);
+	}
+	return r;
+}
+function Zt(e, t, n) {
+	if (!e) return "";
+	let r = t?.features?.includes("html") ?? !1, { text: i, tokens: a } = Jt(e);
+	r || Yt(i);
+	let o = n.markdownParser(i);
+	if (r) {
+		if (!n.htmlSanitizer) throw Error("OQSE Security Error: Set requires 'html' (Tier 2), but no htmlSanitizer (like DOMPurify) was provided to the options.");
+		o = n.htmlSanitizer(o);
+	}
+	return Xt(o, a, n);
 }
 //#endregion
-export { d as AbsoluteURLSchema, _ as AssetDictionarySchema, f as AssetKeySchema, pt as AudioMimeTypeSchema, F as BaseItemSchema, k as BloomLevelSchema, U as CameraSetupSchema, be as CategorizeItemSchema, ze as CategorizeItemTypeSchema, qe as ChessPuzzleItemSchema, R as CircleHotspotSchema, A as CognitiveLoadSchema, Ue as DiagramLabelItemSchema, Ce as DiagramZoneSchema, lt as FeatureFlagSchema, w as FeatureProfileSchema, E as FeatureRequirementSchema, T as FeatureTypeSchema, Me as FillInBlanksItemSchema, Ne as FillInSelectItemSchema, Oe as FlashcardItemSchema, V as HotspotObjectSchema, u as ISO8601DateTimeSchema, ft as ImageMimeTypeSchema, ut as ItemPropertyKeySchema, c as LanguageCodeSchema, Ct as LastAnswerObjectSchema, O as LinkedSetObjectSchema, je as MCQMultiItemSchema, Ae as MCQSingleItemSchema, gt as ManifestAssetsSchema, _t as ManifestCapabilitiesSchema, Fe as MatchComplexItemSchema, Pe as MatchPairsItemSchema, He as MathInputItemSchema, M as MathRendererSchema, N as MathSettingsSchema, Ve as MatrixItemSchema, ve as MediaObjectSchema, B as MeshHotspotSchema, dt as MetaPropertyKeySchema, ht as ModelMimeTypeSchema, De as NoteItemSchema, Ge as NumericInputItemSchema, Ee as NumericRangeSchema, at as OQSEActionSchema, K as OQSEFileSchema, G as OQSEItemSchema, Q as OQSEManifestSchema, P as OQSEMetaSchema, $ as OQSEPFileSchema, st as OQSEQuestionDensitySchema, ot as OQSEStudyModeSchema, ye as OfficialFeatureNameSchema, We as OpenEndedItemSchema, h as OptionalRichContentSchema, j as PedagogySchema, v as PersonObjectSchema, Re as PinOnImageItemSchema, Ke as PinOnModelItemSchema, p as PlainTextSchema, z as PolygonHotspotSchema, Tt as ProgressMetaSchema, wt as ProgressRecordSchema, L as RectHotspotSchema, m as RichContentSchema, we as RubricCriterionSchema, Te as RubricSchema, l as SPDXLicenseSchema, I as SelectBlankObjectSchema, W as ShortAnswerItemSchema, Le as SliderItemSchema, Ie as SortItemsItemSchema, b as SourceMaterialSchema, y as SourceMaterialTypeSchema, x as SourceReferenceSchema, St as StatsObjectSchema, g as SubtitleTrackSchema, C as TagDefinitionDictionarySchema, S as TagDefinitionSchema, Se as TimelineEventSchema, Be as TimelineItemSchema, xe as TimelinePrecisionSchema, D as TranslationObjectSchema, ke as TrueFalseItemSchema, s as UUIDSchema, H as Vector3Schema, mt as VideoMimeTypeSchema, J as compareManifestVersions, bt as formatManifestErrors, Qe as formatValidationErrors, At as generateUUID, ce as isCategorize, ge as isChessPuzzle, o as isCoreItem, fe as isDiagramLabel, _e as isExtendedItem, te as isFillInBlanks, ne as isFillInSelect, n as isFlashcard, a as isMCQMulti, i as isMCQSingle, ie as isMatchComplex, re as isMatchPairs, de as isMathInput, ue as isMatrix, t as isNote, me as isNumericInput, et as isOQSEManifest, pe as isOpenEnded, se as isPinOnImage, he as isPinOnModel, ee as isShortAnswer, oe as isSlider, ae as isSortItems, le as isTimeline, r as isTrueFalse, q as isValidManifestVersion, xt as isValidOQSEManifest, $e as isValidSemVer, kt as isValidUUID, tt as isVersionCompatible, yt as safeValidateManifest, Ye as safeValidateOQSEFile, Ze as safeValidateOQSEItem, Dt as safeValidateOQSEPFile, vt as validateManifest, Je as validateOQSEFile, Xe as validateOQSEItem, Et as validateOQSEPFile };
+export { S as AbsoluteURLSchema, A as AssetDictionarySchema, C as AssetKeySchema, jt as AudioMimeTypeSchema, R as BaseItemSchema, D as BlankTokenSchema, Ne as BloomLevelSchema, ze as CameraSetupSchema, Be as CategorizeItemObjectSchema, at as CategorizeItemSchema, pt as ChessPuzzleItemSchema, B as CircleHotspotSchema, Pe as CognitiveLoadSchema, lt as DiagramLabelItemSchema, Ue as DiagramZoneSchema, Dt as FeatureFlagSchema, F as FeatureProfileSchema, Qe as FillInBlanksItemSchema, $e as FillInSelectItemSchema, qe as FlashcardItemSchema, Re as Hotspot2DSchema, Le as HotspotObjectSchema, x as ISO8601DateTimeSchema, At as ImageMimeTypeSchema, Ot as ItemPropertyKeySchema, y as LanguageCodeSchema, Vt as LastAnswerObjectSchema, I as LinkedSetObjectSchema, Xe as MCQMultiItemSchema, Ye as MCQSingleItemSchema, Pt as ManifestAssetsSchema, Ft as ManifestCapabilitiesSchema, tt as MatchComplexItemSchema, et as MatchPairsItemSchema, ct as MathInputItemSchema, st as MatrixItemSchema, k as MediaObjectSchema, H as MeshHotspotSchema, kt as MetaPropertyKeySchema, Nt as ModelMimeTypeSchema, Ke as NoteItemSchema, dt as NumericInputItemSchema, Ge as NumericRangeSchema, c as OFFICIAL_ACTIONS, l as OFFICIAL_FEATURE_KEYS, u as OFFICIAL_ITEM_PROPERTIES, d as OFFICIAL_META_PROPERTIES, wt as OQSEActionSchema, K as OQSEFileSchema, $ as OQSEHeaderSchema, G as OQSEItemSchema, Z as OQSEManifestSchema, L as OQSEMetaSchema, Q as OQSEPFileSchema, Et as OQSEQuestionDensitySchema, Tt as OQSEStudyModeSchema, ut as OpenEndedItemSchema, E as OptionalRichContentSchema, Fe as PedagogySchema, j as PersonObjectSchema, it as PinOnImageItemSchema, ft as PinOnModelItemSchema, w as PlainTextSchema, V as PolygonHotspotSchema, Ut as ProgressMetaSchema, Ht as ProgressRecordSchema, z as RectHotspotSchema, T as RichContentSchema, W as RubricCriterionSchema, We as RubricSchema, b as SPDXLicenseSchema, Ie as SelectBlankObjectSchema, Ze as ShortAnswerItemSchema, rt as SliderItemSchema, nt as SortItemsItemSchema, N as SourceMaterialSchema, M as SourceMaterialTypeSchema, P as SourceReferenceSchema, Bt as StatsObjectSchema, O as SubtitleTrackSchema, je as TagDefinitionDictionarySchema, Ae as TagDefinitionSchema, He as TimelineEventSchema, ot as TimelineItemSchema, Ve as TimelinePrecisionSchema, Me as TranslationObjectSchema, Je as TrueFalseItemSchema, v as UUIDSchema, U as Vector3Schema, Mt as VideoMimeTypeSchema, p as compareManifestVersions, Xt as detokenizeOqseTags, Rt as formatManifestErrors, yt as formatValidationErrors, ke as generateUUID, se as isCategorize, he as isChessPuzzle, s as isCoreItem, de as isDiagramLabel, ge as isExtendedItem, ee as isFillInBlanks, te as isFillInSelect, n as isFlashcard, a as isMCQMulti, i as isMCQSingle, re as isMatchComplex, ne as isMatchPairs, ue as isMathInput, le as isMatrix, t as isNote, pe as isNumericInput, ve as isOQSEManifest, fe as isOpenEnded, oe as isPinOnImage, me as isPinOnModel, o as isShortAnswer, ae as isSlider, ie as isSortItems, ce as isTimeline, r as isTrueFalse, f as isValidManifestVersion, zt as isValidOQSEManifest, _e as isValidSemVer, Oe as isValidUUID, ye as isVersionCompatible, Zt as prepareRichTextForDisplay, Lt as safeValidateManifest, gt as safeValidateOQSEFile, qt as safeValidateOQSEHeader, vt as safeValidateOQSEItem, Gt as safeValidateOQSEPFile, Jt as tokenizeOqseTags, _ as validateJsonDepth, It as validateManifest, ht as validateOQSEFile, Kt as validateOQSEHeader, _t as validateOQSEItem, Wt as validateOQSEPFile, Yt as validateTier1Markdown };