@longsightgroup/qti3-core 0.9.2 → 0.9.4

package/src/item-submission-materialization.ts

@@ -0,0 +1,120 @@
+import { runTrustedAdaptiveItemTurn } from "./adaptive-turn.js";
+import type { QtiItemSubmissionScoringDisposition } from "./scoring-disposition-policy.js";
+import {
+  buildItemSubmissionMaterializationFailure,
+  buildItemSubmissionMaterializationSuccess,
+} from "./trusted-session-materialization.js";
+import {
+  parseTrustedItemDocument,
+  readPriorAttemptState,
+  runTrustedItemSession,
+  type QtiTrustedItemDocument,
+  type QtiTrustedItemParseOptions,
+  type QtiTrustedResponseInput,
+  type QtiTrustedResponseApplication,
+} from "./trusted-item-session.js";
+import type { QtiAttemptStateV1, QtiDiagnostic } from "./types.js";
+import type { QtiVariableSnapshot } from "./variable-snapshot.js";
+
+export type QtiItemSubmissionResponseInput = QtiTrustedResponseInput;
+export type { QtiItemSubmissionScoringDisposition } from "./scoring-disposition-policy.js";
+export type { QtiVariableSnapshot } from "./variable-snapshot.js";
+
+export interface QtiItemSubmissionMaterializationInput
+  extends QtiTrustedItemParseOptions, QtiTrustedResponseApplication {
+  itemXml: string;
+  existingState?: unknown;
+  allowIncompleteResponses?: boolean | undefined;
+}
+
+export interface QtiItemSubmissionMaterializationResult {
+  ok: boolean;
+  diagnostics: QtiDiagnostic[];
+  state?: QtiAttemptStateV1 | undefined;
+  responseVariables: QtiVariableSnapshot[];
+  outcomeVariables: QtiVariableSnapshot[];
+  score: number | null;
+  scoringDisposition: QtiItemSubmissionScoringDisposition;
+  candidateSafeXml?: string | undefined;
+}
+
+/** Materialize trusted submitted responses into QTI attempt state and variable snapshots. */
+export function materializeQtiItemSubmission(
+  input: QtiItemSubmissionMaterializationInput,
+): QtiItemSubmissionMaterializationResult {
+  const parsedResult = parseTrustedItemDocument(
+    input.itemXml,
+    input.allowedUndeclaredResponseIdentifiers,
+  );
+  if (!parsedResult.ok) {
+    return buildItemSubmissionMaterializationFailure(parsedResult.diagnostics);
+  }
+
+  const item = parsedResult.parsed.document.item;
+  if (item.adaptive) {
+    return materializeAdaptiveSubmission(input, parsedResult.parsed);
+  }
+
+  const priorState = readPriorAttemptState(input.existingState, "itemSubmission");
+  if (priorState.diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return buildItemSubmissionMaterializationFailure(priorState.diagnostics);
+  }
+
+  const result = runTrustedItemSession({
+    itemXml: input.itemXml,
+    parsedItem: parsedResult.parsed,
+    diagnosticPrefix: "itemSubmission",
+    allowedUndeclaredResponseIdentifiers: input.allowedUndeclaredResponseIdentifiers,
+    priorState: priorState.state,
+    submission: {
+      trustedResponses: input.trustedResponses,
+      trustedInteractionStates: input.trustedInteractionStates,
+    },
+    scoring: "always",
+    requireNumericScore: false,
+    submissionValidation: "strict",
+    allowIncompleteResponses: input.allowIncompleteResponses,
+  });
+
+  if (!result.ok) {
+    return buildItemSubmissionMaterializationFailure(result.diagnostics, result.state ?? undefined);
+  }
+
+  return buildItemSubmissionMaterializationSuccess(item, {
+    diagnostics: result.diagnostics,
+    state: result.state,
+    responses: result.responses,
+    outcomes: result.outcomes,
+    score: result.score,
+  });
+}
+
+function materializeAdaptiveSubmission(
+  input: QtiItemSubmissionMaterializationInput,
+  parsedItem: QtiTrustedItemDocument,
+): QtiItemSubmissionMaterializationResult {
+  const result = runTrustedAdaptiveItemTurn({
+    itemXml: input.itemXml,
+    parsedItem,
+    diagnosticPrefix: "itemSubmission",
+    allowedUndeclaredResponseIdentifiers: input.allowedUndeclaredResponseIdentifiers,
+    priorState: input.existingState,
+    trustedResponses: input.trustedResponses,
+    trustedInteractionStates: input.trustedInteractionStates,
+    submissionValidation: "strict",
+    allowIncompleteResponses: input.allowIncompleteResponses,
+  });
+
+  if (!result.ok || !result.state) {
+    return buildItemSubmissionMaterializationFailure(result.diagnostics, result.state ?? undefined);
+  }
+
+  return buildItemSubmissionMaterializationSuccess(parsedItem.document.item, {
+    diagnostics: result.diagnostics,
+    state: result.state,
+    responses: result.responses,
+    outcomes: result.outcomes,
+    score: result.score,
+    candidateSafeXml: result.candidateSafeXml,
+  });
+}

package/src/parser-custom-interactions.ts

@@ -212,7 +212,7 @@ function parseCustomMarkupNode(
       code: options.nestedInteractionCode,
       severity: "error",
       message: `${options.contextName} must not contain nested QTI interaction ${node.localName}.`,
-      path: node.source?.path,
+      path: node.source.path,
       source: node.source,
     });
   }

package/src/parser-declarations.ts

@@ -1,6 +1,7 @@
 import {
   coerceValue,
   normalizeValueForCardinality,
+  parseBaseType,
   parseCardinality,
   parseCoords,
   parseShape,
@@ -18,7 +19,7 @@ import { childElements, textContent, type XmlNode } from "./xml.js";
 
 export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration {
   const cardinality = parseCardinality(node.attributes.cardinality);
-  const baseType = node.attributes["base-type"] as QtiResponseDeclaration["baseType"];
+  const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "response",
     identifier: node.attributes.identifier ?? "",
@@ -37,7 +38,7 @@ export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration
 }
 
 export function parseOutcomeDeclaration(node: XmlNode): QtiOutcomeDeclaration {
-  const baseType = node.attributes["base-type"] as QtiOutcomeDeclaration["baseType"];
+  const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "outcome",
     identifier: node.attributes.identifier ?? "",
@@ -51,7 +52,7 @@ export function parseOutcomeDeclaration(node: XmlNode): QtiOutcomeDeclaration {
 }
 
 export function parseTemplateDeclaration(node: XmlNode): QtiTemplateDeclaration {
-  const baseType = node.attributes["base-type"] as QtiTemplateDeclaration["baseType"];
+  const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "template",
     identifier: node.attributes.identifier ?? "",

package/src/parser-item-metadata.ts

@@ -28,13 +28,14 @@ export function firstChildElement(
   duplicateCode: string,
 ): XmlNode | undefined {
   const matches = childElements(parent, childName);
-  if (matches.length > 1) {
+  const duplicate = matches[1];
+  if (duplicate) {
     diagnostics.push({
       code: duplicateCode,
       severity: "error",
       message: `${parent.localName} allows at most one ${childName} child.`,
-      path: matches[1]?.source?.path ?? parent.source?.path,
-      source: matches[1]?.source ?? parent.source,
+      path: duplicate.source.path,
+      source: duplicate.source,
     });
   }
   return matches[0];
@@ -177,7 +178,7 @@ export function parseCompanionMaterialsInfo(
       code: "companionMaterials.child.unsupported",
       severity: "warning",
       message: `${child.localName} is not currently modeled in companion materials parsing.`,
-      path: child.source?.path,
+      path: child.source.path,
       source: child.source,
     });
   }
@@ -200,7 +201,7 @@ function parsePhysicalMaterial(
       diagnostics,
       "companionMaterials.physicalMaterial.empty",
       "qti-physical-material requires non-empty text content.",
-      node.source?.path,
+      node.source.path,
       node.source,
     );
   }
@@ -225,7 +226,7 @@ function parseDigitalMaterial(
       diagnostics,
       "companionMaterials.digitalMaterial.fileHref.missing",
       "qti-digital-material requires a qti-file-href child.",
-      node.source?.path,
+      node.source.path,
       node.source,
     );
   }
@@ -236,7 +237,7 @@ function parseDigitalMaterial(
       diagnostics,
       "companionMaterials.digitalMaterial.fileHref.empty",
       "qti-digital-material qti-file-href requires non-empty text content.",
-      fileHrefNode.source?.path,
+      fileHrefNode.source.path,
       fileHrefNode.source,
     );
   }

package/src/parser-processing.ts

@@ -672,8 +672,8 @@ function parseExpression(node: XmlNode): QtiProcessingExpression | undefined {
     if (variable && correct) {
       return {
         type: "matchCorrect",
-        identifier: variable?.attributes.identifier ?? "",
-        correctIdentifier: correct?.attributes.identifier ?? "",
+        identifier: variable.attributes.identifier ?? "",
+        correctIdentifier: correct.attributes.identifier ?? "",
         source: node.source,
       };
     }

package/src/parser-values.ts

@@ -1,4 +1,5 @@
 import type {
+  QtiBaseType,
   QtiCardinality,
   QtiRecordValue,
   QtiResponseDeclaration,
@@ -6,6 +7,41 @@ import type {
   QtiValue,
 } from "./types.js";
 
+const QTI_BASE_TYPES = new Set<string>([
+  "identifier",
+  "boolean",
+  "integer",
+  "float",
+  "string",
+  "point",
+  "pair",
+  "directedPair",
+  "duration",
+  "file",
+  "uri",
+]);
+
+export function isQtiBaseType(value: string): value is QtiBaseType {
+  return QTI_BASE_TYPES.has(value);
+}
+
+export function parseBaseType(value: string | undefined): QtiBaseType | undefined {
+  if (value === undefined) return undefined;
+  return isQtiBaseType(value) ? value : undefined;
+}
+
+export function numericTuple3(values: number[]): [number, number, number] | undefined {
+  const [a, b, c] = values;
+  if (a === undefined || b === undefined || c === undefined) return undefined;
+  return [a, b, c];
+}
+
+export function numericTuple4(values: number[]): [number, number, number, number] | undefined {
+  const [a, b, c, d] = values;
+  if (a === undefined || b === undefined || c === undefined || d === undefined) return undefined;
+  return [a, b, c, d];
+}
+
 export function coerceValue(value: string, baseType: string | undefined): QtiScalarValue {
   if (baseType === "integer") return Number.parseInt(value, 10);
   if (baseType === "float") return Number.parseFloat(value);

package/src/processing-evaluator-boolean.ts

@@ -0,0 +1,48 @@
+import type { QtiProcessingExpression, QtiValue } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import type { EvaluationContext } from "./processing-evaluator.js";
+import { booleanValueOrNull } from "./processing-values.js";
+
+type BooleanExpression = Extract<QtiProcessingExpression, { type: "and" | "anyN" | "or" | "not" }>;
+
+export function evaluateBooleanExpression(
+  expression: BooleanExpression,
+  context: EvaluationContext,
+): QtiValue {
+  switch (expression.type) {
+    case "and": {
+      let sawNull = false;
+      for (const item of expression.expressions) {
+        const value = booleanValueOrNull(context.evaluate(item));
+        if (value === false) return false;
+        if (value === null) sawNull = true;
+      }
+      return sawNull ? null : true;
+    }
+    case "anyN": {
+      const min = context.indexValue(expression.min) ?? 0;
+      const max = context.indexValue(expression.max) ?? 0;
+      const values = expression.expressions.map((item) => context.evaluate(item));
+      const trueCount = values.filter((value) => value === true).length;
+      const nullCount = values.filter((value) => value === null).length;
+      if (min > max || trueCount > max || trueCount + nullCount < min) return false;
+      if (trueCount >= min && trueCount <= max) return true;
+      return null;
+    }
+    case "or": {
+      let sawNull = false;
+      for (const item of expression.expressions) {
+        const value = booleanValueOrNull(context.evaluate(item));
+        if (value === true) return true;
+        if (value === null) sawNull = true;
+      }
+      return sawNull ? null : false;
+    }
+    case "not": {
+      const value = booleanValueOrNull(context.evaluate(expression.expression));
+      return value === null ? null : !value;
+    }
+    default:
+      return assertNever(expression);
+  }
+}

package/src/processing-evaluator-collection.ts

@@ -0,0 +1,50 @@
+import type { QtiProcessingExpression, QtiScalarValue, QtiValue } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import type { EvaluationContext } from "./processing-evaluator.js";
+import { valueContainer } from "./processing-values.js";
+
+type CollectionExpression = Extract<
+  QtiProcessingExpression,
+  { type: "multiple" | "ordered" | "index" | "containerSize" }
+>;
+type RepeatExpression = Extract<QtiProcessingExpression, { type: "repeat" }>;
+
+export function evaluateCollectionExpression(
+  expression: CollectionExpression,
+  context: EvaluationContext,
+): QtiValue {
+  switch (expression.type) {
+    case "multiple":
+    case "ordered": {
+      const values = expression.expressions.flatMap((item) =>
+        valueContainer(context.evaluate(item)),
+      );
+      return values.length > 0 ? values : null;
+    }
+    case "index": {
+      const values = valueContainer(context.evaluate(expression.expression));
+      const n = context.indexValue(expression.n);
+      if (n === undefined || n < 1 || n > values.length) return null;
+      return values[n - 1] ?? null;
+    }
+    case "containerSize":
+      return valueContainer(context.evaluate(expression.expression)).length;
+    default:
+      return assertNever(expression);
+  }
+}
+
+export function evaluateRepeatExpression(
+  expression: RepeatExpression,
+  context: EvaluationContext,
+): QtiValue {
+  const repeats = context.indexValue(expression.numberRepeats);
+  if (repeats === undefined || repeats < 1) 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)));
+    }
+  }
+  return container.length > 0 ? container : null;
+}

package/src/processing-evaluator-comparison.ts

@@ -0,0 +1,106 @@
+import type { QtiProcessingExpression, QtiValue } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import type { EvaluationContext } from "./processing-evaluator.js";
+import {
+  containsValues,
+  durationSeconds,
+  numericValueOrNull,
+  qtiMatchValues,
+  valuesEqual,
+  valueContainer,
+} from "./processing-values.js";
+import { expressionIsOrdered } from "./processing-variables.js";
+import { roundWithMode } from "./processing-operators.js";
+
+type ComparisonExpression = Extract<
+  QtiProcessingExpression,
+  {
+    type:
+      | "match"
+      | "equal"
+      | "equalRounded"
+      | "numericCompare"
+      | "durationCompare"
+      | "member"
+      | "delete"
+      | "contains";
+  }
+>;
+
+export function evaluateComparisonExpression(
+  expression: ComparisonExpression,
+  context: EvaluationContext,
+): QtiValue {
+  switch (expression.type) {
+    case "match": {
+      const left = context.evaluate(expression.left);
+      const right = context.evaluate(expression.right);
+      return qtiMatchValues(
+        left,
+        right,
+        expressionIsOrdered(expression.left, context.document) ||
+          expressionIsOrdered(expression.right, context.document),
+      );
+    }
+    case "equal": {
+      const left = context.evaluate(expression.left);
+      const right = context.evaluate(expression.right);
+      return left === null || right === null ? null : valuesEqual(left, right);
+    }
+    case "equalRounded": {
+      const left = context.evaluate(expression.left);
+      const right = context.evaluate(expression.right);
+      if (left === null || right === null) return null;
+      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;
+    }
+    case "numericCompare": {
+      const leftValue = context.evaluate(expression.left);
+      const rightValue = context.evaluate(expression.right);
+      if (leftValue === null || rightValue === null) return null;
+      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") return left <= right;
+      if (expression.operator === "gt") return left > right;
+      return left >= right;
+    }
+    case "durationCompare": {
+      const left = durationSeconds(context.evaluate(expression.left));
+      const right = durationSeconds(context.evaluate(expression.right));
+      if (left === null || right === null) return null;
+      return expression.operator === "lt" ? left < right : left >= right;
+    }
+    case "member": {
+      const value = context.evaluate(expression.value);
+      const collection = context.evaluate(expression.collection);
+      if (value === null || collection === null) return null;
+      return valueContainer(collection).some((item) => valuesEqual(item, value));
+    }
+    case "delete": {
+      const value = context.evaluate(expression.value);
+      const collectionValue = context.evaluate(expression.collection);
+      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;
+    }
+    case "contains": {
+      const collectionValue = context.evaluate(expression.collection);
+      const valuesValue = context.evaluate(expression.values);
+      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);
+    }
+    default:
+      return assertNever(expression);
+  }
+}

package/src/processing-evaluator-custom.ts

@@ -0,0 +1,20 @@
+import type { QtiProcessingExpression, QtiValue } from "./types.js";
+import type { EvaluationContext } from "./processing-evaluator.js";
+
+type CustomOperatorExpression = Extract<QtiProcessingExpression, { type: "customOperator" }>;
+
+export function evaluateCustomOperatorExpression(
+  expression: CustomOperatorExpression,
+  context: EvaluationContext,
+): QtiValue {
+  const operatorKey = expression.definition ?? expression.className ?? "";
+  const handler = context.customOperators[operatorKey];
+  if (!handler) return null;
+  return handler({
+    definition: expression.definition,
+    className: expression.className,
+    attributes: expression.attributes,
+    values: expression.expressions.map((item) => context.evaluate(item)),
+    expression,
+  });
+}

package/src/processing-evaluator-geometry.ts

@@ -0,0 +1,26 @@
+import type { QtiProcessingExpression, QtiValue } from "./types.js";
+import type { EvaluationContext } from "./processing-evaluator.js";
+import { parsePoint, pointInsideArea } from "./processing-mapping.js";
+import { valueContainer } from "./processing-values.js";
+
+type GeometryExpression = Extract<QtiProcessingExpression, { type: "inside" }>;
+
+export function evaluateGeometryExpression(
+  expression: GeometryExpression,
+  context: EvaluationContext,
+): QtiValue {
+  const value = context.evaluate(expression.expression);
+  if (value === null) return null;
+  if (expression.shape === "default") return true;
+  return valueContainer(value).some((pointValue) => {
+    const point = parsePoint(String(pointValue));
+    return point
+      ? pointInsideArea(point, {
+          shape: expression.shape,
+          coords: expression.coords,
+          mappedValue: 0,
+          attributes: {},
+        })
+      : false;
+  });
+}

package/src/processing-evaluator-numeric.ts

@@ -0,0 +1,155 @@
+import type { QtiProcessingExpression, QtiValue } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import type { EvaluationContext } from "./processing-evaluator.js";
+import {
+  generalizedGcd,
+  generalizedLcm,
+  mathOperatorValue,
+  roundToDecimalPlaces,
+  roundToSignificantFigures,
+  statsOperatorValue,
+} from "./processing-operators.js";
+import {
+  isRecordValue,
+  numericValue,
+  numericValueOrNull,
+  valueContainer,
+} from "./processing-values.js";
+
+type NumericExpression = Extract<
+  QtiProcessingExpression,
+  {
+    type:
+      | "sum"
+      | "product"
+      | "min"
+      | "max"
+      | "subtract"
+      | "divide"
+      | "power"
+      | "integerDivide"
+      | "integerModulus"
+      | "round"
+      | "roundTo"
+      | "truncate"
+      | "integerToFloat"
+      | "gcd"
+      | "lcm"
+      | "mathConstant"
+      | "mathOperator"
+      | "statsOperator";
+  }
+>;
+
+export function evaluateNumericExpression(
+  expression: NumericExpression,
+  context: EvaluationContext,
+): QtiValue {
+  switch (expression.type) {
+    case "sum": {
+      const values = context.numericOperands(expression.expressions);
+      return values ? values.reduce((sum, value) => sum + value, 0) : null;
+    }
+    case "product": {
+      const values = context.numericOperands(expression.expressions);
+      return values ? values.reduce((product, value) => product * value, 1) : null;
+    }
+    case "min":
+    case "max": {
+      const values = context.numericOperands(expression.expressions);
+      if (!values || values.length === 0) return null;
+      return expression.type === "min" ? Math.min(...values) : Math.max(...values);
+    }
+    case "subtract": {
+      const values = context.numericOperands([expression.left, expression.right]);
+      return values && values.length === 2 ? values[0]! - values[1]! : null;
+    }
+    case "divide":
+      return divide(context.evaluate(expression.left), context.evaluate(expression.right));
+    case "power": {
+      const values = context.numericOperands([expression.left, expression.right]);
+      if (!values || values.length !== 2) return null;
+      const value = Math.pow(values[0]!, values[1]!);
+      return Number.isFinite(value) ? value : null;
+    }
+    case "integerDivide": {
+      const values = integerOperands(
+        context.evaluate(expression.left),
+        context.evaluate(expression.right),
+      );
+      return values ? Math.floor(values.dividend / values.divisor) : null;
+    }
+    case "integerModulus": {
+      const values = integerOperands(
+        context.evaluate(expression.left),
+        context.evaluate(expression.right),
+      );
+      return values
+        ? values.dividend - Math.floor(values.dividend / values.divisor) * values.divisor
+        : null;
+    }
+    case "round": {
+      const value = numericValueOrNull(context.evaluate(expression.expression));
+      return value === null ? null : Math.round(value);
+    }
+    case "roundTo": {
+      const value = numericValueOrNull(context.evaluate(expression.expression));
+      if (value === null) return null;
+      return expression.roundingMode === "decimalPlaces"
+        ? roundToDecimalPlaces(value, expression.figures)
+        : roundToSignificantFigures(value, expression.figures);
+    }
+    case "truncate": {
+      const value = numericValueOrNull(context.evaluate(expression.expression));
+      return value === null ? null : Math.trunc(value);
+    }
+    case "integerToFloat":
+      return numericValueOrNull(context.evaluate(expression.expression));
+    case "gcd":
+    case "lcm": {
+      const values = expression.expressions.flatMap((item) => {
+        const value = context.evaluate(item);
+        return value === null ? [null] : valueContainer(value);
+      });
+      if (values.length === 0 || values.some((value) => value === null || isRecordValue(value))) {
+        return null;
+      }
+      const integers = values.map((value) => Math.trunc(numericValue(value)));
+      return expression.type === "gcd" ? generalizedGcd(integers) : generalizedLcm(integers);
+    }
+    case "mathConstant":
+      if (expression.name === "pi") return Math.PI;
+      if (expression.name === "e") return Math.E;
+      return null;
+    case "mathOperator": {
+      const values = expression.expressions.map((item) => context.evaluate(item));
+      if (values.length === 0 || values.some((value) => value === null)) return null;
+      return mathOperatorValue(expression.name, values.map(numericValue));
+    }
+    case "statsOperator": {
+      const value = context.evaluate(expression.expression);
+      if (value === null) return null;
+      return statsOperatorValue(expression.name, valueContainer(value).map(numericValue));
+    }
+    default:
+      return assertNever(expression);
+  }
+}
+
+function divide(dividendValue: QtiValue, divisorValue: QtiValue): QtiValue {
+  const values = integerOperands(dividendValue, divisorValue);
+  if (!values) return null;
+  const quotient = values.dividend / values.divisor;
+  return Number.isFinite(quotient) ? quotient : null;
+}
+
+function integerOperands(
+  dividendValue: QtiValue,
+  divisorValue: QtiValue,
+): { dividend: number; divisor: number } | undefined {
+  if (dividendValue === null || divisorValue === null) return undefined;
+  const dividend = numericValueOrNull(dividendValue);
+  const divisor = numericValueOrNull(divisorValue);
+  if (dividend === null || divisor === null || divisor === 0) return undefined;
+  return { dividend, divisor };
+}