@superbuilders/incept-renderer 0.1.0

package/dist/actions/index.js

@@ -0,0 +1,1893 @@
+import { createHash } from 'crypto';
+import 'react';
+import 'clsx';
+import 'tailwind-merge';
+import 'react-dom';
+import 'react/jsx-runtime';
+import '@radix-ui/react-radio-group';
+import '@radix-ui/react-checkbox';
+import 'class-variance-authority';
+import '@radix-ui/react-label';
+import '@radix-ui/react-separator';
+import 'lucide-react';
+import '@dnd-kit/core';
+import '@radix-ui/react-select';
+import '@dnd-kit/sortable';
+import '@dnd-kit/utilities';
+import { XMLParser } from 'fast-xml-parser';
+import { z as z$1 } from 'zod';
+
+// ../../../../../node_modules/server-only/index.js
+throw new Error(
+  "This module cannot be imported from a Client Component module. It should only be used from a Server Component."
+);
+
+// ../../node_modules/@superbuilders/errors/dist/index.js
+function z() {
+  let k2 = [], j2 = this;
+  while (j2 != null) if (k2.push(j2.message), j2.cause instanceof Error) j2 = j2.cause;
+  else break;
+  return k2.join(": ");
+}
+function A(k2) {
+  let j2 = new Error(k2);
+  if (Error.captureStackTrace) Error.captureStackTrace(j2, A);
+  return j2.toString = z, Object.freeze(j2);
+}
+function B(k2, j2) {
+  let x = new Error(j2, { cause: k2 });
+  if (Error.captureStackTrace) Error.captureStackTrace(x, B);
+  return x.toString = z, Object.freeze(x);
+}
+function I(k2) {
+  try {
+    return { data: k2(), error: void 0 };
+  } catch (j2) {
+    return { data: void 0, error: j2 instanceof Error ? j2 : new Error(String(j2)) };
+  }
+}
+
+// ../../node_modules/@superbuilders/slog/dist/index.js
+var b = new ArrayBuffer(8192);
+var K = new Uint8Array(b);
+var Q = new TextEncoder();
+var C = new ArrayBuffer(64);
+var L = new Uint8Array(C);
+var J = { DEBUG: Q.encode(" DEBUG "), INFO: Q.encode(" INFO "), WARN: Q.encode(" WARN "), ERROR: Q.encode(" ERROR "), NEWLINE: Q.encode(`
+`), SPACE: Q.encode(" "), EQUALS: Q.encode("="), SLASH: Q.encode("/"), COLON: Q.encode(":"), NULL: Q.encode("null"), UNDEFINED: Q.encode("undefined"), TRUE: Q.encode("true"), FALSE: Q.encode("false"), QUOTE: Q.encode('"'), BRACKET_OPEN: Q.encode("["), BRACKET_CLOSE: Q.encode("]"), BRACE_OPEN: Q.encode("{"), BRACE_CLOSE: Q.encode("}"), COMMA: Q.encode(","), ZERO: Q.encode("0"), MINUS: Q.encode("-"), DOT: Q.encode(".") };
+var U = new Uint8Array(19);
+var z2 = new Uint8Array(2);
+var V = 0;
+var F = 0;
+var W = 0;
+function j() {
+  let x = Date.now();
+  if (x - V >= 1e3) {
+    let q = new Date(x), D = 0, R = q.getFullYear();
+    U[D++] = 48 + Math.floor(R / 1e3) % 10, U[D++] = 48 + Math.floor(R / 100) % 10, U[D++] = 48 + Math.floor(R / 10) % 10, U[D++] = 48 + R % 10, U[D++] = 47;
+    let N = q.getMonth() + 1;
+    U[D++] = 48 + Math.floor(N / 10), U[D++] = 48 + N % 10, U[D++] = 47;
+    let P = q.getDate();
+    U[D++] = 48 + Math.floor(P / 10), U[D++] = 48 + P % 10, U[D++] = 32;
+    let M = q.getHours();
+    U[D++] = 48 + Math.floor(M / 10), U[D++] = 48 + M % 10, U[D++] = 58;
+    let Z = q.getMinutes();
+    U[D++] = 48 + Math.floor(Z / 10), U[D++] = 48 + Z % 10, U[D++] = 58, F = D;
+    let X = q.getSeconds();
+    z2[0] = 48 + Math.floor(X / 10), z2[1] = 48 + X % 10, W = 2, V = x;
+  }
+}
+var k = 0;
+function H(x, G, q) {
+  let D = 8192 - G;
+  if (D <= 0) return G;
+  let R = Math.min(q.length, D);
+  return x.set(q.subarray(0, R), G), G + R;
+}
+function $(x, G, q) {
+  let D = 8192 - G;
+  if (D <= 0) return G;
+  let R = true, N = q.length;
+  for (let M = 0; M < N; M++) if (q.charCodeAt(M) > 127) {
+    R = false;
+    break;
+  }
+  if (R) {
+    let M = Math.min(N, D);
+    for (let Z = 0; Z < M; Z++) x[G + Z] = q.charCodeAt(Z);
+    return G + M;
+  }
+  let P = Q.encodeInto(q, x.subarray(G));
+  return G + (P.written ?? 0);
+}
+function A2(x, G, q) {
+  if (Number.isNaN(q)) return $(x, G, "NaN");
+  if (q === Number.POSITIVE_INFINITY) return $(x, G, "Infinity");
+  if (q === Number.NEGATIVE_INFINITY) return $(x, G, "-Infinity");
+  let D = G, R = q;
+  if (R < 0) D = H(x, D, J.MINUS), R = -R;
+  if (R === 0) return H(x, D, J.ZERO);
+  if (Number.isInteger(R) && R < Number.MAX_SAFE_INTEGER) {
+    let M = Math.floor(R), Z = 0, X = M;
+    while (X > 0) Z++, X = Math.floor(X / 10);
+    if (D + Z > x.length) return D;
+    let Y = D + Z - 1;
+    while (M > 0) x[Y--] = 48 + M % 10, M = Math.floor(M / 10);
+    return D + Z;
+  }
+  let N = Q.encodeInto(R.toString(), L), P = Math.min(N.written ?? 0, x.length - G);
+  if (P > 0) x.set(L.subarray(0, P), G);
+  return G + P;
+}
+function _(x, G, q) {
+  if (q === null) return H(x, G, J.NULL);
+  if (q === void 0) return H(x, G, J.UNDEFINED);
+  switch (typeof q) {
+    case "string":
+      return $(x, G, q);
+    case "number":
+      return A2(x, G, q);
+    case "boolean":
+      return H(x, G, q ? J.TRUE : J.FALSE);
+    case "bigint":
+      return $(x, G, `${q}`);
+    case "symbol":
+      return $(x, G, String(q));
+    case "function":
+      return $(x, G, `${q}`);
+    case "object": {
+      if (Array.isArray(q)) {
+        let X = H(x, G, J.BRACKET_OPEN), Y = q.length;
+        for (let O = 0; O < Y; O++) {
+          if (O > 0) X = H(x, X, J.COMMA);
+          X = _(x, X, q[O]);
+        }
+        return H(x, X, J.BRACKET_CLOSE);
+      }
+      let N = q.toString;
+      if (typeof N === "function" && N !== Object.prototype.toString) return $(x, G, N.call(q));
+      let P = q, M = H(x, G, J.BRACE_OPEN), Z = true;
+      for (let X in P) if (Object.hasOwn(P, X)) {
+        if (Z === false) M = H(x, M, J.COMMA);
+        M = H(x, M, J.QUOTE), M = $(x, M, X), M = H(x, M, J.QUOTE), M = H(x, M, J.COLON), M = _(x, M, P[X]), Z = false;
+      }
+      return H(x, M, J.BRACE_CLOSE);
+    }
+    default:
+      return $(x, G, `${q}`);
+  }
+}
+function E(x, G, q) {
+  if (!q) return G;
+  let D = G, R = true;
+  for (let N in q) {
+    if (!R) D = H(x, D, J.SPACE);
+    D = $(x, D, N), D = H(x, D, J.EQUALS), D = _(x, D, q[N]), R = false;
+  }
+  return D;
+}
+function I2(x) {
+  let G = K.subarray(0, x);
+  process.stderr.write(G);
+}
+function y(x, G) {
+  if (-4 < k) return;
+  j();
+  let q = 0;
+  if (q = H(K, q, U.subarray(0, F)), q = H(K, q, z2.subarray(0, W)), q = H(K, q, J.DEBUG), q = $(K, q, x), G) q = H(K, q, J.SPACE), q = E(K, q, G);
+  if (q < 8192) q = H(K, q, J.NEWLINE);
+  else {
+    let D = J.NEWLINE[0];
+    if (D !== void 0) K[8191] = D;
+    q = 8192;
+  }
+  I2(q);
+}
+function l(x, G) {
+  if (8 < k) return;
+  j();
+  let q = 0;
+  if (q = H(K, q, U.subarray(0, F)), q = H(K, q, z2.subarray(0, W)), q = H(K, q, J.ERROR), q = $(K, q, x), G) q = H(K, q, J.SPACE), q = E(K, q, G);
+  if (q < 8192) q = H(K, q, J.NEWLINE);
+  else {
+    let D = J.NEWLINE[0];
+    if (D !== void 0) K[8191] = D;
+    q = 8192;
+  }
+  I2(q);
+}
+
+// src/html/sanitize.ts
+var DEFAULT_CONFIG = {
+  // HTML content tags
+  allowedTags: /* @__PURE__ */ new Set([
+    // Text content
+    "p",
+    "span",
+    "div",
+    "br",
+    "hr",
+    // Formatting
+    "b",
+    "i",
+    "u",
+    "strong",
+    "em",
+    "mark",
+    "small",
+    "sub",
+    "sup",
+    "code",
+    "pre",
+    "kbd",
+    // Lists
+    "ul",
+    "ol",
+    "li",
+    "dl",
+    "dt",
+    "dd",
+    // Tables
+    "table",
+    "thead",
+    "tbody",
+    "tfoot",
+    "tr",
+    "th",
+    "td",
+    "caption",
+    "colgroup",
+    "col",
+    // Media
+    "img",
+    "audio",
+    "video",
+    "source",
+    "track",
+    // Semantic
+    "article",
+    "section",
+    "nav",
+    "aside",
+    "header",
+    "footer",
+    "main",
+    "figure",
+    "figcaption",
+    "blockquote",
+    "cite",
+    // Links
+    "a",
+    // Forms (for future interactive elements)
+    "label",
+    "button"
+  ]),
+  allowedAttributes: {
+    // Global attributes
+    "*": /* @__PURE__ */ new Set(["class", "id", "lang", "dir", "title", "style"]),
+    // Specific attributes
+    img: /* @__PURE__ */ new Set(["src", "alt", "width", "height", "style"]),
+    a: /* @__PURE__ */ new Set(["href", "target", "rel"]),
+    audio: /* @__PURE__ */ new Set(["src", "controls", "loop", "muted"]),
+    video: /* @__PURE__ */ new Set(["src", "controls", "loop", "muted", "width", "height", "poster"]),
+    source: /* @__PURE__ */ new Set(["src", "type"]),
+    track: /* @__PURE__ */ new Set(["src", "kind", "srclang", "label"])
+  },
+  allowDataAttributes: false,
+  allowMathML: true
+};
+var MATHML_TAGS = /* @__PURE__ */ new Set([
+  // Root
+  "math",
+  // Token elements
+  "mi",
+  "mn",
+  "mo",
+  "mtext",
+  "mspace",
+  "ms",
+  // Layout
+  "mrow",
+  "mfrac",
+  "msqrt",
+  "mroot",
+  "mstyle",
+  "merror",
+  "mpadded",
+  "mphantom",
+  "mfenced",
+  "menclose",
+  // Scripts and limits
+  "msub",
+  "msup",
+  "msubsup",
+  "munder",
+  "mover",
+  "munderover",
+  "mmultiscripts",
+  "mprescripts",
+  "none",
+  // Tables
+  "mtable",
+  "mtr",
+  "mtd",
+  "maligngroup",
+  "malignmark",
+  // Elementary math
+  "mstack",
+  "mlongdiv",
+  "msgroup",
+  "msrow",
+  "mscarries",
+  "mscarry",
+  "msline",
+  // Semantic
+  "semantics",
+  "annotation",
+  "annotation-xml"
+]);
+function sanitizeHtml(html, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const dangerousPatterns = [
+    /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+    /javascript:/gi,
+    /on\w+\s*=/gi,
+    // Event handlers
+    /<iframe\b/gi,
+    /<embed\b/gi,
+    /<object\b/gi,
+    /data:text\/html/gi
+  ];
+  let sanitized = html;
+  for (const pattern of dangerousPatterns) {
+    sanitized = sanitized.replace(pattern, "");
+  }
+  const cleaned = cleanHtml(sanitized, cfg);
+  return cleaned;
+}
+function cleanHtml(html, config) {
+  let cleaned = html;
+  const tagPattern = /<\/?([a-zA-Z][a-zA-Z0-9-]*)([^>]*)>/g;
+  cleaned = cleaned.replace(tagPattern, (match, tagName, _attrs) => {
+    const tag = tagName.toLowerCase();
+    const isMathML = tag === "math" || cleaned.includes("<math");
+    if (isMathML && config.allowMathML && MATHML_TAGS.has(tag)) {
+      return match;
+    }
+    if (config.allowedTags.has(tag)) {
+      return cleanAttributesString(match, tag, config);
+    }
+    return "";
+  });
+  return cleaned;
+}
+function cleanAttributesString(tagString, tagName, config) {
+  const attrPattern = /\s+([a-zA-Z][a-zA-Z0-9-:]*)(?:="([^"]*)"|'([^']*)'|=([^\s>]+)|(?=\s|>))/g;
+  let cleanedTag = `<${tagString.startsWith("</") ? "/" : ""}${tagName}`;
+  let match = attrPattern.exec(tagString);
+  while (match !== null) {
+    const attrName = (match[1] || "").toLowerCase();
+    const attrValue = match[2] || match[3] || match[4] || "";
+    const globalAttrs = config.allowedAttributes["*"] || /* @__PURE__ */ new Set();
+    const tagAttrs = config.allowedAttributes[tagName] || /* @__PURE__ */ new Set();
+    let isAllowed = globalAttrs.has(attrName) || tagAttrs.has(attrName);
+    if (tagName === "img" && (attrName === "width" || attrName === "height" || attrName === "style")) {
+      isAllowed = false;
+    }
+    if (!isAllowed && config.allowDataAttributes && attrName.startsWith("data-")) {
+      isAllowed = true;
+    }
+    if (isAllowed && !isDangerousAttributeValue(attrName, attrValue)) {
+      cleanedTag += ` ${attrName}="${attrValue.replace(/"/g, "&quot;")}"`;
+    }
+    match = attrPattern.exec(tagString);
+  }
+  cleanedTag += ">";
+  return cleanedTag;
+}
+function isDangerousAttributeValue(name, value) {
+  const valueLower = value.toLowerCase().trim();
+  if (name === "href" || name === "src") {
+    if (valueLower.startsWith("javascript:") || valueLower.startsWith("data:text/html")) {
+      return true;
+    }
+  }
+  if (valueLower.includes("javascript:") || valueLower.includes("onerror=")) {
+    return true;
+  }
+  return false;
+}
+
+// src/html/serialize.ts
+function serializeNodes(nodes) {
+  return nodes.map((node) => {
+    if (typeof node === "string") {
+      return escapeHtml(node);
+    }
+    return serializeNode(node);
+  }).join("");
+}
+function serializeInner(node) {
+  return node.children.map((child) => {
+    if (typeof child === "string") {
+      return escapeHtml(child);
+    }
+    return serializeNode(child);
+  }).join("");
+}
+function serializeNode(node) {
+  const selfClosing = ["br", "hr", "img", "input", "meta", "link"];
+  const tagName = stripQtiPrefix(node.tagName);
+  if (tagName === "math" || isMathMLElement(tagName)) {
+    return serializeVerbatim(node);
+  }
+  const attrs = serializeAttributes(node.attrs);
+  const attrString = attrs ? ` ${attrs}` : "";
+  if (selfClosing.includes(tagName) && node.children.length === 0) {
+    return `<${tagName}${attrString} />`;
+  }
+  const inner = serializeInner(node);
+  return `<${tagName}${attrString}>${inner}</${tagName}>`;
+}
+function stripQtiPrefix(tagName) {
+  const qtiToHtml = {
+    "qti-item-body": "div",
+    "qti-choice-interaction": "div",
+    "qti-simple-choice": "div",
+    "qti-feedback-block": "div",
+    "qti-content-body": "div",
+    "qti-prompt": "div",
+    "qti-value": "span",
+    "qti-variable": "span",
+    "qti-correct-response": "div"
+  };
+  if (qtiToHtml[tagName]) {
+    return qtiToHtml[tagName];
+  }
+  if (tagName.startsWith("qti-")) {
+    return tagName.slice(4);
+  }
+  return tagName;
+}
+function serializeAttributes(attrs) {
+  const excludeAttrs = [
+    "identifier",
+    "response-identifier",
+    "shuffle",
+    "max-choices",
+    "min-choices",
+    "cardinality",
+    "base-type",
+    "outcome-identifier",
+    "show-hide",
+    "time-dependent",
+    "adaptive",
+    "xml-lang"
+  ];
+  const parts = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (excludeAttrs.includes(key)) continue;
+    if (value == null) continue;
+    const htmlKey = key === "xml:lang" ? "lang" : key;
+    const escapedValue = escapeHtml(String(value));
+    parts.push(`${htmlKey}="${escapedValue}"`);
+  }
+  return parts.join(" ");
+}
+function escapeHtml(text) {
+  const escapeMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return text.replace(/[&<>"']/g, (char) => escapeMap[char] || char);
+}
+function isMathMLElement(tagName) {
+  const mathMLTags = [
+    "mi",
+    "mn",
+    "mo",
+    "mtext",
+    "mspace",
+    "ms",
+    "mrow",
+    "mfrac",
+    "msqrt",
+    "mroot",
+    "mstyle",
+    "msub",
+    "msup",
+    "msubsup",
+    "munder",
+    "mover",
+    "munderover",
+    "mtable",
+    "mtr",
+    "mtd"
+  ];
+  return mathMLTags.includes(tagName);
+}
+function serializeVerbatim(node) {
+  const attrs = Object.entries(node.attrs).map(([key, value]) => {
+    if (value == null) return "";
+    return ` ${key}="${String(value).replace(/"/g, "&quot;")}"`;
+  }).join("");
+  if (node.children.length === 0) {
+    return `<${node.tagName}${attrs} />`;
+  }
+  const inner = node.children.map((child) => {
+    if (typeof child === "string") {
+      return escapeHtml(child);
+    }
+    return serializeVerbatim(child);
+  }).join("");
+  return `<${node.tagName}${attrs}>${inner}</${node.tagName}>`;
+}
+var QtiCardinalitySchema = z$1.enum(["single", "multiple", "ordered"]);
+var QtiBaseTypeSchema = z$1.enum(["identifier", "string", "float", "integer", "boolean", "directedPair", "pair"]);
+var SimpleChoiceSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  contentHtml: z$1.string(),
+  // Allows "" for empty or image-only content
+  inlineFeedbackHtml: z$1.string().optional()
+  // Optional per-choice feedback (qti-feedback-inline)
+});
+var InlineChoiceSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  contentHtml: z$1.string()
+});
+var ChoiceInteractionCoreSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  shuffle: z$1.boolean(),
+  minChoices: z$1.number().int().min(0),
+  maxChoices: z$1.number().int().min(1),
+  promptHtml: z$1.string(),
+  choices: z$1.array(SimpleChoiceSchema).min(1)
+});
+var ChoiceInteractionSchema = ChoiceInteractionCoreSchema.extend({ type: z$1.literal("choiceInteraction") });
+var InlineChoiceInteractionCoreSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  shuffle: z$1.boolean(),
+  choices: z$1.array(InlineChoiceSchema).min(1)
+});
+var InlineChoiceInteractionSchema = InlineChoiceInteractionCoreSchema.extend({
+  type: z$1.literal("inlineChoiceInteraction")
+});
+var TextEntryInteractionCoreSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  expectedLength: z$1.number().int().min(0).optional(),
+  placeholderText: z$1.string().optional(),
+  patternMask: z$1.string().optional()
+});
+var TextEntryInteractionSchema = TextEntryInteractionCoreSchema.extend({
+  type: z$1.literal("textEntryInteraction")
+});
+var OrderInteractionCoreSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  shuffle: z$1.boolean(),
+  minChoices: z$1.number().int().min(0),
+  maxChoices: z$1.number().int().min(0).optional(),
+  // 0 or undefined usually means "all"
+  orientation: z$1.enum(["vertical", "horizontal"]),
+  promptHtml: z$1.string(),
+  choices: z$1.array(SimpleChoiceSchema).min(1)
+});
+var OrderInteractionSchema = OrderInteractionCoreSchema.extend({
+  type: z$1.literal("orderInteraction")
+});
+var GapTextSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  contentHtml: z$1.string(),
+  matchMax: z$1.number().int().min(0)
+  // 0 = unlimited
+});
+var GapSchema = z$1.object({
+  identifier: z$1.string().min(1)
+});
+var GapMatchInteractionCoreSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  shuffle: z$1.boolean(),
+  gapTexts: z$1.array(GapTextSchema).min(1),
+  // Draggable source tokens
+  gaps: z$1.array(GapSchema).min(1),
+  // Drop target placeholders
+  contentHtml: z$1.string()
+  // HTML content with gap placeholders
+});
+var GapMatchInteractionSchema = GapMatchInteractionCoreSchema.extend({
+  type: z$1.literal("gapMatchInteraction")
+});
+var AssociableChoiceSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  matchMax: z$1.number().int().min(0),
+  // 0 = unlimited uses
+  contentHtml: z$1.string()
+});
+var MatchInteractionCoreSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  shuffle: z$1.boolean(),
+  maxAssociations: z$1.number().int().min(0),
+  // 0 = unlimited total associations
+  sourceChoices: z$1.array(AssociableChoiceSchema).min(1),
+  // First <qti-simple-match-set>
+  targetChoices: z$1.array(AssociableChoiceSchema).min(1),
+  // Second <qti-simple-match-set>
+  promptHtml: z$1.string()
+});
+var MatchInteractionSchema = MatchInteractionCoreSchema.extend({
+  type: z$1.literal("matchInteraction")
+});
+var AnyInteractionSchema = z$1.discriminatedUnion("type", [
+  ChoiceInteractionSchema,
+  InlineChoiceInteractionSchema,
+  TextEntryInteractionSchema,
+  OrderInteractionSchema,
+  GapMatchInteractionSchema,
+  MatchInteractionSchema
+]);
+var CorrectResponseSchema = z$1.object({
+  values: z$1.array(z$1.string().min(1)).min(1)
+});
+var ResponseDeclarationSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  cardinality: QtiCardinalitySchema,
+  baseType: QtiBaseTypeSchema,
+  correctResponse: CorrectResponseSchema,
+  // Optional response mapping for map-response processing (used for summed feedback/score)
+  mapping: z$1.object({
+    defaultValue: z$1.number().default(0),
+    lowerBound: z$1.number().optional(),
+    upperBound: z$1.number().optional(),
+    entries: z$1.array(
+      z$1.object({
+        key: z$1.string().min(1),
+        value: z$1.number()
+      })
+    )
+  }).optional()
+});
+var OutcomeDefaultValueSchema = z$1.object({
+  value: z$1.string()
+});
+var OutcomeDeclarationSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  cardinality: QtiCardinalitySchema,
+  baseType: QtiBaseTypeSchema,
+  defaultValue: OutcomeDefaultValueSchema.optional()
+});
+var FeedbackBlockSchema = z$1.object({
+  outcomeIdentifier: z$1.string().min(1),
+  identifier: z$1.string().min(1),
+  showHide: z$1.enum(["show", "hide"]).default("show"),
+  contentHtml: z$1.string()
+});
+var StimulusBlockSchema = z$1.object({
+  type: z$1.literal("stimulus"),
+  html: z$1.string()
+});
+var RichStimulusBlockSchema = z$1.object({
+  type: z$1.literal("richStimulus"),
+  html: z$1.string(),
+  inlineEmbeds: z$1.record(z$1.string(), InlineChoiceInteractionSchema),
+  textEmbeds: z$1.record(z$1.string(), TextEntryInteractionSchema)
+});
+var InteractionBlockSchema = z$1.object({
+  type: z$1.literal("interaction"),
+  interaction: AnyInteractionSchema
+});
+var ItemBodySchema = z$1.object({
+  contentBlocks: z$1.array(z$1.union([StimulusBlockSchema, RichStimulusBlockSchema, InteractionBlockSchema])).min(1),
+  feedbackBlocks: z$1.array(FeedbackBlockSchema)
+});
+var BaseRuleSchema = z$1.object({
+  type: z$1.literal("setOutcomeValue"),
+  identifier: z$1.string(),
+  value: z$1.string()
+});
+var MatchConditionSchema = z$1.object({
+  type: z$1.literal("match"),
+  variable: z$1.string(),
+  correct: z$1.literal(true)
+  // Match against correct response
+});
+var MatchValueConditionSchema = z$1.object({
+  type: z$1.literal("matchValue"),
+  variable: z$1.string(),
+  // The response identifier from <qti-variable>
+  value: z$1.string()
+  // The target value from <qti-base-value>
+});
+var StringMatchConditionSchema = z$1.object({
+  type: z$1.literal("stringMatch"),
+  variable: z$1.string(),
+  value: z$1.string(),
+  caseSensitive: z$1.boolean()
+});
+var MemberConditionSchema = z$1.object({
+  type: z$1.literal("member"),
+  variable: z$1.string(),
+  value: z$1.string()
+});
+var EqualMapResponseConditionSchema = z$1.object({
+  type: z$1.literal("equalMapResponse"),
+  variable: z$1.string(),
+  // The response identifier from <qti-map-response>
+  value: z$1.string()
+  // The target sum value from <qti-base-value>
+});
+var AndConditionSchema = z$1.object({
+  type: z$1.literal("and"),
+  conditions: z$1.array(z$1.lazy(() => AnyConditionSchema))
+});
+var OrConditionSchema = z$1.object({
+  type: z$1.literal("or"),
+  conditions: z$1.array(z$1.lazy(() => AnyConditionSchema))
+});
+var NotConditionSchema = z$1.object({
+  type: z$1.literal("not"),
+  condition: z$1.lazy(() => AnyConditionSchema)
+});
+var AnyConditionSchema = z$1.union([
+  MatchConditionSchema,
+  MatchValueConditionSchema,
+  StringMatchConditionSchema,
+  MemberConditionSchema,
+  z$1.lazy(() => AndConditionSchema),
+  z$1.lazy(() => OrConditionSchema),
+  z$1.lazy(() => NotConditionSchema),
+  EqualMapResponseConditionSchema
+]);
+var ConditionBranchSchema = z$1.object({
+  condition: AnyConditionSchema.optional(),
+  actions: z$1.array(BaseRuleSchema),
+  nestedRules: z$1.array(z$1.lazy(() => ResponseRuleSchema)).optional()
+});
+var ResponseRuleSchema = z$1.union([
+  z$1.object({
+    type: z$1.literal("condition"),
+    branches: z$1.array(ConditionBranchSchema)
+  }),
+  z$1.object({
+    type: z$1.literal("action"),
+    action: BaseRuleSchema
+  })
+]);
+var ScoringRuleSchema = z$1.object({
+  responseIdentifier: z$1.string().min(1),
+  correctScore: z$1.number(),
+  incorrectScore: z$1.number()
+});
+var ResponseProcessingSchema = z$1.object({
+  rules: z$1.array(ResponseRuleSchema),
+  scoring: ScoringRuleSchema
+});
+var AssessmentItemSchema = z$1.object({
+  identifier: z$1.string().min(1),
+  title: z$1.string().min(1),
+  timeDependent: z$1.boolean(),
+  xmlLang: z$1.string().min(1),
+  responseDeclarations: z$1.array(ResponseDeclarationSchema).min(1),
+  outcomeDeclarations: z$1.array(OutcomeDeclarationSchema).min(1),
+  itemBody: ItemBodySchema,
+  responseProcessing: ResponseProcessingSchema
+});
+
+// src/parser.ts
+function createXmlParser() {
+  return new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    allowBooleanAttributes: true,
+    parseAttributeValue: true,
+    parseTagValue: false,
+    // CRITICAL: Preserve "000" as string, not convert to number 0
+    trimValues: false,
+    preserveOrder: true
+  });
+}
+function coerceString(value) {
+  if (value == null) return "";
+  return String(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function normalizeNode(rawNode) {
+  if (rawNode == null) return "";
+  if (!isRecord(rawNode)) return coerceString(rawNode);
+  const textContent = rawNode["#text"];
+  if (textContent != null) {
+    return coerceString(textContent);
+  }
+  const tagName = Object.keys(rawNode).find((k2) => k2 !== ":@");
+  if (!tagName) return "";
+  const attrsValue = rawNode[":@"];
+  const attrs = isRecord(attrsValue) ? attrsValue : {};
+  const rawChildren = Array.isArray(rawNode[tagName]) ? rawNode[tagName] : [rawNode[tagName]];
+  return {
+    tagName,
+    attrs,
+    children: rawChildren.map(normalizeNode).filter((n) => n !== "")
+  };
+}
+function nodeToXml(node) {
+  if (typeof node === "string") return node;
+  return serializeNode(node);
+}
+function getInnerHtml(node) {
+  return serializeInner(node);
+}
+function findChild(node, tagName) {
+  const child = node.children.find((c) => typeof c !== "string" && c.tagName === tagName);
+  return typeof child === "string" ? void 0 : child;
+}
+function findChildren(node, tagName) {
+  return node.children.filter((c) => typeof c !== "string" && c.tagName === tagName);
+}
+function getTextContent(node) {
+  if (!node) return "";
+  const firstChild = node.children[0];
+  if (typeof firstChild === "string") return firstChild.trim();
+  return "";
+}
+function findInteractionNodes(node, out = []) {
+  if (node.tagName.includes("-interaction")) {
+    out.push(node);
+  }
+  for (const child of node.children) {
+    if (typeof child !== "string") {
+      findInteractionNodes(child, out);
+    }
+  }
+  return out;
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function attrsToString(attrs) {
+  const parts = [];
+  for (const [key, val] of Object.entries(attrs)) {
+    const str = coerceString(val);
+    if (str === "") continue;
+    parts.push(`${key}="${escapeAttr(str)}"`);
+  }
+  return parts.length ? ` ${parts.join(" ")}` : "";
+}
+function serializeWithInlinePlaceholders(node, inlineEmbeds, textEmbeds) {
+  if (typeof node === "string") return node;
+  if (node.tagName === "qti-inline-choice-interaction") {
+    const interaction = extractInlineChoiceInteraction(node);
+    inlineEmbeds[interaction.responseIdentifier] = interaction;
+    return `<span data-qti-inline="${interaction.responseIdentifier}"></span>`;
+  }
+  if (node.tagName === "qti-text-entry-interaction") {
+    const interaction = extractTextEntryInteraction(node);
+    textEmbeds[interaction.responseIdentifier] = interaction;
+    return `<span data-qti-text-entry="${interaction.responseIdentifier}"></span>`;
+  }
+  const open = `<${node.tagName}${attrsToString(node.attrs)}>`;
+  const childrenHtml = node.children.map((c) => serializeWithInlinePlaceholders(c, inlineEmbeds, textEmbeds)).join("");
+  const close = `</${node.tagName}>`;
+  return `${open}${childrenHtml}${close}`;
+}
+function extractChoiceInteraction(node) {
+  const promptNode = findChild(node, "qti-prompt");
+  const promptHtml = promptNode ? getInnerHtml(promptNode) : "";
+  const choiceNodes = findChildren(node, "qti-simple-choice");
+  const choices = choiceNodes.map((choice) => {
+    const inlineFeedbackNode = findChild(choice, "qti-feedback-inline");
+    const inlineFeedbackHtml = inlineFeedbackNode ? getInnerHtml(inlineFeedbackNode) : void 0;
+    const contentChildren = choice.children.filter(
+      (c) => !(typeof c !== "string" && c.tagName === "qti-feedback-inline")
+    );
+    const contentHtml = serializeNodes(contentChildren);
+    return {
+      identifier: coerceString(choice.attrs.identifier),
+      contentHtml,
+      inlineFeedbackHtml
+    };
+  });
+  return {
+    type: "choiceInteraction",
+    responseIdentifier: coerceString(node.attrs["response-identifier"]),
+    shuffle: Boolean(node.attrs.shuffle),
+    minChoices: Number(node.attrs["min-choices"] ?? 0),
+    maxChoices: Number(node.attrs["max-choices"] ?? 1),
+    promptHtml,
+    choices
+  };
+}
+function extractInlineChoiceInteraction(node) {
+  const choiceNodes = findChildren(node, "qti-inline-choice");
+  const choices = choiceNodes.map((choice) => {
+    const contentHtml = serializeInner(choice);
+    return {
+      identifier: coerceString(choice.attrs.identifier),
+      contentHtml
+    };
+  });
+  return {
+    type: "inlineChoiceInteraction",
+    responseIdentifier: coerceString(node.attrs["response-identifier"]),
+    shuffle: Boolean(node.attrs.shuffle),
+    choices
+  };
+}
+function extractTextEntryInteraction(node) {
+  const expectedLengthAttr = node.attrs["expected-length"];
+  const expectedLength = expectedLengthAttr ? Number(expectedLengthAttr) : void 0;
+  return {
+    type: "textEntryInteraction",
+    responseIdentifier: coerceString(node.attrs["response-identifier"]),
+    expectedLength: expectedLength !== void 0 && !Number.isNaN(expectedLength) ? expectedLength : void 0,
+    placeholderText: coerceString(node.attrs["placeholder-text"]) || void 0,
+    patternMask: coerceString(node.attrs["pattern-mask"]) || void 0
+  };
+}
+function extractOrderInteraction(node) {
+  const promptNode = findChild(node, "qti-prompt");
+  const promptHtml = promptNode ? getInnerHtml(promptNode) : "";
+  const choiceNodes = findChildren(node, "qti-simple-choice");
+  const choices = choiceNodes.map((choice) => {
+    const contentChildren = choice.children.filter(
+      (c) => !(typeof c !== "string" && c.tagName === "qti-feedback-inline")
+    );
+    const contentHtml = serializeNodes(contentChildren);
+    return {
+      identifier: coerceString(choice.attrs.identifier),
+      contentHtml,
+      // Order interaction rarely displays inline feedback per-item
+      inlineFeedbackHtml: void 0
+    };
+  });
+  let orientation = "vertical";
+  const attrOrientation = coerceString(node.attrs.orientation);
+  const classAttr = coerceString(node.attrs.class);
+  if (attrOrientation === "horizontal" || classAttr.includes("qti-orientation-horizontal")) {
+    orientation = "horizontal";
+  }
+  return {
+    type: "orderInteraction",
+    responseIdentifier: coerceString(node.attrs["response-identifier"]),
+    shuffle: Boolean(node.attrs.shuffle),
+    minChoices: Number(node.attrs["min-choices"] ?? 0),
+    maxChoices: Number(node.attrs["max-choices"] ?? 0) || void 0,
+    orientation,
+    promptHtml,
+    choices
+  };
+}
+function extractGapMatchInteraction(node) {
+  const gapTextNodes = findChildren(node, "qti-gap-text");
+  const gapTexts = gapTextNodes.map((gt) => ({
+    identifier: coerceString(gt.attrs.identifier),
+    contentHtml: serializeInner(gt),
+    matchMax: Number(gt.attrs["match-max"] ?? 0)
+    // 0 = unlimited
+  }));
+  const gaps = [];
+  function serializeWithGapPlaceholders(child) {
+    if (typeof child === "string") return child;
+    if (child.tagName === "qti-gap") {
+      const gapId = coerceString(child.attrs.identifier);
+      gaps.push({ identifier: gapId });
+      return `<span data-qti-gap="${gapId}"></span>`;
+    }
+    if (child.tagName === "qti-gap-text") {
+      return "";
+    }
+    const open = `<${child.tagName}${attrsToString(child.attrs)}>`;
+    const childrenHtml = child.children.map((c) => serializeWithGapPlaceholders(c)).join("");
+    const close = `</${child.tagName}>`;
+    return `${open}${childrenHtml}${close}`;
+  }
+  const contentHtml = node.children.filter((c) => typeof c === "string" || c.tagName !== "qti-gap-text").map((c) => serializeWithGapPlaceholders(c)).join("");
+  return {
+    type: "gapMatchInteraction",
+    responseIdentifier: coerceString(node.attrs["response-identifier"]),
+    shuffle: Boolean(node.attrs.shuffle),
+    gapTexts,
+    gaps,
+    contentHtml
+  };
+}
+function extractMatchInteraction(node) {
+  const promptNode = findChild(node, "qti-prompt");
+  const promptHtml = promptNode ? getInnerHtml(promptNode) : "";
+  const matchSets = findChildren(node, "qti-simple-match-set");
+  const extractChoices = (setNode) => {
+    const choiceNodes = findChildren(setNode, "qti-simple-associable-choice");
+    return choiceNodes.map((c) => ({
+      identifier: coerceString(c.attrs.identifier),
+      matchMax: Number(c.attrs["match-max"]) || 1,
+      contentHtml: serializeInner(c)
+    }));
+  };
+  const firstSet = matchSets[0];
+  const secondSet = matchSets[1];
+  const sourceChoices = firstSet ? extractChoices(firstSet) : [];
+  const targetChoices = secondSet ? extractChoices(secondSet) : [];
+  return {
+    type: "matchInteraction",
+    responseIdentifier: coerceString(node.attrs["response-identifier"]),
+    shuffle: node.attrs.shuffle === "true",
+    maxAssociations: Number(node.attrs["max-associations"]) || 0,
+    sourceChoices,
+    targetChoices,
+    promptHtml
+  };
+}
+function extractFeedbackBlock(node) {
+  const contentBodyNode = findChild(node, "qti-content-body");
+  const contentHtml = contentBodyNode ? getInnerHtml(contentBodyNode) : "";
+  const showHide = coerceString(node.attrs["show-hide"]) === "hide" ? "hide" : "show";
+  return {
+    outcomeIdentifier: coerceString(node.attrs["outcome-identifier"]),
+    identifier: coerceString(node.attrs.identifier),
+    showHide,
+    contentHtml
+  };
+}
+function extractResponseDeclarations(rootChildren) {
+  const declNodes = rootChildren.filter((n) => n.tagName === "qti-response-declaration");
+  return declNodes.map((node) => {
+    const correctResponseNode = findChild(node, "qti-correct-response");
+    const valueNodes = correctResponseNode ? findChildren(correctResponseNode, "qti-value") : [];
+    const values = valueNodes.map(getTextContent);
+    const mappingNode = findChild(node, "qti-mapping");
+    let mapping;
+    if (mappingNode) {
+      const defaultValueRaw = coerceString(mappingNode.attrs["default-value"]);
+      const lowerBoundRaw = coerceString(mappingNode.attrs["lower-bound"]);
+      const upperBoundRaw = coerceString(mappingNode.attrs["upper-bound"]);
+      const entryNodes = findChildren(mappingNode, "qti-map-entry");
+      const entries = entryNodes.map((en) => {
+        return {
+          key: coerceString(en.attrs["map-key"]),
+          value: Number(coerceString(en.attrs["mapped-value"]) || 0)
+        };
+      });
+      mapping = {
+        defaultValue: Number(defaultValueRaw || 0),
+        lowerBound: lowerBoundRaw !== "" ? Number(lowerBoundRaw) : void 0,
+        upperBound: upperBoundRaw !== "" ? Number(upperBoundRaw) : void 0,
+        entries
+      };
+    }
+    const cardinalityRaw = coerceString(node.attrs.cardinality);
+    const cardinalityResult = QtiCardinalitySchema.safeParse(cardinalityRaw);
+    if (!cardinalityResult.success) {
+      throw A(`invalid cardinality '${cardinalityRaw}' in response declaration`);
+    }
+    const baseTypeRaw = coerceString(node.attrs["base-type"]);
+    const baseTypeResult = QtiBaseTypeSchema.safeParse(baseTypeRaw);
+    if (!baseTypeResult.success) {
+      throw A(`invalid base-type '${baseTypeRaw}' in response declaration`);
+    }
+    return {
+      identifier: coerceString(node.attrs.identifier),
+      cardinality: cardinalityResult.data,
+      baseType: baseTypeResult.data,
+      correctResponse: { values },
+      mapping
+    };
+  });
+}
+function extractOutcomeDeclarations(rootChildren) {
+  const declNodes = rootChildren.filter((n) => n.tagName === "qti-outcome-declaration");
+  return declNodes.map((node) => {
+    const defaultValueNode = findChild(node, "qti-default-value");
+    const valueNode = defaultValueNode ? findChild(defaultValueNode, "qti-value") : void 0;
+    const defaultValue = valueNode ? { value: getTextContent(valueNode) } : void 0;
+    const cardinalityRaw = coerceString(node.attrs.cardinality);
+    const cardinalityResult = QtiCardinalitySchema.safeParse(cardinalityRaw);
+    if (!cardinalityResult.success) {
+      throw A(`invalid cardinality '${cardinalityRaw}' in outcome declaration`);
+    }
+    const baseTypeRaw = coerceString(node.attrs["base-type"]);
+    const baseTypeResult = QtiBaseTypeSchema.safeParse(baseTypeRaw);
+    if (!baseTypeResult.success) {
+      throw A(`invalid base-type '${baseTypeRaw}' in outcome declaration`);
+    }
+    return {
+      identifier: coerceString(node.attrs.identifier),
+      cardinality: cardinalityResult.data,
+      baseType: baseTypeResult.data,
+      defaultValue
+    };
+  });
+}
+function parseCondition(node) {
+  if (node.tagName === "qti-and") {
+    const conditions = [];
+    for (const child of node.children) {
+      if (typeof child !== "string") {
+        const parsed = parseCondition(child);
+        if (parsed) conditions.push(parsed);
+      }
+    }
+    if (conditions.length === 0) return null;
+    return { type: "and", conditions };
+  }
+  if (node.tagName === "qti-or") {
+    const conditions = [];
+    for (const child of node.children) {
+      if (typeof child !== "string") {
+        const parsed = parseCondition(child);
+        if (parsed) conditions.push(parsed);
+      }
+    }
+    if (conditions.length === 0) return null;
+    return { type: "or", conditions };
+  }
+  if (node.tagName === "qti-not") {
+    for (const child of node.children) {
+      if (typeof child !== "string") {
+        const parsed = parseCondition(child);
+        if (parsed) return { type: "not", condition: parsed };
+      }
+    }
+    return null;
+  }
+  const variableNode = findChild(node, "qti-variable");
+  const baseValueNode = findChild(node, "qti-base-value");
+  const identifier = variableNode ? coerceString(variableNode.attrs.identifier) : void 0;
+  const value = baseValueNode ? getTextContent(baseValueNode) : void 0;
+  if (node.tagName === "qti-match") {
+    if (findChild(node, "qti-correct") && identifier) {
+      return { type: "match", variable: identifier, correct: true };
+    }
+    if (identifier && value !== void 0) {
+      return { type: "matchValue", variable: identifier, value };
+    }
+  }
+  if (node.tagName === "qti-string-match") {
+    if (identifier && value !== void 0) {
+      return {
+        type: "stringMatch",
+        variable: identifier,
+        value,
+        // QTI spec: case-sensitive defaults to true
+        caseSensitive: node.attrs["case-sensitive"] !== "false"
+      };
+    }
+  }
+  if (node.tagName === "qti-member") {
+    if (identifier && value !== void 0) {
+      return { type: "member", variable: identifier, value };
+    }
+  }
+  if (node.tagName === "qti-equal") {
+    const mapResponseNode = findChild(node, "qti-map-response");
+    const equalBaseValueNode = findChild(node, "qti-base-value");
+    if (mapResponseNode && equalBaseValueNode) {
+      return {
+        type: "equalMapResponse",
+        variable: coerceString(mapResponseNode.attrs.identifier),
+        value: getTextContent(equalBaseValueNode)
+      };
+    }
+    if (findChild(node, "qti-correct") && identifier) {
+      return { type: "match", variable: identifier, correct: true };
+    }
+  }
+  return null;
+}
+function parseActions(node) {
+  const rules = [];
+  const setNodes = findChildren(node, "qti-set-outcome-value");
+  for (const setNode of setNodes) {
+    const valueNode = findChild(setNode, "qti-base-value");
+    if (valueNode) {
+      rules.push({
+        type: "setOutcomeValue",
+        identifier: coerceString(setNode.attrs.identifier),
+        value: getTextContent(valueNode)
+      });
+    }
+  }
+  return rules;
+}
+function parseResponseRule(node) {
+  if (node.tagName === "qti-set-outcome-value") {
+    const valueNode = findChild(node, "qti-base-value");
+    if (valueNode) {
+      return {
+        type: "action",
+        action: {
+          type: "setOutcomeValue",
+          identifier: coerceString(node.attrs.identifier),
+          value: getTextContent(valueNode)
+        }
+      };
+    }
+    return null;
+  }
+  if (node.tagName === "qti-response-condition") {
+    const branches = [];
+    const ifNode = findChild(node, "qti-response-if");
+    if (ifNode) {
+      const condition = findConditionInBranch(ifNode);
+      if (condition) {
+        branches.push({
+          condition,
+          actions: parseActions(ifNode),
+          nestedRules: findNestedRules(ifNode)
+        });
+      }
+    }
+    const elseIfNodes = findChildren(node, "qti-response-else-if");
+    for (const elseIfNode of elseIfNodes) {
+      const condition = findConditionInBranch(elseIfNode);
+      if (condition) {
+        branches.push({
+          condition,
+          actions: parseActions(elseIfNode),
+          nestedRules: findNestedRules(elseIfNode)
+        });
+      }
+    }
+    const elseNode = findChild(node, "qti-response-else");
+    if (elseNode) {
+      branches.push({
+        condition: void 0,
+        // Else has no condition
+        actions: parseActions(elseNode),
+        nestedRules: findNestedRules(elseNode)
+      });
+    }
+    if (branches.length > 0) {
+      return {
+        type: "condition",
+        branches
+      };
+    }
+  }
+  return null;
+}
+function findConditionInBranch(node) {
+  const conditionTagNames = ["qti-match", "qti-and", "qti-or", "qti-not", "qti-equal", "qti-string-match", "qti-member"];
+  for (const child of node.children) {
+    if (typeof child !== "string" && conditionTagNames.includes(child.tagName)) {
+      return parseCondition(child);
+    }
+  }
+  return null;
+}
+function findNestedRules(node) {
+  const nested = [];
+  for (const child of node.children) {
+    if (typeof child !== "string" && child.tagName === "qti-response-condition") {
+      const rule = parseResponseRule(child);
+      if (rule) nested.push(rule);
+    }
+  }
+  return nested;
+}
+function extractResponseProcessing(rootChildren) {
+  const processingNode = rootChildren.find((n) => n.tagName === "qti-response-processing");
+  if (!processingNode) {
+    return { rules: [], scoring: { responseIdentifier: "", correctScore: 1, incorrectScore: 0 } };
+  }
+  const rules = [];
+  for (const child of processingNode.children) {
+    if (typeof child !== "string") {
+      const rule = parseResponseRule(child);
+      if (rule) rules.push(rule);
+    }
+  }
+  let scoring = { responseIdentifier: "", correctScore: 1, incorrectScore: 0 };
+  const conditionNodes = findChildren(processingNode, "qti-response-condition");
+  for (const conditionNode of conditionNodes) {
+    const responseIfNode = findChild(conditionNode, "qti-response-if");
+    const responseElseNode = findChild(conditionNode, "qti-response-else");
+    if (responseIfNode && responseElseNode) {
+      const andNode = findChild(responseIfNode, "qti-and");
+      if (andNode) {
+        const matchNode = findChild(andNode, "qti-match");
+        const variableNode = matchNode ? findChild(matchNode, "qti-variable") : void 0;
+        if (variableNode) {
+          const ifSetOutcomeNode = findChild(responseIfNode, "qti-set-outcome-value");
+          const elseSetOutcomeNode = findChild(responseElseNode, "qti-set-outcome-value");
+          const correctValueNode = ifSetOutcomeNode ? findChild(ifSetOutcomeNode, "qti-base-value") : void 0;
+          const incorrectValueNode = elseSetOutcomeNode ? findChild(elseSetOutcomeNode, "qti-base-value") : void 0;
+          scoring = {
+            responseIdentifier: coerceString(variableNode.attrs.identifier),
+            correctScore: Number(getTextContent(correctValueNode) || 1),
+            incorrectScore: Number(getTextContent(incorrectValueNode) || 0)
+          };
+        }
+      }
+    }
+  }
+  return { rules, scoring };
+}
+function parseAssessmentItemXml(xml) {
+  if (!xml || typeof xml !== "string") {
+    throw A("xml input must be a non-empty string");
+  }
+  const parser = createXmlParser();
+  const parseResult = I(() => {
+    return parser.parse(xml, true);
+  });
+  if (parseResult.error) {
+    throw B(parseResult.error, "xml parse");
+  }
+  const raw = parseResult.data;
+  if (!Array.isArray(raw)) {
+    throw A("expected xml parser to output an array for preserveOrder");
+  }
+  const normalizedTree = raw.map(normalizeNode).filter((n) => typeof n !== "string");
+  const rootNode = normalizedTree.find((n) => n.tagName.endsWith("assessment-item"));
+  if (!rootNode) {
+    throw A("qti assessment item not found in xml document");
+  }
+  const rootChildren = rootNode.children.filter((c) => typeof c !== "string");
+  const itemBodyNode = rootChildren.find((n) => n.tagName === "qti-item-body");
+  const contentBlocks = [];
+  const feedbackBlocks = [];
+  if (itemBodyNode) {
+    for (const child of itemBodyNode.children) {
+      if (typeof child === "string") {
+        if (child.trim()) contentBlocks.push({ type: "stimulus", html: child });
+        continue;
+      }
+      if (child.tagName === "qti-feedback-block") {
+        feedbackBlocks.push(extractFeedbackBlock(child));
+      } else {
+        const interactionNodes = findInteractionNodes(child);
+        const hasInline = interactionNodes.some(
+          (n) => n.tagName === "qti-inline-choice-interaction" || n.tagName === "qti-text-entry-interaction"
+        );
+        if (hasInline) {
+          const inlineEmbeds = {};
+          const textEmbeds = {};
+          const html = serializeWithInlinePlaceholders(child, inlineEmbeds, textEmbeds);
+          contentBlocks.push({ type: "richStimulus", html, inlineEmbeds, textEmbeds });
+          continue;
+        }
+        if (interactionNodes.length > 0) {
+          for (const inode of interactionNodes) {
+            if (inode.tagName === "qti-choice-interaction") {
+              const interaction = extractChoiceInteraction(inode);
+              contentBlocks.push({ type: "interaction", interaction });
+            } else if (inode.tagName === "qti-text-entry-interaction") {
+              const interaction = extractTextEntryInteraction(inode);
+              contentBlocks.push({ type: "interaction", interaction });
+            } else if (inode.tagName === "qti-order-interaction") {
+              const interaction = extractOrderInteraction(inode);
+              contentBlocks.push({ type: "interaction", interaction });
+            } else if (inode.tagName === "qti-gap-match-interaction") {
+              const interaction = extractGapMatchInteraction(inode);
+              contentBlocks.push({ type: "interaction", interaction });
+            } else if (inode.tagName === "qti-match-interaction") {
+              const interaction = extractMatchInteraction(inode);
+              contentBlocks.push({ type: "interaction", interaction });
+            } else {
+              contentBlocks.push({ type: "stimulus", html: nodeToXml(inode) });
+            }
+          }
+          continue;
+        }
+        contentBlocks.push({ type: "stimulus", html: nodeToXml(child) });
+      }
+    }
+  }
+  let normalizedItem = {
+    identifier: coerceString(rootNode.attrs.identifier),
+    title: coerceString(rootNode.attrs.title),
+    timeDependent: Boolean(rootNode.attrs["time-dependent"]),
+    xmlLang: coerceString(rootNode.attrs["xml:lang"]) || coerceString(rootNode.attrs["xml-lang"]) || "en",
+    responseDeclarations: extractResponseDeclarations(rootChildren),
+    outcomeDeclarations: extractOutcomeDeclarations(rootChildren),
+    itemBody: { contentBlocks, feedbackBlocks },
+    responseProcessing: extractResponseProcessing(rootChildren)
+  };
+  if (normalizedItem.responseProcessing.scoring.responseIdentifier === "" && normalizedItem.responseDeclarations.length > 0) {
+    const firstDecl = normalizedItem.responseDeclarations[0];
+    if (firstDecl) {
+      normalizedItem.responseProcessing.scoring.responseIdentifier = firstDecl.identifier;
+    }
+  }
+  const validation = AssessmentItemSchema.safeParse(normalizedItem);
+  if (!validation.success) {
+    const errorDetails = validation.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
+    throw A(`qti item validation: ${errorDetails}`);
+  }
+  return validation.data;
+}
+
+// src/evaluator.ts
+function normalizeString(str, caseSensitive) {
+  const s = (str ?? "").trim();
+  return caseSensitive ? s : s.toLowerCase();
+}
+function checkCondition(condition, item, responses, responseResults) {
+  if (condition.type === "and") {
+    const results = condition.conditions.map((c) => checkCondition(c, item, responses, responseResults));
+    const allTrue = results.every((r) => r === true);
+    y("qti evaluator: checking AND condition", {
+      numConditions: condition.conditions.length,
+      results,
+      allTrue
+    });
+    return allTrue;
+  }
+  if (condition.type === "or") {
+    const results = condition.conditions.map((c) => checkCondition(c, item, responses, responseResults));
+    const anyTrue = results.some((r) => r === true);
+    y("qti evaluator: checking OR condition", {
+      numConditions: condition.conditions.length,
+      results,
+      anyTrue
+    });
+    return anyTrue;
+  }
+  if (condition.type === "not") {
+    const result = checkCondition(condition.condition, item, responses, responseResults);
+    y("qti evaluator: checking NOT condition", { result, negated: !result });
+    return !result;
+  }
+  if (condition.type === "match") {
+    const result = responseResults[condition.variable];
+    y("qti evaluator: checking match condition", {
+      variable: condition.variable,
+      isCorrect: result,
+      matches: result === true
+    });
+    return result === true;
+  }
+  if (condition.type === "matchValue") {
+    const userResponse = responses[condition.variable];
+    let userValues;
+    if (Array.isArray(userResponse)) {
+      userValues = userResponse;
+    } else if (userResponse) {
+      userValues = [userResponse];
+    } else {
+      userValues = [];
+    }
+    const matches = userValues.includes(condition.value);
+    y("qti evaluator: checking matchValue condition", {
+      variable: condition.variable,
+      targetValue: condition.value,
+      userValues,
+      matches
+    });
+    return matches;
+  }
+  if (condition.type === "stringMatch") {
+    const userResponse = responses[condition.variable];
+    const val = Array.isArray(userResponse) ? userResponse[0] : userResponse;
+    if (!val) return false;
+    const u = normalizeString(String(val), condition.caseSensitive);
+    const t = normalizeString(condition.value, condition.caseSensitive);
+    const matches = u === t;
+    y("qti evaluator: checking stringMatch", {
+      variable: condition.variable,
+      caseSensitive: condition.caseSensitive,
+      matches
+    });
+    return matches;
+  }
+  if (condition.type === "member") {
+    const userResponse = responses[condition.variable];
+    let userValues;
+    if (Array.isArray(userResponse)) {
+      userValues = userResponse;
+    } else if (userResponse) {
+      userValues = [userResponse];
+    } else {
+      userValues = [];
+    }
+    const matches = userValues.includes(condition.value);
+    y("qti evaluator: checking member", {
+      variable: condition.variable,
+      target: condition.value,
+      userValues,
+      matches
+    });
+    return matches;
+  }
+  if (condition.type === "equalMapResponse") {
+    const responseId = condition.variable;
+    const userResponse = responses[responseId];
+    const responseDecl = item.responseDeclarations.find((rd) => rd.identifier === responseId);
+    if (!userResponse || !responseDecl?.mapping) return false;
+    const userValues = Array.isArray(userResponse) ? userResponse : [userResponse];
+    const valueMap = new Map(responseDecl.mapping.entries.map((e) => [e.key, e.value]));
+    let sum = 0;
+    for (const val of userValues) {
+      sum += valueMap.get(val) ?? responseDecl.mapping.defaultValue;
+    }
+    const target = Number(condition.value);
+    const diff = Math.abs(sum - target);
+    const matches = diff < 1e-4;
+    y("qti evaluator: checking equalMapResponse", {
+      responseId,
+      userValues,
+      sum,
+      target: condition.value,
+      matches
+    });
+    return matches;
+  }
+  return false;
+}
+function evaluateRule(rule, item, responses, responseResults) {
+  const feedbackIds = [];
+  if (rule.type === "action") {
+    const action = rule.action;
+    if (action.type === "setOutcomeValue" && (action.identifier === "FEEDBACK__OVERALL" || action.identifier === "FEEDBACK__PEDAGOGY" || action.identifier === "FEEDBACK")) {
+      y("qti evaluator: executing action", { id: action.identifier, value: action.value });
+      feedbackIds.push(action.value);
+    }
+    return feedbackIds;
+  }
+  if (rule.type === "condition") {
+    for (const branch of rule.branches) {
+      const isMatch = branch.condition ? checkCondition(branch.condition, item, responses, responseResults) : true;
+      y("qti evaluator: evaluating branch", {
+        hasCondition: !!branch.condition,
+        isMatch
+      });
+      if (isMatch) {
+        const feedbackActions = branch.actions.filter(
+          (r) => r.type === "setOutcomeValue" && (r.identifier === "FEEDBACK__OVERALL" || r.identifier === "FEEDBACK__PEDAGOGY" || r.identifier === "FEEDBACK")
+        );
+        for (const action of feedbackActions) {
+          feedbackIds.push(action.value);
+        }
+        if (branch.nestedRules) {
+          for (const nested of branch.nestedRules) {
+            const nestedIds = evaluateRule(nested, item, responses, responseResults);
+            feedbackIds.push(...nestedIds);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return feedbackIds;
+}
+function evaluateFeedbackIdentifiers(item, responses, responseResults) {
+  const processing = item.responseProcessing;
+  if (!processing) {
+    y("qti evaluator: no response processing found");
+    return [];
+  }
+  y("qti evaluator: starting evaluation", {
+    numRules: processing.rules.length,
+    responseResults
+  });
+  const allFeedbackIds = [];
+  for (const rule of processing.rules) {
+    const ids = evaluateRule(rule, item, responses, responseResults);
+    allFeedbackIds.push(...ids);
+  }
+  y("qti evaluator: selected feedback identifiers", { feedbackIds: allFeedbackIds });
+  return allFeedbackIds;
+}
+
+// src/actions/internal/display.ts
+function shuffleArray(items) {
+  const arr = items.slice();
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j2 = Math.floor(Math.random() * (i + 1));
+    const vi = arr[i];
+    const vj = arr[j2];
+    if (vi === void 0 || vj === void 0) {
+      continue;
+    }
+    arr[i] = vj;
+    arr[j2] = vi;
+  }
+  return arr;
+}
+function buildDisplayModelFromXml(qtiXml) {
+  y("qti build display model", {});
+  const parseResult = I(() => parseAssessmentItemXml(qtiXml));
+  if (parseResult.error) {
+    l("qti parse failed", { error: parseResult.error });
+    throw B(parseResult.error, "qti parse");
+  }
+  const item = parseResult.data;
+  const shape = {};
+  for (const rd of item.responseDeclarations) {
+    if (rd.baseType === "directedPair" || rd.baseType === "pair") {
+      shape[rd.identifier] = "directedPair";
+    } else if (rd.cardinality === "single") {
+      shape[rd.identifier] = "single";
+    } else if (rd.cardinality === "ordered") {
+      shape[rd.identifier] = "ordered";
+    } else {
+      shape[rd.identifier] = "multiple";
+    }
+  }
+  const contentBlocks = item.itemBody.contentBlocks.map((block) => {
+    if (block.type === "stimulus") {
+      return { type: "stimulus", html: sanitizeHtml(block.html) };
+    }
+    if (block.type === "richStimulus") {
+      const html = sanitizeHtml(block.html, { allowDataAttributes: true });
+      const inlineEmbeds = {};
+      for (const [key, embed] of Object.entries(block.inlineEmbeds)) {
+        inlineEmbeds[key] = {
+          responseId: embed.responseIdentifier,
+          shuffle: embed.shuffle,
+          choices: embed.choices.map((c) => ({
+            id: c.identifier,
+            contentHtml: sanitizeHtml(c.contentHtml)
+          }))
+        };
+      }
+      const textEmbeds = {};
+      for (const [key, embed] of Object.entries(block.textEmbeds)) {
+        textEmbeds[key] = {
+          responseId: embed.responseIdentifier,
+          expectedLength: embed.expectedLength,
+          placeholder: embed.placeholderText,
+          patternMask: embed.patternMask
+        };
+      }
+      return { type: "richStimulus", html, inlineEmbeds, textEmbeds };
+    }
+    const interaction = block.interaction;
+    if (interaction.type === "choiceInteraction") {
+      const promptHtml = sanitizeHtml(interaction.promptHtml);
+      let choices = interaction.choices.map((c) => ({
+        id: c.identifier,
+        contentHtml: sanitizeHtml(c.contentHtml),
+        inlineFeedbackHtml: c.inlineFeedbackHtml ? sanitizeHtml(c.inlineFeedbackHtml) : void 0
+      }));
+      if (interaction.shuffle === true) {
+        choices = shuffleArray(choices);
+      }
+      const cardinality = shape[interaction.responseIdentifier] === "multiple" ? "multiple" : "single";
+      return {
+        type: "interaction",
+        interaction: {
+          type: "choice",
+          responseId: interaction.responseIdentifier,
+          cardinality,
+          promptHtml,
+          choices,
+          minChoices: interaction.minChoices,
+          maxChoices: interaction.maxChoices
+        }
+      };
+    }
+    if (interaction.type === "textEntryInteraction") {
+      return {
+        type: "interaction",
+        interaction: {
+          type: "text",
+          responseId: interaction.responseIdentifier,
+          expectedLength: interaction.expectedLength,
+          placeholder: interaction.placeholderText,
+          patternMask: interaction.patternMask
+        }
+      };
+    }
+    if (interaction.type === "orderInteraction") {
+      let choices = interaction.choices.map((c) => ({
+        id: c.identifier,
+        contentHtml: sanitizeHtml(c.contentHtml),
+        inlineFeedbackHtml: void 0
+      }));
+      if (interaction.shuffle === true) {
+        choices = shuffleArray(choices);
+      }
+      return {
+        type: "interaction",
+        interaction: {
+          type: "order",
+          responseId: interaction.responseIdentifier,
+          promptHtml: sanitizeHtml(interaction.promptHtml),
+          orientation: interaction.orientation,
+          choices
+        }
+      };
+    }
+    if (interaction.type === "gapMatchInteraction") {
+      let gapTexts = interaction.gapTexts.map((gt) => ({
+        id: gt.identifier,
+        contentHtml: sanitizeHtml(gt.contentHtml),
+        matchMax: gt.matchMax
+      }));
+      if (interaction.shuffle === true) {
+        gapTexts = shuffleArray(gapTexts);
+      }
+      const gaps = interaction.gaps.map((g) => ({
+        id: g.identifier
+      }));
+      return {
+        type: "interaction",
+        interaction: {
+          type: "gapMatch",
+          responseId: interaction.responseIdentifier,
+          gapTexts,
+          gaps,
+          contentHtml: sanitizeHtml(interaction.contentHtml, { allowDataAttributes: true })
+        }
+      };
+    }
+    if (interaction.type === "matchInteraction") {
+      const mapChoice = (c) => ({
+        id: c.identifier,
+        contentHtml: sanitizeHtml(c.contentHtml),
+        matchMax: c.matchMax
+      });
+      let sourceChoices = interaction.sourceChoices.map(mapChoice);
+      const targetChoices = interaction.targetChoices.map(mapChoice);
+      if (interaction.shuffle === true) {
+        sourceChoices = shuffleArray(sourceChoices);
+      }
+      return {
+        type: "interaction",
+        interaction: {
+          type: "match",
+          responseId: interaction.responseIdentifier,
+          promptHtml: sanitizeHtml(interaction.promptHtml),
+          maxAssociations: interaction.maxAssociations,
+          sourceChoices,
+          targetChoices
+        }
+      };
+    }
+    return { type: "stimulus", html: sanitizeHtml("") };
+  });
+  const displayItem = { title: item.title, contentBlocks };
+  const hash = createHash("sha256").update(qtiXml).digest("hex").slice(0, 16);
+  return { itemKey: hash, item: displayItem, shape };
+}
+
+// src/actions/build.ts
+async function buildDisplayModel(qtiXml) {
+  return buildDisplayModelFromXml(qtiXml);
+}
+
+// src/actions/internal/validate.ts
+function validateResponsesFromXml(qtiXml, responses) {
+  y("qti validate secure", {});
+  const parseResult = I(() => parseAssessmentItemXml(qtiXml));
+  if (parseResult.error) {
+    l("qti parse failed during validate", { error: parseResult.error });
+    throw B(parseResult.error, "qti parse");
+  }
+  const item = parseResult.data;
+  y("qti validate: parsed item", {
+    title: item.title,
+    responseCount: Object.keys(responses).length
+  });
+  const perResponse = {};
+  const selectedChoicesByResponse = {};
+  const responseCorrectness = {};
+  let allCorrect = true;
+  for (const rd of item.responseDeclarations) {
+    const respId = rd.identifier;
+    const user = responses[respId];
+    if (user == null) {
+      allCorrect = false;
+      responseCorrectness[respId] = false;
+      y("qti validate: missing response", { responseId: respId });
+      continue;
+    }
+    const userVals = Array.isArray(user) ? user.filter((v) => typeof v === "string") : [user];
+    const correctVals = rd.correctResponse.values;
+    let isCorrect = false;
+    if (rd.cardinality === "ordered") {
+      isCorrect = userVals.length === correctVals.length && userVals.every((val, index) => val === correctVals[index]);
+      y("qti validate: ordered check", {
+        responseId: respId,
+        userVals,
+        correctVals,
+        isCorrect
+      });
+    } else if (rd.baseType === "directedPair" || rd.baseType === "pair") {
+      const correctSet2 = new Set(correctVals);
+      const userSet = new Set(userVals);
+      isCorrect = userSet.size === correctSet2.size && [...userSet].every((v) => correctSet2.has(v));
+      y("qti validate: directedPair check", {
+        responseId: respId,
+        userVals,
+        correctVals,
+        isCorrect
+      });
+    } else if (rd.baseType === "float" || rd.baseType === "integer") {
+      const userVal = userVals[0];
+      if (userVal != null) {
+        const userNum = Number.parseFloat(userVal);
+        if (!Number.isNaN(userNum)) {
+          const epsilon = rd.baseType === "float" ? 1e-6 : 0;
+          isCorrect = correctVals.some((correctVal) => {
+            const correctNum = Number.parseFloat(correctVal);
+            return !Number.isNaN(correctNum) && Math.abs(userNum - correctNum) <= epsilon;
+          });
+        }
+      }
+      y("qti validate: numeric check", {
+        responseId: respId,
+        baseType: rd.baseType,
+        userVal: userVals[0],
+        correctVals,
+        isCorrect
+      });
+    } else if (rd.cardinality === "single") {
+      const userVal = userVals[0];
+      isCorrect = userVal != null && correctVals.includes(userVal);
+      y("qti validate: single cardinality check", {
+        responseId: respId,
+        userVal,
+        correctVals,
+        isCorrect
+      });
+    } else {
+      const correctSet2 = new Set(correctVals);
+      const userSet = new Set(userVals);
+      isCorrect = userSet.size === correctSet2.size && [...userSet].every((v) => correctSet2.has(v));
+      y("qti validate: multiple cardinality check", {
+        responseId: respId,
+        userVals,
+        correctVals,
+        isCorrect
+      });
+    }
+    if (!isCorrect) allCorrect = false;
+    responseCorrectness[respId] = isCorrect;
+    y("qti validate: evaluated response", {
+      responseId: respId,
+      selected: userVals,
+      isCorrect
+    });
+    const correctSet = new Set(correctVals);
+    selectedChoicesByResponse[respId] = userVals.map((id) => ({ id, isCorrect: correctSet.has(id) }));
+    perResponse[respId] = { isCorrect };
+  }
+  const feedbackIdentifiers = evaluateFeedbackIdentifiers(item, responses, responseCorrectness);
+  let overallFeedback;
+  if (feedbackIdentifiers.length > 0) {
+    const feedbackHtmlParts = [];
+    for (const feedbackId of feedbackIdentifiers) {
+      const feedbackBlock = item.itemBody.feedbackBlocks.find((fb) => fb.identifier === feedbackId);
+      if (feedbackBlock) {
+        feedbackHtmlParts.push(sanitizeHtml(feedbackBlock.contentHtml));
+      }
+    }
+    if (feedbackHtmlParts.length > 0) {
+      overallFeedback = {
+        isCorrect: allCorrect,
+        messageHtml: feedbackHtmlParts.join("")
+      };
+      y("qti validate: overall feedback via response processing rules", {
+        isCorrect: allCorrect,
+        feedbackIds: feedbackIdentifiers,
+        numBlocks: feedbackHtmlParts.length
+      });
+    }
+  } else {
+    const targetId = allCorrect ? "CORRECT" : "INCORRECT";
+    const fallbackBlock = item.itemBody.feedbackBlocks.find(
+      (fb) => fb.identifier.toUpperCase() === targetId && (fb.outcomeIdentifier === "FEEDBACK" || fb.outcomeIdentifier === "FEEDBACK__OVERALL")
+    );
+    if (fallbackBlock) {
+      overallFeedback = { isCorrect: allCorrect, messageHtml: sanitizeHtml(fallbackBlock.contentHtml) };
+      y("qti validate: overall feedback via fallback block", {
+        isCorrect: allCorrect,
+        blockId: fallbackBlock.identifier
+      });
+    }
+  }
+  return { overallCorrect: allCorrect, perResponse, selectedChoicesByResponse, overallFeedback };
+}
+
+// src/actions/validate.ts
+async function validateResponsesSecure(qtiXml, responses) {
+  return validateResponsesFromXml(qtiXml, responses);
+}
+
+export { buildDisplayModel, buildDisplayModelFromXml, validateResponsesFromXml, validateResponsesSecure };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map