@conform-ed/qti-xml 0.0.19 → 0.0.21

package/dist/index.js

@@ -5384,6 +5384,808 @@ function serializeQtiDocument(version, key, document) {
       throw new Error(`Serialization is not implemented for ${version} ${String(key)}.`);
   }
 }
+// src/cc-qti/normalize-questestinterop.ts
+import {
+  QtiQuestestinteropProfileDocumentSchema,
+  QtiQuestestinteropRawDocumentSchema
+} from "@conform-ed/contracts/common-cartridge/v1_4";
+var ccQtiNamespace = "http://www.imsglobal.org/xsd/ims_qtiasiv1p2";
+function elements(node, localName) {
+  return node.children.filter((child) => child.type === "element" && (localName === undefined || child.localName === localName));
+}
+function firstElement(node, localName) {
+  return elements(node, localName)[0];
+}
+function attr2(node, name) {
+  const value = node.attributes[name];
+  return value === undefined ? undefined : value;
+}
+function textOf(node) {
+  const parts = [];
+  const walk = (children) => {
+    for (const child of children) {
+      if (child.type === "text") {
+        parts.push(child.value);
+      } else {
+        walk(child.children);
+      }
+    }
+  };
+  walk(node.children);
+  return parts.join("").trim();
+}
+function put(target, key, value) {
+  if (value !== undefined) {
+    target[key] = value;
+  }
+}
+function mapMatText(node) {
+  const out = { kind: "mattext", value: textOf(node) };
+  put(out, "texttype", attr2(node, "texttype"));
+  put(out, "charset", attr2(node, "charset"));
+  put(out, "label", attr2(node, "label"));
+  put(out, "uri", attr2(node, "uri"));
+  put(out, "width", attr2(node, "width"));
+  put(out, "height", attr2(node, "height"));
+  put(out, "x0", attr2(node, "x0"));
+  put(out, "y0", attr2(node, "y0"));
+  put(out, "xmlLang", attr2(node, "xml:lang"));
+  put(out, "xmlSpace", attr2(node, "xml:space"));
+  return out;
+}
+function mapMaterialChild(node) {
+  switch (node.localName) {
+    case "mattext":
+      return mapMatText(node);
+    case "matref":
+      return { kind: "matref", linkrefid: attr2(node, "linkrefid") ?? "" };
+    case "matbreak":
+      return { kind: "matbreak" };
+    default:
+      return;
+  }
+}
+function mapAltMaterial(node) {
+  const out = {
+    kind: "altmaterial",
+    children: elements(node).map(mapMaterialChild).filter((child) => child !== undefined)
+  };
+  put(out, "xmlLang", attr2(node, "xml:lang"));
+  return out;
+}
+function mapMaterial(node) {
+  const out = {
+    kind: "material",
+    children: elements(node).filter((child) => child.localName !== "altmaterial").map(mapMaterialChild).filter((child) => child !== undefined)
+  };
+  put(out, "label", attr2(node, "label"));
+  put(out, "xmlLang", attr2(node, "xml:lang"));
+  const altmaterial = elements(node, "altmaterial");
+  if (altmaterial.length > 0) {
+    out["altmaterial"] = altmaterial.map(mapAltMaterial);
+  }
+  return out;
+}
+function mapMaterialRef(node) {
+  return { kind: "material_ref", linkrefid: attr2(node, "linkrefid") ?? "" };
+}
+function mapFlowMat(node) {
+  const out = {
+    kind: "flow_mat",
+    children: elements(node).map((child) => {
+      if (child.localName === "flow_mat")
+        return mapFlowMat(child);
+      if (child.localName === "material")
+        return mapMaterial(child);
+      if (child.localName === "material_ref")
+        return mapMaterialRef(child);
+      return;
+    }).filter((child) => child !== undefined)
+  };
+  put(out, "class", attr2(node, "class"));
+  return out;
+}
+function mapResponseLabel(node) {
+  const out = { kind: "response_label", ident: attr2(node, "ident") ?? "" };
+  put(out, "labelrefid", attr2(node, "labelrefid"));
+  put(out, "rshuffle", attr2(node, "rshuffle"));
+  put(out, "match_group", attr2(node, "match_group"));
+  put(out, "match_max", attr2(node, "match_max"));
+  const children = elements(node).map((child) => {
+    if (child.localName === "material")
+      return mapMaterial(child);
+    if (child.localName === "material_ref")
+      return mapMaterialRef(child);
+    if (child.localName === "flow_mat")
+      return mapFlowMat(child);
+    return;
+  }).filter((child) => child !== undefined);
+  if (children.length > 0) {
+    out["children"] = children;
+  }
+  return out;
+}
+function mapFlowLabel(node) {
+  const out = {
+    kind: "flow_label",
+    children: elements(node).map((child) => {
+      if (child.localName === "flow_label")
+        return mapFlowLabel(child);
+      if (child.localName === "response_label")
+        return mapResponseLabel(child);
+      return;
+    }).filter((child) => child !== undefined)
+  };
+  put(out, "class", attr2(node, "class"));
+  return out;
+}
+function mapRenderChildren(node) {
+  return elements(node).map((child) => {
+    if (child.localName === "material")
+      return mapMaterial(child);
+    if (child.localName === "material_ref")
+      return mapMaterialRef(child);
+    if (child.localName === "response_label")
+      return mapResponseLabel(child);
+    if (child.localName === "flow_label")
+      return mapFlowLabel(child);
+    return;
+  }).filter((child) => child !== undefined);
+}
+function mapRender(node) {
+  if (node.localName === "render_fib") {
+    const out2 = { kind: "render_fib" };
+    put(out2, "encoding", attr2(node, "encoding"));
+    put(out2, "charset", attr2(node, "charset"));
+    put(out2, "rows", attr2(node, "rows"));
+    put(out2, "columns", attr2(node, "columns"));
+    put(out2, "maxchars", attr2(node, "maxchars"));
+    put(out2, "minnumber", attr2(node, "minnumber"));
+    put(out2, "maxnumber", attr2(node, "maxnumber"));
+    put(out2, "prompt", attr2(node, "prompt"));
+    put(out2, "fibtype", attr2(node, "fibtype"));
+    const children2 = mapRenderChildren(node);
+    if (children2.length > 0)
+      out2["children"] = children2;
+    return out2;
+  }
+  const out = { kind: "render_choice" };
+  put(out, "shuffle", attr2(node, "shuffle"));
+  put(out, "minnumber", attr2(node, "minnumber"));
+  put(out, "maxnumber", attr2(node, "maxnumber"));
+  const children = mapRenderChildren(node);
+  if (children.length > 0)
+    out["children"] = children;
+  return out;
+}
+function mapLeadingTrailing(node) {
+  if (node.localName === "material")
+    return mapMaterial(node);
+  if (node.localName === "material_ref")
+    return mapMaterialRef(node);
+  return;
+}
+function mapResponse(node) {
+  const kind = node.localName === "response_str" ? "response_str" : "response_lid";
+  const out = { kind, ident: attr2(node, "ident") ?? "" };
+  put(out, "rcardinality", attr2(node, "rcardinality"));
+  put(out, "rtiming", attr2(node, "rtiming"));
+  const renderNode = elements(node).find((child) => child.localName.startsWith("render_"));
+  out["render"] = renderNode ? mapRender(renderNode) : { kind: "render_choice" };
+  const childEls = elements(node);
+  const leadingIndex = childEls.findIndex((c) => c.localName === "material" || c.localName === "material_ref");
+  const renderIndex = childEls.findIndex((c) => c.localName.startsWith("render_"));
+  if (leadingIndex !== -1 && (renderIndex === -1 || leadingIndex < renderIndex)) {
+    const leading = mapLeadingTrailing(childEls[leadingIndex]);
+    if (leading)
+      out["leading"] = leading;
+  }
+  const trailingEls = childEls.filter((c, i) => (c.localName === "material" || c.localName === "material_ref") && i > renderIndex && renderIndex !== -1);
+  if (trailingEls.length > 0) {
+    const trailing = mapLeadingTrailing(trailingEls[0]);
+    if (trailing)
+      out["trailing"] = trailing;
+  }
+  return out;
+}
+function mapFlow(node) {
+  const out = {
+    kind: "flow",
+    children: elements(node).map((child) => {
+      if (child.localName === "flow")
+        return mapFlow(child);
+      if (child.localName === "material")
+        return mapMaterial(child);
+      if (child.localName === "material_ref")
+        return mapMaterialRef(child);
+      if (child.localName === "response_lid" || child.localName === "response_str")
+        return mapResponse(child);
+      return;
+    }).filter((child) => child !== undefined)
+  };
+  put(out, "class", attr2(node, "class"));
+  return out;
+}
+function mapPresentation(node) {
+  const flowNode = firstElement(node, "flow");
+  const common = {};
+  put(common, "label", attr2(node, "label"));
+  put(common, "xmlLang", attr2(node, "xml:lang"));
+  put(common, "x0", attr2(node, "x0"));
+  put(common, "y0", attr2(node, "y0"));
+  put(common, "width", attr2(node, "width"));
+  put(common, "height", attr2(node, "height"));
+  if (flowNode) {
+    return { flow: mapFlow(flowNode), ...common };
+  }
+  return {
+    children: elements(node).map((child) => {
+      if (child.localName === "material")
+        return mapMaterial(child);
+      if (child.localName === "response_lid" || child.localName === "response_str")
+        return mapResponse(child);
+      return;
+    }).filter((child) => child !== undefined),
+    ...common
+  };
+}
+function mapConditionNode(node) {
+  switch (node.localName) {
+    case "varequal":
+      return {
+        kind: "varequal",
+        value: textOf(node),
+        respident: attr2(node, "respident") ?? "",
+        ...attr2(node, "case") !== undefined ? { case: attr2(node, "case") } : {}
+      };
+    case "varsubstring":
+      return {
+        kind: "varsubstring",
+        value: textOf(node),
+        respident: attr2(node, "respident") ?? "",
+        ...attr2(node, "case") !== undefined ? { case: attr2(node, "case") } : {}
+      };
+    case "and":
+      return { kind: "and", tests: mapConditionTests(node) };
+    case "or":
+      return { kind: "or", tests: mapConditionTests(node) };
+    case "not":
+      return { kind: "not", tests: mapConditionTests(node) };
+    case "other":
+      return { kind: "other" };
+    default:
+      return;
+  }
+}
+function mapConditionTests(node) {
+  return elements(node).map(mapConditionNode).filter((child) => child !== undefined);
+}
+function mapRespCondition(node) {
+  const conditionvar = firstElement(node, "conditionvar");
+  const out = {
+    conditionvar: { tests: conditionvar ? mapConditionTests(conditionvar) : [] }
+  };
+  put(out, "title", attr2(node, "title"));
+  put(out, "continue", attr2(node, "continue"));
+  const setvars = elements(node, "setvar").map((sv) => {
+    const entry = { value: textOf(sv) };
+    put(entry, "varname", attr2(sv, "varname"));
+    put(entry, "action", attr2(sv, "action"));
+    return entry;
+  });
+  if (setvars.length > 0)
+    out["setvar"] = setvars;
+  const feedbacks = elements(node, "displayfeedback").map((df) => {
+    const entry = {
+      feedbacktype: attr2(df, "feedbacktype") ?? "Response",
+      linkrefid: attr2(df, "linkrefid") ?? ""
+    };
+    const value = textOf(df);
+    if (value.length > 0)
+      entry["value"] = value;
+    return entry;
+  });
+  if (feedbacks.length > 0)
+    out["displayfeedback"] = feedbacks;
+  return out;
+}
+function mapResprocessing(node) {
+  const outcomesNode = firstElement(node, "outcomes");
+  const decvarNode = outcomesNode ? firstElement(outcomesNode, "decvar") : undefined;
+  const decvar = {
+    value: attr2(decvarNode ?? node, "defaultval") ?? "",
+    varname: attr2(decvarNode ?? node, "varname") ?? "SCORE"
+  };
+  put(decvar, "vartype", attr2(decvarNode ?? node, "vartype"));
+  put(decvar, "minvalue", attr2(decvarNode ?? node, "minvalue"));
+  put(decvar, "maxvalue", attr2(decvarNode ?? node, "maxvalue"));
+  return {
+    outcomes: { decvar },
+    respcondition: elements(node, "respcondition").map(mapRespCondition)
+  };
+}
+function mapFeedbackMaterialList(node) {
+  const flowMats = elements(node, "flow_mat");
+  if (flowMats.length > 0) {
+    return { flow_mat: flowMats.map(mapFlowMat) };
+  }
+  return { material: elements(node, "material").map(mapMaterial) };
+}
+function mapSolution(node) {
+  const out = {
+    kind: "solution",
+    solutionmaterial: elements(node, "solutionmaterial").map(mapFeedbackMaterialList)
+  };
+  put(out, "feedbackstyle", attr2(node, "feedbackstyle"));
+  return out;
+}
+function mapHint(node) {
+  const out = { kind: "hint", hintmaterial: elements(node, "hintmaterial").map(mapFeedbackMaterialList) };
+  put(out, "feedbackstyle", attr2(node, "feedbackstyle"));
+  return out;
+}
+function mapItemFeedback(node) {
+  const out = {
+    ident: attr2(node, "ident") ?? "",
+    children: elements(node).map((child) => {
+      if (child.localName === "flow_mat")
+        return mapFlowMat(child);
+      if (child.localName === "material")
+        return mapMaterial(child);
+      if (child.localName === "solution")
+        return mapSolution(child);
+      if (child.localName === "hint")
+        return mapHint(child);
+      return;
+    }).filter((child) => child !== undefined)
+  };
+  put(out, "title", attr2(node, "title"));
+  return out;
+}
+function mapQtimetadata(node) {
+  return {
+    qtimetadatafield: elements(node, "qtimetadatafield").map((field) => {
+      const labelNode = firstElement(field, "fieldlabel");
+      const entryNode = firstElement(field, "fieldentry");
+      const out = {
+        fieldlabel: labelNode ? textOf(labelNode) : "",
+        fieldentry: entryNode ? textOf(entryNode) : ""
+      };
+      put(out, "xmlLang", attr2(field, "xml:lang"));
+      return out;
+    })
+  };
+}
+function mapItem(node) {
+  const out = { ident: attr2(node, "ident") ?? "" };
+  put(out, "title", attr2(node, "title"));
+  put(out, "xmlLang", attr2(node, "xml:lang"));
+  const itemmetadata = firstElement(node, "itemmetadata");
+  if (itemmetadata) {
+    out["itemmetadata"] = {
+      qtimetadata: elements(itemmetadata, "qtimetadata").map(mapQtimetadata)
+    };
+  }
+  const presentation = firstElement(node, "presentation");
+  if (presentation) {
+    out["presentation"] = mapPresentation(presentation);
+  }
+  const resprocessing = elements(node, "resprocessing");
+  if (resprocessing.length > 0) {
+    out["resprocessing"] = resprocessing.map(mapResprocessing);
+  }
+  const itemfeedback = elements(node, "itemfeedback");
+  if (itemfeedback.length > 0) {
+    out["itemfeedback"] = itemfeedback.map(mapItemFeedback);
+  }
+  return out;
+}
+function mapSection(node) {
+  const out = {
+    ident: attr2(node, "ident") ?? "",
+    item: elements(node, "item").map(mapItem)
+  };
+  put(out, "title", attr2(node, "title"));
+  put(out, "xmlLang", attr2(node, "xml:lang"));
+  return out;
+}
+function mapAssessment(node) {
+  const out = {
+    ident: attr2(node, "ident") ?? "",
+    title: attr2(node, "title") ?? ""
+  };
+  put(out, "xmlLang", attr2(node, "xml:lang"));
+  const qtimetadata = firstElement(node, "qtimetadata");
+  if (qtimetadata)
+    out["qtimetadata"] = mapQtimetadata(qtimetadata);
+  const section = firstElement(node, "section");
+  out["section"] = section ? mapSection(section) : { ident: "root_section", item: [] };
+  return out;
+}
+function mapObjectbank(node) {
+  const out = {
+    ident: attr2(node, "ident") ?? "",
+    item: elements(node, "item").map(mapItem)
+  };
+  const qtimetadata = firstElement(node, "qtimetadata");
+  if (qtimetadata)
+    out["qtimetadata"] = mapQtimetadata(qtimetadata);
+  return out;
+}
+function normalizeQuestestinterop(xml, options) {
+  const profile = options?.profile ?? true;
+  let root;
+  try {
+    root = parseXmlDocument(xml);
+  } catch (error) {
+    return { status: "invalid", issues: [error instanceof Error ? error.message : "Invalid XML."] };
+  }
+  if (root.localName !== "questestinterop") {
+    return { status: "invalid", issues: [`Expected <questestinterop> root, found <${root.localName}>.`] };
+  }
+  const assessment = firstElement(root, "assessment");
+  const objectbank = firstElement(root, "objectbank");
+  let candidate;
+  if (assessment) {
+    candidate = { questestinterop: { assessment: mapAssessment(assessment) } };
+  } else if (objectbank) {
+    candidate = { questestinterop: { objectbank: mapObjectbank(objectbank) } };
+  } else {
+    return { status: "invalid", issues: ["<questestinterop> must contain an <assessment> or <objectbank>."] };
+  }
+  const schema = profile ? QtiQuestestinteropProfileDocumentSchema : QtiQuestestinteropRawDocumentSchema;
+  const parsed = schema.safeParse(candidate);
+  if (!parsed.success) {
+    return {
+      status: "invalid",
+      issues: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+    };
+  }
+  return {
+    status: "valid",
+    document: parsed.data
+  };
+}
+// src/cc-qti/convert-to-v3.ts
+var MATCH_CORRECT = "https://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct";
+var MAP_RESPONSE = "https://www.imsglobal.org/question/qti_v3p0/rptemplates/map_response";
+function asNode3(value) {
+  return value ?? {};
+}
+function arr(value) {
+  return Array.isArray(value) ? value : [];
+}
+function strOf(node, key) {
+  const value = node[key];
+  return typeof value === "string" ? value : undefined;
+}
+var QTI_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9._-]*$/u;
+function sanitizeIdentifier(raw) {
+  if (raw.length > 0 && QTI_IDENTIFIER.test(raw))
+    return raw;
+  const replaced = raw.replace(/[^A-Za-z0-9._-]/gu, "_");
+  const prefixed = /^[A-Za-z_]/u.test(replaced) ? replaced : `id_${replaced}`;
+  return prefixed.length > 0 ? prefixed : "_";
+}
+function assignUniqueIdentifiers(rawIds) {
+  const used = new Set;
+  return rawIds.map((rawId) => {
+    const base = sanitizeIdentifier(rawId);
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate)) {
+      candidate = `${base}-${suffix}`;
+      suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+  });
+}
+function htmlToFragments(html) {
+  try {
+    const root = parseXmlDocument(`<div xmlns="${asiNamespace}">${html}</div>`);
+    return mapXmlChildren(root);
+  } catch {
+    return [html];
+  }
+}
+function mapXmlElement(element) {
+  const children = mapXmlChildren(element);
+  const out = { kind: "xml", namespace: asiNamespace, name: element.localName };
+  if (Object.keys(element.attributes).length > 0) {
+    out["attributes"] = element.attributes;
+  }
+  if (children.length > 0) {
+    out["children"] = children;
+  }
+  return out;
+}
+function mapXmlChildren(element) {
+  const fragments2 = [];
+  for (const child of element.children) {
+    if (child.type === "text") {
+      if (child.value.trim().length > 0)
+        fragments2.push(child.value);
+    } else {
+      fragments2.push(mapXmlElement(child));
+    }
+  }
+  return fragments2;
+}
+function mattextFragments(mattext) {
+  const value = strOf(mattext, "value") ?? "";
+  const texttype = strOf(mattext, "texttype");
+  if (texttype && texttype.toLowerCase().includes("html")) {
+    return htmlToFragments(value);
+  }
+  return value.length > 0 ? [value] : [];
+}
+function materialFragments(material) {
+  return arr(material["children"]).flatMap((child) => {
+    const kind = strOf(child, "kind");
+    if (kind === "mattext")
+      return mattextFragments(child);
+    if (kind === "matbreak")
+      return [{ kind: "xml", namespace: asiNamespace, name: "br" }];
+    return [];
+  });
+}
+function stemContent(materials) {
+  const content = [];
+  for (const material of materials) {
+    const fragments2 = materialFragments(material);
+    if (fragments2.length === 0)
+      continue;
+    if (fragments2.every((fragment) => typeof fragment === "string")) {
+      content.push({ kind: "xml", namespace: asiNamespace, name: "p", children: fragments2 });
+    } else {
+      content.push(...fragments2);
+    }
+  }
+  return content;
+}
+function collectPresentation(presentation) {
+  const stemMaterials = [];
+  let response;
+  const visit = (node) => {
+    const kind = strOf(node, "kind");
+    if (kind === "response_lid" || kind === "response_str") {
+      if (!response)
+        response = node;
+      const leading = node["leading"];
+      if (leading && strOf(asNode3(leading), "kind") === "material")
+        stemMaterials.push(asNode3(leading));
+      return;
+    }
+    if (kind === "material") {
+      stemMaterials.push(node);
+      return;
+    }
+    if (kind === "flow") {
+      for (const child of arr(node["children"]))
+        visit(child);
+    }
+  };
+  const flow = presentation["flow"];
+  if (flow) {
+    visit(asNode3(flow));
+  } else {
+    for (const child of arr(presentation["children"]))
+      visit(child);
+  }
+  return { stemMaterials, response };
+}
+function renderChoiceLabels(response) {
+  const render = asNode3(response["render"]);
+  return arr(render["children"]).filter((child) => strOf(child, "kind") === "response_label");
+}
+function choiceContent(label) {
+  const materials = arr(label["children"]).filter((child) => strOf(child, "kind") === "material");
+  const fragments2 = materials.flatMap(materialFragments);
+  return fragments2.length > 0 ? fragments2 : [strOf(label, "ident") ?? ""];
+}
+function collectVarequals(item) {
+  const result = [];
+  const walk = (node) => {
+    const kind = strOf(node, "kind");
+    if (kind === "varequal" || kind === "varsubstring") {
+      result.push({
+        respident: strOf(node, "respident") ?? "",
+        value: strOf(node, "value") ?? "",
+        caseSensitive: strOf(node, "case") === "Yes"
+      });
+      return;
+    }
+    if (kind === "and" || kind === "or" || kind === "not") {
+      for (const test of arr(node["tests"]))
+        walk(test);
+    }
+  };
+  for (const resprocessing of arr(item["resprocessing"])) {
+    for (const respcondition of arr(resprocessing["respcondition"])) {
+      for (const test of arr(asNode3(respcondition["conditionvar"])["tests"]))
+        walk(test);
+    }
+  }
+  return result;
+}
+function findCcProfile(item) {
+  for (const metadata of arr(asNode3(item["itemmetadata"])["qtimetadata"])) {
+    for (const field of arr(metadata["qtimetadatafield"])) {
+      if (strOf(field, "fieldlabel") === "cc_profile")
+        return strOf(field, "fieldentry");
+    }
+  }
+  return;
+}
+function scoreOutcomeDeclaration() {
+  return {
+    identifier: "SCORE",
+    cardinality: "single",
+    baseType: "float",
+    defaultValue: { values: [{ value: "0" }] }
+  };
+}
+function buildChoiceItem(item, response, stem) {
+  const rawResponseId = strOf(response, "ident") ?? "RESPONSE";
+  const responseId = sanitizeIdentifier(rawResponseId);
+  const rcardinality = strOf(response, "rcardinality") ?? "Single";
+  const cardinality = rcardinality === "Multiple" ? "multiple" : rcardinality === "Ordered" ? "ordered" : "single";
+  const labels = renderChoiceLabels(response);
+  const correct = collectVarequals(item).filter((entry) => entry.respident === rawResponseId).map((entry) => sanitizeIdentifier(entry.value));
+  const interaction = {
+    kind: "choiceInteraction",
+    responseIdentifier: responseId,
+    shuffle: strOf(asNode3(response["render"]), "shuffle") === "Yes",
+    maxChoices: cardinality === "single" ? 1 : 0,
+    simpleChoices: labels.map((label) => ({
+      kind: "simpleChoice",
+      identifier: sanitizeIdentifier(strOf(label, "ident") ?? ""),
+      content: choiceContent(label)
+    }))
+  };
+  const responseDeclaration = {
+    identifier: responseId,
+    cardinality,
+    baseType: "identifier",
+    correctResponse: { values: correct.map((value) => ({ value })) }
+  };
+  return {
+    interactionKind: "choice",
+    document: {
+      responseDeclarations: [responseDeclaration],
+      outcomeDeclarations: [scoreOutcomeDeclaration()],
+      itemBody: { content: [...stemContent(stem), interaction] },
+      responseProcessing: { template: MATCH_CORRECT }
+    }
+  };
+}
+function buildTextEntryItem(item, response, stem) {
+  const rawResponseId = strOf(response, "ident") ?? "RESPONSE";
+  const responseId = sanitizeIdentifier(rawResponseId);
+  const correct = collectVarequals(item).filter((entry) => entry.respident === rawResponseId);
+  const responseDeclaration = {
+    identifier: responseId,
+    cardinality: "single",
+    baseType: "string",
+    ...correct[0] ? { correctResponse: { values: [{ value: correct[0].value }] } } : {},
+    mapping: {
+      defaultValue: 0,
+      mapEntries: correct.map((entry) => ({
+        mapKey: entry.value,
+        mappedValue: 1,
+        caseSensitive: entry.caseSensitive
+      }))
+    }
+  };
+  const interaction = { kind: "textEntryInteraction", responseIdentifier: responseId };
+  return {
+    interactionKind: "textEntry",
+    document: {
+      responseDeclarations: [responseDeclaration],
+      outcomeDeclarations: [scoreOutcomeDeclaration()],
+      itemBody: { content: [...stemContent(stem), interaction] },
+      responseProcessing: { template: MAP_RESPONSE }
+    }
+  };
+}
+function buildExtendedTextItem(response, stem) {
+  const responseId = sanitizeIdentifier(strOf(response, "ident") ?? "RESPONSE");
+  return {
+    interactionKind: "extendedText",
+    document: {
+      responseDeclarations: [{ identifier: responseId, cardinality: "single", baseType: "string" }],
+      outcomeDeclarations: [scoreOutcomeDeclaration()],
+      itemBody: {
+        content: [...stemContent(stem), { kind: "extendedTextInteraction", responseIdentifier: responseId }]
+      }
+    }
+  };
+}
+function convertItem(item, identifier) {
+  const title = strOf(item, "title") ?? identifier;
+  const ccProfile = findCcProfile(item);
+  const presentation = asNode3(item["presentation"]);
+  const { stemMaterials, response } = collectPresentation(presentation);
+  let built;
+  if (!response) {
+    built = buildExtendedTextItem({ ident: "RESPONSE" }, stemMaterials);
+  } else {
+    const responseKind = strOf(response, "kind");
+    const renderKind = strOf(asNode3(response["render"]), "kind");
+    const hasCorrect = collectVarequals(item).length > 0;
+    if (responseKind === "response_lid" && renderKind === "render_choice") {
+      built = buildChoiceItem(item, response, stemMaterials);
+    } else if (responseKind === "response_str" && hasCorrect) {
+      built = buildTextEntryItem(item, response, stemMaterials);
+    } else {
+      built = buildExtendedTextItem(response, stemMaterials);
+    }
+  }
+  const assessmentItem = {
+    identifier,
+    title,
+    timeDependent: false,
+    ...built.document
+  };
+  const xml = serializeQtiDocument("3.0.1", "qtiAssessmentItemDocument", { assessmentItem });
+  return { identifier, title, ccProfile, interactionKind: built.interactionKind, xml };
+}
+function buildTest(assessment, items) {
+  const identifier = strOf(assessment, "ident") ?? "assessment";
+  const title = strOf(assessment, "title") ?? identifier;
+  const section = asNode3(assessment["section"]);
+  const sectionId = strOf(section, "ident") ?? "root_section";
+  const assessmentTest = {
+    identifier,
+    title,
+    outcomeDeclarations: [{ identifier: "SCORE", cardinality: "single", baseType: "float" }],
+    testParts: [
+      {
+        identifier: "testpart-1",
+        navigationMode: "nonlinear",
+        submissionMode: "individual",
+        children: [
+          {
+            identifier: sectionId,
+            title: strOf(section, "title") ?? title,
+            visible: true,
+            children: items.map((item) => ({
+              identifier: `ref-${item.identifier}`,
+              href: `${item.identifier}.xml`
+            }))
+          }
+        ]
+      }
+    ]
+  };
+  return {
+    identifier,
+    title,
+    itemIdentifiers: items.map((item) => item.identifier),
+    xml: serializeQtiDocument("3.0.1", "qtiAssessmentTestDocument", { assessmentTest })
+  };
+}
+function convertItems(rawItems) {
+  const identifiers = assignUniqueIdentifiers(rawItems.map((item) => strOf(item, "ident") ?? "item"));
+  return rawItems.map((item, index) => convertItem(item, identifiers[index]));
+}
+function convertCcQtiV1ToV3(xml, options) {
+  const normalized = normalizeQuestestinterop(xml, { profile: options?.profile ?? false });
+  if (normalized.status === "invalid") {
+    return { status: "invalid", issues: normalized.issues };
+  }
+  const root = normalized.document.questestinterop;
+  if ("assessment" in root) {
+    const assessment = asNode3(root["assessment"]);
+    const section = asNode3(assessment["section"]);
+    const items2 = convertItems(arr(section["item"]));
+    return { status: "converted", source: "assessment", items: items2, test: buildTest(assessment, items2) };
+  }
+  const objectbank = asNode3(root["objectbank"]);
+  const items = convertItems(arr(objectbank["item"]));
+  return { status: "converted", source: "objectbank", items };
+}
 export {
   validateQtiXmlFile,
   validateQtiXmlContent,
@@ -5405,10 +6207,13 @@ export {
   serializeQtiAccessForAllPnp,
   selectQtiSchema,
   parseXmlDocument,
+  normalizeQuestestinterop,
   normalizeQtiDocument,
   isSerializationImplemented,
   isNormalizationImplemented,
   detectQtiRoot,
+  convertCcQtiV1ToV3,
+  ccQtiNamespace,
   buildQtiExampleInventory,
   asiNamespace
 };