@conform-ed/qti-react 0.0.17 → 0.0.18

package/dist/headless.js

@@ -0,0 +1,3062 @@
+// 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"
+];
+export {
+  stimulusContentFromNormalized,
+  reportItemCapability,
+  referenceInteractionKinds,
+  assessmentTestViewFromNormalized,
+  assessmentItemViewFromNormalized
+};