@conform-ed/qti-react 0.0.17 → 0.0.19

package/dist/headless.js

@@ -0,0 +1,4804 @@
+// src/graphic.ts
+function parseCoords(coords) {
+  return coords.split(",").map((entry) => Number(entry.trim())).filter((value) => !Number.isNaN(value));
+}
+function parsePoint(value) {
+  const [x, y, ...rest] = value.trim().split(/\s+/u).map(Number);
+  if (x === undefined || y === undefined || rest.length > 0 || Number.isNaN(x) || Number.isNaN(y)) {
+    return null;
+  }
+  return { x, y };
+}
+function formatPoint(point) {
+  return `${point.x} ${point.y}`;
+}
+function pointInPolygon(coords, point) {
+  let inside = false;
+  for (let i = 0, j = coords.length - 2;i < coords.length; j = i, i += 2) {
+    const xi = coords[i];
+    const yi = coords[i + 1];
+    const xj = coords[j];
+    const yj = coords[j + 1];
+    const intersects = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+    if (intersects) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function pointInShape(shape, coords, point) {
+  switch (shape) {
+    case "default":
+      return true;
+    case "circle": {
+      const [cx, cy, r] = coords;
+      if (cx === undefined || cy === undefined || r === undefined) {
+        return false;
+      }
+      return (point.x - cx) ** 2 + (point.y - cy) ** 2 <= r ** 2;
+    }
+    case "rect": {
+      const [left, top, right, bottom] = coords;
+      if (left === undefined || top === undefined || right === undefined || bottom === undefined) {
+        return false;
+      }
+      return point.x >= left && point.x <= right && point.y >= top && point.y <= bottom;
+    }
+    case "ellipse": {
+      const [cx, cy, rx, ry] = coords;
+      if (cx === undefined || cy === undefined || rx === undefined || ry === undefined || rx === 0 || ry === 0) {
+        return false;
+      }
+      return (point.x - cx) ** 2 / rx ** 2 + (point.y - cy) ** 2 / ry ** 2 <= 1;
+    }
+    case "poly":
+      return coords.length >= 6 && pointInPolygon(coords, point);
+    default:
+      return false;
+  }
+}
+
+// src/normalized-item.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+var kindRenames = {
+  hotTextInteraction: "hottextInteraction",
+  hotText: "hottext"
+};
+function numberValue(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && value !== "") {
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+  }
+  return;
+}
+function findImageSource(node) {
+  if (!isRecord(node)) {
+    return {};
+  }
+  const attributes = isRecord(node["attributes"]) ? node["attributes"] : {};
+  if (typeof attributes["data"] === "string" || typeof attributes["src"] === "string") {
+    return attributes;
+  }
+  for (const child of asRecords(node["children"])) {
+    const found = findImageSource(child);
+    if (typeof found["data"] === "string" || typeof found["src"] === "string") {
+      return found;
+    }
+  }
+  return attributes;
+}
+function toStageObject(node) {
+  const attributes = findImageSource(node);
+  const data = attributes["data"] ?? attributes["src"];
+  const width = numberValue(attributes["width"]);
+  const height = numberValue(attributes["height"]);
+  return {
+    data: typeof data === "string" ? data : "",
+    ...width !== undefined ? { width } : {},
+    ...height !== undefined ? { height } : {},
+    ...typeof attributes["type"] === "string" ? { type: attributes["type"] } : {}
+  };
+}
+function flattenText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(flattenText).join("");
+  }
+  if (!isRecord(value)) {
+    return "";
+  }
+  if (value["kind"] === "text") {
+    return typeof value["value"] === "string" ? value["value"] : "";
+  }
+  return flattenText(value["children"]) + flattenText(value["content"]) + flattenText(value["value"]);
+}
+function withNumericCoords(node) {
+  return typeof node["coords"] === "string" ? { ...node, coords: parseCoords(node["coords"]) } : node;
+}
+function reshapeContentNode(node) {
+  const kind = node["kind"];
+  if (typeof kind !== "string") {
+    return node;
+  }
+  const renamed = kindRenames[kind];
+  if (renamed !== undefined) {
+    return { ...node, kind: renamed };
+  }
+  switch (kind) {
+    case "hotspotChoice":
+    case "associableHotspot":
+      return withNumericCoords(node);
+    case "hotspotInteraction":
+    case "graphicOrderInteraction":
+    case "graphicAssociateInteraction":
+    case "selectPointInteraction": {
+      const { image, ...rest } = node;
+      return { ...rest, object: toStageObject(image) };
+    }
+    case "drawingInteraction": {
+      const { content, ...rest } = node;
+      const media = asRecords(content).find((fragment) => fragment["kind"] === "xml" && typeof fragment["name"] === "string" && ["object", "picture", "img"].includes(fragment["name"]));
+      return { ...rest, object: toStageObject(media) };
+    }
+    case "graphicGapMatchInteraction": {
+      const { image, gapChoices, ...rest } = node;
+      const gapImgs = asRecords(gapChoices).map(({ media, content, ...choice }) => choice["kind"] === "gapImg" ? { ...choice, object: toStageObject(media) } : { ...choice, label: flattenText(content) });
+      return { ...rest, object: toStageObject(image), gapImgs };
+    }
+    case "gapMatchInteraction": {
+      const gapTexts = asRecords(node["gapChoices"]).filter((choice) => choice["kind"] === "gapText");
+      return { ...node, gapTexts };
+    }
+    case "mediaInteraction": {
+      const { media, ...rest } = node;
+      return { ...rest, content: media === undefined ? [] : [media] };
+    }
+    case "uploadInteraction": {
+      const acceptedTypes = node["acceptedTypes"];
+      return Array.isArray(acceptedTypes) ? { ...node, type: acceptedTypes.join(",") } : node;
+    }
+    case "positionObjectStage": {
+      const interactions = asRecords(node["positionObjectInteractions"]);
+      const [first] = interactions;
+      if (interactions.length === 1 && first) {
+        return {
+          kind: "positionObjectStage",
+          responseIdentifier: first["responseIdentifier"],
+          stageObject: toStageObject(node["image"]),
+          object: toStageObject(first["image"]),
+          ...first["maxChoices"] !== undefined ? { maxChoices: first["maxChoices"] } : {},
+          ...first["minChoices"] !== undefined ? { minChoices: first["minChoices"] } : {}
+        };
+      }
+      const responseIdentifier = first?.["responseIdentifier"];
+      return { ...node, ...typeof responseIdentifier === "string" ? { responseIdentifier } : {} };
+    }
+    default:
+      return node;
+  }
+}
+function convertContentEntry(entry) {
+  if (typeof entry === "string") {
+    return { kind: "text", value: entry };
+  }
+  return convertContentValue(entry);
+}
+function convertContentValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(convertContentValue);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const converted = Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+    if ((key === "children" || key === "content") && Array.isArray(entry)) {
+      return [key, entry.map(convertContentEntry)];
+    }
+    return [key, convertContentValue(entry)];
+  }));
+  return reshapeContentNode(converted);
+}
+function convertExpression(expression) {
+  const record = isRecord(expression) ? expression : {};
+  const { children, ...rest } = record;
+  return {
+    ...rest,
+    ...Array.isArray(children) ? { expressions: children.map(convertExpression) } : {}
+  };
+}
+function convertBranch(branch, convertRule) {
+  const record = isRecord(branch) ? branch : {};
+  return {
+    expression: convertExpression(record["expression"]),
+    rules: (Array.isArray(record["actions"]) ? record["actions"] : []).map(convertRule)
+  };
+}
+function convertRpRule(rule) {
+  const record = isRecord(rule) ? rule : {};
+  const kind = typeof record["kind"] === "string" ? record["kind"] : "";
+  if (kind === "responseCondition") {
+    const elseIfs = Array.isArray(record["responseElseIf"]) ? record["responseElseIf"].map((branch) => convertBranch(branch, convertRpRule)) : [];
+    return {
+      kind,
+      responseIf: convertBranch(record["responseIf"], convertRpRule),
+      ...elseIfs.length ? { responseElseIfs: elseIfs } : {},
+      ...isRecord(record["responseElse"]) ? {
+        responseElse: {
+          rules: (Array.isArray(record["responseElse"]["actions"]) ? record["responseElse"]["actions"] : []).map(convertRpRule)
+        }
+      } : {}
+    };
+  }
+  if (kind === "responseProcessingFragment") {
+    return { kind, rules: (Array.isArray(record["rules"]) ? record["rules"] : []).map(convertRpRule) };
+  }
+  return {
+    kind,
+    ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
+    ...record["expression"] !== undefined ? { expression: convertExpression(record["expression"]) } : {}
+  };
+}
+function convertTemplateRule(rule) {
+  const record = isRecord(rule) ? rule : {};
+  const kind = typeof record["kind"] === "string" ? record["kind"] : "";
+  if (kind === "templateCondition") {
+    const elseIfs = Array.isArray(record["templateElseIf"]) ? record["templateElseIf"].map((branch) => convertBranch(branch, convertTemplateRule)) : [];
+    return {
+      kind,
+      templateIf: convertBranch(record["templateIf"], convertTemplateRule),
+      ...elseIfs.length ? { templateElseIfs: elseIfs } : {},
+      ...isRecord(record["templateElse"]) ? {
+        templateElse: {
+          rules: (Array.isArray(record["templateElse"]["actions"]) ? record["templateElse"]["actions"] : []).map(convertTemplateRule)
+        }
+      } : {}
+    };
+  }
+  return {
+    kind,
+    ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
+    ...record["expression"] !== undefined ? { expression: convertExpression(record["expression"]) } : {}
+  };
+}
+function convertResponseProcessing(value) {
+  return {
+    ...typeof value["template"] === "string" ? { template: value["template"] } : {},
+    ...Array.isArray(value["rules"]) ? { rules: value["rules"].map(convertRpRule) } : {}
+  };
+}
+function convertResponseDeclaration(declaration) {
+  const areaMapping = declaration["areaMapping"];
+  if (!isRecord(areaMapping)) {
+    return declaration;
+  }
+  const areaMapEntries = asRecords(areaMapping["areaMapEntries"]).map((entry) => withNumericCoords(entry));
+  return { ...declaration, areaMapping: { ...areaMapping, areaMapEntries } };
+}
+function appendCatalogViews(target, value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      appendCatalogViews(target, entry);
+    }
+    return;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  const catalogInfo = value["catalogInfo"];
+  if (isRecord(catalogInfo) && Array.isArray(catalogInfo["catalogs"])) {
+    target.push(...catalogInfo["catalogs"]);
+  }
+  appendCatalogViews(target, value["content"]);
+  appendCatalogViews(target, value["children"]);
+}
+function documentCatalogViews(root, convertedContent) {
+  const catalogs = [];
+  appendCatalogViews(catalogs, isRecord(root["catalogInfo"]) ? { catalogInfo: convertContentValue(root["catalogInfo"]) } : undefined);
+  appendCatalogViews(catalogs, convertedContent);
+  return catalogs;
+}
+function assessmentItemViewFromNormalized(document) {
+  if (!isRecord(document) || !isRecord(document["assessmentItem"])) {
+    return null;
+  }
+  const item = document["assessmentItem"];
+  const itemBody = isRecord(item["itemBody"]) ? item["itemBody"] : {};
+  const content = Array.isArray(itemBody["content"]) ? itemBody["content"].map(convertContentEntry) : [];
+  const templateRules = isRecord(item["templateProcessing"]) ? item["templateProcessing"]["rules"] : undefined;
+  const convertedModalFeedbacks = Array.isArray(item["modalFeedbacks"]) ? item["modalFeedbacks"].map(convertContentValue) : undefined;
+  const catalogs = documentCatalogViews(item, [content, convertedModalFeedbacks]);
+  return {
+    responseDeclarations: asRecords(item["responseDeclarations"]).map(convertResponseDeclaration),
+    outcomeDeclarations: item["outcomeDeclarations"] ?? [],
+    ...isRecord(item["responseProcessing"]) ? { responseProcessing: convertResponseProcessing(item["responseProcessing"]) } : {},
+    ...Array.isArray(item["templateDeclarations"]) ? { templateDeclarations: item["templateDeclarations"] } : {},
+    ...Array.isArray(templateRules) ? {
+      templateProcessing: {
+        rules: templateRules.map(convertTemplateRule)
+      }
+    } : {},
+    ...typeof item["adaptive"] === "boolean" ? { adaptive: item["adaptive"] } : {},
+    ...convertedModalFeedbacks ? { modalFeedbacks: convertedModalFeedbacks } : {},
+    ...catalogs.length ? { catalogs } : {},
+    ...isRecord(item["companionMaterialsInfo"]) ? { companionMaterials: item["companionMaterialsInfo"] } : {},
+    ...Array.isArray(item["assessmentStimulusRefs"]) ? {
+      assessmentStimulusRefs: asRecords(item["assessmentStimulusRefs"]).map((ref) => ({
+        identifier: typeof ref["identifier"] === "string" ? ref["identifier"] : "",
+        href: typeof ref["href"] === "string" ? ref["href"] : "",
+        ...typeof ref["title"] === "string" ? { title: ref["title"] } : {}
+      }))
+    } : {},
+    itemBody: { content }
+  };
+}
+function stimulusContentFromNormalized(document) {
+  if (!isRecord(document) || !isRecord(document["assessmentStimulus"])) {
+    return null;
+  }
+  const stimulus = document["assessmentStimulus"];
+  const body = isRecord(stimulus["stimulusBody"]) ? stimulus["stimulusBody"] : {};
+  const content = Array.isArray(body["content"]) ? body["content"].map(convertContentEntry) : [];
+  const catalogs = documentCatalogViews(stimulus, content);
+  return { content, ...catalogs.length ? { catalogs } : {} };
+}
+function convertPreConditions(value) {
+  return asRecords(value).map((wrapper) => convertExpression(wrapper["expression"]));
+}
+function convertBranchRules(value) {
+  return asRecords(value).map((rule) => ({
+    target: typeof rule["target"] === "string" ? rule["target"] : "",
+    expression: convertExpression(rule["expression"])
+  }));
+}
+function convertOutcomeRule(rule) {
+  const record = isRecord(rule) ? rule : {};
+  const kind = typeof record["kind"] === "string" ? record["kind"] : "";
+  if (kind === "outcomeCondition") {
+    const elseIfs = Array.isArray(record["outcomeElseIf"]) ? record["outcomeElseIf"].map((branch) => convertBranch(branch, convertOutcomeRule)) : [];
+    return {
+      kind,
+      outcomeIf: convertBranch(record["outcomeIf"], convertOutcomeRule),
+      ...elseIfs.length ? { outcomeElseIfs: elseIfs } : {},
+      ...isRecord(record["outcomeElse"]) ? {
+        outcomeElse: {
+          rules: (Array.isArray(record["outcomeElse"]["actions"]) ? record["outcomeElse"]["actions"] : []).map(convertOutcomeRule)
+        }
+      } : {}
+    };
+  }
+  if (kind === "outcomeProcessingFragment") {
+    return { kind, rules: (Array.isArray(record["rules"]) ? record["rules"] : []).map(convertOutcomeRule) };
+  }
+  return {
+    kind,
+    ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
+    ...record["expression"] !== undefined ? { expression: convertExpression(record["expression"]) } : {}
+  };
+}
+function sessionControlAndTimeLimits(record) {
+  return {
+    ...isRecord(record["itemSessionControl"]) ? { itemSessionControl: record["itemSessionControl"] } : {},
+    ...isRecord(record["timeLimits"]) ? { timeLimits: record["timeLimits"] } : {}
+  };
+}
+function convertItemRef(ref) {
+  return {
+    kind: "assessmentItemRef",
+    identifier: typeof ref["identifier"] === "string" ? ref["identifier"] : "",
+    ...typeof ref["href"] === "string" ? { href: ref["href"] } : {},
+    ...Array.isArray(ref["category"]) ? { categories: ref["category"] } : {},
+    ...typeof ref["fixed"] === "boolean" ? { fixed: ref["fixed"] } : {},
+    ...typeof ref["required"] === "boolean" ? { required: ref["required"] } : {},
+    ...ref["preConditions"] !== undefined ? { preConditions: convertPreConditions(ref["preConditions"]) } : {},
+    ...ref["branchRules"] !== undefined ? { branchRules: convertBranchRules(ref["branchRules"]) } : {},
+    ...Array.isArray(ref["weights"]) ? { weights: ref["weights"] } : {},
+    ...Array.isArray(ref["templateDefaults"]) ? {
+      templateDefaults: asRecords(ref["templateDefaults"]).map((entry) => ({
+        templateIdentifier: typeof entry["templateIdentifier"] === "string" ? entry["templateIdentifier"] : "",
+        expression: convertExpression(entry["expression"])
+      }))
+    } : {},
+    ...sessionControlAndTimeLimits(ref)
+  };
+}
+function convertSection(section) {
+  const children = asRecords(section["children"]).map((child) => child["visible"] !== undefined || child["children"] !== undefined ? convertSection(child) : convertItemRef(child));
+  return {
+    kind: "assessmentSection",
+    identifier: typeof section["identifier"] === "string" ? section["identifier"] : "",
+    ...typeof section["title"] === "string" ? { title: section["title"] } : {},
+    ...typeof section["visible"] === "boolean" ? { visible: section["visible"] } : {},
+    ...typeof section["fixed"] === "boolean" ? { fixed: section["fixed"] } : {},
+    ...typeof section["required"] === "boolean" ? { required: section["required"] } : {},
+    ...typeof section["keepTogether"] === "boolean" ? { keepTogether: section["keepTogether"] } : {},
+    ...isRecord(section["selection"]) ? { selection: section["selection"] } : {},
+    ...isRecord(section["ordering"]) ? { ordering: section["ordering"] } : {},
+    ...section["preConditions"] !== undefined ? { preConditions: convertPreConditions(section["preConditions"]) } : {},
+    ...section["branchRules"] !== undefined ? { branchRules: convertBranchRules(section["branchRules"]) } : {},
+    ...sessionControlAndTimeLimits(section),
+    children
+  };
+}
+function convertTestFeedback(feedback) {
+  const converted = convertContentValue(feedback);
+  return {
+    outcomeIdentifier: typeof converted["outcomeIdentifier"] === "string" ? converted["outcomeIdentifier"] : "",
+    identifier: typeof converted["identifier"] === "string" ? converted["identifier"] : "",
+    ...converted["access"] === "atEnd" || converted["access"] === "during" ? { access: converted["access"] } : {},
+    ...converted["showHide"] === "show" || converted["showHide"] === "hide" ? { showHide: converted["showHide"] } : {},
+    ...Array.isArray(converted["content"]) ? { content: converted["content"] } : {}
+  };
+}
+function assessmentTestViewFromNormalized(document) {
+  if (!isRecord(document) || !isRecord(document["assessmentTest"])) {
+    return null;
+  }
+  const testDocument = document["assessmentTest"];
+  const outcomeRules = isRecord(testDocument["outcomeProcessing"]) ? testDocument["outcomeProcessing"]["rules"] : undefined;
+  const testParts = asRecords(testDocument["testParts"]).map((part) => ({
+    identifier: typeof part["identifier"] === "string" ? part["identifier"] : "",
+    navigationMode: part["navigationMode"] === "nonlinear" ? "nonlinear" : "linear",
+    submissionMode: part["submissionMode"] === "simultaneous" ? "simultaneous" : "individual",
+    ...part["preConditions"] !== undefined ? { preConditions: convertPreConditions(part["preConditions"]) } : {},
+    ...part["branchRules"] !== undefined ? { branchRules: convertBranchRules(part["branchRules"]) } : {},
+    ...sessionControlAndTimeLimits(part),
+    assessmentSections: asRecords(part["children"]).map(convertSection)
+  }));
+  return {
+    identifier: typeof testDocument["identifier"] === "string" ? testDocument["identifier"] : "",
+    ...typeof testDocument["title"] === "string" ? { title: testDocument["title"] } : {},
+    outcomeDeclarations: testDocument["outcomeDeclarations"] ?? [],
+    ...isRecord(testDocument["timeLimits"]) ? { timeLimits: testDocument["timeLimits"] } : {},
+    testParts,
+    ...Array.isArray(outcomeRules) ? { outcomeProcessing: { rules: outcomeRules.map(convertOutcomeRule) } } : {},
+    ...Array.isArray(testDocument["testFeedbacks"]) ? { testFeedbacks: asRecords(testDocument["testFeedbacks"]).map(convertTestFeedback) } : {}
+  };
+}
+// src/content-model.ts
+var v0InteractionKinds = [
+  "associateInteraction",
+  "choiceInteraction",
+  "drawingInteraction",
+  "endAttemptInteraction",
+  "extendedTextInteraction",
+  "gapMatchInteraction",
+  "graphicAssociateInteraction",
+  "graphicGapMatchInteraction",
+  "graphicOrderInteraction",
+  "hotspotInteraction",
+  "hottextInteraction",
+  "inlineChoiceInteraction",
+  "matchInteraction",
+  "mediaInteraction",
+  "orderInteraction",
+  "positionObjectStage",
+  "selectPointInteraction",
+  "sliderInteraction",
+  "textEntryInteraction",
+  "uploadInteraction"
+];
+var v0FlowElements = new Set([
+  "p",
+  "span",
+  "strong",
+  "em",
+  "b",
+  "i",
+  "sub",
+  "sup",
+  "br",
+  "ul",
+  "ol",
+  "li",
+  "ruby",
+  "rb",
+  "rt",
+  "rp",
+  "rtc",
+  "bdo",
+  "bdi",
+  "img",
+  "audio",
+  "video",
+  "source",
+  "track",
+  "picture",
+  "figure",
+  "figcaption",
+  "object",
+  "div",
+  "section",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "hr",
+  "table",
+  "caption",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "a",
+  "abbr",
+  "acronym",
+  "address",
+  "article",
+  "aside",
+  "big",
+  "code",
+  "details",
+  "summary",
+  "dfn",
+  "dl",
+  "dt",
+  "dd",
+  "kbd",
+  "label",
+  "nav",
+  "pre",
+  "q",
+  "samp",
+  "small",
+  "tt",
+  "var",
+  "footer",
+  "header"
+]);
+var v0ElementAttributes = new Map([
+  ["a", new Set(["href", "type"])],
+  ["img", new Set(["src", "alt", "width", "height"])],
+  ["audio", new Set(["src", "controls", "loop", "muted", "preload"])],
+  ["video", new Set(["src", "controls", "loop", "muted", "preload", "poster", "width", "height"])],
+  ["source", new Set(["src", "type"])],
+  ["track", new Set(["src", "kind", "srclang", "label", "default"])],
+  ["object", new Set(["data", "type", "width", "height"])]
+]);
+var v0UrlAttributes = new Set(["src", "poster", "data", "href"]);
+var v0MathRoot = "math";
+var v0GlobalAttributes = new Set(["id", "class", "lang", "xml:lang", "dir"]);
+var v0ContentModel = {
+  interactionKinds: new Set(v0InteractionKinds),
+  flowElements: v0FlowElements,
+  mathRoot: v0MathRoot,
+  globalAttributes: v0GlobalAttributes,
+  elementAttributes: v0ElementAttributes,
+  urlAttributes: v0UrlAttributes
+};
+function isAllowedFlowElement(model, name) {
+  return model.flowElements.has(name) || name === model.mathRoot;
+}
+function isInteractionKind(model, kind) {
+  return model.interactionKinds.has(kind);
+}
+function isUnsafeAttribute(name, value) {
+  const lowerName = name.toLowerCase();
+  if (lowerName.startsWith("on")) {
+    return true;
+  }
+  if (typeof value === "string" && /^\s*javascript:/iu.test(value)) {
+    return true;
+  }
+  return false;
+}
+function sanitizeAttributes(model, elementName, attributes) {
+  const safe = {};
+  if (!attributes) {
+    return safe;
+  }
+  const elementAllowed = model.elementAttributes.get(elementName);
+  for (const [name, value] of Object.entries(attributes)) {
+    if (isUnsafeAttribute(name, value)) {
+      continue;
+    }
+    const ariaOrData = name === "role" || name.startsWith("aria-") || name.startsWith("data-");
+    if (!ariaOrData && !model.globalAttributes.has(name) && !elementAllowed?.has(name)) {
+      continue;
+    }
+    if (typeof value === "string") {
+      safe[name] = value;
+    }
+  }
+  return safe;
+}
+function sanitizeMathAttributes(attributes) {
+  const safe = {};
+  if (!attributes) {
+    return safe;
+  }
+  for (const [name, value] of Object.entries(attributes)) {
+    if (!isUnsafeAttribute(name, value) && typeof value === "string") {
+      safe[name] = value;
+    }
+  }
+  return safe;
+}
+
+// ../../node_modules/.bun/whynot@5.0.0/node_modules/whynot/dist/whynot.esm.js
+function t(t2, s, r, i) {
+  const n = { op: s, func: r, data: i };
+  return t2.push(n), n;
+}
+function s(t2, s2) {
+  return t2;
+}
+
+class r {
+  constructor() {
+    this.program = [];
+  }
+  test(s2, r2) {
+    return t(this.program, 5, s2, r2 === undefined ? null : r2);
+  }
+  jump(s2) {
+    return t(this.program, 3, null, s2);
+  }
+  record(r2, i) {
+    return t(this.program, 4, i === undefined ? s : i, r2);
+  }
+  bad(s2 = 1) {
+    return t(this.program, 1, null, s2);
+  }
+  accept() {
+    return t(this.program, 0, null, null);
+  }
+  fail(s2) {
+    return t(this.program, 2, s2 || null, null);
+  }
+}
+
+class i {
+  constructor(t2, s2, r2) {
+    this.programLength = t2, this.maxFromByPc = s2, this.maxSurvivorFromByPc = r2;
+  }
+  static fromProgram(t2) {
+    const s2 = t2.length, r2 = [], n = [];
+    return t2.forEach((t3) => {
+      r2.push(0), n.push(0);
+    }), t2.forEach((t3, i2) => {
+      switch (t3.op) {
+        case 2:
+          if (t3.func === null)
+            return;
+          if (i2 + 1 >= s2)
+            throw new Error("Invalid program: program could run past end");
+          r2[i2 + 1] += 1;
+          break;
+        case 1:
+        case 4:
+          if (i2 + 1 >= s2)
+            throw new Error("Invalid program: program could run past end");
+          r2[i2 + 1] += 1;
+          break;
+        case 3:
+          t3.data.forEach((t4) => {
+            if (t4 < 0 || t4 >= s2)
+              throw new Error("Invalid program: program could run past end");
+            r2[t4] += 1;
+          });
+          break;
+        case 5:
+          if (i2 + 1 >= s2)
+            throw new Error("Invalid program: program could run past end");
+          n[i2 + 1] += 1;
+          break;
+        case 0:
+          n[i2] += 1;
+      }
+    }), new i(s2, r2, n);
+  }
+  static createStub(t2) {
+    const s2 = [], r2 = [];
+    for (let i2 = 0;i2 < t2; ++i2)
+      s2.push(t2), r2.push(t2);
+    return new i(t2, s2, r2);
+  }
+}
+
+class n {
+  constructor(t2) {
+    this.acceptingTraces = t2, this.success = t2.length > 0;
+  }
+}
+
+class h {
+  constructor(t2) {
+    this.t = 0, this.i = 0, this.h = new Uint16Array(t2), this.l = new Uint8Array(t2);
+  }
+  getBadness(t2) {
+    return this.l[t2];
+  }
+  add(t2, s2) {
+    this.l[t2] = s2 > 255 ? 255 : s2;
+    const r2 = function(t3, s3, r3, i2, n2) {
+      let h2 = i2, e = n2;
+      for (;h2 < e; ) {
+        const i3 = h2 + e >>> 1;
+        r3 < s3[t3[i3]] ? e = i3 : h2 = i3 + 1;
+      }
+      return h2;
+    }(this.h, this.l, s2, this.i, this.t);
+    this.h.copyWithin(r2 + 1, r2, this.t), this.h[r2] = t2, this.t += 1;
+  }
+  reschedule(t2, s2) {
+    const r2 = Math.max(this.l[t2], s2 > 255 ? 255 : s2);
+    if (this.l[t2] !== r2) {
+      const s3 = this.h.indexOf(t2, this.i);
+      if (s3 < 0 || s3 >= this.t)
+        return void (this.l[t2] = r2);
+      this.h.copyWithin(s3, s3 + 1, this.t), this.t -= 1, this.add(t2, r2);
+    }
+  }
+  getNextPc() {
+    return this.i >= this.t ? null : this.h[this.i++];
+  }
+  reset() {
+    this.t = 0, this.i = 0, this.l.fill(0);
+  }
+}
+
+class e {
+  constructor(t2) {
+    this.o = [];
+    let s2 = t2.length;
+    t2.forEach((t3) => {
+      this.o.push(t3 > 0 ? s2 : -1), s2 += t3;
+    }), this.u = new Uint16Array(s2);
+  }
+  clear() {
+    this.u.fill(0, 0, this.o.length);
+  }
+  add(t2, s2) {
+    const r2 = this.u[s2], i2 = this.o[s2];
+    this.u[s2] += 1, this.u[i2 + r2] = t2;
+  }
+  has(t2) {
+    return this.u[t2] > 0;
+  }
+  forEach(t2, s2) {
+    const r2 = this.u[t2], i2 = this.o[t2];
+    for (let t3 = i2;t3 < i2 + r2; ++t3)
+      s2(this.u[t3]);
+  }
+}
+function l(t2, s2, r2 = false) {
+  return t2 === null ? s2 : Array.isArray(t2) ? (t2.indexOf(s2) === -1 && (r2 && (t2 = t2.slice()), t2.push(s2)), t2) : t2 === s2 ? t2 : [t2, s2];
+}
+
+class c {
+  constructor(t2, s2) {
+    this.prefixes = t2, this.record = s2;
+  }
+}
+function o(t2, s2) {
+  let r2;
+  if (s2 === null) {
+    if (!Array.isArray(t2))
+      return t2;
+    r2 = t2;
+  } else
+    r2 = t2 === c.EMPTY ? [] : Array.isArray(t2) ? t2 : [t2];
+  return new c(r2, s2);
+}
+c.EMPTY = new c([], null);
+
+class u {
+  constructor(t2) {
+    this.p = [], this.v = [];
+    for (let s2 = 0;s2 < t2; ++s2)
+      this.p.push(0), this.v.push(null);
+  }
+  mergeTraces(t2, s2, r2, i2, n2, h2) {
+    let e2 = false;
+    return r2.forEach(s2, (s3) => {
+      const r3 = this.trace(s3, i2, n2, h2);
+      var c2, o2, u2;
+      o2 = r3, u2 = e2, t2 = (c2 = t2) === null ? o2 : o2 === null ? c2 : Array.isArray(o2) ? o2.reduce((t3, s4) => l(t3, s4, t3 === o2), c2) : l(c2, o2, u2), e2 = t2 === r3;
+    }), t2;
+  }
+  trace(t2, s2, r2, i2) {
+    switch (this.p[t2]) {
+      case 2:
+        return this.v[t2];
+      case 1:
+        return null;
+    }
+    this.p[t2] = 1;
+    let n2 = null;
+    const h2 = s2[t2];
+    if (h2 !== null)
+      n2 = h2;
+    else if (!r2.has(t2))
+      throw new Error("Trace without source at pc " + t2);
+    if (n2 = this.mergeTraces(n2, t2, r2, s2, r2, i2), n2 !== null) {
+      const s3 = i2[t2];
+      s3 !== null && (n2 = o(n2, s3));
+    }
+    return this.v[t2] = n2, this.p[t2] = 2, n2;
+  }
+  buildSurvivorTraces(t2, s2, r2, i2, n2) {
+    for (let h2 = 0, e2 = t2.length;h2 < e2; ++h2) {
+      if (!r2.has(h2)) {
+        s2[h2] = null;
+        continue;
+      }
+      this.v.fill(null), this.p.fill(0);
+      const e3 = this.mergeTraces(null, h2, r2, t2, i2, n2);
+      if (e3 === null)
+        throw new Error("No non-cyclic paths found to survivor " + h2);
+      s2[h2] = o(e3, null);
+    }
+    this.v.fill(null);
+  }
+}
+
+class a {
+  constructor(t2) {
+    this.g = [], this.k = [], this.m = [], this.A = new e(t2.maxFromByPc), this.T = new e(t2.maxSurvivorFromByPc), this.S = new u(t2.programLength);
+    for (let s2 = 0;s2 < t2.programLength; ++s2)
+      this.g.push(null), this.k.push(null), this.m.push(null);
+    this.k[0] = c.EMPTY;
+  }
+  reset(t2) {
+    this.A.clear(), this.T.clear(), this.g.fill(null), t2 && (this.k.fill(null), this.m.fill(null), this.k[0] = c.EMPTY);
+  }
+  record(t2, s2) {
+    this.g[t2] = s2;
+  }
+  has(t2) {
+    return this.A.has(t2) || this.k[t2] !== null;
+  }
+  add(t2, s2) {
+    this.A.add(t2, s2);
+  }
+  hasSurvivor(t2) {
+    return this.T.has(t2);
+  }
+  addSurvivor(t2, s2) {
+    this.T.add(t2, s2);
+  }
+  buildSurvivorTraces() {
+    const t2 = this.k;
+    this.S.buildSurvivorTraces(t2, this.m, this.T, this.A, this.g), this.k = this.m, this.m = t2;
+  }
+  getTraces(t2) {
+    const s2 = t2.reduce((t3, s3) => l(t3, this.k[s3]), null);
+    return s2 === null ? [] : Array.isArray(s2) ? s2 : [s2];
+  }
+}
+
+class f {
+  constructor(t2) {
+    this.I = [], this.N = new h(t2.programLength), this.M = new h(t2.programLength), this.P = new a(t2);
+  }
+  reset() {
+    this.N.reset(), this.N.add(0, 0), this.I.length = 0, this.P.reset(true);
+  }
+  getNextThreadPc() {
+    return this.N.getNextPc();
+  }
+  step(t2, s2, r2) {
+    const i2 = this.P.has(s2);
+    this.P.add(t2, s2);
+    const n2 = this.N.getBadness(t2) + r2;
+    i2 ? this.N.reschedule(s2, n2) : this.N.add(s2, n2);
+  }
+  stepToNextGeneration(t2, s2) {
+    const r2 = this.P.hasSurvivor(s2);
+    this.P.addSurvivor(t2, s2);
+    const i2 = this.N.getBadness(t2);
+    r2 ? this.M.reschedule(s2, i2) : this.M.add(s2, i2);
+  }
+  accept(t2) {
+    this.I.push(t2), this.P.addSurvivor(t2, t2);
+  }
+  fail(t2) {}
+  record(t2, s2) {
+    this.P.record(t2, s2);
+  }
+  nextGeneration() {
+    this.P.buildSurvivorTraces(), this.P.reset(false);
+    const t2 = this.N;
+    t2.reset(), this.N = this.M, this.M = t2;
+  }
+  getAcceptingTraces() {
+    return this.P.getTraces(this.I);
+  }
+}
+
+class d {
+  constructor(t2) {
+    this.U = [], this.G = t2, this.V = i.fromProgram(t2), this.U.push(new f(this.V));
+  }
+  execute(t2, s2) {
+    const r2 = this.U.pop() || new f(this.V);
+    r2.reset();
+    const i2 = t2.length;
+    let h2, e2 = -1;
+    do {
+      let n2 = r2.getNextThreadPc();
+      if (n2 === null)
+        break;
+      for (++e2, h2 = e2 >= i2 ? null : t2[e2];n2 !== null; ) {
+        const t3 = this.G[n2];
+        switch (t3.op) {
+          case 0:
+            h2 === null ? r2.accept(n2) : r2.fail(n2);
+            break;
+          case 2: {
+            const i3 = t3.func;
+            if (i3 === null || i3(s2)) {
+              r2.fail(n2);
+              break;
+            }
+            r2.step(n2, n2 + 1, 0);
+            break;
+          }
+          case 1:
+            r2.step(n2, n2 + 1, t3.data);
+            break;
+          case 5:
+            if (h2 === null) {
+              r2.fail(n2);
+              break;
+            }
+            if (!(0, t3.func)(h2, t3.data, s2)) {
+              r2.fail(n2);
+              break;
+            }
+            r2.stepToNextGeneration(n2, n2 + 1);
+            break;
+          case 3: {
+            const s3 = t3.data, i3 = s3.length;
+            if (i3 === 0) {
+              r2.fail(n2);
+              break;
+            }
+            for (let t4 = 0;t4 < i3; ++t4)
+              r2.step(n2, s3[t4], 0);
+            break;
+          }
+          case 4: {
+            const i3 = (0, t3.func)(t3.data, e2, s2);
+            i3 != null && r2.record(n2, i3), r2.step(n2, n2 + 1, 0);
+            break;
+          }
+        }
+        n2 = r2.getNextThreadPc();
+      }
+      r2.nextGeneration();
+    } while (h2 !== null);
+    const l2 = new n(r2.getAcceptingTraces());
+    return r2.reset(), this.U.push(r2), l2;
+  }
+}
+function w(t2) {
+  const s2 = new r;
+  return t2(s2), new d(s2.program);
+}
+
+// ../../node_modules/.bun/xspattern@3.1.0/node_modules/xspattern/dist/xspattern.esm.js
+function B(A) {
+  return (B2) => B2 === A;
+}
+function a2(A, B2) {
+  if (A === null || B2 === null)
+    throw new Error("unescaped hyphen may not be used as a range endpoint");
+  if (B2 < A)
+    throw new Error("character range is in the wrong order");
+  return (a3) => A <= a3 && a3 <= B2;
+}
+function n2(A) {
+  return true;
+}
+function e2() {
+  return false;
+}
+function t2(A, B2) {
+  return (a3) => A(a3) || B2(a3);
+}
+function G(A, B2) {
+  switch (B2.kind) {
+    case "predicate":
+      return void A.test(B2.value);
+    case "regexp":
+      return void r2(A, B2.value, false);
+  }
+}
+function i2(A, B2) {
+  B2.forEach((B3) => {
+    (function(A2, B4) {
+      const [a3, { min: n3, max: e3 }] = B4;
+      if (e3 !== null) {
+        for (let B5 = 0;B5 < n3; ++B5)
+          G(A2, a3);
+        for (let B5 = n3;B5 < e3; ++B5) {
+          const B6 = A2.jump([]);
+          B6.data.push(A2.program.length), G(A2, a3), B6.data.push(A2.program.length);
+        }
+      } else if (n3 > 0) {
+        for (let B6 = 0;B6 < n3 - 1; ++B6)
+          G(A2, a3);
+        const B5 = A2.program.length;
+        G(A2, a3), A2.jump([B5]).data.push(A2.program.length);
+      } else {
+        const B5 = A2.program.length, n4 = A2.jump([]);
+        n4.data.push(A2.program.length), G(A2, a3), A2.jump([B5]), n4.data.push(A2.program.length);
+      }
+    })(A, B3);
+  });
+}
+function r2(A, B2, a3) {
+  const n3 = A.program.length, e3 = A.jump([]);
+  a3 && (e3.data.push(A.program.length), A.test(() => true), A.jump([n3]));
+  const t3 = [];
+  if (B2.forEach((B3) => {
+    e3.data.push(A.program.length), i2(A, B3), t3.push(A.jump([]));
+  }), t3.forEach((B3) => {
+    B3.data.push(A.program.length);
+  }), a3) {
+    const B3 = A.program.length, a4 = A.jump([]);
+    a4.data.push(A.program.length), A.test(() => true), A.jump([B3]), a4.data.push(A.program.length);
+  }
+}
+function o2(A, B2) {
+  return { success: true, offset: A, value: B2 };
+}
+function l2(A) {
+  return o2(A, undefined);
+}
+function H(A, B2, a3 = false) {
+  return { success: false, offset: A, expected: B2, fatal: a3 };
+}
+function C(A) {
+  return (B2, a3) => {
+    const n3 = a3 + A.length;
+    return B2.slice(a3, n3) === A ? o2(n3, A) : H(a3, [A]);
+  };
+}
+function u2(A, B2) {
+  return (a3, n3) => {
+    const e3 = A(a3, n3);
+    return e3.success ? o2(e3.offset, B2(e3.value)) : e3;
+  };
+}
+function s2(A, B2, a3, n3) {
+  return (e3, t3) => {
+    const G2 = A(e3, t3);
+    return G2.success ? B2(G2.value) ? G2 : H(t3, a3, n3) : G2;
+  };
+}
+function c2(A, B2) {
+  return (a3, n3) => {
+    let e3 = null;
+    for (const t3 of A) {
+      const A2 = t3(a3, n3);
+      if (A2.success)
+        return A2;
+      if (e3 === null || A2.offset > e3.offset ? e3 = A2 : A2.offset === e3.offset && B2 === undefined && (e3.expected = e3.expected.concat(A2.expected)), A2.fatal)
+        return A2;
+    }
+    return B2 = B2 || (e3 == null ? undefined : e3.expected) || [], e3 && (e3.expected = B2), e3 || H(n3, B2);
+  };
+}
+function D(A) {
+  return (B2, a3) => {
+    const n3 = A(B2, a3);
+    return n3.success || n3.fatal ? n3 : o2(a3, null);
+  };
+}
+function m(A) {
+  return (B2, a3) => {
+    let n3 = [], e3 = a3;
+    for (;; ) {
+      const a4 = A(B2, e3);
+      if (!a4.success) {
+        if (a4.fatal)
+          return a4;
+        break;
+      }
+      if (n3.push(a4.value), a4.offset === e3)
+        break;
+      e3 = a4.offset;
+    }
+    return o2(e3, n3);
+  };
+}
+function I(A, B2, a3) {
+  return (n3, e3) => {
+    const t3 = A(n3, e3);
+    if (!t3.success)
+      return t3;
+    const G2 = B2(n3, t3.offset);
+    return G2.success ? o2(G2.offset, a3(t3.value, G2.value)) : G2;
+  };
+}
+function d2(A) {
+  return I(A, m(A), (A2, B2) => [A2].concat(B2));
+}
+function h2(A, B2) {
+  return A;
+}
+function p(A, B2) {
+  return B2;
+}
+function T(A, B2) {
+  return I(A, B2, p);
+}
+function F(A, B2) {
+  return I(A, B2, h2);
+}
+function E(A, B2, a3, n3 = false) {
+  return T(A, n3 ? f2(F(B2, a3)) : F(B2, a3));
+}
+function g(A, B2) {
+  return (a3, n3) => A(a3, n3).success ? H(n3, B2) : l2(n3);
+}
+function f2(A) {
+  return (B2, a3) => {
+    const n3 = A(B2, a3);
+    return n3.success ? n3 : H(n3.offset, n3.expected, true);
+  };
+}
+var P = (A, B2) => A.length === B2 ? l2(B2) : H(B2, ["end of input"]);
+var M = ["Lu", "Ll", "Lt", "Lm", "Lo", "Mn", "Mc", "Me", "Nd", "Nl", "No", "Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po", "Zs", "Zl", "Zp", "Sm", "Sc", "Sk", "So", "Cc", "Cf", "Co", "Cn"];
+var J = {};
+function S(A) {
+  return A.codePointAt(0);
+}
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("").forEach((A, B2) => {
+  J[A] = B2;
+});
+var K = (A) => A === -1 || A === -2;
+function b(A) {
+  return (B2) => !K(B2) && !A(B2);
+}
+function y(A, B2) {
+  return B2 === null ? A : (a3) => A(a3) && !B2(a3);
+}
+var Q = function(A, B2) {
+  const n3 = new Map;
+  let e3 = 0;
+  return A.forEach((A2, G2) => {
+    const i3 = B2[G2];
+    A2 !== null && A2.split("|").forEach((A3) => {
+      const B3 = n3.get(A3), G3 = a2(e3, e3 + i3 - 1);
+      n3.set(A3, B3 ? t2(B3, G3) : G3);
+    }), e3 += i3;
+  }), n3;
+}(["BasicLatin", "Latin-1Supplement", "LatinExtended-A", "LatinExtended-B", "IPAExtensions", "SpacingModifierLetters", "CombiningDiacriticalMarks", "GreekandCoptic|Greek", "Cyrillic", "CyrillicSupplement", "Armenian", "Hebrew", "Arabic", "Syriac", "ArabicSupplement", "Thaana", "NKo", "Samaritan", "Mandaic", "SyriacSupplement", "ArabicExtended-B", "ArabicExtended-A", "Devanagari", "Bengali", "Gurmukhi", "Gujarati", "Oriya", "Tamil", "Telugu", "Kannada", "Malayalam", "Sinhala", "Thai", "Lao", "Tibetan", "Myanmar", "Georgian", "HangulJamo", "Ethiopic", "EthiopicSupplement", "Cherokee", "UnifiedCanadianAboriginalSyllabics", "Ogham", "Runic", "Tagalog", "Hanunoo", "Buhid", "Tagbanwa", "Khmer", "Mongolian", "UnifiedCanadianAboriginalSyllabicsExtended", "Limbu", "TaiLe", "NewTaiLue", "KhmerSymbols", "Buginese", "TaiTham", "CombiningDiacriticalMarksExtended", "Balinese", "Sundanese", "Batak", "Lepcha", "OlChiki", "CyrillicExtended-C", "GeorgianExtended", "SundaneseSupplement", "VedicExtensions", "PhoneticExtensions", "PhoneticExtensionsSupplement", "CombiningDiacriticalMarksSupplement", "LatinExtendedAdditional", "GreekExtended", "GeneralPunctuation", "SuperscriptsandSubscripts", "CurrencySymbols", "CombiningDiacriticalMarksforSymbols|CombiningMarksforSymbols", "LetterlikeSymbols", "NumberForms", "Arrows", "MathematicalOperators", "MiscellaneousTechnical", "ControlPictures", "OpticalCharacterRecognition", "EnclosedAlphanumerics", "BoxDrawing", "BlockElements", "GeometricShapes", "MiscellaneousSymbols", "Dingbats", "MiscellaneousMathematicalSymbols-A", "SupplementalArrows-A", "BraillePatterns", "SupplementalArrows-B", "MiscellaneousMathematicalSymbols-B", "SupplementalMathematicalOperators", "MiscellaneousSymbolsandArrows", "Glagolitic", "LatinExtended-C", "Coptic", "GeorgianSupplement", "Tifinagh", "EthiopicExtended", "CyrillicExtended-A", "SupplementalPunctuation", "CJKRadicalsSupplement", "KangxiRadicals", null, "IdeographicDescriptionCharacters", "CJKSymbolsandPunctuation", "Hiragana", "Katakana", "Bopomofo", "HangulCompatibilityJamo", "Kanbun", "BopomofoExtended", "CJKStrokes", "KatakanaPhoneticExtensions", "EnclosedCJKLettersandMonths", "CJKCompatibility", "CJKUnifiedIdeographsExtensionA", "YijingHexagramSymbols", "CJKUnifiedIdeographs", "YiSyllables", "YiRadicals", "Lisu", "Vai", "CyrillicExtended-B", "Bamum", "ModifierToneLetters", "LatinExtended-D", "SylotiNagri", "CommonIndicNumberForms", "Phags-pa", "Saurashtra", "DevanagariExtended", "KayahLi", "Rejang", "HangulJamoExtended-A", "Javanese", "MyanmarExtended-B", "Cham", "MyanmarExtended-A", "TaiViet", "MeeteiMayekExtensions", "EthiopicExtended-A", "LatinExtended-E", "CherokeeSupplement", "MeeteiMayek", "HangulSyllables", "HangulJamoExtended-B", "HighSurrogates", "HighPrivateUseSurrogates", "LowSurrogates", "PrivateUseArea|PrivateUse", "CJKCompatibilityIdeographs", "AlphabeticPresentationForms", "ArabicPresentationForms-A", "VariationSelectors", "VerticalForms", "CombiningHalfMarks", "CJKCompatibilityForms", "SmallFormVariants", "ArabicPresentationForms-B", "HalfwidthandFullwidthForms", "Specials", "LinearBSyllabary", "LinearBIdeograms", "AegeanNumbers", "AncientGreekNumbers", "AncientSymbols", "PhaistosDisc", null, "Lycian", "Carian", "CopticEpactNumbers", "OldItalic", "Gothic", "OldPermic", "Ugaritic", "OldPersian", null, "Deseret", "Shavian", "Osmanya", "Osage", "Elbasan", "CaucasianAlbanian", "Vithkuqi", null, "LinearA", "LatinExtended-F", null, "CypriotSyllabary", "ImperialAramaic", "Palmyrene", "Nabataean", null, "Hatran", "Phoenician", "Lydian", null, "MeroiticHieroglyphs", "MeroiticCursive", "Kharoshthi", "OldSouthArabian", "OldNorthArabian", null, "Manichaean", "Avestan", "InscriptionalParthian", "InscriptionalPahlavi", "PsalterPahlavi", null, "OldTurkic", null, "OldHungarian", "HanifiRohingya", null, "RumiNumeralSymbols", "Yezidi", "ArabicExtended-C", "OldSogdian", "Sogdian", "OldUyghur", "Chorasmian", "Elymaic", "Brahmi", "Kaithi", "SoraSompeng", "Chakma", "Mahajani", "Sharada", "SinhalaArchaicNumbers", "Khojki", null, "Multani", "Khudawadi", "Grantha", null, "Newa", "Tirhuta", null, "Siddham", "Modi", "MongolianSupplement", "Takri", null, "Ahom", null, "Dogra", null, "WarangCiti", "DivesAkuru", null, "Nandinagari", "ZanabazarSquare", "Soyombo", "UnifiedCanadianAboriginalSyllabicsExtended-A", "PauCinHau", "DevanagariExtended-A", null, "Bhaiksuki", "Marchen", null, "MasaramGondi", "GunjalaGondi", null, "Makasar", "Kawi", null, "LisuSupplement", "TamilSupplement", "Cuneiform", "CuneiformNumbersandPunctuation", "EarlyDynasticCuneiform", null, "Cypro-Minoan", "EgyptianHieroglyphs", "EgyptianHieroglyphFormatControls", null, "AnatolianHieroglyphs", null, "BamumSupplement", "Mro", "Tangsa", "BassaVah", "PahawhHmong", null, "Medefaidrin", null, "Miao", null, "IdeographicSymbolsandPunctuation", "Tangut", "TangutComponents", "KhitanSmallScript", "TangutSupplement", null, "KanaExtended-B", "KanaSupplement", "KanaExtended-A", "SmallKanaExtension", "Nushu", null, "Duployan", "ShorthandFormatControls", null, "ZnamennyMusicalNotation", null, "ByzantineMusicalSymbols", "MusicalSymbols", "AncientGreekMusicalNotation", null, "KaktovikNumerals", "MayanNumerals", "TaiXuanJingSymbols", "CountingRodNumerals", null, "MathematicalAlphanumericSymbols", "SuttonSignWriting", null, "LatinExtended-G", "GlagoliticSupplement", "CyrillicExtended-D", null, "NyiakengPuachueHmong", null, "Toto", "Wancho", null, "NagMundari", null, "EthiopicExtended-B", "MendeKikakui", null, "Adlam", null, "IndicSiyaqNumbers", null, "OttomanSiyaqNumbers", null, "ArabicMathematicalAlphabeticSymbols", null, "MahjongTiles", "DominoTiles", "PlayingCards", "EnclosedAlphanumericSupplement", "EnclosedIdeographicSupplement", "MiscellaneousSymbolsandPictographs", "Emoticons", "OrnamentalDingbats", "TransportandMapSymbols", "AlchemicalSymbols", "GeometricShapesExtended", "SupplementalArrows-C", "SupplementalSymbolsandPictographs", "ChessSymbols", "SymbolsandPictographsExtended-A", "SymbolsforLegacyComputing", null, "CJKUnifiedIdeographsExtensionB", null, "CJKUnifiedIdeographsExtensionC", "CJKUnifiedIdeographsExtensionD", "CJKUnifiedIdeographsExtensionE", "CJKUnifiedIdeographsExtensionF", null, "CJKCompatibilityIdeographsSupplement", null, "CJKUnifiedIdeographsExtensionG", "CJKUnifiedIdeographsExtensionH", null, "Tags", null, "VariationSelectorsSupplement", null, "SupplementaryPrivateUseArea-A|PrivateUse", "SupplementaryPrivateUseArea-B|PrivateUse"], [128, 128, 128, 208, 96, 80, 112, 144, 256, 48, 96, 112, 256, 80, 48, 64, 64, 64, 32, 16, 48, 96, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 256, 160, 96, 256, 384, 32, 96, 640, 32, 96, 32, 32, 32, 32, 128, 176, 80, 80, 48, 96, 32, 32, 144, 80, 128, 64, 64, 80, 48, 16, 48, 16, 48, 128, 64, 64, 256, 256, 112, 48, 48, 48, 80, 64, 112, 256, 256, 64, 32, 160, 128, 32, 96, 256, 192, 48, 16, 256, 128, 128, 256, 256, 96, 32, 128, 48, 80, 96, 32, 128, 128, 224, 16, 16, 64, 96, 96, 48, 96, 16, 32, 48, 16, 256, 256, 6592, 64, 20992, 1168, 64, 48, 320, 96, 96, 32, 224, 48, 16, 64, 96, 32, 48, 48, 32, 96, 32, 96, 32, 96, 32, 48, 64, 80, 64, 11184, 80, 896, 128, 1024, 6400, 512, 80, 688, 16, 16, 16, 32, 32, 144, 240, 16, 128, 128, 64, 80, 64, 48, 128, 32, 64, 32, 48, 32, 48, 32, 64, 32, 80, 48, 48, 80, 48, 64, 80, 64, 384, 64, 64, 64, 32, 32, 48, 48, 32, 32, 32, 64, 32, 96, 96, 32, 32, 32, 64, 64, 32, 32, 48, 80, 80, 48, 128, 64, 288, 32, 64, 64, 48, 64, 64, 48, 32, 128, 80, 48, 80, 48, 96, 32, 80, 48, 48, 80, 128, 128, 128, 96, 160, 128, 96, 32, 80, 48, 80, 176, 80, 80, 96, 96, 64, 96, 80, 96, 16, 64, 96, 160, 112, 80, 64, 96, 80, 304, 32, 96, 80, 16, 64, 1024, 128, 208, 2624, 112, 1072, 48, 4000, 640, 8576, 576, 48, 96, 48, 144, 688, 96, 96, 160, 64, 32, 6144, 768, 512, 128, 8816, 16, 256, 48, 64, 400, 2304, 160, 16, 4688, 208, 48, 256, 256, 80, 112, 32, 32, 96, 32, 128, 1024, 688, 1104, 256, 48, 96, 112, 80, 320, 48, 64, 464, 48, 736, 32, 224, 32, 96, 784, 80, 64, 80, 176, 256, 256, 48, 112, 96, 256, 256, 768, 80, 48, 128, 128, 128, 256, 256, 112, 144, 256, 1024, 42720, 32, 4160, 224, 5776, 7488, 3088, 544, 1504, 4944, 4192, 711760, 128, 128, 240, 65040, 65536, 65536]);
+var x = function(A) {
+  const n3 = new Map, G2 = A.split(""), i3 = M.map(() => []);
+  let r3 = 0, o3 = 0;
+  for (;o3 < G2.length; ) {
+    const A2 = J[G2[o3]], n4 = (31 & A2) - 2;
+    let e3 = 1 + J[G2[o3 + 1]];
+    switch (32 & A2 ? (e3 += J[G2[o3 + 2]] << 6, e3 += J[G2[o3 + 3]] << 12, e3 += J[G2[o3 + 4]] << 18, o3 += 5) : o3 += 2, n4) {
+      case -2: {
+        let A3 = 0;
+        for (let a3 = r3;a3 < r3 + e3; ++a3) {
+          i3[A3].push(B(a3)), A3 = (A3 + 1) % 2;
+        }
+        break;
+      }
+      case -1:
+        break;
+      default: {
+        const A3 = i3[n4];
+        e3 === 1 ? A3.push(B(r3)) : A3.push(a2(r3, r3 + e3 - 1));
+        break;
+      }
+    }
+    r3 += e3;
+  }
+  const l3 = new Map;
+  return M.forEach((A2, B2) => {
+    const a3 = i3[B2].reduce(t2, e2);
+    n3.set(A2, a3);
+    const G3 = A2.charAt(0), r4 = l3.get(G3) || [];
+    l3.set(G3, r4), r4.push(a3);
+  }), l3.forEach((A2, B2) => {
+    n3.set(B2, A2.reduce(t2, e2));
+  }), n3;
+}("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");
+function L(A) {
+  return A === 32 || A === 9 || A === 10 || A === 13;
+}
+var X = [B(S(":")), a2(S("A"), S("Z")), B(S("_")), a2(S("a"), S("z")), a2(192, 214), a2(216, 246), a2(192, 214), a2(216, 246), a2(248, 767), a2(880, 893), a2(895, 8191), a2(8204, 8205), a2(8304, 8591), a2(11264, 12271), a2(12289, 55295), a2(63744, 64975), a2(65008, 65533), a2(65536, 983039)].reduce(t2);
+var Z = [X, B(S("-")), B(S(".")), a2(S("0"), S("9")), B(183), a2(768, 879), a2(8255, 8256)].reduce(t2);
+var O = x.get("Nd");
+var k = b(O);
+var N = y(a2(0, 1114111), [x.get("P"), x.get("Z"), x.get("C")].reduce(t2));
+var v = b(N);
+function w2(A) {
+  return A !== 10 && A !== 13 && !K(A);
+}
+var Y = { s: L, S: b(L), i: X, I: b(X), c: Z, C: b(Z), d: O, D: k, w: N, W: v };
+var U = C("*");
+var j = C("\\");
+var R = C("{");
+var V = C("}");
+var W = C("[");
+var q = C("]");
+var z = C("^");
+var $ = C("$");
+var _ = C(",");
+var AA = C("-");
+var BA = C("(");
+var aA = C(")");
+var nA = C(".");
+var eA = C("|");
+var tA = C("+");
+var GA = C("?");
+var iA = C("-[");
+var rA = S("0");
+function oA(A) {
+  function e3(A2) {
+    return new Set(A2.split("").map((A3) => S(A3)));
+  }
+  function G2(A2, B2) {
+    const a3 = A2.codePointAt(B2);
+    return a3 === undefined ? H(B2, ["any character"]) : o2(B2 + String.fromCodePoint(a3).length, a3);
+  }
+  const i3 = A.language === "xpath" ? T(j, c2([u2(C("n"), () => 10), u2(C("r"), () => 13), u2(C("t"), () => 9), u2(c2([j, eA, nA, AA, z, GA, U, tA, R, V, $, BA, aA, W, q]), (A2) => S(A2))])) : T(j, c2([u2(C("n"), () => 10), u2(C("r"), () => 13), u2(C("t"), () => 9), u2(c2([j, eA, nA, AA, z, GA, U, tA, R, V, BA, aA, W, q]), (A2) => S(A2))]));
+  function r3(A2, B2) {
+    const a3 = e3(B2);
+    return I(C(A2), D(s2(G2, (A3) => a3.has(A3), B2.split(""))), (A3, B3) => function(A4) {
+      const B4 = x.get(A4);
+      if (B4 == null)
+        throw new Error(A4 + " is not a valid unicode category");
+      return B4;
+    }(B3 === null ? A3 : A3 + String.fromCodePoint(B3)));
+  }
+  const l3 = c2([r3("L", "ultmo"), r3("M", "nce"), r3("N", "dlo"), r3("P", "cdseifo"), r3("Z", "slp"), r3("S", "mcko"), r3("C", "cfon")]), p2 = [a2(S("a"), S("z")), a2(S("A"), S("Z")), a2(S("0"), S("9")), B(45)].reduce(t2), M2 = c2([l3, u2(T(C("Is"), function(A2) {
+    return (B2, a3) => {
+      const n3 = A2(B2, a3);
+      return n3.success ? o2(n3.offset, B2.slice(a3, n3.offset)) : n3;
+    };
+  }(d2(s2(G2, p2, ["block identifier"])))), (B2) => function(A2, B3) {
+    const a3 = Q.get(A2);
+    if (a3 === undefined) {
+      if (B3)
+        return n2;
+      throw new Error(`The unicode block identifier "${A2}" is not known.`);
+    }
+    return a3;
+  }(B2, A.language !== "xpath"))]), J2 = E(C("\\p{"), M2, V, true), K2 = u2(E(C("\\P{"), M2, V, true), b), L2 = T(j, u2(c2("sSiIcCdDwW".split("").map((A2) => C(A2))), (A2) => Y[A2])), X2 = u2(nA, () => w2), Z2 = c2([L2, J2, K2]), O2 = e3("\\[]"), k2 = c2([i3, s2(G2, (A2) => !O2.has(A2), ["unescaped character"])]), N2 = c2([u2(AA, () => null), k2]), v2 = I(N2, T(AA, N2), a2);
+  function oA2(A2, B2) {
+    return [A2].concat(B2 || []);
+  }
+  const lA = u2(function(A2) {
+    return (B2, a3) => {
+      const n3 = A2(B2, a3);
+      return n3.success ? o2(a3, n3.value) : n3;
+    };
+  }(c2([q, iA])), () => null), HA = S("-"), CA = c2([u2(F(F(AA, g(W, ["not ["])), lA), () => HA), T(g(AA, ["not -"]), k2)]), uA = c2([I(u2(CA, B), c2([function(A2, B2) {
+    return uA(A2, B2);
+  }, lA]), oA2), I(c2([v2, Z2]), c2([cA, lA]), oA2)]);
+  const sA = c2([I(u2(k2, B), c2([uA, lA]), oA2), I(c2([v2, Z2]), c2([cA, lA]), oA2)]);
+  function cA(A2, B2) {
+    return sA(A2, B2);
+  }
+  const DA = u2(sA, (A2) => A2.reduce(t2)), mA = u2(T(z, DA), b), IA = I(c2([T(g(z, ["not ^"]), DA), mA]), D(T(AA, function(A2, B2) {
+    return dA(A2, B2);
+  })), y), dA = E(W, IA, q, true);
+  const hA = A.language === "xpath" ? c2([u2(i3, B), Z2, dA, X2, u2(z, () => (A2) => A2 === -1), u2($, () => (A2) => A2 === -2)]) : c2([u2(i3, B), Z2, dA, X2]), pA = A.language === "xpath" ? e3(".\\?*+{}()|^$[]") : e3(".\\?*+{}()|[]"), TA = s2(G2, (A2) => !pA.has(A2), ["NormalChar"]), FA = u2(T(j, I(u2(s2(G2, a2(S("1"), S("9")), ["digit"]), (A2) => A2 - rA), m(u2(s2(G2, a2(rA, S("9")), ["digit"]), (A2) => A2 - rA)), (A2, B2) => {
+    B2.reduce((A3, B3) => 10 * A3 + B3, A2);
+  })), (A2) => {
+    throw new Error("Backreferences in XPath patterns are not yet implemented.");
+  }), EA = A.language === "xpath" ? c2([u2(TA, (A2) => ({ kind: "predicate", value: B(A2) })), u2(hA, (A2) => ({ kind: "predicate", value: A2 })), u2(E(BA, T(D(C("?:")), SA), aA, true), (A2) => ({ kind: "regexp", value: A2 })), FA]) : c2([u2(TA, (A2) => ({ kind: "predicate", value: B(A2) })), u2(hA, (A2) => ({ kind: "predicate", value: A2 })), u2(E(BA, SA, aA, true), (A2) => ({ kind: "regexp", value: A2 }))]), gA = u2(d2(u2(s2(G2, a2(rA, S("9")), ["digit"]), (A2) => A2 - rA)), (A2) => A2.reduce((A3, B2) => 10 * A3 + B2)), fA = c2([I(gA, T(_, gA), (A2, B2) => {
+    if (B2 < A2)
+      throw new Error("quantifier range is in the wrong order");
+    return { min: A2, max: B2 };
+  }), I(gA, _, (A2) => ({ min: A2, max: null })), u2(gA, (A2) => ({ min: A2, max: A2 }))]), PA = A.language === "xpath" ? I(c2([u2(GA, () => ({ min: 0, max: 1 })), u2(U, () => ({ min: 0, max: null })), u2(tA, () => ({ min: 1, max: null })), E(R, fA, V, true)]), D(GA), (A2, B2) => A2) : c2([u2(GA, () => ({ min: 0, max: 1 })), u2(U, () => ({ min: 0, max: null })), u2(tA, () => ({ min: 1, max: null })), E(R, fA, V, true)]), MA = m(I(EA, u2(D(PA), (A2) => A2 === null ? { min: 1, max: 1 } : A2), (A2, B2) => [A2, B2])), JA = I(MA, m(T(eA, f2(MA))), (A2, B2) => [A2].concat(B2));
+  function SA(A2, B2) {
+    return JA(A2, B2);
+  }
+  const KA = function(A2) {
+    return I(A2, P, h2);
+  }(JA);
+  return function(A2) {
+    let B2;
+    try {
+      B2 = KA(A2, 0);
+    } catch (B3) {
+      throw new Error(`Error parsing pattern "${A2}": ${B3 instanceof Error ? B3.message : B3}`);
+    }
+    return B2.success ? B2.value : function(A3, B3, a3) {
+      const n3 = a3.map((A4) => `"${A4}"`);
+      throw new Error(`Error parsing pattern "${A3}" at offset ${B3}: expected ${n3.length > 1 ? "one of " + n3.join(", ") : n3[0]} but found "${A3.slice(B3, B3 + 1)}"`);
+    }(A2, B2.offset, B2.expected);
+  };
+}
+function lA(A) {
+  return [...A].map((A2) => A2.codePointAt(0));
+}
+function HA(B2, a3 = { language: "xsd" }) {
+  const n3 = oA(a3)(B2), e3 = w((A) => {
+    r2(A, n3, a3.language === "xpath"), A.accept();
+  });
+  return function(A) {
+    const B3 = a3.language === "xpath" ? [-1, ...lA(A), -2] : lA(A);
+    return e3.execute(B3).success;
+  };
+}
+
+// src/response-processing.ts
+function foldString(value) {
+  return value.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLocaleLowerCase();
+}
+function asList(response) {
+  if (response === null) {
+    return [];
+  }
+  return typeof response === "string" ? [response] : Array.isArray(response) ? [...response] : [];
+}
+function isStringBaseType(declaration) {
+  return declaration.baseType === "string" || declaration.baseType === undefined;
+}
+function pairsEqual(a3, b2, directed) {
+  const [a1, a22] = a3.trim().split(/\s+/u);
+  const [b1, b22] = b2.trim().split(/\s+/u);
+  if (a1 === undefined || a22 === undefined || b1 === undefined || b22 === undefined) {
+    return false;
+  }
+  if (a1 === b1 && a22 === b22) {
+    return true;
+  }
+  return !directed && a1 === b22 && a22 === b1;
+}
+var numericBaseTypes = new Set(["float", "integer"]);
+function makeValueComparator(declaration, normalize) {
+  if (declaration.baseType === "pair") {
+    return (a3, b2) => pairsEqual(a3, b2, false);
+  }
+  if (declaration.baseType === "directedPair") {
+    return (a3, b2) => pairsEqual(a3, b2, true);
+  }
+  if (declaration.baseType !== undefined && numericBaseTypes.has(declaration.baseType)) {
+    return (a3, b2) => a3.trim() !== "" && b2.trim() !== "" && Number(a3) === Number(b2);
+  }
+  if (declaration.baseType === "point") {
+    return (a3, b2) => {
+      const pointA = parsePoint(a3);
+      const pointB = parsePoint(b2);
+      return pointA !== null && pointB !== null && pointA.x === pointB.x && pointA.y === pointB.y;
+    };
+  }
+  if (normalize && isStringBaseType(declaration)) {
+    return (a3, b2) => normalize(a3, declaration) === normalize(b2, declaration);
+  }
+  return (a3, b2) => a3 === b2;
+}
+function matchCorrect(declaration, response, normalize) {
+  const correct = declaration.correctResponse;
+  if (!correct) {
+    return false;
+  }
+  const equals = makeValueComparator(declaration, normalize);
+  const expected = correct.values.map((entry) => entry.value);
+  const actual = asList(response);
+  if (expected.length !== actual.length) {
+    return false;
+  }
+  if (declaration.cardinality === "ordered") {
+    return expected.every((value, index) => equals(value, actual[index] ?? ""));
+  }
+  const remaining = [...actual];
+  for (const value of expected) {
+    const matchIndex = remaining.findIndex((candidate) => equals(candidate, value));
+    if (matchIndex === -1) {
+      return false;
+    }
+    remaining.splice(matchIndex, 1);
+  }
+  return remaining.length === 0;
+}
+function clamp(value, lower, upper) {
+  let result = value;
+  if (lower !== undefined && result < lower) {
+    result = lower;
+  }
+  if (upper !== undefined && result > upper) {
+    result = upper;
+  }
+  return result;
+}
+function mapResponse(declaration, response, normalize) {
+  const mapping = declaration.mapping;
+  if (!mapping) {
+    return 0;
+  }
+  const isPairType = declaration.baseType === "pair" || declaration.baseType === "directedPair";
+  const applyNormalize = normalize && isStringBaseType(declaration) ? normalize : undefined;
+  const defaultValue = mapping.defaultValue ?? 0;
+  let total = 0;
+  for (const member of asList(response)) {
+    const entry = mapping.mapEntries.find((candidate) => {
+      if (isPairType) {
+        return pairsEqual(candidate.mapKey, member, declaration.baseType === "directedPair");
+      }
+      let key = candidate.mapKey;
+      let candidateMember = member;
+      if (candidate.caseSensitive === false) {
+        key = key.toLocaleLowerCase();
+        candidateMember = candidateMember.toLocaleLowerCase();
+      }
+      if (applyNormalize) {
+        key = applyNormalize(key, declaration);
+        candidateMember = applyNormalize(candidateMember, declaration);
+      }
+      return key === candidateMember;
+    });
+    total += entry ? entry.mappedValue : defaultValue;
+  }
+  return clamp(total, mapping.lowerBound, mapping.upperBound);
+}
+function mapResponsePoint(declaration, response) {
+  const areaMapping = declaration.areaMapping;
+  if (!areaMapping) {
+    return 0;
+  }
+  const defaultValue = areaMapping.defaultValue ?? 0;
+  const usedAreas = new Set;
+  let total = 0;
+  for (const member of asList(response)) {
+    const point = parsePoint(member);
+    if (!point) {
+      continue;
+    }
+    const areaIndex = areaMapping.areaMapEntries.findIndex((entry, index) => !usedAreas.has(index) && pointInShape(entry.shape, entry.coords, point));
+    if (areaIndex === -1) {
+      total += defaultValue;
+    } else {
+      usedAreas.add(areaIndex);
+      total += areaMapping.areaMapEntries[areaIndex].mappedValue;
+    }
+  }
+  return clamp(total, areaMapping.lowerBound, areaMapping.upperBound);
+}
+function scoreResponse(declaration, response, normalize) {
+  if (declaration.areaMapping) {
+    const score = mapResponsePoint(declaration, response);
+    const positiveSum = declaration.areaMapping.areaMapEntries.reduce((sum, entry) => sum + Math.max(entry.mappedValue, 0), 0);
+    const maxScore = declaration.areaMapping.upperBound ?? positiveSum;
+    return {
+      identifier: declaration.identifier,
+      score,
+      maxScore,
+      correct: maxScore > 0 && score >= maxScore
+    };
+  }
+  if (declaration.mapping) {
+    const score = mapResponse(declaration, response, normalize);
+    const positiveSum = declaration.mapping.mapEntries.reduce((sum, entry) => sum + Math.max(entry.mappedValue, 0), 0);
+    const maxScore = declaration.mapping.upperBound ?? positiveSum;
+    return {
+      identifier: declaration.identifier,
+      score,
+      maxScore,
+      correct: maxScore > 0 && score >= maxScore
+    };
+  }
+  const correct = matchCorrect(declaration, response, normalize);
+  return {
+    identifier: declaration.identifier,
+    score: correct ? 1 : 0,
+    maxScore: 1,
+    correct
+  };
+}
+
+// src/types.ts
+function isResponseRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/rp/values.ts
+var numericBaseTypes2 = new Set(["float", "integer", "duration"]);
+function isNumericBaseType(baseType) {
+  return baseType !== undefined && numericBaseTypes2.has(baseType);
+}
+function coerceScalar(value, baseType) {
+  if (isNumericBaseType(baseType) && typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  if (baseType === "boolean" && typeof value === "string") {
+    return value === "true";
+  }
+  return value;
+}
+function fieldBaseType(value) {
+  return typeof value === "boolean" ? "boolean" : typeof value === "number" ? "float" : "string";
+}
+function fromResponse(declaration, response) {
+  if (response === null) {
+    return null;
+  }
+  if (isResponseRecord(response)) {
+    const fields = Object.entries(response).flatMap(([name, member]) => member === null ? [] : [{ name, baseType: fieldBaseType(member), value: member }]);
+    return fields.length === 0 ? null : { cardinality: "record", fields, values: fields.map((field) => field.value) };
+  }
+  const raw = typeof response === "string" ? [response] : [...response];
+  if (raw.length === 0) {
+    return null;
+  }
+  return rpValue(declaration.cardinality, raw.map((value) => coerceScalar(value, declaration.baseType)), declaration.baseType);
+}
+function singleNumber(value) {
+  if (value === null || value.values.length !== 1) {
+    return null;
+  }
+  const member = value.values[0];
+  return typeof member === "number" ? member : null;
+}
+function singleBoolean(value) {
+  if (value === null || value.values.length !== 1) {
+    return null;
+  }
+  const member = value.values[0];
+  return typeof member === "boolean" ? member : null;
+}
+function rpValue(cardinality, values, baseType) {
+  return {
+    cardinality,
+    values,
+    ...baseType !== undefined ? { baseType } : {}
+  };
+}
+function booleanValue(value) {
+  return { cardinality: "single", baseType: "boolean", values: [value] };
+}
+function floatValue(value) {
+  return { cardinality: "single", baseType: "float", values: [value] };
+}
+function pairsEqual2(a3, b2, directed) {
+  const [a1, a22] = a3.trim().split(/\s+/u);
+  const [b1, b22] = b2.trim().split(/\s+/u);
+  if (a1 === undefined || a22 === undefined || b1 === undefined || b22 === undefined) {
+    return false;
+  }
+  if (a1 === b1 && a22 === b22) {
+    return true;
+  }
+  return !directed && a1 === b22 && a22 === b1;
+}
+function scalarsEqual(a3, b2, baseType, normalize) {
+  if (baseType === "pair" || baseType === "directedPair") {
+    return typeof a3 === "string" && typeof b2 === "string" && pairsEqual2(a3, b2, baseType === "directedPair");
+  }
+  if (baseType === "point") {
+    if (typeof a3 !== "string" || typeof b2 !== "string") {
+      return false;
+    }
+    const pointA = parsePoint(a3);
+    const pointB = parsePoint(b2);
+    return pointA !== null && pointB !== null && pointA.x === pointB.x && pointA.y === pointB.y;
+  }
+  if (typeof a3 === "number" || typeof b2 === "number") {
+    return Number(a3) === Number(b2);
+  }
+  if (normalize && baseType === "string" && typeof a3 === "string" && typeof b2 === "string") {
+    return normalize(a3) === normalize(b2);
+  }
+  return a3 === b2;
+}
+function valuesMatch(a3, b2, normalize) {
+  const baseType = a3.baseType ?? b2.baseType;
+  if (a3.values.length !== b2.values.length) {
+    return false;
+  }
+  if (a3.cardinality === "ordered" || b2.cardinality === "ordered") {
+    return a3.values.every((value, index) => scalarsEqual(value, b2.values[index], baseType, normalize));
+  }
+  const remaining = [...b2.values];
+  for (const value of a3.values) {
+    const matchIndex = remaining.findIndex((candidate) => scalarsEqual(candidate, value, baseType, normalize));
+    if (matchIndex === -1) {
+      return false;
+    }
+    remaining.splice(matchIndex, 1);
+  }
+  return true;
+}
+function fromFlatValue(value, cardinality, baseType) {
+  if (value === null) {
+    return null;
+  }
+  const values = Array.isArray(value) ? [...value] : [value];
+  if (values.length === 0) {
+    return null;
+  }
+  return rpValue(cardinality, values.map((member) => coerceScalar(member, baseType)), baseType);
+}
+function toOutcomeValue(value) {
+  if (value === null || value.values.length === 0) {
+    return null;
+  }
+  if (value.cardinality === "single") {
+    return value.values[0] ?? null;
+  }
+  return value.values;
+}
+
+// src/rp/evaluate.ts
+var deterministicExpressionKinds = new Set([
+  "and",
+  "anyN",
+  "baseValue",
+  "containerSize",
+  "contains",
+  "correct",
+  "default",
+  "delete",
+  "divide",
+  "durationGte",
+  "durationLt",
+  "equal",
+  "equalRounded",
+  "fieldValue",
+  "gcd",
+  "gt",
+  "gte",
+  "index",
+  "inside",
+  "lcm",
+  "integerDivide",
+  "integerModulus",
+  "integerToFloat",
+  "isNull",
+  "lt",
+  "lte",
+  "mapResponse",
+  "mapResponsePoint",
+  "match",
+  "mathConstant",
+  "mathOperator",
+  "max",
+  "member",
+  "min",
+  "multiple",
+  "not",
+  "null",
+  "or",
+  "ordered",
+  "patternMatch",
+  "power",
+  "product",
+  "repeat",
+  "round",
+  "roundTo",
+  "statsOperator",
+  "stringMatch",
+  "substring",
+  "subtract",
+  "sum",
+  "truncate",
+  "variable"
+]);
+var randomExpressionKinds = new Set(["random", "randomFloat", "randomInteger"]);
+
+class RpUnsupportedError extends Error {
+  kindName;
+  constructor(kindName) {
+    super(`Unsupported response-processing construct: ${kindName}`);
+    this.kindName = kindName;
+  }
+}
+var mathConstants = { pi: Math.PI, e: Math.E };
+var xsdPatternMatchers = new Map;
+function xsdPatternMatcher(pattern) {
+  const cached = xsdPatternMatchers.get(pattern);
+  if (cached !== undefined) {
+    return cached;
+  }
+  let matcher;
+  try {
+    matcher = HA(pattern);
+  } catch {
+    matcher = null;
+  }
+  xsdPatternMatchers.set(pattern, matcher);
+  return matcher;
+}
+var encVariableStringPattern = /^\{[^{}]+\}$/u;
+function applyMathOperator(name, x2, y2) {
+  switch (name) {
+    case "sin":
+      return Math.sin(x2);
+    case "cos":
+      return Math.cos(x2);
+    case "tan":
+      return Math.tan(x2);
+    case "sec":
+      return 1 / Math.cos(x2);
+    case "csc":
+      return 1 / Math.sin(x2);
+    case "cot":
+      return Math.cos(x2) / Math.sin(x2);
+    case "asin":
+      return Math.asin(x2);
+    case "acos":
+      return Math.acos(x2);
+    case "atan":
+      return Math.atan(x2);
+    case "atan2":
+      return Math.atan2(x2, y2);
+    case "asec":
+      return Math.acos(1 / x2);
+    case "acsc":
+      return Math.asin(1 / x2);
+    case "acot":
+      return Math.atan(1 / x2);
+    case "sinh":
+      return Math.sinh(x2);
+    case "cosh":
+      return Math.cosh(x2);
+    case "tanh":
+      return Math.tanh(x2);
+    case "sech":
+      return 1 / Math.cosh(x2);
+    case "csch":
+      return 1 / Math.sinh(x2);
+    case "coth":
+      return Math.cosh(x2) / Math.sinh(x2);
+    case "log":
+      return Math.log10(x2);
+    case "ln":
+      return Math.log(x2);
+    case "exp":
+      return Math.exp(x2);
+    case "abs":
+      return Math.abs(x2);
+    case "signum":
+      return Math.sign(x2);
+    case "floor":
+      return Math.floor(x2);
+    case "ceil":
+      return Math.ceil(x2);
+    case "toDegrees":
+      return x2 * 180 / Math.PI;
+    case "toRadians":
+      return x2 * Math.PI / 180;
+    default:
+      return;
+  }
+}
+function resolveNumericAttribute(raw, env) {
+  if (raw === undefined) {
+    return;
+  }
+  if (typeof raw === "number") {
+    return raw;
+  }
+  const identifier = raw.startsWith("{") && raw.endsWith("}") ? raw.slice(1, -1) : raw;
+  return singleNumber(env.lookupVariable(identifier));
+}
+function roundToFigures(value, mode, figures) {
+  if (mode === "decimalPlaces") {
+    const scale2 = 10 ** figures;
+    return Math.round(value * scale2) / scale2;
+  }
+  if (figures < 1) {
+    return null;
+  }
+  if (value === 0) {
+    return 0;
+  }
+  const magnitude = Math.floor(Math.log10(Math.abs(value)));
+  const scale = 10 ** (figures - 1 - magnitude);
+  return Math.round(value * scale) / scale;
+}
+function evaluateExpression(expression, env) {
+  function evaluate(child) {
+    return evaluateExpression(child, env);
+  }
+  switch (expression.kind) {
+    case "baseValue": {
+      const baseType = expression.baseType;
+      const value = expression.value;
+      return value === undefined ? null : rpValue("single", [coerceScalar(value, baseType)], baseType);
+    }
+    case "variable":
+      return env.lookupVariable(expression.identifier ?? "");
+    case "correct": {
+      const declaration = env.responseDeclaration(expression.identifier ?? "");
+      if (!declaration?.correctResponse) {
+        return null;
+      }
+      return rpValue(declaration.cardinality, declaration.correctResponse.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType);
+    }
+    case "mapResponse": {
+      const identifier = expression.identifier ?? "";
+      const declaration = env.responseDeclaration(identifier);
+      if (!declaration) {
+        return null;
+      }
+      return floatValue(mapResponse(declaration, env.responseValue(identifier), env.normalization));
+    }
+    case "mapResponsePoint": {
+      const identifier = expression.identifier ?? "";
+      const declaration = env.responseDeclaration(identifier);
+      if (!declaration) {
+        return null;
+      }
+      return floatValue(mapResponsePoint(declaration, env.responseValue(identifier)));
+    }
+    case "match": {
+      const [a3, b2] = (expression.expressions ?? []).map(evaluate);
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      return booleanValue(valuesMatch(a3, b2, env.normalization));
+    }
+    case "isNull": {
+      const operand = expression.expressions?.[0];
+      return booleanValue(operand === undefined || evaluate(operand) === null);
+    }
+    case "not": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleBoolean(evaluate(operand));
+      return value === null ? null : booleanValue(!value);
+    }
+    case "fieldValue": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : evaluate(operand);
+      const field = value?.fields?.find((entry) => entry.name === expression.fieldIdentifier);
+      return field === undefined ? null : rpValue("single", [field.value], field.baseType);
+    }
+    case "and":
+    case "or": {
+      const members = (expression.expressions ?? []).map((child) => singleBoolean(evaluate(child)));
+      if (expression.kind === "and") {
+        if (members.some((member) => member === false)) {
+          return booleanValue(false);
+        }
+        return members.some((member) => member === null) ? null : booleanValue(true);
+      }
+      if (members.some((member) => member === true)) {
+        return booleanValue(true);
+      }
+      return members.some((member) => member === null) ? null : booleanValue(false);
+    }
+    case "sum":
+    case "product": {
+      let result = expression.kind === "sum" ? 0 : 1;
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          return null;
+        }
+        for (const member of value.values) {
+          if (typeof member !== "number") {
+            return null;
+          }
+          result = expression.kind === "sum" ? result + member : result * member;
+        }
+      }
+      return floatValue(result);
+    }
+    case "subtract":
+    case "divide": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      if (expression.kind === "divide") {
+        return b2 === 0 ? null : floatValue(a3 / b2);
+      }
+      return floatValue(a3 - b2);
+    }
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      const comparisons = { gt: a3 > b2, gte: a3 >= b2, lt: a3 < b2, lte: a3 <= b2 };
+      return booleanValue(comparisons[expression.kind]);
+    }
+    case "equal": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      const mode = expression.toleranceMode ?? "exact";
+      if (mode === "exact") {
+        return booleanValue(a3 === b2);
+      }
+      const t0 = resolveNumericAttribute(expression.tolerance?.[0], env);
+      const t1raw = expression.tolerance?.[1];
+      const t1 = t1raw === undefined ? t0 : resolveNumericAttribute(t1raw, env);
+      if (typeof t0 !== "number" || typeof t1 !== "number") {
+        return null;
+      }
+      const lower = mode === "absolute" ? a3 - t0 : a3 * (1 - t0 / 100);
+      const upper = mode === "absolute" ? a3 + t1 : a3 * (1 + t1 / 100);
+      const aboveLower = expression.includeLowerBound ?? true ? b2 >= lower : b2 > lower;
+      const belowUpper = expression.includeUpperBound ?? true ? b2 <= upper : b2 < upper;
+      return booleanValue(aboveLower && belowUpper);
+    }
+    case "round":
+    case "truncate": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleNumber(evaluate(operand));
+      if (value === null) {
+        return null;
+      }
+      const rounded = expression.kind === "round" ? Math.round(value) : Math.trunc(value);
+      return { cardinality: "single", baseType: "integer", values: [rounded] };
+    }
+    case "index": {
+      const n3 = resolveNumericAttribute(expression.n, env);
+      if (typeof n3 !== "number") {
+        return null;
+      }
+      const operand = expression.expressions?.[0];
+      const container = operand === undefined ? null : evaluate(operand);
+      if (container === null) {
+        return null;
+      }
+      const member = container.values[n3 - 1];
+      if (member === undefined) {
+        return null;
+      }
+      return rpValue("single", [member], container.baseType);
+    }
+    case "mathConstant": {
+      const constant = expression.name === undefined ? undefined : mathConstants[expression.name];
+      if (constant === undefined) {
+        throw new RpUnsupportedError("mathConstant");
+      }
+      return floatValue(constant);
+    }
+    case "mathOperator": {
+      const [x2, y2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (x2 === undefined || x2 === null || expression.name === "atan2" && (y2 === undefined || y2 === null)) {
+        return null;
+      }
+      const result = expression.name === undefined ? undefined : applyMathOperator(expression.name, x2, y2 ?? NaN);
+      if (result === undefined) {
+        throw new RpUnsupportedError("mathOperator");
+      }
+      return Number.isFinite(result) ? floatValue(result) : null;
+    }
+    case "integerDivide":
+    case "integerModulus": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null || b2 === 0) {
+        return null;
+      }
+      const result = expression.kind === "integerDivide" ? Math.trunc(a3 / b2) : a3 % b2;
+      return { cardinality: "single", baseType: "integer", values: [result] };
+    }
+    case "integerToFloat": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleNumber(evaluate(operand));
+      return value === null ? null : floatValue(value);
+    }
+    case "min":
+    case "max": {
+      const members = [];
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          return null;
+        }
+        for (const member of value.values) {
+          if (typeof member !== "number") {
+            return null;
+          }
+          members.push(member);
+        }
+      }
+      if (members.length === 0) {
+        return null;
+      }
+      return floatValue(expression.kind === "min" ? Math.min(...members) : Math.max(...members));
+    }
+    case "gcd":
+    case "lcm": {
+      const members = [];
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          return null;
+        }
+        for (const member of value.values) {
+          if (typeof member !== "number" || !Number.isInteger(member)) {
+            return null;
+          }
+          members.push(Math.abs(member));
+        }
+      }
+      if (members.length === 0) {
+        return null;
+      }
+      const gcdOf = (a3, b2) => b2 === 0 ? a3 : gcdOf(b2, a3 % b2);
+      const result = expression.kind === "gcd" ? members.reduce(gcdOf) : members.reduce((a3, b2) => a3 === 0 || b2 === 0 ? 0 : a3 / gcdOf(a3, b2) * b2);
+      return { cardinality: "single", baseType: "integer", values: [result] };
+    }
+    case "roundTo": {
+      const figures = resolveNumericAttribute(expression.figures, env);
+      if (typeof figures !== "number") {
+        return null;
+      }
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleNumber(evaluate(operand));
+      if (value === null) {
+        return null;
+      }
+      const rounded = roundToFigures(value, expression.roundingMode ?? "significantFigures", figures);
+      return rounded === null ? null : floatValue(rounded);
+    }
+    case "equalRounded": {
+      const figures = resolveNumericAttribute(expression.figures, env);
+      if (typeof figures !== "number") {
+        return null;
+      }
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      const mode = expression.roundingMode ?? "significantFigures";
+      const roundedA = roundToFigures(a3, mode, figures);
+      const roundedB = roundToFigures(b2, mode, figures);
+      return roundedA === null || roundedB === null ? null : booleanValue(roundedA === roundedB);
+    }
+    case "statsOperator": {
+      const operand = expression.expressions?.[0];
+      const container = operand === undefined ? null : evaluate(operand);
+      if (container === null) {
+        return null;
+      }
+      const members = [];
+      for (const member of container.values) {
+        if (typeof member !== "number") {
+          return null;
+        }
+        members.push(member);
+      }
+      const count = members.length;
+      if (count === 0) {
+        return null;
+      }
+      const mean = members.reduce((sum, member) => sum + member, 0) / count;
+      const sumSquares = members.reduce((sum, member) => sum + (member - mean) ** 2, 0);
+      switch (expression.name) {
+        case "mean":
+          return floatValue(mean);
+        case "popVariance":
+          return floatValue(sumSquares / count);
+        case "popSD":
+          return floatValue(Math.sqrt(sumSquares / count));
+        case "sampleVariance":
+          return count < 2 ? null : floatValue(sumSquares / (count - 1));
+        case "sampleSD":
+          return count < 2 ? null : floatValue(Math.sqrt(sumSquares / (count - 1)));
+        default:
+          throw new RpUnsupportedError("statsOperator");
+      }
+    }
+    case "delete": {
+      const [valueExpression, containerExpression] = expression.expressions ?? [];
+      if (valueExpression === undefined || containerExpression === undefined) {
+        return null;
+      }
+      const value = evaluate(valueExpression);
+      const container = evaluate(containerExpression);
+      if (value === null || container === null) {
+        return null;
+      }
+      const scalar = value.values[0];
+      if (scalar === undefined) {
+        return null;
+      }
+      const baseType = container.baseType ?? value.baseType;
+      const remaining = container.values.filter((member) => !scalarsEqual(member, scalar, baseType, env.normalization));
+      return remaining.length === 0 ? null : rpValue(container.cardinality, remaining, container.baseType);
+    }
+    case "repeat": {
+      const numberRepeats = resolveNumericAttribute(expression.numberRepeats, env);
+      if (typeof numberRepeats !== "number" || numberRepeats < 1) {
+        return null;
+      }
+      const members = [];
+      let baseType;
+      for (let pass = 0;pass < numberRepeats; pass += 1) {
+        for (const child of expression.expressions ?? []) {
+          const value = evaluate(child);
+          if (value === null) {
+            continue;
+          }
+          baseType ??= value.baseType;
+          members.push(...value.values);
+        }
+      }
+      return members.length === 0 ? null : rpValue("ordered", members, baseType);
+    }
+    case "null":
+      return null;
+    case "durationGte":
+    case "durationLt": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      return booleanValue(expression.kind === "durationGte" ? a3 >= b2 : a3 < b2);
+    }
+    case "default":
+      return env.variableDefault?.(expression.identifier ?? "") ?? null;
+    case "patternMatch": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : evaluate(operand);
+      const member = value?.values[0];
+      if (value === null || typeof member !== "string") {
+        return null;
+      }
+      if (expression.pattern === undefined) {
+        throw new RpUnsupportedError("patternMatch");
+      }
+      const pattern = encVariableStringPattern.test(expression.pattern) ? env.lookupVariable(expression.pattern.slice(1, -1))?.values[0] : expression.pattern;
+      if (typeof pattern !== "string") {
+        return null;
+      }
+      const matcher = xsdPatternMatcher(pattern);
+      if (matcher === null) {
+        throw new RpUnsupportedError("patternMatch");
+      }
+      return booleanValue(matcher(member));
+    }
+    case "power": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      const result = a3 ** b2;
+      return Number.isFinite(result) ? floatValue(result) : null;
+    }
+    case "containerSize": {
+      const operand = expression.expressions?.[0];
+      const container = operand === undefined ? null : evaluate(operand);
+      return {
+        cardinality: "single",
+        baseType: "integer",
+        values: [container === null ? 0 : container.values.length]
+      };
+    }
+    case "contains": {
+      const [firstExpression, secondExpression] = expression.expressions ?? [];
+      if (firstExpression === undefined || secondExpression === undefined) {
+        return null;
+      }
+      const first = evaluate(firstExpression);
+      const second = evaluate(secondExpression);
+      if (first === null || second === null || first.cardinality === "record" || second.cardinality === "record") {
+        return null;
+      }
+      const baseType = first.baseType ?? second.baseType;
+      if (first.cardinality === "ordered") {
+        const found = first.values.some((_2, start) => start + second.values.length <= first.values.length && second.values.every((member, offset) => scalarsEqual(first.values[start + offset], member, baseType, env.normalization)));
+        return booleanValue(found);
+      }
+      const remaining = [...first.values];
+      for (const member of second.values) {
+        const at = remaining.findIndex((candidate) => scalarsEqual(candidate, member, baseType, env.normalization));
+        if (at === -1) {
+          return booleanValue(false);
+        }
+        remaining.splice(at, 1);
+      }
+      return booleanValue(true);
+    }
+    case "anyN": {
+      const min = resolveNumericAttribute(expression.min, env);
+      const max = resolveNumericAttribute(expression.max, env);
+      if (typeof min !== "number" || typeof max !== "number") {
+        return null;
+      }
+      const members = (expression.expressions ?? []).map((child) => singleBoolean(evaluate(child)));
+      const trueCount = members.filter((member) => member === true).length;
+      const nullCount = members.filter((member) => member === null).length;
+      if (trueCount >= min && trueCount + nullCount <= max) {
+        return booleanValue(true);
+      }
+      if (trueCount + nullCount < min || trueCount > max) {
+        return booleanValue(false);
+      }
+      return null;
+    }
+    case "stringMatch":
+    case "substring": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => {
+        const value = evaluate(child);
+        const member = value?.values[0];
+        return typeof member === "string" ? member : null;
+      });
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      const normalize = (input) => {
+        const normalized = env.normalization?.(input) ?? input;
+        return expression.caseSensitive === false ? normalized.toLowerCase() : normalized;
+      };
+      const [left, right] = [normalize(a3), normalize(b2)];
+      const contains = expression.kind === "substring" || expression.substring === true;
+      return booleanValue(contains ? right.includes(left) : left === right);
+    }
+    case "inside": {
+      if (typeof expression.shape !== "string" || typeof expression.coords !== "string") {
+        throw new RpUnsupportedError("inside");
+      }
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : evaluate(operand);
+      const member = value?.values[0];
+      if (value === null || typeof member !== "string") {
+        return null;
+      }
+      const point = parsePoint(member);
+      if (point === null) {
+        return null;
+      }
+      return booleanValue(pointInShape(expression.shape, parseCoords(expression.coords), point));
+    }
+    case "member": {
+      const [needleExpression, containerExpression] = expression.expressions ?? [];
+      if (needleExpression === undefined || containerExpression === undefined) {
+        return null;
+      }
+      const needle = evaluate(needleExpression);
+      const container = evaluate(containerExpression);
+      if (needle === null || container === null) {
+        return null;
+      }
+      const scalar = needle.values[0];
+      if (scalar === undefined) {
+        return null;
+      }
+      const baseType = container.baseType ?? needle.baseType;
+      return booleanValue(container.values.some((member) => scalarsEqual(member, scalar, baseType, env.normalization)));
+    }
+    case "multiple":
+    case "ordered": {
+      const members = [];
+      let baseType;
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          continue;
+        }
+        baseType ??= value.baseType;
+        members.push(...value.values);
+      }
+      if (members.length === 0) {
+        return null;
+      }
+      return rpValue(expression.kind, members, baseType);
+    }
+    case "randomInteger": {
+      if (!env.random) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      const min = resolveNumericAttribute(expression.min, env) ?? 0;
+      const max = resolveNumericAttribute(expression.max, env) ?? min;
+      const step = resolveNumericAttribute(expression.step, env) ?? 1;
+      const count = Math.max(1, Math.floor((max - min) / step) + 1);
+      return { cardinality: "single", baseType: "integer", values: [min + Math.floor(env.random() * count) * step] };
+    }
+    case "randomFloat": {
+      if (!env.random) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      const min = resolveNumericAttribute(expression.min, env) ?? 0;
+      const max = resolveNumericAttribute(expression.max, env) ?? min;
+      return floatValue(min + env.random() * (max - min));
+    }
+    case "testVariables": {
+      if (!env.testVariables) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      return env.testVariables(expression);
+    }
+    case "customOperator": {
+      const implementation = env.customOperators?.[expression.class ?? ""];
+      if (!implementation) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      return implementation((expression.expressions ?? []).map(evaluate), expression);
+    }
+    case "numberCorrect":
+    case "numberIncorrect":
+    case "numberPresented":
+    case "numberResponded":
+    case "numberSelected":
+    case "outcomeMinimum":
+    case "outcomeMaximum": {
+      if (!env.testAggregate) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      return env.testAggregate(expression);
+    }
+    case "random": {
+      if (!env.random) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      const container = expression.expressions?.[0] === undefined ? null : evaluate(expression.expressions[0]);
+      if (container === null || container.values.length === 0) {
+        return null;
+      }
+      const pick = container.values[Math.floor(env.random() * container.values.length)];
+      return rpValue("single", [pick], container.baseType);
+    }
+    default:
+      throw new RpUnsupportedError(expression.kind);
+  }
+}
+function collectExpressionIssues(expression, allowedKinds, report, customOperatorClasses) {
+  if (expression.kind === "customOperator") {
+    if (!customOperatorClasses?.has(expression.class ?? "")) {
+      report(expression.kind);
+    }
+  } else if (!allowedKinds.has(expression.kind)) {
+    report(expression.kind);
+  } else if (expression.kind === "patternMatch" && expression.pattern !== undefined && !encVariableStringPattern.test(expression.pattern) && xsdPatternMatcher(expression.pattern) === null) {
+    report(expression.kind);
+  }
+  for (const child of expression.expressions ?? []) {
+    collectExpressionIssues(child, allowedKinds, report, customOperatorClasses);
+  }
+}
+
+// src/rp/lookup-table.ts
+function hasLookupTable(declaration) {
+  return declaration?.matchTable !== undefined || declaration?.interpolationTable !== undefined;
+}
+function lookupTableValue(declaration, source) {
+  const value = singleNumber(source);
+  const table = declaration.matchTable ?? declaration.interpolationTable;
+  const target = value === null ? undefined : matchedTarget(declaration, value);
+  const result = target ?? table?.defaultValue;
+  if (result === undefined) {
+    return null;
+  }
+  return rpValue("single", [coerceScalar(result, declaration.baseType)], declaration.baseType);
+}
+function matchedTarget(declaration, value) {
+  if (declaration.matchTable) {
+    return declaration.matchTable.matchTableEntries.find((entry) => entry.sourceValue === value)?.targetValue;
+  }
+  return declaration.interpolationTable?.interpolationTableEntries.find((entry) => entry.includeBoundary ?? true ? entry.sourceValue <= value : entry.sourceValue < value)?.targetValue;
+}
+
+// src/rp/templates.ts
+var matchCorrectRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: {
+        kind: "match",
+        expressions: [
+          { kind: "variable", identifier: "RESPONSE" },
+          { kind: "correct", identifier: "RESPONSE" }
+        ]
+      },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 1 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    }
+  }
+];
+var mapResponseRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: { kind: "isNull", expressions: [{ kind: "variable", identifier: "RESPONSE" }] },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        { kind: "setOutcomeValue", identifier: "SCORE", expression: { kind: "mapResponse", identifier: "RESPONSE" } }
+      ]
+    }
+  }
+];
+var mapResponsePointRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: { kind: "isNull", expressions: [{ kind: "variable", identifier: "RESPONSE" }] },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "mapResponsePoint", identifier: "RESPONSE" }
+        }
+      ]
+    }
+  }
+];
+var cc2MatchBasicRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: {
+        kind: "match",
+        expressions: [
+          { kind: "variable", identifier: "RESPONSE" },
+          { kind: "correct", identifier: "RESPONSE" }
+        ]
+      },
+      rules: [
+        { kind: "setOutcomeValue", identifier: "SCORE", expression: { kind: "variable", identifier: "MAXSCORE" } },
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACKBASIC",
+          expression: { kind: "baseValue", baseType: "identifier", value: "correct" }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACKBASIC",
+          expression: { kind: "baseValue", baseType: "identifier", value: "incorrect" }
+        }
+      ]
+    }
+  }
+];
+var cc2MapResponseRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: { kind: "isNull", expressions: [{ kind: "variable", identifier: "RESPONSE" }] },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        { kind: "setOutcomeValue", identifier: "SCORE", expression: { kind: "mapResponse", identifier: "RESPONSE" } }
+      ]
+    }
+  },
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: {
+        kind: "equal",
+        toleranceMode: "exact",
+        expressions: [
+          { kind: "variable", identifier: "MAXSCORE" },
+          { kind: "variable", identifier: "SCORE" }
+        ]
+      },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACK",
+          expression: { kind: "baseValue", baseType: "identifier", value: "correct" }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACK",
+          expression: { kind: "baseValue", baseType: "identifier", value: "incorrect" }
+        }
+      ]
+    }
+  }
+];
+var templatesBySegment = new Map([
+  ["match_correct", matchCorrectRules],
+  ["map_response", mapResponseRules],
+  ["map_response_point", mapResponsePointRules],
+  ["CC2_match", matchCorrectRules],
+  ["CC2_match_basic", cc2MatchBasicRules],
+  ["CC2_map_response", cc2MapResponseRules]
+]);
+function resolveTemplate(uri) {
+  const segment = uri.split("/").at(-1)?.replace(/\.xml$/u, "") ?? "";
+  return templatesBySegment.get(segment) ?? null;
+}
+
+// src/rp/interpreter.ts
+var supportedRuleKinds = new Set([
+  "responseCondition",
+  "setOutcomeValue",
+  "lookupOutcomeValue",
+  "responseProcessingFragment",
+  "exitResponse"
+]);
+var rpExpressionKinds = new Set([...deterministicExpressionKinds, "random", "randomInteger", "randomFloat"]);
+
+class ExitResponseSignal extends Error {
+}
+function defaultOutcomes(declarations) {
+  const outcomes = new Map;
+  for (const declaration of declarations) {
+    if (declaration.defaultValue) {
+      outcomes.set(declaration.identifier, rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType));
+      continue;
+    }
+    outcomes.set(declaration.identifier, isNumericBaseType(declaration.baseType) ? floatValue(0) : null);
+  }
+  return outcomes;
+}
+function executeResponseProcessing(view, context) {
+  const issues = [];
+  const declarationsById = new Map(context.responseDeclarations.map((declaration) => [declaration.identifier, declaration]));
+  const templateDeclarationsById = new Map((context.templateDeclarations ?? []).map((declaration) => [declaration.identifier, declaration]));
+  function initialOutcomes() {
+    const outcomes2 = defaultOutcomes(context.outcomeDeclarations);
+    if (!outcomes2.has("completionStatus")) {
+      outcomes2.set("completionStatus", rpValue("single", [context.completionStatus ?? "not_attempted"], "identifier"));
+    }
+    for (const [identifier, prior] of Object.entries(context.priorOutcomes ?? {})) {
+      const declaration = context.outcomeDeclarations.find((entry) => entry.identifier === identifier);
+      outcomes2.set(identifier, fromFlatValue(prior, declaration?.cardinality ?? "single", declaration?.baseType));
+    }
+    return outcomes2;
+  }
+  let outcomes = initialOutcomes();
+  let rules = view?.rules ?? [];
+  if (view && !view.rules && view.template) {
+    const resolved = resolveTemplate(view.template);
+    if (resolved) {
+      rules = resolved;
+    } else {
+      issues.push({ type: "unsupported-rp", name: view.template, detail: "Unknown response-processing template URI." });
+    }
+  }
+  const env = {
+    lookupVariable: (identifier) => {
+      if (identifier === "duration") {
+        return context.duration === undefined ? null : rpValue("single", [context.duration], "duration");
+      }
+      if (identifier === "numAttempts") {
+        return context.numAttempts === undefined ? null : rpValue("single", [context.numAttempts], "integer");
+      }
+      const declaration = declarationsById.get(identifier);
+      if (declaration) {
+        return fromResponse(declaration, context.responses[identifier] ?? null);
+      }
+      const templateDeclaration = templateDeclarationsById.get(identifier);
+      if (templateDeclaration) {
+        return fromFlatValue(context.templateValues?.[identifier] ?? null, templateDeclaration.cardinality, templateDeclaration.baseType);
+      }
+      return outcomes.get(identifier) ?? null;
+    },
+    responseDeclaration: (identifier) => declarationsById.get(identifier),
+    responseValue: (identifier) => context.responses[identifier] ?? null,
+    variableDefault: (identifier) => {
+      const declaration = declarationsById.get(identifier) ?? context.outcomeDeclarations.find((entry) => entry.identifier === identifier) ?? templateDeclarationsById.get(identifier);
+      if (!declaration?.defaultValue) {
+        return null;
+      }
+      return rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType);
+    },
+    normalization: context.normalization,
+    random: context.random,
+    customOperators: context.customOperators
+  };
+  function branchTaken(branch) {
+    if (singleBoolean(evaluateExpression(branch.expression, env)) !== true) {
+      return false;
+    }
+    executeRules(branch.rules);
+    return true;
+  }
+  function executeRules(rules_) {
+    for (const rule of rules_) {
+      if (!supportedRuleKinds.has(rule.kind)) {
+        throw new RpUnsupportedError(rule.kind);
+      }
+      if (rule.kind === "exitResponse") {
+        throw new ExitResponseSignal;
+      }
+      if (rule.kind === "setOutcomeValue") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          outcomes.set(rule.identifier, evaluateExpression(rule.expression, env));
+        }
+        continue;
+      }
+      if (rule.kind === "responseProcessingFragment") {
+        executeRules(rule.rules ?? []);
+        continue;
+      }
+      if (rule.kind === "lookupOutcomeValue") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          const declaration = context.outcomeDeclarations.find((entry) => entry.identifier === rule.identifier);
+          if (!hasLookupTable(declaration)) {
+            throw new RpUnsupportedError("lookupOutcomeValue");
+          }
+          outcomes.set(rule.identifier, lookupTableValue(declaration, evaluateExpression(rule.expression, env)));
+        }
+        continue;
+      }
+      if (rule.responseIf && branchTaken(rule.responseIf)) {
+        continue;
+      }
+      const elseIfTaken = (rule.responseElseIfs ?? []).some((branch) => branchTaken(branch));
+      if (!elseIfTaken && rule.responseElse) {
+        executeRules(rule.responseElse.rules);
+      }
+    }
+  }
+  try {
+    executeRules(rules);
+  } catch (error) {
+    if (error instanceof RpUnsupportedError) {
+      issues.push({ type: "unsupported-rp", name: error.kindName });
+      outcomes = initialOutcomes();
+    } else if (!(error instanceof ExitResponseSignal)) {
+      throw error;
+    }
+  }
+  return {
+    outcomes: Object.fromEntries([...outcomes].map(([identifier, value]) => [identifier, toOutcomeValue(value)])),
+    issues
+  };
+}
+function collectRpIssues(view, options) {
+  if (!view) {
+    return [];
+  }
+  const issues = [];
+  const seen = new Set;
+  function report(name, detail) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      issues.push({ type: "unsupported-rp", name, ...detail === undefined ? {} : { detail } });
+    }
+  }
+  function walkRules(rules) {
+    for (const rule of rules) {
+      if (!supportedRuleKinds.has(rule.kind)) {
+        report(rule.kind);
+        continue;
+      }
+      if (rule.kind === "lookupOutcomeValue" && options?.outcomeDeclarations !== undefined) {
+        const declaration = options.outcomeDeclarations.find((entry) => entry.identifier === rule.identifier);
+        if (!hasLookupTable(declaration)) {
+          report("lookupOutcomeValue", "Outcome declaration has no matchTable/interpolationTable.");
+        }
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, rpExpressionKinds, report, options?.customOperatorClasses);
+      }
+      if (rule.rules) {
+        walkRules(rule.rules);
+      }
+      for (const branch of [rule.responseIf, ...rule.responseElseIfs ?? []]) {
+        if (branch) {
+          collectExpressionIssues(branch.expression, rpExpressionKinds, report, options?.customOperatorClasses);
+          walkRules(branch.rules);
+        }
+      }
+      if (rule.responseElse) {
+        walkRules(rule.responseElse.rules);
+      }
+    }
+  }
+  if (view.rules) {
+    walkRules(view.rules);
+  } else if (view.template) {
+    const resolved = resolveTemplate(view.template);
+    if (resolved === null) {
+      report(view.template, "Unknown response-processing template URI.");
+    }
+  }
+  return issues;
+}
+// src/rp/template-processing.ts
+var supportedTemplateRuleKinds = new Set([
+  "setTemplateValue",
+  "templateCondition",
+  "templateConstraint",
+  "setCorrectResponse",
+  "exitTemplate"
+]);
+var templateExpressionKinds = new Set([...deterministicExpressionKinds, ...randomExpressionKinds]);
+
+class ExitTemplateSignal extends Error {
+}
+
+class TemplateConstraintSignal extends Error {
+}
+var maxConstraintAttempts = 100;
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t3 = state;
+    t3 = Math.imul(t3 ^ t3 >>> 15, t3 | 1);
+    t3 ^= t3 + Math.imul(t3 ^ t3 >>> 7, t3 | 61);
+    return ((t3 ^ t3 >>> 14) >>> 0) / 4294967296;
+  };
+}
+function executeTemplateProcessing(view, context) {
+  const issues = [];
+  const declarationsById = new Map(context.templateDeclarations.map((entry) => [entry.identifier, entry]));
+  const responseDeclarationsById = new Map(context.responseDeclarations.map((entry) => [entry.identifier, entry]));
+  const correctResponseOverrides = {};
+  function initialValues() {
+    const values = new Map;
+    for (const declaration of context.templateDeclarations) {
+      values.set(declaration.identifier, declaration.defaultValue ? rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType) : null);
+    }
+    return values;
+  }
+  let templateValues = initialValues();
+  const env = {
+    lookupVariable: (identifier) => templateValues.get(identifier) ?? null,
+    responseDeclaration: (identifier) => responseDeclarationsById.get(identifier),
+    responseValue: () => null,
+    variableDefault: (identifier) => {
+      const declaration = declarationsById.get(identifier) ?? responseDeclarationsById.get(identifier);
+      if (!declaration?.defaultValue) {
+        return null;
+      }
+      return rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType);
+    },
+    random: mulberry32(context.seed),
+    customOperators: context.customOperators
+  };
+  function branchTaken(branch) {
+    if (singleBoolean(evaluateExpression(branch.expression, env)) !== true) {
+      return false;
+    }
+    executeRules(branch.rules);
+    return true;
+  }
+  function executeRules(rules) {
+    for (const rule of rules) {
+      if (!supportedTemplateRuleKinds.has(rule.kind)) {
+        throw new RpUnsupportedError(rule.kind);
+      }
+      if (rule.kind === "exitTemplate") {
+        throw new ExitTemplateSignal;
+      }
+      if (rule.kind === "setTemplateValue") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          const declaration = declarationsById.get(rule.identifier);
+          const value = evaluateExpression(rule.expression, env);
+          templateValues.set(rule.identifier, value === null || !declaration ? value : rpValue(declaration.cardinality, value.values, declaration.baseType ?? value.baseType));
+        }
+        continue;
+      }
+      if (rule.kind === "setCorrectResponse") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          const value = evaluateExpression(rule.expression, env);
+          if (value !== null) {
+            correctResponseOverrides[rule.identifier] = {
+              values: value.values.map((member) => ({ value: String(member) }))
+            };
+          }
+        }
+        continue;
+      }
+      if (rule.kind === "templateConstraint") {
+        if (rule.expression !== undefined && singleBoolean(evaluateExpression(rule.expression, env)) !== true) {
+          throw new TemplateConstraintSignal;
+        }
+        continue;
+      }
+      if (rule.templateIf && branchTaken(rule.templateIf)) {
+        continue;
+      }
+      const elseIfTaken = (rule.templateElseIfs ?? []).some((branch) => branchTaken(branch));
+      if (!elseIfTaken && rule.templateElse) {
+        executeRules(rule.templateElse.rules);
+      }
+    }
+  }
+  for (let attempt = 0;attempt < maxConstraintAttempts; attempt += 1) {
+    try {
+      executeRules(view?.rules ?? []);
+      break;
+    } catch (error) {
+      if (error instanceof TemplateConstraintSignal) {
+        templateValues = initialValues();
+        for (const key of Object.keys(correctResponseOverrides)) {
+          delete correctResponseOverrides[key];
+        }
+        continue;
+      }
+      if (error instanceof RpUnsupportedError) {
+        issues.push({ type: "unsupported-rp", name: error.kindName });
+        templateValues = initialValues();
+      } else if (!(error instanceof ExitTemplateSignal)) {
+        throw error;
+      }
+      break;
+    }
+  }
+  return {
+    templateValues: Object.fromEntries([...templateValues].map(([identifier, value]) => [identifier, toOutcomeValue(value)])),
+    correctResponseOverrides,
+    issues
+  };
+}
+function applyTemplateDefaultOverrides(declarations, overrides) {
+  return declarations.map((declaration) => {
+    if (!(declaration.identifier in overrides)) {
+      return declaration;
+    }
+    const value = overrides[declaration.identifier];
+    if (value === null || value === undefined) {
+      const { defaultValue: _cleared, ...rest } = declaration;
+      return rest;
+    }
+    return {
+      ...declaration,
+      defaultValue: { values: (Array.isArray(value) ? value : [value]).map((member) => ({ value: member })) }
+    };
+  });
+}
+function applyCorrectResponseOverrides(declarations, overrides) {
+  return declarations.map((declaration) => {
+    const override = overrides[declaration.identifier];
+    return override ? { ...declaration, correctResponse: override } : declaration;
+  });
+}
+function collectTemplateIssues(view, options) {
+  if (!view) {
+    return [];
+  }
+  const issues = [];
+  const seen = new Set;
+  function report(name) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      issues.push({ type: "unsupported-rp", name });
+    }
+  }
+  function walkRules(rules) {
+    for (const rule of rules) {
+      if (!supportedTemplateRuleKinds.has(rule.kind)) {
+        report(rule.kind);
+        continue;
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, templateExpressionKinds, report, options?.customOperatorClasses);
+      }
+      for (const branch of [rule.templateIf, ...rule.templateElseIfs ?? []]) {
+        if (branch) {
+          collectExpressionIssues(branch.expression, templateExpressionKinds, report, options?.customOperatorClasses);
+          walkRules(branch.rules);
+        }
+      }
+      if (rule.templateElse) {
+        walkRules(rule.templateElse.rules);
+      }
+    }
+  }
+  walkRules(view.rules);
+  return issues;
+}
+// src/item-capability.ts
+var feedbackKinds = new Set(["feedbackInline", "feedbackBlock"]);
+var templateContentKinds = new Set(["templateInline", "templateBlock"]);
+var intrinsicLeafKinds = new Set(["text", "printedVariable"]);
+function isFeedbackNode(node) {
+  return feedbackKinds.has(node.kind);
+}
+function isTemplateContentNode(node) {
+  return templateContentKinds.has(node.kind);
+}
+function isInteractionNode(node) {
+  return node.kind !== "xml" && typeof node.responseIdentifier === "string";
+}
+function reportItemCapability(item, options) {
+  const model = options.model ?? v0ContentModel;
+  const customOperatorClasses = options.customOperatorClasses ?? new Set;
+  const issues = [];
+  const seen = new Set;
+  function report(issue) {
+    const dedupeKey = `${issue.type}:${issue.name}:${issue.responseIdentifier ?? ""}`;
+    if (!seen.has(dedupeKey)) {
+      seen.add(dedupeKey);
+      issues.push(issue);
+    }
+  }
+  function walk(node) {
+    if (isFeedbackNode(node) || isTemplateContentNode(node) || node.kind === "rubricBlock") {
+      for (const child of node.content ?? []) {
+        walk(child);
+      }
+      return;
+    }
+    if (isInteractionNode(node)) {
+      if (!options.supportedInteractions.has(node.kind)) {
+        report({ type: "unsupported-interaction", name: node.kind, responseIdentifier: node.responseIdentifier });
+        return;
+      }
+      const schema = options.interactionSchemas?.get(node.kind);
+      if (schema) {
+        const parsed = schema.safeParse(node);
+        if (!parsed.success) {
+          const detail = parsed.error.issues[0]?.message;
+          report({
+            type: "invalid-interaction",
+            name: node.kind,
+            responseIdentifier: node.responseIdentifier,
+            ...detail !== undefined ? { detail } : {}
+          });
+        }
+      }
+      return;
+    }
+    if (node.kind === "xml") {
+      const xmlNode = node;
+      if (xmlNode.name === model.mathRoot) {
+        return;
+      }
+      if (!isAllowedFlowElement(model, xmlNode.name)) {
+        report({ type: "unsupported-element", name: xmlNode.name });
+      }
+      for (const child of xmlNode.children ?? []) {
+        walk(child);
+      }
+      return;
+    }
+    if (intrinsicLeafKinds.has(node.kind)) {
+      return;
+    }
+    report({ type: "unsupported-element", name: node.kind });
+  }
+  for (const node of item.itemBody.content ?? []) {
+    walk(node);
+  }
+  for (const ref of item.assessmentStimulusRefs ?? []) {
+    const stimulus = options.resolveStimulus?.(ref) ?? null;
+    if (stimulus === null) {
+      report({ type: "unsupported-element", name: "assessmentStimulusRef", detail: ref.href });
+      continue;
+    }
+    for (const node of stimulus.content) {
+      walk(node);
+    }
+  }
+  for (const feedback of item.modalFeedbacks ?? []) {
+    for (const child of feedback.content ?? []) {
+      walk(child);
+    }
+  }
+  for (const issue of collectRpIssues(item.responseProcessing, {
+    customOperatorClasses,
+    outcomeDeclarations: item.outcomeDeclarations ?? []
+  })) {
+    report(issue);
+  }
+  for (const issue of collectTemplateIssues(item.templateProcessing, { customOperatorClasses })) {
+    report(issue);
+  }
+  return { deliverable: issues.length === 0, issues };
+}
+var referenceInteractionKinds = [
+  "associateInteraction",
+  "choiceInteraction",
+  "drawingInteraction",
+  "endAttemptInteraction",
+  "extendedTextInteraction",
+  "gapMatchInteraction",
+  "graphicAssociateInteraction",
+  "graphicGapMatchInteraction",
+  "graphicOrderInteraction",
+  "hotspotInteraction",
+  "hottextInteraction",
+  "inlineChoiceInteraction",
+  "matchInteraction",
+  "mediaInteraction",
+  "orderInteraction",
+  "positionObjectStage",
+  "selectPointInteraction",
+  "sliderInteraction",
+  "textEntryInteraction",
+  "uploadInteraction"
+];
+// src/item-score.ts
+function numericOutcome(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function effectiveItemScore(scores, outcomes) {
+  const scoreOutcome = numericOutcome(outcomes["SCORE"]);
+  const maxOutcome = numericOutcome(outcomes["MAXSCORE"]);
+  const summedMax = scores.reduce((total, score) => total + score.maxScore, 0);
+  if (scoreOutcome !== null) {
+    return { raw: scoreOutcome, max: maxOutcome ?? summedMax, fromOutcomes: true };
+  }
+  return {
+    raw: scores.reduce((total, score) => total + score.score, 0),
+    max: maxOutcome ?? summedMax,
+    fromOutcomes: false
+  };
+}
+// src/response-validity.ts
+var countConstraintKinds = ["minChoices", "maxChoices", "minAssociations", "maxAssociations", "minStrings"];
+function collectInteractionConstraints(content) {
+  const constraints = [];
+  function walk(node) {
+    const record = node;
+    if (isInteractionKind(v0ContentModel, node.kind) && typeof record["responseIdentifier"] === "string") {
+      const responseIdentifier = record["responseIdentifier"];
+      for (const kind of [...countConstraintKinds, "minPlays"]) {
+        const bound = record[kind];
+        if (typeof bound === "number" && bound > 0) {
+          constraints.push({ responseIdentifier, kind, bound });
+        }
+      }
+      const patternMask = record["patternMask"];
+      if (typeof patternMask === "string" && patternMask !== "") {
+        constraints.push({ responseIdentifier, kind: "patternMask", bound: patternMask });
+      }
+      return;
+    }
+    for (const key of ["content", "children"]) {
+      const nested = record[key];
+      if (Array.isArray(nested)) {
+        for (const child of nested) {
+          walk(child);
+        }
+      }
+    }
+  }
+  for (const node of content ?? []) {
+    walk(node);
+  }
+  return constraints;
+}
+function memberCount(value) {
+  if (value === null || value === undefined || value === "") {
+    return 0;
+  }
+  if (Array.isArray(value)) {
+    return value.filter((member) => member !== null && member !== "").length;
+  }
+  return 1;
+}
+function stringMembers(value) {
+  if (typeof value === "string") {
+    return value === "" ? [] : [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((member) => typeof member === "string" && member !== "");
+  }
+  return [];
+}
+function violates(constraint, value) {
+  switch (constraint.kind) {
+    case "minChoices":
+    case "minAssociations":
+    case "minStrings":
+      return memberCount(value) < Number(constraint.bound);
+    case "maxChoices":
+    case "maxAssociations":
+      return memberCount(value) > Number(constraint.bound);
+    case "minPlays": {
+      const plays = typeof value === "number" ? value : 0;
+      return plays < Number(constraint.bound);
+    }
+    case "patternMask": {
+      const members = stringMembers(value);
+      if (members.length === 0) {
+        return false;
+      }
+      try {
+        const matches = HA(String(constraint.bound), { language: "xsd" });
+        return !members.every((member) => matches(member));
+      } catch {
+        return false;
+      }
+    }
+  }
+}
+function collectResponseViolations(constraints, responses) {
+  return constraints.filter((constraint) => {
+    const value = responses[constraint.responseIdentifier] ?? null;
+    return !isResponseRecord(value) && violates(constraint, value);
+  });
+}
+
+// src/store.ts
+function createAttemptStore(declarations, initialResponses, options) {
+  const seed = options?.seed ?? Math.floor(Math.random() * 2 ** 31);
+  const templateDeclarations = options?.templateDefaultValues ? applyTemplateDefaultOverrides(options.templateDeclarations ?? [], options.templateDefaultValues) : options?.templateDeclarations ?? [];
+  const templateResult = options?.templateProcessing ? executeTemplateProcessing(options.templateProcessing, {
+    templateDeclarations,
+    responseDeclarations: declarations,
+    seed,
+    customOperators: options.customOperators
+  }) : null;
+  const effectiveDeclarations = templateResult ? applyCorrectResponseOverrides(declarations, templateResult.correctResponseOverrides) : declarations;
+  const declarationsById = new Map(effectiveDeclarations.map((declaration) => [declaration.identifier, declaration]));
+  const listeners = new Set;
+  const responseCollectors = new Map;
+  const rpRandom = mulberry32((seed ^ 2654435769) >>> 0);
+  const now = options?.now ?? Date.now;
+  let activeMs = 0;
+  let runningSinceMs = now();
+  const activeSeconds = () => (activeMs + (runningSinceMs === null ? 0 : now() - runningSinceMs)) / 1000;
+  const completionStatusDeclared = (options?.outcomeDeclarations ?? []).some((declaration) => declaration.identifier === "completionStatus");
+  const maintainedOutcomes = () => completionStatusDeclared ? {} : { completionStatus: "unknown" };
+  const violationsOf = (responses) => options?.constraints ? collectResponseViolations(options.constraints, responses) : [];
+  const correctResponses = {};
+  for (const declaration of effectiveDeclarations) {
+    const values = declaration.correctResponse?.values;
+    if (values !== undefined) {
+      correctResponses[declaration.identifier] = declaration.cardinality === "single" ? values[0]?.value ?? null : values.map((entry) => entry.value);
+    }
+  }
+  let snapshot = {
+    responses: { ...initialResponses },
+    submitted: false,
+    scores: [],
+    outcomes: maintainedOutcomes(),
+    templateValues: templateResult?.templateValues ?? {},
+    attemptCount: 0,
+    durationSeconds: null,
+    responseViolations: violationsOf(initialResponses),
+    correctResponses
+  };
+  function emit(next) {
+    snapshot = next;
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function computeScores(responses) {
+    return [...declarationsById.values()].map((declaration) => scoreResponse(declaration, responses[declaration.identifier] ?? null, options?.normalization));
+  }
+  function computeOutcomes(responses, durationSeconds, priorOutcomes) {
+    if (!options?.responseProcessing) {
+      return {};
+    }
+    return executeResponseProcessing(options.responseProcessing, {
+      responseDeclarations: effectiveDeclarations,
+      outcomeDeclarations: options.outcomeDeclarations ?? [],
+      responses,
+      normalization: options.normalization,
+      templateDeclarations,
+      templateValues: snapshot.templateValues,
+      priorOutcomes,
+      random: rpRandom,
+      customOperators: options.customOperators,
+      duration: durationSeconds,
+      numAttempts: snapshot.attemptCount + 1,
+      ...typeof snapshot.outcomes["completionStatus"] === "string" ? { completionStatus: snapshot.outcomes["completionStatus"] } : {}
+    }).outcomes;
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setResponse: (responseIdentifier, value) => {
+      if (snapshot.submitted) {
+        return;
+      }
+      const responses = { ...snapshot.responses, [responseIdentifier]: value };
+      emit({
+        ...snapshot,
+        responses,
+        responseViolations: violationsOf(responses)
+      });
+    },
+    registerResponseCollector: (responseIdentifier, collector) => {
+      responseCollectors.set(responseIdentifier, collector);
+      return () => {
+        if (responseCollectors.get(responseIdentifier) === collector) {
+          responseCollectors.delete(responseIdentifier);
+        }
+      };
+    },
+    submit: () => {
+      if (snapshot.submitted) {
+        return snapshot.scores;
+      }
+      let collected = snapshot.responses;
+      for (const [responseIdentifier, collector] of responseCollectors) {
+        const value = collector();
+        if (value !== undefined) {
+          collected = { ...collected, [responseIdentifier]: value };
+        }
+      }
+      if (collected !== snapshot.responses) {
+        snapshot = { ...snapshot, responses: collected, responseViolations: violationsOf(collected) };
+      }
+      if (options?.validateResponses && snapshot.responseViolations.length > 0) {
+        emit(snapshot);
+        return snapshot.scores;
+      }
+      const scores = computeScores(snapshot.responses);
+      const durationSeconds = activeSeconds();
+      const priorOutcomes = options?.adaptive && snapshot.attemptCount > 0 ? snapshot.outcomes : undefined;
+      const rpOutcomes = computeOutcomes(snapshot.responses, durationSeconds, priorOutcomes);
+      const outcomes = options?.responseProcessing ? rpOutcomes : { ...maintainedOutcomes(), ...rpOutcomes };
+      const completionStatus = outcomes["completionStatus"] ?? outcomes["completion_status"];
+      const completed = !options?.adaptive || completionStatus === "completed";
+      let responses = snapshot.responses;
+      if (options?.adaptive && !completed) {
+        responses = { ...responses };
+        for (const declaration of effectiveDeclarations) {
+          if (declaration.baseType === "boolean") {
+            responses = { ...responses, [declaration.identifier]: null };
+          }
+        }
+      }
+      emit({
+        ...snapshot,
+        responses,
+        submitted: completed,
+        scores,
+        outcomes,
+        attemptCount: snapshot.attemptCount + 1,
+        durationSeconds
+      });
+      return scores;
+    },
+    suspend: () => {
+      if (runningSinceMs !== null) {
+        activeMs += now() - runningSinceMs;
+        runningSinceMs = null;
+      }
+    },
+    resume: () => {
+      runningSinceMs ??= now();
+    },
+    reset: () => {
+      activeMs = 0;
+      runningSinceMs = now();
+      emit({
+        responses: { ...initialResponses },
+        submitted: false,
+        scores: [],
+        outcomes: maintainedOutcomes(),
+        templateValues: snapshot.templateValues,
+        attemptCount: 0,
+        durationSeconds: null,
+        responseViolations: violationsOf(initialResponses),
+        correctResponses
+      });
+    }
+  };
+}
+// src/pnp.ts
+var pnpFeatureFields = {
+  "linguistic-guidance": "linguisticGuidance",
+  "keyword-emphasis": "keywordEmphasis",
+  "keyword-translation": "keywordTranslation",
+  "simplified-language-portions": "simplifiedLanguagePortions",
+  "simplified-graphics": "simplifiedGraphics",
+  "item-translation": "itemTranslation",
+  "sign-language": "signLanguage",
+  encouragement: "encouragement",
+  "additional-testing-time": "additionalTestingTime",
+  "line-reader": "lineReader",
+  "invert-display-polarity": "invertDisplayPolarity",
+  magnification: "magnification",
+  spoken: "spoken",
+  tactile: "tactile",
+  braille: "braille",
+  "answer-masking": "answerMasking",
+  "keyboard-directions": "keyboardDirections",
+  "additional-directions": "additionalDirections",
+  "long-description": "longDescription",
+  captions: "captions",
+  transcript: "transcript",
+  "alternative-text": "alternativeText",
+  "audio-description": "audioDescription",
+  "high-contrast": "highContrast",
+  "input-requirements": "inputRequirements",
+  "language-of-interface": "languageOfInterface",
+  "layout-single-column": "layoutSingleColumn",
+  "text-appearance": "textAppearance",
+  "calculator-on-screen": "calculatorOnScreen",
+  "dictionary-on-screen": "dictionaryOnScreen",
+  "glossary-on-screen": "glossaryOnScreen",
+  "thesaurus-on-screen": "thesaurusOnScreen",
+  "homophone-checker-on-screen": "homophoneCheckerOnScreen",
+  "note-taking-on-screen": "noteTakingOnScreen",
+  "visual-organizer-on-screen": "visualOrganizerOnScreen",
+  "outliner-on-screen": "outlinerOnScreen",
+  "peer-interaction-on-screen": "peerInteractionOnScreen",
+  "spell-checker-on-screen": "spellCheckerOnScreen"
+};
+function resolvePnpActivation(pnp) {
+  const prohibited = new Set(pnp?.prohibitSet?.features ?? []);
+  const active = new Set;
+  const optional = new Set;
+  if (!pnp) {
+    return { active, optional, prohibited };
+  }
+  const optedIn = new Set(pnp.activateAsOptionSet?.features ?? []);
+  for (const feature of pnp.activateAtInitializationSet?.features ?? []) {
+    active.add(feature);
+  }
+  for (const [feature, field] of Object.entries(pnpFeatureFields)) {
+    if (pnp[field] === undefined || active.has(feature) || optedIn.has(feature)) {
+      continue;
+    }
+    active.add(feature);
+  }
+  for (const feature of optedIn) {
+    if (!active.has(feature)) {
+      optional.add(feature);
+    }
+  }
+  for (const feature of prohibited) {
+    active.delete(feature);
+    optional.delete(feature);
+  }
+  return { active, optional, prohibited };
+}
+function languagesMatch(left, right) {
+  const a3 = left.toLowerCase();
+  const b2 = right.toLowerCase();
+  return a3 === b2 || a3.split("-")[0] === b2.split("-")[0];
+}
+function camelCase(name) {
+  return name.replace(/-([a-z])/gu, (_2, letter) => letter.toUpperCase());
+}
+function pnpFeaturePreference(pnp, feature) {
+  const field = pnpFeatureFields[feature];
+  if (!pnp || !field) {
+    return;
+  }
+  const value = pnp[field];
+  const first = Array.isArray(value) ? value[0] : value;
+  return typeof first === "object" && first !== null ? first : undefined;
+}
+function entryMatches(entry, preference) {
+  if (entry.xmlLang !== undefined) {
+    const preferred = preference?.["xmlLang"];
+    if (typeof preferred !== "string" || !languagesMatch(entry.xmlLang, preferred)) {
+      return false;
+    }
+  }
+  for (const [name, value] of Object.entries(entry.dataAttributes ?? {})) {
+    const preferred = preference?.[camelCase(name)];
+    const comparable = typeof preferred === "string" || typeof preferred === "number" || typeof preferred === "boolean" ? `${preferred}` : undefined;
+    if (comparable === undefined || comparable !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveCard(card, pnp) {
+  if (!card.cardEntries) {
+    const cardLang = card.xmlLang ?? card.htmlContent?.xmlLang;
+    return {
+      support: card.support,
+      ...cardLang !== undefined ? { xmlLang: cardLang } : {},
+      ...card.htmlContent?.content ? { content: card.htmlContent.content } : {},
+      ...card.fileHrefs ? { fileHrefs: card.fileHrefs } : {}
+    };
+  }
+  const preference = pnpFeaturePreference(pnp, card.support);
+  const entry = card.cardEntries.find((candidate) => entryMatches(candidate, preference)) ?? card.cardEntries.find((candidate) => candidate.default === true);
+  if (!entry) {
+    return;
+  }
+  const xmlLang = entry.xmlLang ?? entry.htmlContent?.xmlLang ?? card.xmlLang;
+  return {
+    support: card.support,
+    ...xmlLang !== undefined ? { xmlLang } : {},
+    ...entry.htmlContent?.content ? { content: entry.htmlContent.content } : {},
+    ...entry.fileHrefs ? { fileHrefs: entry.fileHrefs } : {}
+  };
+}
+function resolveCatalogSupports(options) {
+  const activation = resolvePnpActivation(options.pnp);
+  const effective = new Set(activation.active);
+  for (const support of options.activeSupports ?? []) {
+    if (!activation.prohibited.has(support)) {
+      effective.add(support);
+    }
+  }
+  const byCatalogId = new Map;
+  for (const catalog of options.catalogs ?? []) {
+    const resolved = [];
+    for (const card of catalog.cards) {
+      if (!effective.has(card.support)) {
+        continue;
+      }
+      const support = resolveCard(card, options.pnp);
+      if (support) {
+        resolved.push(support);
+      }
+    }
+    byCatalogId.set(catalog.id, resolved);
+  }
+  return { activation, byCatalogId };
+}
+
+// src/test/controller.ts
+var supportedOutcomeRuleKinds = new Set([
+  "outcomeCondition",
+  "setOutcomeValue",
+  "lookupOutcomeValue",
+  "outcomeProcessingFragment",
+  "exitTest"
+]);
+var testExpressionKinds = new Set([
+  ...deterministicExpressionKinds,
+  "testVariables",
+  "outcomeMinimum",
+  "outcomeMaximum",
+  "numberCorrect",
+  "numberIncorrect",
+  "numberPresented",
+  "numberResponded",
+  "numberSelected"
+]);
+
+class ExitTestSignal extends Error {
+}
+function inferBaseType(value) {
+  if (typeof value === "number") {
+    return "float";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  return;
+}
+function liftFlat(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return fromFlatValue(value, "multiple", inferBaseType(value[0]));
+  }
+  return fromFlatValue(value, "single", inferBaseType(value));
+}
+var specSessionControlDefaults = {
+  maxAttempts: 1,
+  showFeedback: false,
+  allowReview: true,
+  showSolution: false,
+  allowComment: false,
+  allowSkipping: true,
+  validateResponses: false
+};
+function definedControl(control) {
+  return control ? Object.fromEntries(Object.entries(control).filter(([, value]) => value !== undefined)) : {};
+}
+function seededPick(pool, count, random) {
+  const indices = pool.map((_2, index) => index);
+  for (let i3 = indices.length - 1;i3 > 0; i3 -= 1) {
+    const j2 = Math.floor(random() * (i3 + 1));
+    [indices[i3], indices[j2]] = [indices[j2], indices[i3]];
+  }
+  return indices.slice(0, Math.min(count, indices.length)).sort((a3, b2) => a3 - b2).map((index) => pool[index]);
+}
+function applySelection(children, selection, random) {
+  const required = children.filter((child) => child.required === true);
+  const needed = Math.max(0, selection.select - required.length);
+  if (selection.withReplacement === true) {
+    const counts = children.map((child) => child.required === true ? 1 : 0);
+    for (let draw = 0;draw < needed; draw += 1) {
+      const index = Math.floor(random() * children.length);
+      counts[index] = (counts[index] ?? 0) + 1;
+    }
+    return children.flatMap((child, index) => Array.from({ length: counts[index] ?? 0 }, () => child));
+  }
+  const optional = children.filter((child) => child.required !== true);
+  const picked = new Set([...required, ...seededPick(optional, needed, random)]);
+  return children.filter((child) => picked.has(child));
+}
+function applyOrdering(units, random) {
+  const result = units.map((unit) => unit.child.fixed === true ? unit : null);
+  const movable = units.filter((unit) => unit.child.fixed !== true);
+  const shuffled = seededPick(movable, movable.length, random);
+  for (let i3 = shuffled.length - 1;i3 > 0; i3 -= 1) {
+    const j2 = Math.floor(random() * (i3 + 1));
+    [shuffled[i3], shuffled[j2]] = [shuffled[j2], shuffled[i3]];
+  }
+  let cursor = 0;
+  return result.map((slot) => slot ?? shuffled[cursor++]);
+}
+function mixedUnits(children, random, sections) {
+  return children.flatMap((child) => {
+    if (child.kind !== "assessmentSection" || child.visible !== false || child.keepTogether !== false) {
+      return [{ child, via: [] }];
+    }
+    sections[child.identifier] = {
+      identifier: child.identifier,
+      ...child.timeLimits ? { timeLimits: child.timeLimits } : {}
+    };
+    const inner = child.selection ? applySelection(child.children, child.selection, random) : child.children;
+    return mixedUnits(inner, random, sections).map((unit) => ({ child: unit.child, via: [child, ...unit.via] }));
+  });
+}
+function resolveSection(section, partIdentifier, sectionPath, inheritedPreConditions, inheritedControl, random, sections) {
+  const path = [...sectionPath, section.identifier];
+  sections[section.identifier] = {
+    identifier: section.identifier,
+    ...section.timeLimits ? { timeLimits: section.timeLimits } : {}
+  };
+  const preConditions = [...inheritedPreConditions, ...section.preConditions ?? []];
+  const control = { ...inheritedControl, ...definedControl(section.itemSessionControl) };
+  let children = section.children;
+  if (section.selection) {
+    children = applySelection(children, section.selection, random);
+  }
+  let units = children.map((child) => ({ child, via: [] }));
+  if (section.ordering?.shuffle) {
+    units = applyOrdering(mixedUnits(children, random, sections), random);
+  }
+  const items = [];
+  for (const { child, via } of units) {
+    const viaPath = [...path, ...via.map((entry) => entry.identifier)];
+    const viaPreConditions = [...preConditions, ...via.flatMap((entry) => entry.preConditions ?? [])];
+    const viaControl = via.reduce((merged, entry) => ({ ...merged, ...definedControl(entry.itemSessionControl) }), control);
+    if (child.kind === "assessmentSection") {
+      items.push(...resolveSection(child, partIdentifier, viaPath, viaPreConditions, viaControl, random, sections));
+    } else {
+      items.push({
+        key: child.identifier,
+        ref: child,
+        partIdentifier,
+        sectionPath: viaPath,
+        preConditions: [...viaPreConditions, ...child.preConditions ?? []],
+        sessionControl: { ...specSessionControlDefaults, ...viaControl, ...definedControl(child.itemSessionControl) },
+        ...child.timeLimits ? { timeLimits: child.timeLimits } : {}
+      });
+    }
+  }
+  return items;
+}
+function resolvePlan(view, seed) {
+  const random = mulberry32(seed);
+  const sections = {};
+  const parts = view.testParts.map((part) => ({
+    identifier: part.identifier,
+    navigationMode: part.navigationMode,
+    submissionMode: part.submissionMode,
+    ...part.timeLimits ? { timeLimits: part.timeLimits } : {},
+    items: part.assessmentSections.flatMap((section) => resolveSection(section, part.identifier, [], [], definedControl(part.itemSessionControl), random, sections))
+  }));
+  const totals = new Map;
+  for (const part of parts) {
+    for (const item of part.items) {
+      totals.set(item.ref.identifier, (totals.get(item.ref.identifier) ?? 0) + 1);
+    }
+  }
+  const ordinals = new Map;
+  const keyedParts = parts.map((part) => ({
+    ...part,
+    items: part.items.map((item) => {
+      if ((totals.get(item.ref.identifier) ?? 0) < 2) {
+        return item;
+      }
+      const instance = (ordinals.get(item.ref.identifier) ?? 0) + 1;
+      ordinals.set(item.ref.identifier, instance);
+      return { ...item, key: `${item.ref.identifier}.${instance}`, instance };
+    })
+  }));
+  return {
+    ...view.timeLimits ? { timeLimits: view.timeLimits } : {},
+    parts: keyedParts,
+    sections
+  };
+}
+function createTestController(view, options) {
+  const plan = resolvePlan(view, options.seed);
+  const allItems = plan.parts.flatMap((part) => [...part.items]);
+  const partIndexByItemKey = new Map;
+  const itemsByKey = new Map;
+  const instancesByRef = new Map;
+  plan.parts.forEach((part, partIndex) => {
+    for (const item of part.items) {
+      partIndexByItemKey.set(item.key, partIndex);
+      itemsByKey.set(item.key, item);
+      const siblings = instancesByRef.get(item.ref.identifier);
+      if (siblings) {
+        siblings.push(item);
+      } else {
+        instancesByRef.set(item.ref.identifier, [item]);
+      }
+    }
+  });
+  function attemptsOf(state, itemKey) {
+    return (state.attemptCounts ?? {})[itemKey] ?? 0;
+  }
+  function subsetItems(expression) {
+    const asList2 = (value) => typeof value === "string" ? [value] : value;
+    const includeCategory = asList2(expression.includeCategory);
+    const excludeCategory = asList2(expression.excludeCategory);
+    return allItems.filter((item) => {
+      if (expression.sectionIdentifier !== undefined && !item.sectionPath.includes(expression.sectionIdentifier)) {
+        return false;
+      }
+      const categories = item.ref.categories ?? [];
+      if (includeCategory !== undefined && !includeCategory.some((category) => categories.includes(category))) {
+        return false;
+      }
+      return !(excludeCategory !== undefined && excludeCategory.some((category) => categories.includes(category)));
+    });
+  }
+  function weightOf(item, weightIdentifier) {
+    if (weightIdentifier === undefined) {
+      return 1;
+    }
+    return item.ref.weights?.find((entry) => entry.identifier === weightIdentifier)?.value ?? 1;
+  }
+  function remainingAttempts(state, itemKey) {
+    const item = itemsByKey.get(itemKey);
+    if (!item) {
+      return 0;
+    }
+    const max = item.sessionControl.maxAttempts;
+    return max === 0 ? Number.POSITIVE_INFINITY : Math.max(0, max - attemptsOf(state, itemKey));
+  }
+  const now = options.now ?? Date.now;
+  function touch(state) {
+    if (state.status !== "in-progress") {
+      return state;
+    }
+    const nowMs = now();
+    const timing = state.timing ?? {
+      lastTransitionAtMs: nowMs,
+      testSeconds: 0,
+      partSeconds: {},
+      sectionSeconds: {},
+      itemSeconds: {}
+    };
+    const elapsed = Math.max(0, nowMs - timing.lastTransitionAtMs) / 1000;
+    const bump = (record, key) => ({
+      ...record,
+      [key]: (record[key] ?? 0) + elapsed
+    });
+    const item = state.currentItemKey === null ? undefined : itemsByKey.get(state.currentItemKey);
+    return {
+      ...state,
+      timing: {
+        lastTransitionAtMs: nowMs,
+        testSeconds: timing.testSeconds + elapsed,
+        partSeconds: item ? bump(timing.partSeconds, item.partIdentifier) : timing.partSeconds,
+        sectionSeconds: item ? item.sectionPath.reduce((record, identifier) => bump(record, identifier), timing.sectionSeconds) : timing.sectionSeconds,
+        itemSeconds: item ? bump(timing.itemSeconds, item.key) : timing.itemSeconds
+      }
+    };
+  }
+  function secondsOf(state, scope) {
+    const timing = state.timing;
+    if (!timing) {
+      return 0;
+    }
+    switch (scope.kind) {
+      case "test":
+        return timing.testSeconds;
+      case "part":
+        return timing.partSeconds[scope.identifier] ?? 0;
+      case "section":
+        return timing.sectionSeconds[scope.identifier] ?? 0;
+      case "item":
+        return timing.itemSeconds[scope.key] ?? 0;
+    }
+  }
+  function timeLimitsOf(scope) {
+    switch (scope.kind) {
+      case "test":
+        return plan.timeLimits;
+      case "part":
+        return plan.parts.find((part) => part.identifier === scope.identifier)?.timeLimits;
+      case "section":
+        return plan.sections[scope.identifier]?.timeLimits;
+      case "item":
+        return itemsByKey.get(scope.key)?.timeLimits;
+    }
+  }
+  const additionalTestingTime = resolvePnpActivation(options.pnp).active.has("additional-testing-time") ? options.pnp?.additionalTestingTime : undefined;
+  function effectiveMaxTime(scope) {
+    if (additionalTestingTime?.unlimited === true) {
+      return;
+    }
+    const declared = timeLimitsOf(scope)?.maxTime;
+    if (declared === undefined) {
+      return;
+    }
+    if (additionalTestingTime?.timeMultiplier !== undefined) {
+      return declared * additionalTestingTime.timeMultiplier;
+    }
+    if (additionalTestingTime?.fixedMinutes !== undefined && scope.kind === "test") {
+      return declared + additionalTestingTime.fixedMinutes * 60;
+    }
+    return declared;
+  }
+  function scopeExpired(state, scope) {
+    const maxTime = effectiveMaxTime(scope);
+    return maxTime !== undefined && secondsOf(state, scope) > maxTime;
+  }
+  function enclosingScopes(item) {
+    return [
+      { kind: "item", key: item.key },
+      ...[...item.sectionPath].reverse().map((identifier) => ({ kind: "section", identifier })),
+      { kind: "part", identifier: item.partIdentifier },
+      { kind: "test" }
+    ];
+  }
+  function navigableInTime(state, item) {
+    return !enclosingScopes(item).some((scope) => scopeExpired(state, scope));
+  }
+  function minTimeBlocked(state, from, to) {
+    const itemMin = from.timeLimits?.minTime;
+    if (itemMin !== undefined && secondsOf(state, { kind: "item", key: from.key }) < itemMin) {
+      return true;
+    }
+    const destinationSections = new Set(to?.sectionPath ?? []);
+    return from.sectionPath.some((identifier) => {
+      if (destinationSections.has(identifier)) {
+        return false;
+      }
+      const minTime = plan.sections[identifier]?.timeLimits?.minTime;
+      return minTime !== undefined && secondsOf(state, { kind: "section", identifier }) < minTime;
+    });
+  }
+  function defaultTestOutcomes() {
+    const outcomes = new Map;
+    for (const declaration of view.outcomeDeclarations ?? []) {
+      if (declaration.defaultValue) {
+        outcomes.set(declaration.identifier, rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType));
+        continue;
+      }
+      outcomes.set(declaration.identifier, isNumericBaseType(declaration.baseType) ? floatValue(0) : null);
+    }
+    return outcomes;
+  }
+  const durationValue = (seconds) => rpValue("single", [seconds], "duration");
+  function makeEnv(state, outcomes) {
+    return {
+      lookupVariable: (identifier) => {
+        if (identifier === "duration") {
+          return state.timing === undefined ? null : durationValue(state.timing.testSeconds);
+        }
+        const dot = identifier.indexOf(".");
+        if (dot !== -1) {
+          let itemKey = identifier.slice(0, dot);
+          let variableName = identifier.slice(dot + 1);
+          const secondDot = identifier.indexOf(".", dot + 1);
+          if (secondDot !== -1 && itemsByKey.has(identifier.slice(0, secondDot))) {
+            itemKey = identifier.slice(0, secondDot);
+            variableName = identifier.slice(secondDot + 1);
+          }
+          const instances = instancesByRef.get(itemKey);
+          if (instances !== undefined && instances.length > 1) {
+            const partIndex = partIndexByItemKey.get(instances[0].key);
+            if (partIndex === undefined || plan.parts[partIndex].submissionMode !== "simultaneous") {
+              return null;
+            }
+            for (let index = instances.length - 1;index >= 0; index -= 1) {
+              const instanceKey = instances[index].key;
+              if (variableName === "duration") {
+                const seconds = state.itemDurationSeconds?.[instanceKey];
+                if (seconds !== undefined) {
+                  return durationValue(seconds);
+                }
+              } else if (state.itemOutcomes[instanceKey] !== undefined) {
+                return liftFlat(state.itemOutcomes[instanceKey]?.[variableName] ?? null);
+              }
+            }
+            return null;
+          }
+          if (variableName === "duration") {
+            if (itemsByKey.has(itemKey)) {
+              const seconds = state.itemDurationSeconds?.[itemKey];
+              return seconds === undefined ? null : durationValue(seconds);
+            }
+            const partSeconds = state.timing?.partSeconds[itemKey];
+            if (plan.parts.some((part) => part.identifier === itemKey)) {
+              return partSeconds === undefined ? null : durationValue(partSeconds);
+            }
+            if (plan.sections[itemKey]) {
+              const seconds = state.timing?.sectionSeconds[itemKey];
+              return seconds === undefined ? null : durationValue(seconds);
+            }
+            return null;
+          }
+          return liftFlat(state.itemOutcomes[itemKey]?.[variableName] ?? null);
+        }
+        if (outcomes?.has(identifier)) {
+          return outcomes.get(identifier) ?? null;
+        }
+        return liftFlat(state.testOutcomes[identifier] ?? null);
+      },
+      responseDeclaration: () => {
+        return;
+      },
+      responseValue: () => null,
+      testVariables: (expression) => {
+        const variableName = expression.variableIdentifier ?? expression.identifier ?? "";
+        const weightIdentifier = expression.weightIdentifier;
+        const members = [];
+        let baseType = expression.baseType;
+        for (const item of subsetItems(expression)) {
+          const value = state.itemOutcomes[item.key]?.[variableName];
+          if (value === undefined || value === null) {
+            continue;
+          }
+          const lifted = liftFlat(value);
+          if (lifted === null) {
+            continue;
+          }
+          if (weightIdentifier !== undefined && isNumericBaseType(lifted.baseType)) {
+            baseType = "float";
+            members.push(...lifted.values.map((entry) => Number(entry) * weightOf(item, weightIdentifier)));
+            continue;
+          }
+          baseType ??= lifted.baseType;
+          members.push(...lifted.values);
+        }
+        return members.length === 0 ? null : rpValue("multiple", members, baseType);
+      },
+      testAggregate: (expression) => {
+        const subset = subsetItems(expression);
+        const integer = (value) => ({
+          cardinality: "single",
+          baseType: "integer",
+          values: [value]
+        });
+        const countIn = (list) => {
+          const flagged = new Set(list ?? []);
+          return subset.filter((item) => flagged.has(item.key)).length;
+        };
+        switch (expression.kind) {
+          case "numberSelected":
+            return integer(subset.length);
+          case "numberPresented":
+            return integer(countIn(state.presentedItems));
+          case "numberResponded":
+            return integer(countIn(state.respondedItems));
+          case "numberCorrect":
+            return integer(countIn(state.correctItems));
+          case "numberIncorrect":
+            return integer(countIn(state.incorrectItems));
+          case "outcomeMinimum":
+          case "outcomeMaximum": {
+            const bound = expression.kind === "outcomeMaximum" ? "normalMaximum" : "normalMinimum";
+            const members = [];
+            for (const item of subset) {
+              const declared = options.itemOutcomeDeclarations?.[item.ref.identifier]?.find((entry) => entry.identifier === expression.outcomeIdentifier)?.[bound];
+              if (declared === undefined) {
+                if (expression.kind === "outcomeMaximum") {
+                  return null;
+                }
+                continue;
+              }
+              members.push(declared * weightOf(item, expression.weightIdentifier));
+            }
+            return members.length === 0 ? null : rpValue("multiple", members, "float");
+          }
+          default:
+            throw new RpUnsupportedError(expression.kind);
+        }
+      }
+    };
+  }
+  function conditionPasses(expression, state) {
+    try {
+      return singleBoolean(evaluateExpression(expression, makeEnv(state))) === true;
+    } catch (error) {
+      if (error instanceof RpUnsupportedError) {
+        return true;
+      }
+      throw error;
+    }
+  }
+  function preConditionsPass(item, state) {
+    return item.preConditions.every((expression) => conditionPasses(expression, state));
+  }
+  function runOutcomeProcessing(state) {
+    let outcomes = defaultTestOutcomes();
+    const env = makeEnv(state, outcomes);
+    function branchTaken(branch) {
+      if (singleBoolean(evaluateExpression(branch.expression, env)) !== true) {
+        return false;
+      }
+      executeRules(branch.rules);
+      return true;
+    }
+    function executeRules(rules) {
+      for (const rule of rules) {
+        if (!supportedOutcomeRuleKinds.has(rule.kind)) {
+          throw new RpUnsupportedError(rule.kind);
+        }
+        if (rule.kind === "exitTest") {
+          throw new ExitTestSignal;
+        }
+        if (rule.kind === "setOutcomeValue") {
+          if (rule.identifier !== undefined && rule.expression !== undefined) {
+            outcomes.set(rule.identifier, evaluateExpression(rule.expression, env));
+          }
+          continue;
+        }
+        if (rule.kind === "outcomeProcessingFragment") {
+          executeRules(rule.rules ?? []);
+          continue;
+        }
+        if (rule.kind === "lookupOutcomeValue") {
+          if (rule.identifier !== undefined && rule.expression !== undefined) {
+            const declaration = (view.outcomeDeclarations ?? []).find((entry) => entry.identifier === rule.identifier);
+            if (!hasLookupTable(declaration)) {
+              throw new RpUnsupportedError("lookupOutcomeValue");
+            }
+            outcomes.set(rule.identifier, lookupTableValue(declaration, evaluateExpression(rule.expression, env)));
+          }
+          continue;
+        }
+        if (rule.outcomeIf && branchTaken(rule.outcomeIf)) {
+          continue;
+        }
+        const elseIfTaken = (rule.outcomeElseIfs ?? []).some((branch) => branchTaken(branch));
+        if (!elseIfTaken && rule.outcomeElse) {
+          executeRules(rule.outcomeElse.rules);
+        }
+      }
+    }
+    try {
+      executeRules(view.outcomeProcessing?.rules ?? []);
+    } catch (error) {
+      if (error instanceof RpUnsupportedError) {
+        outcomes = defaultTestOutcomes();
+      } else if (!(error instanceof ExitTestSignal)) {
+        throw error;
+      }
+    }
+    return Object.fromEntries([...outcomes].map(([identifier, value]) => [identifier, toOutcomeValue(value)]));
+  }
+  function firstNavigable(state, partIndex, itemIndex) {
+    for (let p2 = partIndex;p2 < plan.parts.length; p2 += 1) {
+      const items = plan.parts[p2].items;
+      for (let i3 = p2 === partIndex ? itemIndex : 0;i3 < items.length; i3 += 1) {
+        const item = items[i3];
+        if (preConditionsPass(item, state) && navigableInTime(state, item)) {
+          return item;
+        }
+      }
+    }
+    return null;
+  }
+  function positionOf(itemKey) {
+    const partIndex = partIndexByItemKey.get(itemKey);
+    if (partIndex === undefined) {
+      return null;
+    }
+    const itemIndex = plan.parts[partIndex].items.findIndex((item) => item.key === itemKey);
+    return itemIndex === -1 ? null : { partIndex, itemIndex };
+  }
+  function withFlag(list, itemKey, present) {
+    const existing = list ?? [];
+    if (existing.includes(itemKey) === present) {
+      return existing;
+    }
+    return present ? [...existing, itemKey] : existing.filter((entry) => entry !== itemKey);
+  }
+  function applyResultFlags(state, itemKey, result) {
+    return {
+      ...state,
+      respondedItems: withFlag(state.respondedItems, itemKey, result.responded === true),
+      correctItems: withFlag(state.correctItems, itemKey, result.correct === true),
+      incorrectItems: withFlag(state.incorrectItems, itemKey, result.correct === false)
+    };
+  }
+  function markPresented(state, itemKey) {
+    return (state.presentedItems ?? []).includes(itemKey) ? state : { ...state, presentedItems: [...state.presentedItems ?? [], itemKey] };
+  }
+  function withRecordedAttempt(state, itemKey, result, atMs) {
+    const entry = {
+      atMs,
+      outcomes: result.outcomes,
+      ...result.responses !== undefined ? { responses: result.responses } : {},
+      ...result.durationSeconds !== undefined ? { durationSeconds: result.durationSeconds } : {}
+    };
+    return {
+      ...state,
+      attemptHistory: {
+        ...state.attemptHistory ?? {},
+        [itemKey]: [...state.attemptHistory?.[itemKey] ?? [], entry]
+      }
+    };
+  }
+  function flushPending(state, partIndex) {
+    const pending = state.pendingItemResults ?? {};
+    const keys = Object.keys(pending).filter((key) => partIndex === null || partIndexByItemKey.get(key) === partIndex);
+    if (keys.length === 0) {
+      return state;
+    }
+    const itemOutcomes = { ...state.itemOutcomes };
+    const attemptCounts = { ...state.attemptCounts ?? {} };
+    const itemDurations = { ...state.itemDurationSeconds ?? {} };
+    const remaining = { ...pending };
+    let flagged = state;
+    for (const key of keys) {
+      const result = pending[key];
+      itemOutcomes[key] = result.outcomes;
+      attemptCounts[key] = (attemptCounts[key] ?? 0) + 1;
+      delete remaining[key];
+      if (result.durationSeconds !== undefined) {
+        itemDurations[key] = result.durationSeconds;
+      }
+      flagged = withRecordedAttempt(applyResultFlags(flagged, key, result), key, result, result.submittedAtMs ?? now());
+    }
+    return {
+      ...flagged,
+      itemOutcomes,
+      attemptCounts,
+      itemDurationSeconds: itemDurations,
+      pendingItemResults: remaining
+    };
+  }
+  function ended(state) {
+    const flushed = flushPending(state, null);
+    return { ...flushed, status: "ended", currentItemKey: null, testOutcomes: runOutcomeProcessing(flushed) };
+  }
+  function evaluateTemplateDefaults(state, item) {
+    const defaults = item.ref.templateDefaults;
+    if (!defaults || defaults.length === 0) {
+      return;
+    }
+    const env = makeEnv(state);
+    const values = {};
+    for (const entry of defaults) {
+      try {
+        values[entry.templateIdentifier] = toOutcomeValue(evaluateExpression(entry.expression, env));
+      } catch (error) {
+        if (!(error instanceof RpUnsupportedError)) {
+          throw error;
+        }
+      }
+    }
+    return values;
+  }
+  function withTemplateDefaults(state, items) {
+    let merged = state.templateDefaultValues ?? {};
+    let changed = false;
+    for (const item of items) {
+      if (merged[item.key] !== undefined) {
+        continue;
+      }
+      const values = evaluateTemplateDefaults(state, item);
+      if (values) {
+        merged = { ...merged, [item.key]: values };
+        changed = true;
+      }
+    }
+    return changed ? { ...state, templateDefaultValues: merged } : state;
+  }
+  function moveToItem(state, item) {
+    if (item === null) {
+      return ended(state);
+    }
+    const fromPart = state.currentItemKey === null ? undefined : partIndexByItemKey.get(state.currentItemKey);
+    const toPart = partIndexByItemKey.get(item.key);
+    let next = state;
+    if (fromPart !== undefined && toPart !== fromPart) {
+      const flushed = flushPending(state, fromPart);
+      if (flushed !== state) {
+        next = { ...flushed, testOutcomes: runOutcomeProcessing(flushed) };
+      }
+    }
+    const part = toPart === undefined ? undefined : plan.parts[toPart];
+    if (part) {
+      next = withTemplateDefaults(next, part.navigationMode === "nonlinear" ? part.items : [item]);
+    }
+    return markPresented({ ...next, currentItemKey: item.key }, item.key);
+  }
+  function nextState(state) {
+    if (state.status !== "in-progress" || state.currentItemKey === null) {
+      return state;
+    }
+    const current = positionOf(state.currentItemKey);
+    if (!current) {
+      return ended(state);
+    }
+    const part = plan.parts[current.partIndex];
+    const currentItem = part.items[current.itemIndex];
+    if (part.navigationMode === "linear" && !currentItem.sessionControl.allowSkipping && !state.attemptedItems.includes(currentItem.key)) {
+      return state;
+    }
+    if (part.navigationMode === "linear" && minTimeBlocked(state, currentItem, firstNavigable(state, current.partIndex, current.itemIndex + 1))) {
+      return state;
+    }
+    for (const branchRule of currentItem.ref.branchRules ?? []) {
+      if (!conditionPasses(branchRule.expression, state)) {
+        continue;
+      }
+      if (branchRule.target === "EXIT_TEST") {
+        return ended(state);
+      }
+      if (branchRule.target === "EXIT_TESTPART") {
+        return moveToItem(state, firstNavigable(state, current.partIndex + 1, 0));
+      }
+      if (branchRule.target === "EXIT_SECTION") {
+        const items = part.items;
+        const sectionKey = currentItem.sectionPath.join("/");
+        let index = current.itemIndex + 1;
+        while (index < items.length && items[index].sectionPath.join("/") === sectionKey) {
+          index += 1;
+        }
+        return moveToItem(state, firstNavigable(state, current.partIndex, index));
+      }
+      const target = positionOf(branchRule.target) ?? (instancesByRef.get(branchRule.target) ?? []).map((instance) => positionOf(instance.key)).find((position) => position !== null && position.partIndex === current.partIndex && position.itemIndex > current.itemIndex) ?? null;
+      if (target && target.partIndex === current.partIndex) {
+        return moveToItem(state, firstNavigable(state, target.partIndex, target.itemIndex));
+      }
+    }
+    const destination = firstNavigable(state, current.partIndex, current.itemIndex + 1);
+    if (part.navigationMode === "nonlinear" && (destination === null || partIndexByItemKey.get(destination.key) !== current.partIndex)) {
+      const blocked = part.items.some((item) => !item.sessionControl.allowSkipping && !state.attemptedItems.includes(item.key) && preConditionsPass(item, state) && navigableInTime(state, item));
+      if (blocked) {
+        return state;
+      }
+    }
+    return moveToItem(state, destination);
+  }
+  function reviewBarred(state, item) {
+    return item.sessionControl.allowReview === false && remainingAttempts(state, item.key) <= 0;
+  }
+  function reviewable(state, itemKey) {
+    const item = itemsByKey.get(itemKey);
+    return state.status === "ended" && item !== undefined && item.sessionControl.allowReview && (state.presentedItems ?? []).includes(itemKey);
+  }
+  function commentable(state, itemKey) {
+    return state.status === "in-progress" && itemsByKey.get(itemKey)?.sessionControl.allowComment === true;
+  }
+  function submitBody(state, itemKey, result) {
+    const partIndex = partIndexByItemKey.get(itemKey);
+    if (partIndex !== undefined && plan.parts[partIndex].submissionMode === "simultaneous") {
+      if (attemptsOf(state, itemKey) > 0) {
+        return state;
+      }
+      return {
+        ...state,
+        pendingItemResults: { ...state.pendingItemResults ?? {}, [itemKey]: { ...result, submittedAtMs: now() } },
+        attemptedItems: state.attemptedItems.includes(itemKey) ? state.attemptedItems : [...state.attemptedItems, itemKey]
+      };
+    }
+    if (result.valid === false && itemsByKey.get(itemKey)?.sessionControl.validateResponses === true) {
+      return state;
+    }
+    if (result.adaptive !== true && remainingAttempts(state, itemKey) <= 0) {
+      return state;
+    }
+    const next = {
+      ...withRecordedAttempt(applyResultFlags(state, itemKey, result), itemKey, result, now()),
+      itemOutcomes: { ...state.itemOutcomes, [itemKey]: result.outcomes },
+      attemptedItems: state.attemptedItems.includes(itemKey) ? state.attemptedItems : [...state.attemptedItems, itemKey],
+      attemptCounts: { ...state.attemptCounts ?? {}, [itemKey]: attemptsOf(state, itemKey) + 1 },
+      ...result.durationSeconds !== undefined ? { itemDurationSeconds: { ...state.itemDurationSeconds ?? {}, [itemKey]: result.durationSeconds } } : {}
+    };
+    return { ...next, testOutcomes: runOutcomeProcessing(next) };
+  }
+  function applyExpiries(state) {
+    if (state.status !== "in-progress") {
+      return state;
+    }
+    if (scopeExpired(state, { kind: "test" })) {
+      return ended(state);
+    }
+    const currentKey = state.currentItemKey;
+    const item = currentKey === null ? undefined : itemsByKey.get(currentKey);
+    if (!item || navigableInTime(state, item)) {
+      return state;
+    }
+    const position = positionOf(item.key);
+    return position === null ? ended(state) : moveToItem(state, firstNavigable(state, position.partIndex, position.itemIndex + 1));
+  }
+  function withTransition(state, op) {
+    if (state.status !== "in-progress") {
+      return state;
+    }
+    const touched = touch(state);
+    const settled = applyExpiries(touched);
+    if (settled !== touched) {
+      return settled;
+    }
+    const result = op(settled);
+    return result === settled ? state : result;
+  }
+  const issues = [];
+  const seenIssues = new Set;
+  function report(name) {
+    if (!seenIssues.has(name)) {
+      seenIssues.add(name);
+      issues.push({ type: "unsupported-rp", name });
+    }
+  }
+  function walkOutcomeRules(rules) {
+    for (const rule of rules) {
+      if (!supportedOutcomeRuleKinds.has(rule.kind)) {
+        report(rule.kind);
+        continue;
+      }
+      if (rule.kind === "lookupOutcomeValue") {
+        const declaration = (view.outcomeDeclarations ?? []).find((entry) => entry.identifier === rule.identifier);
+        if (!hasLookupTable(declaration)) {
+          report("lookupOutcomeValue");
+        }
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, testExpressionKinds, report);
+      }
+      if (rule.rules) {
+        walkOutcomeRules(rule.rules);
+      }
+      for (const branch of [rule.outcomeIf, ...rule.outcomeElseIfs ?? []]) {
+        if (branch) {
+          collectExpressionIssues(branch.expression, testExpressionKinds, report);
+          walkOutcomeRules(branch.rules);
+        }
+      }
+      if (rule.outcomeElse) {
+        walkOutcomeRules(rule.outcomeElse.rules);
+      }
+    }
+  }
+  walkOutcomeRules(view.outcomeProcessing?.rules ?? []);
+  for (const item of allItems) {
+    for (const expression of item.preConditions) {
+      collectExpressionIssues(expression, testExpressionKinds, report);
+    }
+    for (const branchRule of item.ref.branchRules ?? []) {
+      collectExpressionIssues(branchRule.expression, testExpressionKinds, report);
+    }
+    for (const entry of item.ref.templateDefaults ?? []) {
+      collectExpressionIssues(entry.expression, testExpressionKinds, report);
+    }
+  }
+  return {
+    test: view,
+    plan,
+    issues,
+    start: () => {
+      const initial = {
+        status: "in-progress",
+        currentItemKey: null,
+        itemOutcomes: {},
+        attemptedItems: [],
+        attemptCounts: {},
+        presentedItems: [],
+        respondedItems: [],
+        correctItems: [],
+        incorrectItems: [],
+        pendingItemResults: {},
+        testOutcomes: {},
+        timing: {
+          lastTransitionAtMs: now(),
+          testSeconds: 0,
+          partSeconds: {},
+          sectionSeconds: {},
+          itemSeconds: {}
+        }
+      };
+      const opened = { ...initial, testOutcomes: runOutcomeProcessing(initial) };
+      return moveToItem(opened, firstNavigable(opened, 0, 0));
+    },
+    currentItem: (state) => state.currentItemKey === null ? null : allItems.find((item) => item.key === state.currentItemKey) ?? null,
+    canMoveTo: (state, itemKey) => {
+      if (state.status !== "in-progress" || state.currentItemKey === null) {
+        return false;
+      }
+      const current = positionOf(state.currentItemKey);
+      const target = positionOf(itemKey);
+      if (!current || !target || target.partIndex !== current.partIndex) {
+        return false;
+      }
+      if (plan.parts[current.partIndex].navigationMode !== "nonlinear") {
+        return false;
+      }
+      const item = plan.parts[target.partIndex].items[target.itemIndex];
+      return preConditionsPass(item, state) && navigableInTime(state, item) && !reviewBarred(state, item);
+    },
+    moveTo: (state, itemKey) => withTransition(state, (settled) => {
+      const current = positionOf(settled.currentItemKey ?? "");
+      const target = positionOf(itemKey);
+      const item = itemsByKey.get(itemKey);
+      if (!current || !target || !item || target.partIndex !== current.partIndex || plan.parts[current.partIndex].navigationMode !== "nonlinear" || !navigableInTime(settled, item) || reviewBarred(settled, item)) {
+        return settled;
+      }
+      return markPresented({ ...settled, currentItemKey: itemKey }, itemKey);
+    }),
+    canNext: (state) => nextState(state) !== state,
+    next: (state) => withTransition(state, nextState),
+    remainingAttempts,
+    canSubmitItem: (state, itemKey) => {
+      if (state.status !== "in-progress" || remainingAttempts(state, itemKey) <= 0) {
+        return false;
+      }
+      const item = itemsByKey.get(itemKey);
+      return item !== undefined && enclosingScopes(item).every((scope) => !scopeExpired(state, scope) || timeLimitsOf(scope)?.allowLateSubmission === true);
+    },
+    submitItem: (state, itemKey, result) => {
+      const item = itemsByKey.get(itemKey);
+      if (state.status !== "in-progress" || !item) {
+        return state;
+      }
+      const touched = touch(state);
+      const barring = enclosingScopes(item).find((scope) => scopeExpired(touched, scope) && timeLimitsOf(scope)?.allowLateSubmission !== true);
+      if (barring) {
+        return applyExpiries({
+          ...touched,
+          rejectedSubmissions: [
+            ...touched.rejectedSubmissions ?? [],
+            { itemKey, scope: barring, atTestSeconds: touched.timing?.testSeconds ?? 0 }
+          ]
+        });
+      }
+      const accepted = submitBody(touched, itemKey, result);
+      return accepted === touched ? state : applyExpiries(accepted);
+    },
+    end: (state) => state.status === "ended" ? state : ended(touch(state)),
+    tick: (state) => state.status !== "in-progress" ? state : applyExpiries(touch(state)),
+    suspend: (state) => {
+      if (state.status !== "in-progress") {
+        return state;
+      }
+      const settled = applyExpiries(touch(state));
+      return settled.status === "in-progress" ? { ...settled, status: "suspended" } : settled;
+    },
+    resume: (state) => state.status !== "suspended" ? state : {
+      ...state,
+      status: "in-progress",
+      ...state.timing ? { timing: { ...state.timing, lastTransitionAtMs: now() } } : {}
+    },
+    canReview: reviewable,
+    review: (state, itemKey) => reviewable(state, itemKey) ? { ...state, currentItemKey: itemKey } : state,
+    canComment: commentable,
+    setItemComment: (state, itemKey, comment) => commentable(state, itemKey) ? { ...state, itemComments: { ...state.itemComments ?? {}, [itemKey]: comment } } : state,
+    visibleTestFeedbacks: (state) => (view.testFeedbacks ?? []).filter((feedback) => {
+      const accessOk = (feedback.access ?? "atEnd") === (state.status === "ended" ? "atEnd" : "during");
+      if (!accessOk) {
+        return false;
+      }
+      const outcome = state.testOutcomes[feedback.outcomeIdentifier] ?? null;
+      const matched = Array.isArray(outcome) ? outcome.map(String).includes(feedback.identifier) : outcome !== null && String(outcome) === feedback.identifier;
+      return matched !== (feedback.showHide === "hide");
+    })
+  };
+}
+// src/test/results.ts
+function iso(ms) {
+  return new Date(ms).toISOString();
+}
+function pnpSupports(pnp) {
+  if (!pnp) {
+    return [];
+  }
+  const activation = resolvePnpActivation(pnp);
+  const names = [...new Set([...activation.active, ...activation.optional, ...activation.prohibited])].sort();
+  return names.map((name) => {
+    if (activation.prohibited.has(name)) {
+      return { name, assignment: "prohibited" };
+    }
+    const preference = pnpFeaturePreference(pnp, name);
+    const xmlLang = typeof preference?.["xmlLang"] === "string" ? preference["xmlLang"] : undefined;
+    let value;
+    if (name === "additional-testing-time") {
+      const time = pnp.additionalTestingTime;
+      value = time?.unlimited === true ? "unlimited" : time?.timeMultiplier !== undefined ? String(time.timeMultiplier) : time?.fixedMinutes !== undefined ? String(time.fixedMinutes) : undefined;
+    }
+    return {
+      name,
+      assignment: "assigned",
+      ...value !== undefined ? { value } : {},
+      ...xmlLang !== undefined ? { xmlLang } : {}
+    };
+  });
+}
+function valueViews(value) {
+  if (value === null || value === undefined || value === "") {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((member) => member !== null && member !== "").map((member) => ({ value: String(member) }));
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).filter(([, member]) => member !== null && member !== "").map(([fieldIdentifier, member]) => ({ fieldIdentifier, value: String(member) }));
+  }
+  return [{ value: String(value) }];
+}
+function inferBaseType2(value, identifier) {
+  const sample = Array.isArray(value) ? value[0] : value;
+  if (typeof sample === "number") {
+    return "float";
+  }
+  if (typeof sample === "boolean") {
+    return "boolean";
+  }
+  if (identifier === "completionStatus" || identifier === "completion_status") {
+    return "identifier";
+  }
+  return typeof sample === "string" ? "string" : undefined;
+}
+function outcomeVariablesOf(outcomes, declarations) {
+  return Object.entries(outcomes).map(([identifier, value]) => {
+    const declaration = declarations?.find((entry) => entry.identifier === identifier);
+    const cardinality = declaration?.cardinality ?? (Array.isArray(value) ? "multiple" : "single");
+    const baseType = declaration?.baseType ?? inferBaseType2(value, identifier);
+    return {
+      identifier,
+      cardinality,
+      ...baseType !== undefined && cardinality !== "record" ? { baseType } : {},
+      values: valueViews(value)
+    };
+  });
+}
+function durationVariable(identifier, seconds) {
+  return {
+    identifier,
+    cardinality: "single",
+    baseType: "duration",
+    candidateResponse: { values: [{ value: String(seconds) }] }
+  };
+}
+function numAttemptsVariable(count) {
+  return {
+    identifier: "numAttempts",
+    cardinality: "single",
+    baseType: "integer",
+    candidateResponse: { values: [{ value: String(count) }] }
+  };
+}
+function responseVariablesOf(responses, details) {
+  return Object.entries(responses ?? {}).map(([identifier, value]) => {
+    const declaration = details?.responseDeclarations?.find((entry) => entry.identifier === identifier);
+    const cardinality = declaration?.cardinality ?? (Array.isArray(value) ? "multiple" : "single");
+    const baseType = declaration?.baseType;
+    const correct = details?.correctResponses?.[identifier];
+    const correctValues = correct === undefined ? [] : valueViews(correct);
+    return {
+      identifier,
+      cardinality,
+      ...baseType !== undefined && cardinality !== "record" ? { baseType } : {},
+      candidateResponse: { values: valueViews(value) },
+      ...correctValues.length > 0 ? { correctResponse: { values: correctValues } } : {}
+    };
+  });
+}
+function buildAssessmentResult(input) {
+  const { test, plan, state } = input;
+  const nowMs = input.nowMs ?? Date.now();
+  const timing = state.timing;
+  const scopeDurations = timing ? [
+    durationVariable("duration", timing.testSeconds),
+    ...plan.parts.filter((part) => timing.partSeconds[part.identifier] !== undefined).map((part) => durationVariable(`${part.identifier}.duration`, timing.partSeconds[part.identifier])),
+    ...Object.keys(plan.sections).filter((identifier) => timing.sectionSeconds[identifier] !== undefined).map((identifier) => durationVariable(`${identifier}.duration`, timing.sectionSeconds[identifier]))
+  ] : [];
+  const testOutcomes = outcomeVariablesOf(state.testOutcomes, test.outcomeDeclarations);
+  const supports = pnpSupports(input.pnp);
+  const testResult = {
+    identifier: test.identifier,
+    datestamp: iso(nowMs),
+    ...scopeDurations.length > 0 ? { responseVariables: scopeDurations } : {},
+    ...testOutcomes.length > 0 ? { outcomeVariables: testOutcomes } : {},
+    ...supports.length > 0 ? { supports } : {}
+  };
+  const itemResults = [];
+  let sequenceIndex = 0;
+  for (const part of plan.parts) {
+    for (const item of part.items) {
+      sequenceIndex += 1;
+      const details = input.itemDetails?.(item) ?? null;
+      const entries = [];
+      (state.attemptHistory?.[item.key] ?? []).forEach((attempt, index) => {
+        const outcomeVariables = outcomeVariablesOf(attempt.outcomes, details?.outcomeDeclarations);
+        entries.push({
+          identifier: item.key,
+          sequenceIndex,
+          datestamp: iso(attempt.atMs),
+          sessionStatus: "final",
+          responseVariables: [
+            numAttemptsVariable(index + 1),
+            ...attempt.durationSeconds !== undefined ? [durationVariable("duration", attempt.durationSeconds)] : [],
+            ...responseVariablesOf(attempt.responses, details)
+          ],
+          ...outcomeVariables.length > 0 ? { outcomeVariables } : {}
+        });
+      });
+      const pending = state.pendingItemResults?.[item.key];
+      if (pending) {
+        entries.push({
+          identifier: item.key,
+          sequenceIndex,
+          datestamp: iso(pending.submittedAtMs ?? nowMs),
+          sessionStatus: "pendingResponseProcessing",
+          responseVariables: [
+            numAttemptsVariable(1),
+            ...pending.durationSeconds !== undefined ? [durationVariable("duration", pending.durationSeconds)] : [],
+            ...responseVariablesOf(pending.responses, details)
+          ]
+        });
+      }
+      if (entries.length === 0) {
+        const itemSeconds = timing?.itemSeconds[item.key];
+        entries.push({
+          identifier: item.key,
+          sequenceIndex,
+          datestamp: iso(nowMs),
+          sessionStatus: "initial",
+          responseVariables: [
+            numAttemptsVariable(0),
+            ...itemSeconds !== undefined ? [durationVariable("duration", itemSeconds)] : []
+          ]
+        });
+      }
+      const comment = state.itemComments?.[item.key];
+      if (comment !== undefined) {
+        entries[entries.length - 1] = { ...entries[entries.length - 1], candidateComment: comment };
+      }
+      itemResults.push(...entries);
+    }
+  }
+  return {
+    assessmentResult: {
+      context: input.context ?? {},
+      testResult,
+      ...itemResults.length > 0 ? { itemResults } : {}
+    }
+  };
+}
+// src/test/session-store.ts
+function collectCorrectResponseTargets(rules, into) {
+  for (const rule of rules ?? []) {
+    if (rule.kind === "setCorrectResponse" && rule.identifier !== undefined) {
+      into.add(rule.identifier);
+    }
+    for (const branch of [rule.templateIf, ...rule.templateElseIfs ?? []]) {
+      if (branch) {
+        collectCorrectResponseTargets(branch.rules, into);
+      }
+    }
+    if (rule.templateElse) {
+      collectCorrectResponseTargets(rule.templateElse.rules, into);
+    }
+  }
+}
+function scorableIdentifiers(view) {
+  const templated = new Set;
+  collectCorrectResponseTargets(view.templateProcessing?.rules, templated);
+  return new Set(view.responseDeclarations.filter((declaration) => declaration.correctResponse !== undefined || declaration.mapping !== undefined || declaration.areaMapping !== undefined || templated.has(declaration.identifier)).map((declaration) => declaration.identifier));
+}
+function hasResponse(value) {
+  if (value === null || value === undefined || value === "") {
+    return false;
+  }
+  if (isResponseRecord(value)) {
+    return Object.values(value).some((member) => member !== null && member !== "");
+  }
+  return !Array.isArray(value) || value.length > 0;
+}
+function resultFlags(attempt, scorable) {
+  const relevant = attempt.scores.filter((score) => scorable.has(score.identifier));
+  return {
+    ...relevant.length > 0 ? { correct: relevant.every((score) => score.correct) } : {},
+    responded: Object.values(attempt.responses).some(hasResponse)
+  };
+}
+function deriveItemSeed(seed, itemKey) {
+  let hash = (2166136261 ^ seed) >>> 0;
+  for (let index = 0;index < itemKey.length; index += 1) {
+    hash = Math.imul(hash ^ itemKey.charCodeAt(index), 16777619) >>> 0;
+  }
+  return hash;
+}
+function createTestSessionStore(controller, options) {
+  const listeners = new Set;
+  const planItemsByKey = new Map;
+  for (const part of controller.plan.parts) {
+    for (const item of part.items) {
+      planItemsByKey.set(item.key, item);
+    }
+  }
+  const itemViews = new Map;
+  const itemStores = new Map;
+  const forwardedAttempts = new Map;
+  let state = options.initialState ?? controller.start();
+  let snapshot = buildSnapshot();
+  function buildSnapshot() {
+    const currentItem = controller.currentItem(state);
+    return {
+      state,
+      currentItem,
+      currentItemView: currentItem === null ? null : itemView(currentItem.key),
+      visibleFeedbacks: controller.visibleTestFeedbacks(state)
+    };
+  }
+  function activeKeyOf(sessionState) {
+    return sessionState.status === "in-progress" ? sessionState.currentItemKey : null;
+  }
+  function emit(next) {
+    const previousActive = activeKeyOf(state);
+    state = next;
+    snapshot = buildSnapshot();
+    const nextActive = activeKeyOf(next);
+    if (previousActive !== nextActive) {
+      if (previousActive !== null) {
+        itemStores.get(previousActive)?.suspend();
+      }
+      if (nextActive !== null) {
+        itemStores.get(nextActive)?.resume();
+      }
+    }
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function itemView(itemKey) {
+    if (!itemViews.has(itemKey)) {
+      const planItem = planItemsByKey.get(itemKey);
+      itemViews.set(itemKey, planItem ? options.resolveItem(planItem.ref) : null);
+    }
+    return itemViews.get(itemKey) ?? null;
+  }
+  function itemStore(itemKey) {
+    if (itemStores.has(itemKey)) {
+      return itemStores.get(itemKey) ?? null;
+    }
+    const view = itemView(itemKey);
+    const planItem = planItemsByKey.get(itemKey);
+    if (!view || !planItem) {
+      itemStores.set(itemKey, null);
+      return null;
+    }
+    const individual = controller.plan.parts.some((part) => part.identifier === planItem.partIdentifier && part.submissionMode === "individual");
+    const store = createAttemptStore(view.responseDeclarations, {}, {
+      constraints: collectInteractionConstraints(view.itemBody.content),
+      validateResponses: planItem.sessionControl.validateResponses && individual,
+      outcomeDeclarations: view.outcomeDeclarations,
+      responseProcessing: view.responseProcessing,
+      templateDeclarations: view.templateDeclarations,
+      templateProcessing: view.templateProcessing,
+      adaptive: view.adaptive,
+      seed: deriveItemSeed(options.seed, itemKey),
+      normalization: options.normalization,
+      customOperators: options.customOperators,
+      templateDefaultValues: state.templateDefaultValues?.[itemKey],
+      now: options.now
+    });
+    if (activeKeyOf(state) !== itemKey) {
+      store.suspend();
+    }
+    const scorable = scorableIdentifiers(view);
+    store.subscribe(() => {
+      const attempt = store.getSnapshot();
+      if (attempt.submitted && forwardedAttempts.get(itemKey) !== attempt) {
+        forwardedAttempts.set(itemKey, attempt);
+        const next = controller.submitItem(state, itemKey, {
+          outcomes: attempt.outcomes,
+          ...resultFlags(attempt, scorable),
+          ...view.adaptive === true ? { adaptive: true } : {},
+          ...attempt.durationSeconds !== null ? { durationSeconds: attempt.durationSeconds } : {},
+          valid: attempt.responseViolations.length === 0,
+          responses: attempt.responses
+        });
+        if (next !== state) {
+          emit(next);
+        }
+      }
+    });
+    itemStores.set(itemKey, store);
+    return store;
+  }
+  return {
+    controller,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getSnapshot: () => snapshot,
+    itemStore,
+    itemView,
+    next: () => emit(controller.next(state)),
+    canMoveTo: (itemKey) => controller.canMoveTo(state, itemKey),
+    moveTo: (itemKey) => emit(controller.moveTo(state, itemKey)),
+    end: () => emit(controller.end(state)),
+    tick: () => emit(controller.tick(state)),
+    review: (itemKey) => emit(controller.review(state, itemKey)),
+    setItemComment: (itemKey, comment) => emit(controller.setItemComment(state, itemKey, comment)),
+    suspend: () => emit(controller.suspend(state)),
+    resume: () => emit(controller.resume(state)),
+    assessmentResult: (resultOptions) => buildAssessmentResult({
+      test: controller.test,
+      plan: controller.plan,
+      state,
+      ...resultOptions?.context !== undefined ? { context: resultOptions.context } : {},
+      nowMs: resultOptions?.nowMs ?? (options.now ?? Date.now)(),
+      ...options.pnp !== undefined ? { pnp: options.pnp } : {},
+      itemDetails: (item) => {
+        const view = itemView(item.key);
+        if (!view) {
+          return null;
+        }
+        return {
+          responseDeclarations: view.responseDeclarations,
+          ...view.outcomeDeclarations !== undefined ? { outcomeDeclarations: view.outcomeDeclarations } : {},
+          correctResponses: itemStore(item.key)?.getSnapshot().correctResponses ?? {}
+        };
+      }
+    })
+  };
+}
+export {
+  stimulusContentFromNormalized,
+  scoreResponse,
+  resolveTemplate,
+  reportItemCapability,
+  referenceInteractionKinds,
+  mulberry32,
+  matchCorrect,
+  mapResponsePoint,
+  mapResponse,
+  foldString,
+  executeTemplateProcessing,
+  executeResponseProcessing,
+  effectiveItemScore,
+  createTestController,
+  createAttemptStore,
+  collectTemplateIssues,
+  collectRpIssues,
+  assessmentTestViewFromNormalized,
+  assessmentItemViewFromNormalized,
+  applyCorrectResponseOverrides
+};