@longsightgroup/qti3-core 0.10.1 → 0.10.3

package/src/parser-item-metadata.ts

@@ -19,6 +19,7 @@ import {
   type ParsedCompanionMaterialChildQtiName,
   pushCompanionMaterialParseWarning,
 } from "./companion-materials.js";
+import { visibleTextContent } from "./content-text.js";
 import { parseXmlBoolean } from "./parser-values.js";
 import { childElements, descendants, textContent, type XmlNode } from "./xml.js";
 
@@ -75,7 +76,7 @@ export function parseModalFeedback(node: XmlNode): QtiModalFeedback {
     identifier: node.attributes.identifier ?? "",
     outcomeIdentifier: node.attributes["outcome-identifier"] ?? "",
     showHide,
-    text: textContent(node),
+    text: visibleTextContent(node),
     source: node.source,
   };
 }
@@ -119,7 +120,7 @@ function parseCatalogCardEntry(node: XmlNode): QtiCatalogCardEntry {
 function parseCatalogHtmlContent(node: XmlNode | undefined): QtiCatalogHtmlContent | undefined {
   if (!node) return undefined;
   return {
-    text: textContent(node),
+    text: visibleTextContent(node),
     children: parseCatalogHtmlChildren(node),
     attributes: node.attributes,
     source: node.source,
@@ -202,7 +203,7 @@ function parsePhysicalMaterial(
   node: XmlNode,
   diagnostics: QtiDiagnostic[],
 ): QtiPhysicalMaterial | undefined {
-  const text = textContent(node).trim();
+  const text = visibleTextContent(node);
   if (text.length === 0) {
     return pushCompanionMaterialParseWarning(
       diagnostics,

package/src/parser-processing.ts

@@ -646,15 +646,16 @@ function parseExpression(node: XmlNode): QtiProcessingExpression | undefined {
   }
 
   if (node.localName === "qti-stats-operator") {
-    const expression = parseFirstExpression(node);
-    if (expression) {
-      return {
-        type: "statsOperator",
-        name: node.attributes.name ?? "",
-        expression,
-        source: node.source,
-      };
-    }
+    const expressions = childElements(node)
+      .map(parseExpression)
+      .filter((expression): expression is QtiProcessingExpression => expression !== undefined);
+    return {
+      type: "statsOperator",
+      name: node.attributes.name ?? "",
+      expression: expressions[0] ?? { type: "null", source: node.source },
+      expressions,
+      source: node.source,
+    };
   }
 
   if (node.localName === "qti-custom-operator") {

package/src/parser-values.ts

@@ -66,6 +66,13 @@ export function parseXmlBoolean(value: string | undefined): boolean | undefined
   return undefined;
 }
 
+/** Parse a non-empty finite numeric XML attribute value. */
+export function parseFiniteNumber(value: string | undefined): number | undefined {
+  if (value === undefined || value.trim().length === 0) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
 export function normalizeValueForCardinality(
   value: QtiValue,
   cardinality: QtiCardinality,

package/src/parser.ts

@@ -1,4 +1,4 @@
-import { appendContentTextNode, flatTextFromContent } from "./content-text.js";
+import { appendContentTextNode, flatTextFromContent, visibleTextContent } from "./content-text.js";
 import {
   parseOutcomeDeclaration,
   parseResponseDeclaration,
@@ -36,7 +36,7 @@ import type {
   QtiResponseDeclaration,
 } from "./types.js";
 import { validateAssessmentItem } from "./validation.js";
-import { childElements, descendants, parseXmlTree, textContent, type XmlNode } from "./xml.js";
+import { childElements, descendants, parseXmlTree, type XmlNode } from "./xml.js";
 
 const qtiAssessmentItemNamespace = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0";
 const supportedProcessingNames = new Set(processingSupport.map((entry) => entry.qtiName));
@@ -109,16 +109,16 @@ export function parseQtiXml(xml: string): QtiParseResult {
 function parseAssessmentItem(node: XmlNode, diagnostics: QtiDiagnostic[]): QtiAssessmentItem {
   const identifier = node.attributes.identifier ?? "";
   const responseDeclarations = childElements(node, "qti-response-declaration").map(
-    parseResponseDeclaration,
+    (declarationNode) => parseResponseDeclaration(declarationNode, diagnostics),
   );
   const responseDeclarationMap = new Map(
     responseDeclarations.map((declaration) => [declaration.identifier, declaration]),
   );
   const outcomeDeclarations = childElements(node, "qti-outcome-declaration").map(
-    parseOutcomeDeclaration,
+    (declarationNode) => parseOutcomeDeclaration(declarationNode, diagnostics),
   );
   const templateDeclarations = childElements(node, "qti-template-declaration").map(
-    parseTemplateDeclaration,
+    (declarationNode) => parseTemplateDeclaration(declarationNode, diagnostics),
   );
   const templateProcessing = parseTemplateProcessing(
     childElements(node, "qti-template-processing")[0],
@@ -166,7 +166,7 @@ function parseAssessmentItem(node: XmlNode, diagnostics: QtiDiagnostic[]): QtiAs
     adaptive: parseXmlBoolean(node.attributes.adaptive) === true,
     timeDependent: parseXmlBoolean(node.attributes["time-dependent"]),
     attributes: node.attributes,
-    prompt: prompt ? textContent(prompt) : undefined,
+    prompt: prompt ? visibleTextContent(prompt) : undefined,
     itemBodyAttributes: itemBody?.attributes,
     itemBodySource: itemBody?.source,
     responseDeclarations,
@@ -181,7 +181,10 @@ function parseAssessmentItem(node: XmlNode, diagnostics: QtiDiagnostic[]): QtiAs
     catalogReferences,
     stylesheets,
     body,
-    bodyText: textContent(node),
+    bodyText: flatTextFromContent(body, {
+      excludeAnnotations: true,
+      interactionText: (interactionIndex) => interactions[interactionIndex]?.prompt ?? "",
+    }),
     source: node.source,
   };
 }
@@ -334,7 +337,7 @@ function parseInteraction(
     prompt: promptContent
       ? flatTextFromContent(promptContent, { excludeAnnotations: true }) || undefined
       : prompt
-        ? textContent(prompt)
+        ? visibleTextContent(prompt)
         : undefined,
     promptContent: promptContent && promptContent.length > 0 ? promptContent : undefined,
     promptAttributes: prompt?.attributes,
@@ -357,7 +360,7 @@ function parseInteraction(
       source: child.source,
     })),
     attributes: node.attributes,
-    text: textContent(node),
+    text: visibleTextContent(node),
     source: node.source,
   };
 }
@@ -417,7 +420,7 @@ function parseHottextSegments(node: XmlNode): QtiInteraction["hottextSegments"]
       segments.push({
         kind: "hottext",
         identifier: entry.attributes.identifier ?? "",
-        text: textContent(entry),
+        text: visibleTextContent(entry),
         attributes: entry.attributes,
         source: entry.source,
       });
@@ -475,7 +478,7 @@ function inlineInteractionContext(
   if (interactionType !== "inlineChoice" && interactionType !== "textEntry") return undefined;
   const parent = node.parent;
   if (!parent) return undefined;
-  return normalizeInlineContext(parent.text) ?? normalizeInlineContext(textContent(parent));
+  return normalizeInlineContext(parent.text) ?? normalizeInlineContext(visibleTextContent(parent));
 }
 
 function normalizeInlineContext(value: string): string | undefined {
@@ -505,7 +508,7 @@ function parseObjectAsset(node: XmlNode | undefined): QtiObjectAsset | undefined
       node.attributes.height ?? pictureImage?.attributes.height ?? inferredSvgDimensions?.height,
     sources,
     tracks,
-    text: textContent(node) || node.attributes.alt || pictureImage?.attributes.alt || "",
+    text: visibleTextContent(node) || node.attributes.alt || pictureImage?.attributes.alt || "",
     attributes: node.attributes,
     source: node.source,
   };
@@ -670,7 +673,7 @@ function parseChoices(
     const flatChoiceText =
       content.length > 0
         ? flatTextFromContent(content, { excludeAnnotations: true })
-        : textContent(choice);
+        : visibleTextContent(choice);
     return {
       identifier,
       text:

package/src/processing-evaluator-collection.ts

@@ -1,6 +1,7 @@
 import type { QtiProcessingExpression, QtiScalarValue, QtiValue } from "./types.js";
 import { assertNever } from "./assert-never.js";
 import type { EvaluationContext } from "./processing-evaluator.js";
+import { MAX_QTI_REPEAT_RESULT_ELEMENTS } from "./processing-limits.js";
 import { valueContainer } from "./processing-values.js";
 
 type CollectionExpression = Extract<
@@ -39,11 +40,15 @@ export function evaluateRepeatExpression(
   context: EvaluationContext,
 ): QtiValue {
   const repeats = context.indexValue(expression.numberRepeats);
-  if (repeats === undefined || repeats < 1) return null;
+  if (repeats === undefined || repeats < 1 || repeats > MAX_QTI_REPEAT_RESULT_ELEMENTS) {
+    return null;
+  }
   const container: QtiScalarValue[] = [];
   for (let repeat = 0; repeat < repeats; repeat += 1) {
     for (const item of expression.expressions) {
-      container.push(...valueContainer(context.evaluate(item)));
+      const values = valueContainer(context.evaluate(item));
+      if (values.length > MAX_QTI_REPEAT_RESULT_ELEMENTS - container.length) return null;
+      for (const value of values) container.push(value);
     }
   }
   return container.length > 0 ? container : null;

package/src/processing-evaluator-comparison.ts

@@ -48,6 +48,12 @@ export function evaluateComparisonExpression(
       return left === null || right === null ? null : valuesEqual(left, right);
     }
     case "equalRounded": {
+      const validRounding =
+        Number.isInteger(expression.figures) &&
+        (expression.roundingMode === "decimalPlaces"
+          ? expression.figures >= 0
+          : expression.roundingMode === "significantFigures" && expression.figures > 0);
+      if (!validRounding) return null;
       const left = context.evaluate(expression.left);
       const right = context.evaluate(expression.right);
       if (left === null || right === null) return null;

package/src/processing-evaluator-numeric.ts

@@ -47,10 +47,12 @@ export function evaluateNumericExpression(
 ): QtiValue {
   switch (expression.type) {
     case "sum": {
+      if (expression.expressions.length === 0) return null;
       const values = context.numericOperands(expression.expressions);
       return values ? values.reduce((sum, value) => sum + value, 0) : null;
     }
     case "product": {
+      if (expression.expressions.length === 0) return null;
       const values = context.numericOperands(expression.expressions);
       return values ? values.reduce((product, value) => product * value, 1) : null;
     }
@@ -127,7 +129,9 @@ export function evaluateNumericExpression(
       return mathOperatorValue(expression.name, values.map(numericValue));
     }
     case "statsOperator": {
-      const value = context.evaluate(expression.expression);
+      const expressions = expression.expressions ?? [expression.expression];
+      if (expressions.length !== 1) return null;
+      const value = context.evaluate(expressions[0]!);
       if (value === null) return null;
       return statsOperatorValue(expression.name, valueContainer(value).map(numericValue));
     }

package/src/processing-expression-children.ts

@@ -43,8 +43,9 @@ export function expressionChildren(expression: QtiProcessingExpression): QtiProc
     case "patternMatch":
     case "fieldValue":
     case "inside":
-    case "statsOperator":
       return [expression.expression];
+    case "statsOperator":
+      return expression.expressions ?? [expression.expression];
     case "member":
     case "delete":
       return [expression.value, expression.collection];

package/src/processing-limits.ts

@@ -0,0 +1,2 @@
+/** Maximum scalar elements a single qti-repeat expression may produce. */
+export const MAX_QTI_REPEAT_RESULT_ELEMENTS = 10_000;

package/src/processing-mapping.ts

@@ -49,6 +49,7 @@ export function scoreAreaMapping(
     : response === null
       ? []
       : qtiValueToStringList(response);
+  const matchedAreaIndexes = new Set<number>();
   let score = 0;
   for (const point of points) {
     const parsed = parsePoint(point);
@@ -56,8 +57,15 @@ export function scoreAreaMapping(
       score += areaMapping.defaultValue;
       continue;
     }
-    const entry = areaMapping.entries.find((candidate) => pointInsideArea(parsed, candidate));
-    score += entry?.mappedValue ?? areaMapping.defaultValue;
+    let matchedArea = false;
+    for (const [index, entry] of areaMapping.entries.entries()) {
+      if (!pointInsideArea(parsed, entry)) continue;
+      matchedArea = true;
+      if (matchedAreaIndexes.has(index)) continue;
+      matchedAreaIndexes.add(index);
+      score += entry.mappedValue;
+    }
+    if (!matchedArea) score += areaMapping.defaultValue;
   }
   return clampMappedScore(score, areaMapping.attributes);
 }

package/src/processing-operators.ts

@@ -39,15 +39,45 @@ export const STATS_OPERATOR_NAMES = [
   "popSD",
 ] as const;
 
+/** Round decimal ties away from zero without an intermediate scaled binary float. */
 export function roundToDecimalPlaces(value: number, figures: number): number {
-  const factor = 10 ** figures;
-  return Math.round(value * factor) / factor;
+  if (!Number.isFinite(value) || value === 0) return value;
+  const decimal = decimalDigits(value);
+  const retainedDigits = decimal.exponent + figures + 1;
+  return roundDecimalDigits(value, decimal, retainedDigits);
 }
 
+/** Round significant decimal digits, with half-up ties on the absolute magnitude. */
 export function roundToSignificantFigures(value: number, figures: number): number {
   if (value === 0 || figures <= 0) return 0;
-  const factor = 10 ** (figures - 1 - Math.floor(Math.log10(Math.abs(value))));
-  return Math.round(value * factor) / factor;
+  if (!Number.isFinite(value)) return Number.NaN;
+  return roundDecimalDigits(value, decimalDigits(value), figures);
+}
+
+interface DecimalDigits {
+  digits: string;
+  exponent: number;
+}
+
+function decimalDigits(value: number): DecimalDigits {
+  const [coefficient = "", exponent = "0"] = Math.abs(value).toExponential().split("e");
+  return {
+    digits: coefficient.replace(".", ""),
+    exponent: Number(exponent),
+  };
+}
+
+function roundDecimalDigits(value: number, decimal: DecimalDigits, retainedDigits: number): number {
+  if (retainedDigits >= decimal.digits.length) return value;
+  if (retainedDigits < 0) return value < 0 ? -0 : 0;
+
+  const roundingDigit = decimal.digits[retainedDigits] ?? "0";
+  const retained = retainedDigits === 0 ? 0n : BigInt(decimal.digits.slice(0, retainedDigits));
+  const rounded = roundingDigit >= "5" ? retained + 1n : retained;
+  if (rounded === 0n) return value < 0 ? -0 : 0;
+
+  const unitExponent = decimal.exponent - retainedDigits + 1;
+  return Number(`${value < 0 ? "-" : ""}${rounded}e${unitExponent}`);
 }
 
 export function roundWithMode(value: number, roundingMode: string, figures: number): number | null {
@@ -151,7 +181,10 @@ export function mathOperatorValue(name: string, values: number[]): QtiValue {
 }
 
 export function statsOperatorValue(name: string, values: number[]): QtiValue {
-  if (values.length === 0) return 0;
+  // QTI 3.0.1 defines the input as a numeric container but does not define empty-container
+  // results, so this implementation conservatively returns NULL.
+  // https://www.imsglobal.org/sites/default/files/spec/qti/v3/info/index.html#OpStatsOp
+  if (values.length === 0) return null;
   const meanValue = mean(values);
   const squareDiffs = values.map((value) => (value - meanValue) ** 2);
   switch (name) {

package/src/response-validation-policy.ts

@@ -1,4 +1,5 @@
 import type { QtiChoice, QtiDiagnostic, QtiInteraction, QtiValue } from "./types.js";
+import { parseQtiMediaDefinition } from "./media-definition.js";
 import { parseXmlBoolean } from "./parser-values.js";
 import { parseNonNegativeInteger } from "./validation-primitives.js";
 import { qtiValueToIdentifierList } from "./value-format.js";
@@ -75,14 +76,13 @@ export function mediaPlayCount(value: QtiValue): number {
 }
 
 function minimumMediaPlays(interaction: QtiInteraction): number {
-  const parsed = parseNonNegativeInteger(interaction.attributes["min-plays"]);
-  if (parsed !== undefined) return parsed;
-  return interactionRequiresResponse(interaction) ? 1 : 0;
+  const definition = parseQtiMediaDefinition(interaction);
+  return definition.ok ? definition.value.minPlays : 0;
 }
 
 function maximumMediaPlays(interaction: QtiInteraction): number | undefined {
-  const parsed = parseNonNegativeInteger(interaction.attributes["max-plays"]);
-  return parsed === undefined || parsed <= 0 ? undefined : parsed;
+  const definition = parseQtiMediaDefinition(interaction);
+  return definition.ok ? definition.value.maxPlays : undefined;
 }
 
 export { maximumMediaPlays, minimumMediaPlays };

package/src/serializer-processing-expressions.ts

@@ -262,7 +262,7 @@ export function serializeExpression(
       return renderExpressionContainer(
         "qti-stats-operator",
         [["name", expression.name]],
-        [expression.expression],
+        expression.expressions ?? [expression.expression],
         context,
         indent,
       );