@longsightgroup/qti3-core 0.2.1 → 0.3.0

package/dist/session.js

@@ -1,3 +1,4 @@
+import { qtiScalarToString, qtiValueToString, qtiValueToStringList } from "./value-format.js";
 const COMPLETION_STATUS = "completionStatus";
 const COMPLETION_NOT_ATTEMPTED = "not_attempted";
 const COMPLETION_UNKNOWN = "unknown";
@@ -14,9 +15,10 @@ export function visibleModalFeedback(item, outcomes) {
         if (feedback.showHide === "hide")
             return false;
         const outcome = outcomes[feedback.outcomeIdentifier];
-        if (Array.isArray(outcome))
-            return outcome.includes(feedback.identifier);
-        return String(outcome ?? "") === feedback.identifier;
+        const outcomeValue = outcome === undefined ? null : outcome;
+        if (Array.isArray(outcomeValue))
+            return outcomeValue.includes(feedback.identifier);
+        return qtiValueToString(outcomeValue) === feedback.identifier;
     });
 }
 export function createItemSession(document, priorState, options = {}) {
@@ -27,6 +29,7 @@ export function createItemSession(document, priorState, options = {}) {
     const priorInteractionStates = clonePortableCustomStateRecord(priorState?.interactionStates ?? {});
     let validationMessages = cloneDiagnostics(priorState?.validationMessages ?? []);
     const responses = {};
+    const responseDefaults = {};
     const outcomes = {};
     const templateValues = {};
     const interactionStates = {};
@@ -40,8 +43,8 @@ export function createItemSession(document, priorState, options = {}) {
         .filter((identifier) => Boolean(identifier)));
     for (const declaration of document.item.responseDeclarations) {
         correctResponses[declaration.identifier] = cloneValue(declaration.correctResponse);
-        if (declaration.defaultValue !== null && responses[declaration.identifier] === undefined) {
-            responses[declaration.identifier] = cloneValue(declaration.defaultValue);
+        if (declaration.defaultValue !== null) {
+            responseDefaults[declaration.identifier] = cloneValue(declaration.defaultValue);
         }
     }
     for (const declaration of document.item.templateDeclarations) {
@@ -52,12 +55,13 @@ export function createItemSession(document, priorState, options = {}) {
     }
     outcomes[COMPLETION_STATUS] = COMPLETION_NOT_ATTEMPTED;
     const baseResponses = cloneValueRecord(responses);
+    const baseResponseDefaults = cloneValueRecord(responseDefaults);
     const baseOutcomes = cloneValueRecord(outcomes);
-    applyTemplateProcessing(document, templateValues, responses, outcomes, correctResponses, random, customOperators, new Set(), baseResponses, baseOutcomes);
+    applyTemplateProcessing(document, templateValues, responses, responseDefaults, outcomes, correctResponses, random, customOperators, new Set(), baseResponses, baseResponseDefaults, baseOutcomes);
     if (priorState) {
         Object.assign(templateValues, priorTemplateValues);
         resetCorrectResponses(document, correctResponses);
-        applyTemplateProcessing(document, templateValues, responses, outcomes, correctResponses, random, customOperators, new Set(Object.keys(priorTemplateValues)), baseResponses, baseOutcomes);
+        applyTemplateProcessing(document, templateValues, responses, responseDefaults, outcomes, correctResponses, random, customOperators, new Set(Object.keys(priorTemplateValues)), baseResponses, baseResponseDefaults, baseOutcomes);
     }
     const defaultOutcomes = cloneValueRecord(outcomes);
     Object.assign(responses, priorResponses);
@@ -90,7 +94,7 @@ export function createItemSession(document, priorState, options = {}) {
         },
         score() {
             const diagnostics = [];
-            if (document.item.adaptive || status !== "initialized" || Object.keys(responses).length > 0) {
+            if (document.item.adaptive || status !== "initialized") {
                 startAttempt();
             }
             const completionStatus = outcomes[COMPLETION_STATUS] ?? COMPLETION_NOT_ATTEMPTED;
@@ -110,6 +114,10 @@ export function createItemSession(document, priorState, options = {}) {
         },
     };
     function startAttempt() {
+        for (const [identifier, value] of Object.entries(responseDefaults)) {
+            if (responses[identifier] === undefined)
+                responses[identifier] = cloneValue(value);
+        }
         if (status === "initialized" || status === "suspended")
             status = "interacting";
         if (outcomes[COMPLETION_STATUS] === COMPLETION_NOT_ATTEMPTED) {
@@ -172,7 +180,7 @@ function assertCompatiblePriorState(document, priorState) {
         completionStatus !== COMPLETION_UNKNOWN &&
         completionStatus !== COMPLETION_COMPLETED &&
         completionStatus !== "incomplete") {
-        throw new Error(`Cannot restore unsupported completionStatus ${String(completionStatus)}.`);
+        throw new Error(`Cannot restore unsupported completionStatus ${qtiValueToString(completionStatus)}.`);
     }
 }
 function assertKnownStateIdentifiers(kind, record, allowed) {
@@ -281,12 +289,12 @@ function attemptStateErrors(value) {
     }
     return errors;
 }
-function applyTemplateProcessing(document, templateValues, responses, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers = new Set(), baseResponses = cloneValueRecord(responses), baseOutcomes = cloneValueRecord(outcomes)) {
+function applyTemplateProcessing(document, templateValues, responses, responseDefaults, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers = new Set(), baseResponses = cloneValueRecord(responses), baseResponseDefaults = cloneValueRecord(responseDefaults), baseOutcomes = cloneValueRecord(outcomes)) {
     const rules = document.item.templateProcessing?.rules ?? [];
     let restarts = 0;
     for (let index = 0; index < rules.length; index += 1) {
         const rule = rules[index];
-        const shouldExit = applyTemplateRule(rule, document, templateValues, responses, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers);
+        const shouldExit = applyTemplateRule(rule, document, templateValues, responses, responseDefaults, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers);
         if (shouldExit)
             return;
         if (rule.type === "templateConstraint") {
@@ -294,6 +302,7 @@ function applyTemplateProcessing(document, templateValues, responses, outcomes,
             if (!satisfied) {
                 resetTemplateValues(document, templateValues);
                 resetRecord(responses, cloneValueRecord(baseResponses));
+                resetRecord(responseDefaults, cloneValueRecord(baseResponseDefaults));
                 resetRecord(outcomes, cloneValueRecord(baseOutcomes));
                 resetCorrectResponses(document, correctResponses);
                 restarts += 1;
@@ -316,7 +325,7 @@ function resetCorrectResponses(document, correctResponses) {
         correctResponses[declaration.identifier] = cloneValue(declaration.correctResponse);
     }
 }
-function applyTemplateRule(rule, document, templateValues, responses, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers) {
+function applyTemplateRule(rule, document, templateValues, responses, responseDefaults, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers) {
     if (rule.type === "exitTemplate")
         return true;
     if (rule.type === "templateConstraint")
@@ -335,7 +344,7 @@ function applyTemplateRule(rule, document, templateValues, responses, outcomes,
         }
         branch ??= rule.elseRules;
         for (const branchRule of branch) {
-            const shouldExit = applyTemplateRule(branchRule, document, templateValues, responses, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers);
+            const shouldExit = applyTemplateRule(branchRule, document, templateValues, responses, responseDefaults, outcomes, correctResponses, random, customOperators, preservedTemplateIdentifiers);
             if (shouldExit)
                 return true;
         }
@@ -352,7 +361,12 @@ function applyTemplateRule(rule, document, templateValues, responses, outcomes,
         const responseDeclaration = getResponseDeclaration(document, rule.identifier);
         if (responseDeclaration) {
             const normalized = normalizeValueForCardinality(value, responseDeclaration.cardinality);
-            responses[rule.identifier] = normalized;
+            if (normalized === null) {
+                delete responseDefaults[rule.identifier];
+            }
+            else {
+                responseDefaults[rule.identifier] = normalized;
+            }
             return false;
         }
         const outcomeDeclaration = document.item.outcomeDeclarations.find((declaration) => declaration.identifier === rule.identifier);
@@ -372,29 +386,37 @@ function applyResponseProcessing(document, responses, outcomes, templateValues,
         applyResponseRules(processing.rules, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         return;
     }
-    const template = processing?.template ?? "";
-    if (template.includes("map_response")) {
-        let score = 0;
-        for (const declaration of document.item.responseDeclarations) {
-            score += mapOrMatchResponse(declaration, responses[declaration.identifier] ?? null, correctResponses[declaration.identifier] ?? null);
-        }
-        outcomes.SCORE = score;
+    const templateKind = responseProcessingTemplateKind(processing?.template);
+    if (templateKind === "unsupported") {
         return;
     }
-    let score = 0;
-    let scored = false;
-    for (const declaration of document.item.responseDeclarations) {
-        const response = responses[declaration.identifier] ?? null;
-        const correctResponse = correctResponses[declaration.identifier] ?? null;
-        if (correctResponse !== null) {
-            score += valuesEqual(response, correctResponse, declaration.cardinality === "ordered")
-                ? 1
-                : 0;
-            scored = true;
-        }
+    if (templateKind === "mapResponse" || templateKind === "mapResponsePoint") {
+        const declaration = getResponseDeclaration(document, "RESPONSE");
+        outcomes.SCORE = declaration
+            ? mapOrMatchResponse(declaration, responses.RESPONSE ?? null, correctResponses.RESPONSE ?? null)
+            : 0;
+        return;
     }
-    if (scored)
-        outcomes.SCORE = score;
+    if (templateKind === "matchCorrect") {
+        const declaration = getResponseDeclaration(document, "RESPONSE");
+        const matches = declaration
+            ? qtiMatchValues(responses.RESPONSE ?? null, correctResponses.RESPONSE ?? null, declaration.cardinality === "ordered")
+            : null;
+        outcomes.SCORE = matches === true ? 1 : 0;
+    }
+}
+function responseProcessingTemplateKind(template) {
+    if (!template)
+        return undefined;
+    const path = template.split(/[?#]/, 1)[0] ?? "";
+    const name = path.slice(path.lastIndexOf("/") + 1).replace(/\.xml$/i, "");
+    if (name === "match_correct")
+        return "matchCorrect";
+    if (name === "map_response")
+        return "mapResponse";
+    if (name === "map_response_point")
+        return "mapResponsePoint";
+    return "unsupported";
 }
 function applyResponseRules(rules, document, responses, outcomes, templateValues, correctResponses, random, customOperators) {
     for (const rule of rules) {
@@ -450,11 +472,13 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
     if (expression.type === "matchCorrect") {
         const declaration = getResponseDeclaration(document, expression.correctIdentifier);
         return declaration
-            ? valuesEqual(responses[expression.identifier] ?? null, correctResponses[expression.correctIdentifier] ?? null, declaration.cardinality === "ordered")
+            ? qtiMatchValues(responses[expression.identifier] ?? null, correctResponses[expression.correctIdentifier] ?? null, declaration.cardinality === "ordered")
             : false;
     }
     if (expression.type === "match") {
-        return valuesEqual(evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators), evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators), expressionIsOrdered(expression.left, document) ||
+        const left = evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        const right = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        return qtiMatchValues(left, right, expressionIsOrdered(expression.left, document) ||
             expressionIsOrdered(expression.right, document));
     }
     if (expression.type === "mapResponse") {
@@ -510,37 +534,40 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
         return valueContainer(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators)).length;
     }
     if (expression.type === "sum") {
-        return expression.expressions.reduce((sum, item) => sum +
-            numericValue(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators)), 0);
+        const values = evaluateNumericOperands(expression.expressions, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        return values ? values.reduce((sum, value) => sum + value, 0) : null;
     }
     if (expression.type === "product") {
-        return expression.expressions.reduce((product, item) => product *
-            numericValue(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators)), 1);
+        const values = evaluateNumericOperands(expression.expressions, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        return values ? values.reduce((product, value) => product * value, 1) : null;
     }
     if (expression.type === "min" || expression.type === "max") {
-        const values = expression.expressions.flatMap((item) => valueContainer(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
-        if (values.length === 0)
+        const values = evaluateNumericOperands(expression.expressions, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        if (!values || values.length === 0)
             return null;
-        const numericValues = values.map((value) => numericValue(value));
-        return expression.type === "min" ? Math.min(...numericValues) : Math.max(...numericValues);
+        return expression.type === "min" ? Math.min(...values) : Math.max(...values);
     }
     if (expression.type === "subtract") {
-        return (numericValue(evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators)) -
-            numericValue(evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
+        const values = evaluateNumericOperands([expression.left, expression.right], document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        return values && values.length === 2 ? values[0] - values[1] : null;
     }
     if (expression.type === "divide") {
         const dividendValue = evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         const divisorValue = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         if (dividendValue === null || divisorValue === null)
             return null;
-        const divisor = numericValue(divisorValue);
-        if (divisor === 0)
+        const dividend = numericValueOrNull(dividendValue);
+        const divisor = numericValueOrNull(divisorValue);
+        if (dividend === null || divisor === null || divisor === 0)
             return null;
-        const quotient = numericValue(dividendValue) / divisor;
+        const quotient = dividend / divisor;
         return Number.isFinite(quotient) ? quotient : null;
     }
     if (expression.type === "power") {
-        const value = Math.pow(numericValue(evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators)), numericValue(evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
+        const values = evaluateNumericOperands([expression.left, expression.right], document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        if (!values || values.length !== 2)
+            return null;
+        const value = Math.pow(values[0], values[1]);
         return Number.isFinite(value) ? value : null;
     }
     if (expression.type === "integerDivide") {
@@ -548,40 +575,53 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
         const divisorValue = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         if (dividendValue === null || divisorValue === null)
             return null;
-        const divisor = numericValue(divisorValue);
-        if (divisor === 0)
+        const dividend = numericValueOrNull(dividendValue);
+        const divisor = numericValueOrNull(divisorValue);
+        if (dividend === null || divisor === null || divisor === 0)
             return null;
-        return Math.floor(numericValue(dividendValue) / divisor);
+        return Math.floor(dividend / divisor);
     }
     if (expression.type === "integerModulus") {
         const dividendValue = evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         const divisorValue = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         if (dividendValue === null || divisorValue === null)
             return null;
-        const divisor = numericValue(divisorValue);
-        if (divisor === 0)
+        const dividend = numericValueOrNull(dividendValue);
+        const divisor = numericValueOrNull(divisorValue);
+        if (dividend === null || divisor === null || divisor === 0)
             return null;
-        const dividend = numericValue(dividendValue);
         return dividend - Math.floor(dividend / divisor) * divisor;
     }
     if (expression.type === "round") {
-        return Math.round(numericValue(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
+        const value = numericValueOrNull(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        return value === null ? null : Math.round(value);
     }
     if (expression.type === "roundTo") {
-        const value = numericValue(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        const value = numericValueOrNull(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        if (value === null)
+            return null;
         return expression.roundingMode === "decimalPlaces"
             ? roundToDecimalPlaces(value, expression.figures)
             : roundToSignificantFigures(value, expression.figures);
     }
     if (expression.type === "truncate") {
-        return Math.trunc(numericValue(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
+        const value = numericValueOrNull(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        return value === null ? null : Math.trunc(value);
     }
     if (expression.type === "integerToFloat") {
         const value = evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
-        return value === null ? null : numericValue(value);
+        return numericValueOrNull(value);
     }
     if (expression.type === "and") {
-        return expression.expressions.every((item) => booleanValue(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
+        let sawNull = false;
+        for (const item of expression.expressions) {
+            const value = booleanValueOrNull(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+            if (value === false)
+                return false;
+            if (value === null)
+                sawNull = true;
+        }
+        return sawNull ? null : true;
     }
     if (expression.type === "anyN") {
         const min = indexValue(expression.min, outcomes, templateValues) ?? 0;
@@ -596,21 +636,36 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
         return null;
     }
     if (expression.type === "or") {
-        return expression.expressions.some((item) => booleanValue(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators)));
+        let sawNull = false;
+        for (const item of expression.expressions) {
+            const value = booleanValueOrNull(evaluateValue(item, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+            if (value === true)
+                return true;
+            if (value === null)
+                sawNull = true;
+        }
+        return sawNull ? null : false;
     }
     if (expression.type === "not") {
-        return !booleanValue(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        const value = booleanValueOrNull(evaluateValue(expression.expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        return value === null ? null : !value;
     }
     if (expression.type === "equal") {
-        return valuesEqual(evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators), evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        const left = evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        const right = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        return left === null || right === null ? null : valuesEqual(left, right);
     }
     if (expression.type === "equalRounded") {
         const left = evaluateValue(expression.left, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         const right = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         if (left === null || right === null)
             return null;
-        const roundedLeft = roundWithMode(numericValue(left), expression.roundingMode, expression.figures);
-        const roundedRight = roundWithMode(numericValue(right), expression.roundingMode, expression.figures);
+        const leftNumber = numericValueOrNull(left);
+        const rightNumber = numericValueOrNull(right);
+        if (leftNumber === null || rightNumber === null)
+            return null;
+        const roundedLeft = roundWithMode(leftNumber, expression.roundingMode, expression.figures);
+        const roundedRight = roundWithMode(rightNumber, expression.roundingMode, expression.figures);
         return roundedLeft === null || roundedRight === null ? null : roundedLeft === roundedRight;
     }
     if (expression.type === "numericCompare") {
@@ -618,8 +673,10 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
         const rightValue = evaluateValue(expression.right, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         if (leftValue === null || rightValue === null)
             return null;
-        const left = numericValue(leftValue);
-        const right = numericValue(rightValue);
+        const left = numericValueOrNull(leftValue);
+        const right = numericValueOrNull(rightValue);
+        if (left === null || right === null)
+            return null;
         if (expression.operator === "lt")
             return left < right;
         if (expression.operator === "lte")
@@ -652,7 +709,7 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
             templateValues[expression.pattern] ??
             expression.pattern;
         try {
-            return new RegExp(String(patternValue)).test(String(value));
+            return new RegExp(typeof patternValue === "string" ? patternValue : qtiValueToString(patternValue)).test(qtiValueToString(value));
         }
         catch {
             return null;
@@ -665,20 +722,29 @@ function evaluateValue(expression, document, responses, outcomes = {}, templateV
     if (expression.type === "member") {
         const value = evaluateValue(expression.value, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
         const collection = evaluateValue(expression.collection, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        if (value === null || collection === null)
+            return null;
         const values = valueContainer(collection);
-        return value === null ? null : values.some((item) => valuesEqual(item, value));
+        return values.some((item) => valuesEqual(item, value));
     }
     if (expression.type === "delete") {
         const value = evaluateValue(expression.value, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
-        const collection = valueContainer(evaluateValue(expression.collection, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
-        if (value === null || collection.length === 0)
+        const collectionValue = evaluateValue(expression.collection, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        if (value === null || collectionValue === null)
+            return null;
+        const collection = valueContainer(collectionValue);
+        if (collection.length === 0)
             return null;
         const filtered = collection.filter((item) => !valuesEqual(item, value));
         return filtered.length > 0 ? filtered : null;
     }
     if (expression.type === "contains") {
-        const collection = valueContainer(evaluateValue(expression.collection, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
-        const values = valueContainer(evaluateValue(expression.values, document, responses, outcomes, templateValues, correctResponses, random, customOperators));
+        const collectionValue = evaluateValue(expression.collection, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        const valuesValue = evaluateValue(expression.values, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        if (collectionValue === null || valuesValue === null)
+            return null;
+        const collection = valueContainer(collectionValue);
+        const values = valueContainer(valuesValue);
         if (collection.length === 0 || values.length === 0)
             return null;
         return containsValues(collection, values);
@@ -817,7 +883,11 @@ function mapOrMatchResponse(declaration, response, correctResponse) {
     return valuesEqual(response, correctResponse, declaration.cardinality === "ordered") ? 1 : 0;
 }
 function scoreAreaMapping(response, areaMapping) {
-    const points = Array.isArray(response) ? response : response === null ? [] : [String(response)];
+    const points = Array.isArray(response)
+        ? response.map(qtiScalarToString)
+        : response === null
+            ? []
+            : qtiValueToStringList(response);
     let score = 0;
     for (const point of points) {
         const parsed = parsePoint(String(point));
@@ -924,7 +994,9 @@ function scoreMapping(response, mapping) {
         const score = response.reduce((sum, value) => sum + (values[String(value)] ?? mapping.defaultValue), 0);
         return clampMappedScore(score, mapping.attributes);
     }
-    const score = typeof response === "string" ? (values[response] ?? mapping.defaultValue) : 0;
+    const score = response === null || isRecordValue(response)
+        ? 0
+        : (values[String(response)] ?? mapping.defaultValue);
     return clampMappedScore(score, mapping.attributes);
 }
 function clampMappedScore(score, attributes) {
@@ -966,6 +1038,11 @@ function valuesEqual(actual, expected, ordered = false) {
     }
     return scalarValuesEqual(actual, expected);
 }
+function qtiMatchValues(actual, expected, ordered = false) {
+    if (actual === null || expected === null)
+        return null;
+    return valuesEqual(actual, expected, ordered);
+}
 function scalarValuesEqual(actual, expected) {
     if (typeof actual === "boolean" && typeof expected === "string") {
         return String(actual) === expected;
@@ -1058,8 +1135,24 @@ function indexValue(n, outcomes, templateValues) {
     if (Number.isInteger(parsed))
         return parsed;
     const value = outcomes[n] ?? templateValues[n] ?? null;
-    const numeric = numericValue(value);
-    return Number.isInteger(numeric) ? numeric : undefined;
+    const numeric = numericValueOrNull(value);
+    return numeric !== null && Number.isInteger(numeric) ? numeric : undefined;
+}
+function evaluateNumericOperands(expressions, document, responses, outcomes, templateValues, correctResponses, random, customOperators) {
+    const numericValues = [];
+    for (const expression of expressions) {
+        const value = evaluateValue(expression, document, responses, outcomes, templateValues, correctResponses, random, customOperators);
+        if (value === null || isRecordValue(value))
+            return null;
+        const values = Array.isArray(value) ? value : [value];
+        for (const item of values) {
+            const numeric = numericValueOrNull(item);
+            if (numeric === null)
+                return null;
+            numericValues.push(numeric);
+        }
+    }
+    return numericValues;
 }
 function containsValues(collection, values) {
     const remaining = [...collection];
@@ -1083,6 +1176,17 @@ function numericValue(value) {
         return Number(value);
     return 0;
 }
+function numericValueOrNull(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "boolean")
+        return value ? 1 : 0;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
 function durationSeconds(value) {
     if (value === null || Array.isArray(value) || isRecordValue(value))
         return null;
@@ -1117,6 +1221,11 @@ function booleanValue(value) {
         return value.length > 0;
     return false;
 }
+function booleanValueOrNull(value) {
+    if (value === null)
+        return null;
+    return booleanValue(value);
+}
 function roundToDecimalPlaces(value, figures) {
     const factor = 10 ** figures;
     return Math.round(value * factor) / factor;
@@ -1258,8 +1367,10 @@ function finiteOrNull(value) {
     return Number.isFinite(value) ? value : null;
 }
 function stringMatch(left, right, caseSensitive, substring) {
-    let actual = String(left ?? "");
-    let expected = String(right ?? "");
+    if (left === null || right === null)
+        return null;
+    let actual = qtiValueToString(left);
+    let expected = qtiValueToString(right);
     if (!caseSensitive) {
         actual = actual.toLocaleLowerCase();
         expected = expected.toLocaleLowerCase();