@longsightgroup/qti3-core 0.1.0

package/dist/parser.js

@@ -0,0 +1,1338 @@
+import { getInteractionSupport, interactionNameToType, processingSupport } from "./support.js";
+import { validateAssessmentItem } from "./validation.js";
+import { childElements, descendants, parseXmlTree, textContent } from "./xml.js";
+const supportedProcessingNames = new Set(processingSupport.map((entry) => entry.qtiName));
+const processingContainerNames = new Set(["qti-template-processing", "qti-response-processing"]);
+const responseProcessingForbiddenNames = new Set([
+    "qti-number-correct",
+    "qti-number-incorrect",
+    "qti-number-presented",
+    "qti-number-responded",
+    "qti-number-selected",
+    "qti-outcome-minimum",
+    "qti-outcome-maximum",
+    "qti-test-variables",
+]);
+export function parseQtiXml(xml) {
+    const diagnostics = [];
+    const tree = parseXmlTree(xml);
+    for (const error of tree.errors) {
+        diagnostics.push({
+            code: "xml.parse",
+            severity: "error",
+            message: error.message,
+        });
+    }
+    if (!tree.root) {
+        diagnostics.push({
+            code: "xml.empty",
+            severity: "error",
+            message: "No XML root element was found.",
+        });
+        return { ok: false, diagnostics };
+    }
+    const itemNode = tree.root.localName === "qti-assessment-item" ? tree.root : undefined;
+    if (!itemNode) {
+        diagnostics.push({
+            code: "qti.root",
+            severity: "error",
+            message: `Expected qti-assessment-item root, found ${tree.root.localName}.`,
+            path: tree.root.source.path,
+            source: tree.root.source,
+        });
+        return { ok: false, diagnostics };
+    }
+    const item = parseAssessmentItem(itemNode, diagnostics);
+    const document = { item, diagnostics };
+    const validation = validateAssessmentItem(document);
+    diagnostics.push(...validation.diagnostics);
+    return {
+        ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"),
+        document,
+        diagnostics,
+    };
+}
+function parseAssessmentItem(node, diagnostics) {
+    const identifier = node.attributes.identifier ?? "";
+    const responseDeclarations = childElements(node, "qti-response-declaration").map(parseResponseDeclaration);
+    const responseDeclarationMap = new Map(responseDeclarations.map((declaration) => [declaration.identifier, declaration]));
+    const outcomeDeclarations = childElements(node, "qti-outcome-declaration").map(parseOutcomeDeclaration);
+    const templateDeclarations = childElements(node, "qti-template-declaration").map(parseTemplateDeclaration);
+    const templateProcessing = parseTemplateProcessing(childElements(node, "qti-template-processing")[0]);
+    const responseProcessing = parseResponseProcessing(childElements(node, "qti-response-processing")[0]);
+    diagnoseProcessingElements(childElements(node, "qti-template-processing")[0], diagnostics);
+    diagnoseProcessingElements(childElements(node, "qti-response-processing")[0], diagnostics);
+    const itemBody = childElements(node, "qti-item-body")[0];
+    const interactions = [];
+    const body = itemBody
+        ? parseContentChildren(itemBody, diagnostics, responseDeclarationMap, interactions)
+        : [];
+    if (!itemBody) {
+        interactions.push(...descendants(node, isInteractionElement).map((interactionNode) => parseInteraction(interactionNode, diagnostics, responseDeclarationMap)));
+    }
+    const modalFeedback = childElements(node, "qti-modal-feedback").map(parseModalFeedback);
+    const catalogInfo = parseCatalogInfo(childElements(node, "qti-catalog-info")[0]);
+    const catalogReferences = itemBody ? parseCatalogReferences(itemBody) : [];
+    const stylesheets = childElements(node, "qti-stylesheet").map(parseStylesheet);
+    const prompt = itemBody ? childElements(itemBody, "qti-prompt")[0] : undefined;
+    return {
+        identifier,
+        title: node.attributes.title,
+        adaptive: node.attributes.adaptive === "true",
+        prompt: prompt ? textContent(prompt) : undefined,
+        responseDeclarations,
+        outcomeDeclarations,
+        templateDeclarations,
+        templateProcessing,
+        responseProcessing,
+        interactions,
+        modalFeedback,
+        catalogInfo,
+        catalogReferences,
+        stylesheets,
+        body,
+        bodyText: textContent(node),
+        source: node.source,
+    };
+}
+function diagnoseProcessingElements(processingNode, diagnostics) {
+    if (!processingNode)
+        return;
+    for (const node of [processingNode, ...descendants(processingNode, () => true)]) {
+        if (!node.localName.startsWith("qti-"))
+            continue;
+        if (processingNode.localName === "qti-response-processing" &&
+            responseProcessingForbiddenNames.has(node.localName)) {
+            diagnostics.push({
+                code: "processing.response.forbidden",
+                severity: "error",
+                message: `${node.localName} must not be used in qti-response-processing.`,
+                path: node.source.path,
+                source: node.source,
+            });
+            continue;
+        }
+        if (processingContainerNames.has(node.localName) ||
+            supportedProcessingNames.has(node.localName)) {
+            continue;
+        }
+        diagnostics.push({
+            code: "processing.unsupported",
+            severity: "error",
+            message: `${node.localName} is not currently supported as a QTI processing element.`,
+            path: node.source.path,
+            source: node.source,
+        });
+    }
+}
+function parseStylesheet(node) {
+    return {
+        href: node.attributes.href ?? "",
+        type: node.attributes.type,
+        media: node.attributes.media,
+        title: node.attributes.title,
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseCatalogReferences(node) {
+    const references = [
+        ...(node.attributes["data-catalog-idref"] ? [node] : []),
+        ...descendants(node, (child) => Boolean(child.attributes["data-catalog-idref"])),
+    ];
+    return references.map((reference) => ({
+        idref: reference.attributes["data-catalog-idref"] ?? "",
+        source: reference.source,
+    }));
+}
+function isInteractionElement(node) {
+    return interactionNameToType.has(node.localName) || /^qti-.+-interaction$/.test(node.localName);
+}
+function parseModalFeedback(node) {
+    const showHide = node.attributes["show-hide"] === "hide" ? "hide" : "show";
+    return {
+        identifier: node.attributes.identifier ?? "",
+        outcomeIdentifier: node.attributes["outcome-identifier"] ?? "",
+        showHide,
+        text: textContent(node),
+        source: node.source,
+    };
+}
+function parseContentChildren(node, diagnostics, responseDeclarationMap, interactions) {
+    const content = [];
+    for (const entry of node.content) {
+        if (typeof entry === "string") {
+            if (entry.length > 0)
+                content.push({ kind: "text", text: entry, source: node.source });
+            continue;
+        }
+        const parsed = parseContentNode(entry, diagnostics, responseDeclarationMap, interactions);
+        if (parsed)
+            content.push(parsed);
+    }
+    return content;
+}
+function parseContentNode(node, diagnostics, responseDeclarationMap, interactions) {
+    if (isInteractionElement(node)) {
+        const interaction = parseInteraction(node, diagnostics, responseDeclarationMap);
+        const interactionIndex = interactions.push(interaction) - 1;
+        return {
+            kind: "interaction",
+            interactionIndex,
+            qtiName: node.localName,
+            responseIdentifier: interaction.responseIdentifier,
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-printed-variable") {
+        return {
+            kind: "printedVariable",
+            identifier: node.attributes.identifier ?? "",
+            format: node.attributes.format,
+            attributes: node.attributes,
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-feedback-block" || node.localName === "qti-feedback-inline") {
+        return {
+            kind: "feedback",
+            feedbackType: node.localName === "qti-feedback-block" ? "block" : "inline",
+            identifier: node.attributes.identifier ?? "",
+            outcomeIdentifier: node.attributes["outcome-identifier"] ?? "",
+            showHide: node.attributes["show-hide"] === "hide" ? "hide" : "show",
+            attributes: node.attributes,
+            children: parseContentChildren(node, diagnostics, responseDeclarationMap, interactions),
+            source: node.source,
+        };
+    }
+    return {
+        kind: "element",
+        qtiName: node.localName,
+        attributes: node.attributes,
+        children: parseContentChildren(node, diagnostics, responseDeclarationMap, interactions),
+        source: node.source,
+    };
+}
+function parseCatalogInfo(node) {
+    if (!node)
+        return undefined;
+    return {
+        catalogs: childElements(node, "qti-catalog").map((catalog) => ({
+            id: catalog.attributes.id ?? "",
+            attributes: catalog.attributes,
+            cards: childElements(catalog, "qti-card").map(parseCatalogCard),
+            source: catalog.source,
+        })),
+        source: node.source,
+    };
+}
+function parseCatalogCard(node) {
+    return {
+        support: node.attributes.support ?? "",
+        htmlContent: parseCatalogHtmlContent(childElements(node, "qti-html-content")[0]),
+        fileHrefs: childElements(node, "qti-file-href").map(parseCatalogFileHref),
+        entries: childElements(node, "qti-card-entry").map(parseCatalogCardEntry),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseCatalogCardEntry(node) {
+    return {
+        language: node.attributes["xml:lang"] ?? node.attributes.lang,
+        default: node.attributes.default === "true",
+        htmlContent: parseCatalogHtmlContent(childElements(node, "qti-html-content")[0]),
+        fileHrefs: childElements(node, "qti-file-href").map(parseCatalogFileHref),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseCatalogHtmlContent(node) {
+    if (!node)
+        return undefined;
+    return {
+        text: textContent(node),
+        children: parseCatalogHtmlChildren(node),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseCatalogHtmlChildren(node) {
+    const content = [];
+    for (const entry of node.content) {
+        if (typeof entry === "string") {
+            if (entry.length > 0)
+                content.push({ kind: "text", text: entry, source: node.source });
+            continue;
+        }
+        content.push({
+            kind: "element",
+            qtiName: entry.localName,
+            attributes: entry.attributes,
+            children: parseCatalogHtmlChildren(entry),
+            source: entry.source,
+        });
+    }
+    return content;
+}
+function parseCatalogFileHref(node) {
+    return {
+        href: textContent(node).trim(),
+        mimeType: node.attributes["mime-type"],
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseResponseDeclaration(node) {
+    const cardinality = parseCardinality(node.attributes.cardinality);
+    return {
+        kind: "response",
+        identifier: node.attributes.identifier ?? "",
+        cardinality,
+        baseType: node.attributes["base-type"],
+        defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0]),
+        correctResponse: normalizeValueForCardinality(parseVariableValue(childElements(node, "qti-correct-response")[0]), cardinality),
+        mapping: parseMapping(childElements(node, "qti-mapping")[0]),
+        areaMapping: parseAreaMapping(childElements(node, "qti-area-mapping")[0]),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseOutcomeDeclaration(node) {
+    const baseType = node.attributes["base-type"];
+    return {
+        kind: "outcome",
+        identifier: node.attributes.identifier ?? "",
+        cardinality: parseCardinality(node.attributes.cardinality),
+        baseType,
+        defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0]),
+        lookupTable: parseLookupTable(node, baseType),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseTemplateDeclaration(node) {
+    return {
+        kind: "template",
+        identifier: node.attributes.identifier ?? "",
+        cardinality: parseCardinality(node.attributes.cardinality),
+        baseType: node.attributes["base-type"],
+        defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0]),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function parseInteraction(node, diagnostics, responseDeclarationMap) {
+    const interactionType = interactionNameToType.get(node.localName);
+    const responseIdentifier = node.attributes["response-identifier"];
+    const responseDeclaration = responseIdentifier
+        ? responseDeclarationMap.get(responseIdentifier)
+        : undefined;
+    const prompt = childElements(node, "qti-prompt")[0];
+    if (!interactionType) {
+        diagnostics.push({
+            code: "interaction.unsupported",
+            severity: "warning",
+            message: `${node.localName} is not currently in the support registry.`,
+            path: node.source.path,
+            source: node.source,
+        });
+    }
+    const support = getInteractionSupport(node.localName);
+    if (support?.support === "deprecated") {
+        diagnostics.push({
+            code: "interaction.deprecated",
+            severity: "warning",
+            message: `${node.localName} is deprecated. ${support.notes ?? ""}`.trim(),
+            path: node.source.path,
+            source: node.source,
+        });
+    }
+    const objectNode = interactionType === "positionObject"
+        ? positionObjectInteractionObject(node)
+        : descendants(node, (child) => child.localName === "object" || child.localName === "img")[0];
+    return {
+        type: interactionType ?? "custom",
+        qtiName: node.localName,
+        responseIdentifier,
+        responseCardinality: responseDeclaration?.cardinality,
+        responseBaseType: responseDeclaration?.baseType,
+        prompt: prompt ? textContent(prompt) : undefined,
+        contextText: inlineInteractionContext(node, interactionType),
+        object: parseObjectAsset(objectNode),
+        positionObjectStage: interactionType === "positionObject"
+            ? parseObjectAsset(positionObjectStageObject(node))
+            : undefined,
+        choices: parseChoices(node),
+        hottextSegments: interactionType === "hottext" ? parseHottextSegments(node) : undefined,
+        gapMatchSegments: interactionType === "gapMatch" || interactionType === "graphicGapMatch"
+            ? parseGapMatchSegments(node)
+            : undefined,
+        childElements: childElements(node).map((child) => ({
+            qtiName: child.localName,
+            source: child.source,
+        })),
+        attributes: node.attributes,
+        text: textContent(node),
+        source: node.source,
+    };
+}
+function positionObjectInteractionObject(node) {
+    return childElements(node).find((child) => child.localName === "object" || child.localName === "img");
+}
+function positionObjectStageObject(node) {
+    const ancestorStage = nearestAncestor(node, "qti-position-object-stage");
+    const stage = ancestorStage ?? childElements(node, "qti-position-object-stage")[0];
+    if (!stage)
+        return undefined;
+    return childElements(stage).find((child) => child.localName === "object" || child.localName === "img");
+}
+function nearestAncestor(node, localName) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (parent.localName === localName)
+            return parent;
+    }
+    return undefined;
+}
+function parseHottextSegments(node) {
+    const segments = [];
+    const visit = (entry) => {
+        if (typeof entry === "string") {
+            const text = entry.replace(/\s+/g, " ");
+            if (text.trim().length > 0)
+                segments.push({ kind: "text", text });
+            return;
+        }
+        if (entry.localName === "qti-prompt")
+            return;
+        if (entry.localName === "qti-hottext") {
+            segments.push({
+                kind: "hottext",
+                identifier: entry.attributes.identifier ?? "",
+                text: textContent(entry),
+                attributes: entry.attributes,
+                source: entry.source,
+            });
+            return;
+        }
+        for (const child of entry.content)
+            visit(child);
+        if (entry.localName === "p" || entry.localName === "div") {
+            segments.push({ kind: "text", text: " " });
+        }
+    };
+    for (const entry of node.content)
+        visit(entry);
+    return segments;
+}
+function parseGapMatchSegments(node) {
+    const segments = [];
+    const visit = (entry) => {
+        if (typeof entry === "string") {
+            const text = entry.replace(/\s+/g, " ");
+            if (text.trim().length > 0)
+                segments.push({ kind: "text", text });
+            return;
+        }
+        if (entry.localName === "qti-prompt")
+            return;
+        if (entry.localName === "qti-gap-text" || entry.localName === "qti-gap-img")
+            return;
+        if (entry.localName === "object" || entry.localName === "img")
+            return;
+        if (entry.localName === "qti-gap") {
+            segments.push({
+                kind: "gap",
+                identifier: entry.attributes.identifier ?? "",
+                attributes: entry.attributes,
+                source: entry.source,
+            });
+            return;
+        }
+        for (const child of entry.content)
+            visit(child);
+        if (entry.localName === "p" || entry.localName === "div") {
+            segments.push({ kind: "text", text: " " });
+        }
+    };
+    for (const entry of node.content)
+        visit(entry);
+    return segments;
+}
+function inlineInteractionContext(node, interactionType) {
+    if (interactionType !== "inlineChoice" && interactionType !== "textEntry")
+        return undefined;
+    const parent = node.parent;
+    if (!parent)
+        return undefined;
+    return normalizeInlineContext(parent.text) ?? normalizeInlineContext(textContent(parent));
+}
+function normalizeInlineContext(value) {
+    const normalized = value
+        .replace(/\s+/g, " ")
+        .replace(/\s+([.,;:!?])/g, "$1")
+        .trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function parseObjectAsset(node) {
+    if (!node)
+        return undefined;
+    const data = node.attributes.data ?? node.attributes.src;
+    return {
+        data,
+        type: node.attributes.type ?? assetTypeFromData(data),
+        width: node.attributes.width,
+        height: node.attributes.height,
+        text: textContent(node),
+        attributes: node.attributes,
+        source: node.source,
+    };
+}
+function assetTypeFromData(data) {
+    if (!data)
+        return undefined;
+    if (data.startsWith("data:image/svg+xml"))
+        return "image/svg+xml";
+    if (data.startsWith("data:image/"))
+        return "image/*";
+    if (/\.(svg|png|jpg|jpeg|gif|webp)(?:[?#].*)?$/i.test(data))
+        return "image/*";
+    return undefined;
+}
+function parseChoices(node) {
+    const choiceNames = new Set([
+        "qti-simple-choice",
+        "qti-simple-associable-choice",
+        "qti-inline-choice",
+        "qti-gap-text",
+        "qti-gap-img",
+        "qti-hottext",
+        "qti-hotspot-choice",
+        "qti-associable-hotspot",
+        "qti-gap",
+    ]);
+    return descendants(node, (child) => choiceNames.has(child.localName)).map((choice, index) => {
+        const identifier = choice.attributes.identifier ?? "";
+        return {
+            identifier,
+            text: textContent(choice) || identifier || `Choice ${index + 1}`,
+            role: choiceRole(choice),
+            qtiName: choice.localName,
+            attributes: choice.attributes,
+            source: choice.source,
+        };
+    });
+}
+function choiceRole(node) {
+    if (node.localName === "qti-simple-choice")
+        return "simpleChoice";
+    if (node.localName === "qti-inline-choice")
+        return "inlineChoice";
+    if (node.localName === "qti-gap-text" || node.localName === "qti-gap-img")
+        return "gapChoice";
+    if (node.localName === "qti-gap")
+        return "gap";
+    if (node.localName === "qti-hottext")
+        return "hottext";
+    if (node.localName === "qti-hotspot-choice" || node.localName === "qti-associable-hotspot") {
+        return "hotspot";
+    }
+    if (node.localName === "qti-simple-associable-choice") {
+        const matchSet = node.parent?.localName === "qti-simple-match-set" ? node.parent : undefined;
+        const interaction = nearestInteraction(node);
+        if (matchSet && interaction?.localName === "qti-match-interaction") {
+            return matchSetIndex(matchSet) === 0 ? "matchSource" : "matchTarget";
+        }
+        return "associableChoice";
+    }
+    return "simpleChoice";
+}
+function nearestInteraction(node) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (interactionNameToType.has(parent.localName))
+            return parent;
+    }
+    return undefined;
+}
+function matchSetIndex(node) {
+    const siblings = node.parent?.children.filter((sibling) => sibling.localName === "qti-simple-match-set") ?? [];
+    return siblings.indexOf(node);
+}
+function parseVariableValue(node) {
+    if (!node)
+        return null;
+    const valueNodes = childElements(node, "qti-value");
+    const recordEntries = valueNodes
+        .map((valueNode) => ({
+        fieldIdentifier: valueNode.attributes["field-identifier"],
+        value: coerceValue(textContent(valueNode), valueNode.attributes["base-type"]),
+    }))
+        .filter((entry) => Boolean(entry.fieldIdentifier));
+    if (recordEntries.length > 0) {
+        return Object.fromEntries(recordEntries.map((entry) => [entry.fieldIdentifier, entry.value]));
+    }
+    const values = valueNodes.map((valueNode) => textContent(valueNode));
+    if (values.length === 0) {
+        const text = textContent(node);
+        return text.length > 0 ? text : null;
+    }
+    if (values.length === 1)
+        return values[0] ?? null;
+    return values;
+}
+function parseMapping(node) {
+    if (!node)
+        return undefined;
+    return {
+        defaultValue: Number(node.attributes["default-value"] ?? 0),
+        attributes: node.attributes,
+        source: node.source,
+        entries: childElements(node, "qti-map-entry").map((entry) => ({
+            mapKey: entry.attributes["map-key"],
+            mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+            attributes: entry.attributes,
+            source: entry.source,
+        })),
+    };
+}
+function parseAreaMapping(node) {
+    if (!node)
+        return undefined;
+    return {
+        defaultValue: Number(node.attributes["default-value"] ?? 0),
+        attributes: node.attributes,
+        source: node.source,
+        entries: childElements(node, "qti-area-map-entry").map((entry) => ({
+            shape: parseShape(entry.attributes.shape),
+            coords: parseCoords(entry.attributes.coords),
+            mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+            attributes: entry.attributes,
+            source: entry.source,
+        })),
+    };
+}
+function parseLookupTable(node, baseType) {
+    const matchTable = childElements(node, "qti-match-table")[0];
+    if (matchTable)
+        return parseMatchTable(matchTable, baseType);
+    const interpolationTable = childElements(node, "qti-interpolation-table")[0];
+    if (interpolationTable)
+        return parseInterpolationTable(interpolationTable, baseType);
+    return undefined;
+}
+function parseMatchTable(node, baseType) {
+    return {
+        type: "match",
+        defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
+        attributes: node.attributes,
+        source: node.source,
+        entries: childElements(node, "qti-match-table-entry").map((entry) => ({
+            sourceValue: Number(entry.attributes["source-value"]),
+            targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
+            attributes: entry.attributes,
+            source: entry.source,
+        })),
+    };
+}
+function parseInterpolationTable(node, baseType) {
+    return {
+        type: "interpolation",
+        defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
+        attributes: node.attributes,
+        source: node.source,
+        entries: childElements(node, "qti-interpolation-table-entry").map((entry) => ({
+            sourceValue: Number(entry.attributes["source-value"]),
+            targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
+            includeBoundary: entry.attributes["include-boundary"] !== "false",
+            attributes: entry.attributes,
+            source: entry.source,
+        })),
+    };
+}
+function parseLookupValue(value, baseType) {
+    return value === undefined ? null : coerceValue(value, baseType);
+}
+function parseShape(shape) {
+    if (shape === "circle" || shape === "rect" || shape === "poly")
+        return shape;
+    return "default";
+}
+function parseCoords(value) {
+    return (value ?? "")
+        .split(",")
+        .map((part) => Number(part.trim()))
+        .filter((part) => Number.isFinite(part));
+}
+function parseResponseProcessing(node) {
+    if (!node)
+        return undefined;
+    return {
+        template: node.attributes.template,
+        rules: parseResponseRules(node),
+        conditions: responseConditionsFromChildren(node),
+    };
+}
+function parseTemplateProcessing(node) {
+    if (!node)
+        return undefined;
+    return {
+        rules: parseTemplateRules(node),
+    };
+}
+function parseTemplateRules(node) {
+    return childElements(node)
+        .map(parseTemplateRule)
+        .filter((rule) => rule !== undefined);
+}
+function parseTemplateRule(node) {
+    if (node.localName === "qti-set-template-value") {
+        return {
+            type: "setTemplateValue",
+            identifier: node.attributes.identifier ?? "",
+            expression: parseFirstExpression(node) ?? {
+                type: "baseValue",
+                value: null,
+                source: node.source,
+            },
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-set-default-value") {
+        return {
+            type: "setDefaultValue",
+            identifier: node.attributes.identifier ?? "",
+            expression: parseFirstExpression(node) ?? {
+                type: "baseValue",
+                value: null,
+                source: node.source,
+            },
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-set-correct-response") {
+        return {
+            type: "setCorrectResponse",
+            identifier: node.attributes.identifier ?? "",
+            expression: parseFirstExpression(node) ?? {
+                type: "baseValue",
+                value: null,
+                source: node.source,
+            },
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-template-condition") {
+        const templateIf = childElements(node, "qti-template-if")[0];
+        const templateElse = childElements(node, "qti-template-else")[0];
+        return {
+            type: "templateCondition",
+            ifExpression: templateIf ? parseFirstExpression(templateIf) : undefined,
+            thenRules: templateIf ? parseTemplateRules(templateIf) : [],
+            elseIfs: childElements(node, "qti-template-else-if").map((branch) => ({
+                expression: parseFirstExpression(branch),
+                rules: parseTemplateRules(branch),
+            })),
+            elseRules: templateElse ? parseTemplateRules(templateElse) : [],
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-exit-template") {
+        return {
+            type: "exitTemplate",
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-template-constraint") {
+        return {
+            type: "templateConstraint",
+            expression: parseFirstExpression(node) ?? {
+                type: "baseValue",
+                value: null,
+                source: node.source,
+            },
+            source: node.source,
+        };
+    }
+    return undefined;
+}
+function responseConditionsFromChildren(node) {
+    return childElements(node).flatMap((child) => {
+        if (child.localName === "qti-response-condition")
+            return [parseResponseCondition(child)];
+        if (child.localName === "qti-response-processing-fragment") {
+            return responseConditionsFromChildren(child);
+        }
+        return [];
+    });
+}
+function parseResponseCondition(node) {
+    const responseIf = childElements(node, "qti-response-if")[0];
+    const responseElse = childElements(node, "qti-response-else")[0];
+    return {
+        ifExpression: responseIf ? parseFirstExpression(responseIf) : undefined,
+        thenRules: responseIf ? parseResponseRules(responseIf) : [],
+        elseIfs: childElements(node, "qti-response-else-if").map((branch) => ({
+            expression: parseFirstExpression(branch),
+            rules: parseResponseRules(branch),
+        })),
+        elseRules: responseElse ? parseResponseRules(responseElse) : [],
+    };
+}
+function parseResponseRules(node) {
+    return childElements(node)
+        .map(parseResponseRule)
+        .filter((rule) => rule !== undefined);
+}
+function parseResponseRule(node) {
+    if (node.localName === "qti-response-condition") {
+        return {
+            type: "responseCondition",
+            condition: parseResponseCondition(node),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-set-outcome-value")
+        return parseSetOutcomeValue(node);
+    if (node.localName === "qti-lookup-outcome-value")
+        return parseLookupOutcomeValue(node);
+    if (node.localName === "qti-exit-response") {
+        return { type: "exitResponse", source: node.source };
+    }
+    if (node.localName === "qti-response-processing-fragment") {
+        return {
+            type: "responseProcessingFragment",
+            rules: parseResponseRules(node),
+            source: node.source,
+        };
+    }
+    return undefined;
+}
+function parseLookupOutcomeValue(node) {
+    return {
+        type: "lookupOutcomeValue",
+        identifier: node.attributes.identifier ?? "",
+        expression: parseFirstExpression(node) ?? {
+            type: "baseValue",
+            value: null,
+            source: node.source,
+        },
+        source: node.source,
+    };
+}
+function parseSetOutcomeValue(setNode) {
+    return {
+        type: "setOutcomeValue",
+        identifier: setNode.attributes.identifier ?? "",
+        expression: parseFirstExpression(setNode) ?? {
+            type: "baseValue",
+            value: null,
+            source: setNode.source,
+        },
+        source: setNode.source,
+    };
+}
+function parseFirstExpression(node) {
+    for (const child of node.children) {
+        const expression = parseExpression(child);
+        if (expression)
+            return expression;
+    }
+    return undefined;
+}
+function parseExpression(node) {
+    if (node.localName === "qti-base-value") {
+        const rawValue = textContent(node);
+        return {
+            type: "baseValue",
+            value: coerceValue(rawValue, node.attributes["base-type"]),
+            rawValue,
+            baseType: node.attributes["base-type"],
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-null") {
+        return { type: "null", source: node.source };
+    }
+    if (node.localName === "qti-is-null") {
+        const variable = childElements(node, "qti-variable")[0];
+        return {
+            type: "isNull",
+            identifier: variable?.attributes.identifier ?? "",
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-map-response") {
+        return {
+            type: "mapResponse",
+            identifier: node.attributes.identifier ?? "",
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-map-response-point") {
+        return {
+            type: "mapResponsePoint",
+            identifier: node.attributes.identifier ?? "",
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-correct") {
+        return {
+            type: "correct",
+            identifier: node.attributes.identifier ?? "",
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-default") {
+        return {
+            type: "default",
+            identifier: node.attributes.identifier ?? "",
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-variable") {
+        return { type: "variable", identifier: node.attributes.identifier ?? "", source: node.source };
+    }
+    if (node.localName === "qti-random-integer") {
+        return {
+            type: "randomInteger",
+            min: Number(node.attributes.min ?? 0),
+            max: Number(node.attributes.max ?? 0),
+            step: Number(node.attributes.step ?? 1),
+            attributes: node.attributes,
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-random-float") {
+        return {
+            type: "randomFloat",
+            min: Number(node.attributes.min ?? 0),
+            max: Number(node.attributes.max ?? 0),
+            attributes: node.attributes,
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-random") {
+        const multiple = childElements(node, "qti-multiple")[0];
+        return {
+            type: "random",
+            values: childElements(multiple ?? node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-multiple") {
+        return {
+            type: "multiple",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-ordered") {
+        return {
+            type: "ordered",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-index") {
+        const expression = parseFirstExpression(node);
+        if (expression) {
+            return { type: "index", expression, n: node.attributes.n ?? "", source: node.source };
+        }
+    }
+    if (node.localName === "qti-container-size") {
+        const expression = parseFirstExpression(node);
+        if (expression)
+            return { type: "containerSize", expression, source: node.source };
+    }
+    if (node.localName === "qti-sum") {
+        return {
+            type: "sum",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-product") {
+        return {
+            type: "product",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-min") {
+        return {
+            type: "min",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-max") {
+        return {
+            type: "max",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-subtract") {
+        const expressions = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        const [left, right] = expressions;
+        if (left && right)
+            return { type: "subtract", left, right, source: node.source };
+    }
+    if (node.localName === "qti-divide") {
+        const expressions = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        const [left, right] = expressions;
+        if (left && right)
+            return { type: "divide", left, right, source: node.source };
+    }
+    if (node.localName === "qti-power") {
+        const expressions = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        const [left, right] = expressions;
+        if (left && right)
+            return { type: "power", left, right, source: node.source };
+    }
+    if (node.localName === "qti-integer-divide") {
+        const expressions = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        const [left, right] = expressions;
+        if (left && right)
+            return { type: "integerDivide", left, right, source: node.source };
+    }
+    if (node.localName === "qti-integer-modulus") {
+        const expressions = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        const [left, right] = expressions;
+        if (left && right)
+            return { type: "integerModulus", left, right, source: node.source };
+    }
+    if (node.localName === "qti-round") {
+        const expression = parseFirstExpression(node);
+        if (expression)
+            return { type: "round", expression, source: node.source };
+    }
+    if (node.localName === "qti-round-to") {
+        const expression = parseFirstExpression(node);
+        const roundingMode = node.attributes["rounding-mode"];
+        const figures = Number(node.attributes.figures ?? 0);
+        if (expression &&
+            (roundingMode === "decimalPlaces" || roundingMode === "significantFigures") &&
+            Number.isInteger(figures) &&
+            (roundingMode === "decimalPlaces" ? figures >= 0 : figures > 0)) {
+            return { type: "roundTo", expression, roundingMode, figures, source: node.source };
+        }
+    }
+    if (node.localName === "qti-truncate") {
+        const expression = parseFirstExpression(node);
+        if (expression)
+            return { type: "truncate", expression, source: node.source };
+    }
+    if (node.localName === "qti-integer-to-float") {
+        const expression = parseFirstExpression(node);
+        if (expression)
+            return { type: "integerToFloat", expression, source: node.source };
+    }
+    if (node.localName === "qti-and") {
+        return {
+            type: "and",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-any-n") {
+        return {
+            type: "anyN",
+            min: node.attributes.min ?? "",
+            max: node.attributes.max ?? "",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-or") {
+        return {
+            type: "or",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-not") {
+        const expression = parseFirstExpression(node);
+        if (expression)
+            return { type: "not", expression, source: node.source };
+    }
+    if (node.localName === "qti-equal") {
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (left && right)
+            return { type: "equal", left, right, source: node.source };
+    }
+    if (node.localName === "qti-equal-rounded") {
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        const roundingMode = node.attributes["rounding-mode"] ?? "";
+        const figures = Number(node.attributes.figures ?? 0);
+        if (left && right) {
+            return { type: "equalRounded", left, right, roundingMode, figures, source: node.source };
+        }
+    }
+    const numericCompareOperator = numericCompareOperatorFor(node.localName);
+    if (numericCompareOperator) {
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (left && right) {
+            return {
+                type: "numericCompare",
+                operator: numericCompareOperator,
+                left,
+                right,
+                source: node.source,
+            };
+        }
+    }
+    const durationCompareOperator = durationCompareOperatorFor(node.localName);
+    if (durationCompareOperator) {
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (left && right) {
+            return {
+                type: "durationCompare",
+                operator: durationCompareOperator,
+                left,
+                right,
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-string-match") {
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (left && right) {
+            return {
+                type: "stringMatch",
+                left,
+                right,
+                caseSensitive: node.attributes["case-sensitive"] !== "false",
+                substring: node.attributes.substring === "true",
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-substring") {
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (left && right) {
+            return {
+                type: "substring",
+                left,
+                right,
+                caseSensitive: node.attributes["case-sensitive"] !== "false",
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-pattern-match") {
+        const expression = parseFirstExpression(node);
+        if (expression) {
+            return {
+                type: "patternMatch",
+                expression,
+                pattern: node.attributes.pattern ?? "",
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-field-value") {
+        const expression = parseFirstExpression(node);
+        if (expression) {
+            return {
+                type: "fieldValue",
+                fieldIdentifier: node.attributes["field-identifier"] ?? "",
+                expression,
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-member") {
+        const [value, collection] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (value && collection)
+            return { type: "member", value, collection, source: node.source };
+    }
+    if (node.localName === "qti-delete") {
+        const [value, collection] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (value && collection)
+            return { type: "delete", value, collection, source: node.source };
+    }
+    if (node.localName === "qti-contains") {
+        const [collection, values] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (collection && values)
+            return { type: "contains", collection, values, source: node.source };
+    }
+    if (node.localName === "qti-gcd" || node.localName === "qti-lcm") {
+        return {
+            type: node.localName === "qti-gcd" ? "gcd" : "lcm",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-inside") {
+        const expression = parseFirstExpression(node);
+        if (expression) {
+            return {
+                type: "inside",
+                expression,
+                shape: parseShape(node.attributes.shape),
+                coords: parseCoords(node.attributes.coords),
+                attributes: node.attributes,
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-math-constant") {
+        return { type: "mathConstant", name: node.attributes.name ?? "", source: node.source };
+    }
+    if (node.localName === "qti-math-operator") {
+        return {
+            type: "mathOperator",
+            name: node.attributes.name ?? "",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-repeat") {
+        return {
+            type: "repeat",
+            numberRepeats: node.attributes["number-repeats"] ?? "",
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-stats-operator") {
+        const expression = parseFirstExpression(node);
+        if (expression) {
+            return {
+                type: "statsOperator",
+                name: node.attributes.name ?? "",
+                expression,
+                source: node.source,
+            };
+        }
+    }
+    if (node.localName === "qti-custom-operator") {
+        return {
+            type: "customOperator",
+            definition: node.attributes.definition,
+            className: node.attributes.class,
+            attributes: node.attributes,
+            expressions: childElements(node)
+                .map(parseExpression)
+                .filter((expression) => expression !== undefined),
+            source: node.source,
+        };
+    }
+    if (node.localName === "qti-match") {
+        const variable = childElements(node, "qti-variable")[0];
+        const correct = childElements(node, "qti-correct")[0];
+        if (variable && correct) {
+            return {
+                type: "matchCorrect",
+                identifier: variable?.attributes.identifier ?? "",
+                correctIdentifier: correct?.attributes.identifier ?? "",
+                source: node.source,
+            };
+        }
+        const [left, right] = childElements(node)
+            .map(parseExpression)
+            .filter((expression) => expression !== undefined);
+        if (left && right)
+            return { type: "match", left, right, source: node.source };
+    }
+    return undefined;
+}
+function numericCompareOperatorFor(localName) {
+    if (localName === "qti-lt")
+        return "lt";
+    if (localName === "qti-lte")
+        return "lte";
+    if (localName === "qti-gt")
+        return "gt";
+    if (localName === "qti-gte")
+        return "gte";
+    return undefined;
+}
+function durationCompareOperatorFor(localName) {
+    if (localName === "qti-duration-lt")
+        return "lt";
+    if (localName === "qti-duration-gte")
+        return "gte";
+    return undefined;
+}
+function coerceValue(value, baseType) {
+    if (baseType === "integer")
+        return Number.parseInt(value, 10);
+    if (baseType === "float")
+        return Number.parseFloat(value);
+    if (baseType === "boolean")
+        return value === "true";
+    return value;
+}
+function parseCardinality(value) {
+    if (value === "multiple" || value === "ordered" || value === "record")
+        return value;
+    return "single";
+}
+function normalizeValueForCardinality(value, cardinality) {
+    if ((cardinality === "multiple" || cardinality === "ordered") &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !isRecordValue(value)) {
+        return [value];
+    }
+    return value;
+}
+function isRecordValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=parser.js.map