@longsightgroup/qti3-core 0.10.3 → 0.10.5

package/src/processing-evaluator-comparison.ts

@@ -9,7 +9,7 @@ import {
   valuesEqual,
   valueContainer,
 } from "./processing-values.js";
-import { expressionIsOrdered } from "./processing-variables.js";
+import { expressionBaseType, expressionIsOrdered } from "./processing-variables.js";
 import { roundWithMode } from "./processing-operators.js";
 
 type ComparisonExpression = Extract<
@@ -40,12 +40,22 @@ export function evaluateComparisonExpression(
         right,
         expressionIsOrdered(expression.left, context.document) ||
           expressionIsOrdered(expression.right, context.document),
+        expressionBaseType(expression.left, context.document) ??
+          expressionBaseType(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);
+      return left === null || right === null
+        ? null
+        : valuesEqual(
+            left,
+            right,
+            false,
+            expressionBaseType(expression.left, context.document) ??
+              expressionBaseType(expression.right, context.document),
+          );
     }
     case "equalRounded": {
       const validRounding =
@@ -86,7 +96,10 @@ export function evaluateComparisonExpression(
       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));
+      const baseType =
+        expressionBaseType(expression.value, context.document) ??
+        expressionBaseType(expression.collection, context.document);
+      return valueContainer(collection).some((item) => valuesEqual(item, value, false, baseType));
     }
     case "delete": {
       const value = context.evaluate(expression.value);
@@ -94,7 +107,10 @@ export function evaluateComparisonExpression(
       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));
+      const baseType =
+        expressionBaseType(expression.value, context.document) ??
+        expressionBaseType(expression.collection, context.document);
+      const filtered = collection.filter((item) => !valuesEqual(item, value, false, baseType));
       return filtered.length > 0 ? filtered : null;
     }
     case "contains": {
@@ -104,7 +120,10 @@ export function evaluateComparisonExpression(
       const collection = valueContainer(collectionValue);
       const values = valueContainer(valuesValue);
       if (collection.length === 0 || values.length === 0) return null;
-      return containsValues(collection, values);
+      const baseType =
+        expressionBaseType(expression.collection, context.document) ??
+        expressionBaseType(expression.values, context.document);
+      return containsValues(collection, values, baseType);
     }
     default:
       return assertNever(expression);

package/src/processing-evaluator-variable.ts

@@ -37,6 +37,7 @@ export function evaluateVariableExpression(
             context.responses[expression.identifier] ?? null,
             context.correctResponses[expression.correctIdentifier] ?? null,
             declaration.cardinality === "ordered",
+            declaration.baseType,
           )
         : false;
     }

package/src/processing-mapping.ts

@@ -1,4 +1,5 @@
 import type { QtiDocument, QtiResponseDeclaration, QtiValue } from "./types.js";
+import { parseQtiPair } from "./parser-values.js";
 import { qtiScalarToString, qtiValueToStringList } from "./value-format.js";
 import { isRecordValue, numericValue, valuesEqual } from "./processing-values.js";
 
@@ -36,8 +37,15 @@ export function mapOrMatchResponse(
   correctResponse: QtiValue,
 ): number {
   if (declaration.areaMapping) return scoreAreaMapping(response, declaration.areaMapping);
-  if (declaration.mapping) return scoreMapping(response, declaration.mapping);
-  return valuesEqual(response, correctResponse, declaration.cardinality === "ordered") ? 1 : 0;
+  if (declaration.mapping) return scoreMapping(response, declaration.mapping, declaration.baseType);
+  return valuesEqual(
+    response,
+    correctResponse,
+    declaration.cardinality === "ordered",
+    declaration.baseType,
+  )
+    ? 1
+    : 0;
 }
 
 export function scoreAreaMapping(
@@ -125,15 +133,17 @@ function pointInsidePolygon(point: { x: number; y: number }, coords: number[]):
 function scoreMapping(
   response: QtiValue,
   mapping: NonNullable<QtiResponseDeclaration["mapping"]>,
+  baseType: QtiResponseDeclaration["baseType"],
 ): number {
-  const values = Object.fromEntries(
+  const values = new Map(
     mapping.entries
       .filter((entry) => entry.mapKey !== undefined)
-      .map((entry) => [entry.mapKey!, entry.mappedValue]),
+      .map((entry) => [mappingKey(entry.mapKey!, baseType), entry.mappedValue] as const),
   );
   if (Array.isArray(response)) {
     const score = response.reduce<number>(
-      (sum, value) => sum + (values[String(value)] ?? mapping.defaultValue),
+      (sum, value) =>
+        sum + (values.get(mappingKey(String(value), baseType)) ?? mapping.defaultValue),
       0,
     );
     return clampMappedScore(score, mapping.attributes);
@@ -141,10 +151,16 @@ function scoreMapping(
   const score =
     response === null || isRecordValue(response)
       ? 0
-      : (values[String(response)] ?? mapping.defaultValue);
+      : (values.get(mappingKey(String(response), baseType)) ?? mapping.defaultValue);
   return clampMappedScore(score, mapping.attributes);
 }
 
+function mappingKey(value: string, baseType: QtiResponseDeclaration["baseType"]): string {
+  return baseType === "pair" || baseType === "directedPair"
+    ? (parseQtiPair(value, baseType) ?? value)
+    : value;
+}
+
 function clampMappedScore(score: number, attributes: Record<string, string>): number {
   const lower = numericBound(attributes["lower-bound"]);
   const upper = numericBound(attributes["upper-bound"]);

package/src/processing-values.ts

@@ -1,18 +1,32 @@
-import type { QtiRecordValue, QtiResponseDeclaration, QtiScalarValue, QtiValue } from "./types.js";
+import { parseQtiPair } from "./parser-values.js";
+import type {
+  QtiBaseType,
+  QtiRecordValue,
+  QtiResponseDeclaration,
+  QtiScalarValue,
+  QtiValue,
+} from "./types.js";
 import { qtiValueToString } from "./value-format.js";
 
 export function isNullResponse(response: QtiValue): boolean {
   return response === null || response === "" || (Array.isArray(response) && response.length === 0);
 }
 
-export function valuesEqual(actual: QtiValue, expected: QtiValue, ordered = false): boolean {
+export function valuesEqual(
+  actual: QtiValue,
+  expected: QtiValue,
+  ordered = false,
+  baseType?: QtiBaseType,
+): boolean {
   if (isRecordValue(actual) || isRecordValue(expected)) {
     if (!isRecordValue(actual) || !isRecordValue(expected)) return false;
     const actualKeys = Object.keys(actual).toSorted();
     const expectedKeys = Object.keys(expected).toSorted();
     return (
       valuesEqual(actualKeys, expectedKeys, true) &&
-      actualKeys.every((key) => valuesEqual(actual[key] ?? null, expected[key] ?? null, ordered))
+      actualKeys.every((key) =>
+        valuesEqual(actual[key] ?? null, expected[key] ?? null, ordered, baseType),
+      )
     );
   }
   if (Array.isArray(actual) || Array.isArray(expected)) {
@@ -20,25 +34,38 @@ export function valuesEqual(actual: QtiValue, expected: QtiValue, ordered = fals
     const expectedValues = Array.isArray(expected) ? expected : expected === null ? [] : [expected];
     if (actualValues.length !== expectedValues.length) return false;
     if (ordered)
-      return actualValues.every((value, index) => scalarValuesEqual(value, expectedValues[index]!));
-    const sortedExpected = [...expectedValues].toSorted(compareScalarValues);
+      return actualValues.every((value, index) =>
+        scalarValuesEqual(value, expectedValues[index]!, baseType),
+      );
+    const compareValues = (left: QtiScalarValue, right: QtiScalarValue): number =>
+      compareScalarValues(left, right, baseType);
+    const sortedExpected = [...expectedValues].toSorted(compareValues);
     return [...actualValues]
-      .toSorted(compareScalarValues)
-      .every((value, index) => scalarValuesEqual(value, sortedExpected[index]!));
+      .toSorted(compareValues)
+      .every((value, index) => scalarValuesEqual(value, sortedExpected[index]!, baseType));
   }
-  return scalarValuesEqual(actual, expected);
+  return scalarValuesEqual(actual, expected, baseType);
 }
 
 export function qtiMatchValues(
   actual: QtiValue,
   expected: QtiValue,
   ordered = false,
+  baseType?: QtiBaseType,
 ): boolean | null {
   if (actual === null || expected === null) return null;
-  return valuesEqual(actual, expected, ordered);
+  return valuesEqual(actual, expected, ordered, baseType);
 }
 
-function scalarValuesEqual(actual: QtiValue, expected: QtiValue): boolean {
+function scalarValuesEqual(actual: QtiValue, expected: QtiValue, baseType?: QtiBaseType): boolean {
+  if (
+    (baseType === "pair" || baseType === "directedPair") &&
+    typeof actual === "string" &&
+    typeof expected === "string"
+  ) {
+    const normalizedActual = parseQtiPair(actual, baseType);
+    return normalizedActual !== undefined && normalizedActual === parseQtiPair(expected, baseType);
+  }
   if (typeof actual === "boolean" && typeof expected === "string") {
     return String(actual) === expected;
   }
@@ -79,18 +106,36 @@ export function isRecordValue(value: QtiValue): value is QtiRecordValue {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-export function containsValues(collection: QtiScalarValue[], values: QtiScalarValue[]): boolean {
+export function containsValues(
+  collection: QtiScalarValue[],
+  values: QtiScalarValue[],
+  baseType?: QtiBaseType,
+): boolean {
   const remaining = [...collection];
   for (const value of values) {
-    const index = remaining.findIndex((candidate) => valuesEqual(candidate, value));
+    const index = remaining.findIndex((candidate) =>
+      valuesEqual(candidate, value, false, baseType),
+    );
     if (index === -1) return false;
     remaining.splice(index, 1);
   }
   return true;
 }
 
-function compareScalarValues(left: QtiScalarValue, right: QtiScalarValue): number {
-  return String(left).localeCompare(String(right));
+function compareScalarValues(
+  left: QtiScalarValue,
+  right: QtiScalarValue,
+  baseType?: QtiBaseType,
+): number {
+  const leftKey =
+    (baseType === "pair" || baseType === "directedPair") && typeof left === "string"
+      ? (parseQtiPair(left, baseType) ?? left)
+      : String(left);
+  const rightKey =
+    (baseType === "pair" || baseType === "directedPair") && typeof right === "string"
+      ? (parseQtiPair(right, baseType) ?? right)
+      : String(right);
+  return leftKey.localeCompare(rightKey);
 }
 
 export function numericValue(value: QtiValue): number {

package/src/processing-variables.ts

@@ -1,4 +1,5 @@
 import type {
+  QtiBaseType,
   QtiDocument,
   QtiOutcomeDeclaration,
   QtiProcessingExpression,
@@ -6,6 +7,7 @@ import type {
   QtiTemplateDeclaration,
   QtiValue,
 } from "./types.js";
+import { parseBaseType } from "./parser-values.js";
 
 export function getResponseDeclaration(
   document: QtiDocument,
@@ -51,11 +53,11 @@ export function expressionIsOrdered(
   document: QtiDocument,
 ): boolean {
   if (expression.type === "ordered") return true;
+  if (expression.type === "delete") return expressionIsOrdered(expression.collection, document);
   if (
     (expression.type === "variable" ||
       expression.type === "correct" ||
-      expression.type === "default" ||
-      expression.type === "isNull") &&
+      expression.type === "default") &&
     variableCardinality(document, expression.identifier) === "ordered"
   ) {
     return true;
@@ -63,6 +65,49 @@ export function expressionIsOrdered(
   return false;
 }
 
+/** Resolve the declared atomic base type for an expression when it is statically knowable. */
+export function expressionBaseType(
+  expression: QtiProcessingExpression,
+  document: QtiDocument,
+): QtiBaseType | undefined {
+  if (expression.type === "baseValue") return parseBaseType(expression.baseType);
+  if (expression.type === "isNull") return "boolean";
+  if (
+    expression.type === "variable" ||
+    expression.type === "correct" ||
+    expression.type === "default"
+  ) {
+    return resolveVariableDeclaration(document, expression.identifier)?.baseType;
+  }
+  if (expression.type === "index") return expressionBaseType(expression.expression, document);
+  if (expression.type === "delete") return expressionBaseType(expression.collection, document);
+  if (
+    expression.type === "random" ||
+    expression.type === "multiple" ||
+    expression.type === "ordered" ||
+    expression.type === "repeat"
+  ) {
+    return commonExpressionBaseType(
+      expression.type === "random" ? expression.values : expression.expressions,
+      document,
+    );
+  }
+  return undefined;
+}
+
+function commonExpressionBaseType(
+  expressions: QtiProcessingExpression[],
+  document: QtiDocument,
+): QtiBaseType | undefined {
+  const [first, ...rest] = expressions;
+  if (!first) return undefined;
+  const baseType = expressionBaseType(first, document);
+  if (!baseType) return undefined;
+  return rest.every((expression) => expressionBaseType(expression, document) === baseType)
+    ? baseType
+    : undefined;
+}
+
 function variableCardinality(document: QtiDocument, identifier: string): string | undefined {
   return resolveVariableDeclaration(document, identifier)?.cardinality;
 }

package/src/qti-namespaces.ts

@@ -0,0 +1,8 @@
+/** Namespace for QTI 3 assessment, section, and item documents. */
+export const QTI_ASI_NAMESPACE = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0";
+
+/** Namespace for MathML embedded in QTI content. */
+export const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+
+/** Namespace for QTI 3 content-package manifests. */
+export const QTI_PACKAGE_MANIFEST_NAMESPACE = "http://www.imsglobal.org/xsd/qti/qtiv3p0/imscp_v1p1";

package/src/qti-package-assets.ts

@@ -14,7 +14,6 @@ import {
   resolvePackageHref,
   type PackageXmlFile,
 } from "./qti-package-xml.js";
-import type { QtiPackageEntry } from "./qti-package-zip.js";
 import type { QtiDiagnostic } from "./types.js";
 
 interface PendingAssetReference {
@@ -87,8 +86,8 @@ export function discoverContentAssetHrefs(
 export function collectPackageAssets(
   resourcesByIdentifier: ReadonlyMap<string, QtiManifestResource>,
   assessmentTest: QtiAssessmentTestPackageModel | undefined,
-  items: readonly QtiPackageItem[],
-  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  items: readonly Pick<QtiPackageItem, "href" | "manifestResourceIdentifier" | "assetHrefs">[],
+  entriesByPath: { has(path: string): boolean },
   diagnostics: QtiDiagnostic[],
 ): QtiPackageAsset[] {
   const pending: PendingAssetReference[] = [];
@@ -220,7 +219,7 @@ function collectPackageRelativeTextRefs(
 
 function materializeAssets(
   pending: readonly PendingAssetReference[],
-  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  entriesByPath: { has(path: string): boolean },
 ): QtiPackageAsset[] {
   const assetsByHref = new Map<string, PendingAssetReference[]>();
   for (const reference of pending) {

package/src/qti-package-items.ts

@@ -34,6 +34,7 @@ import {
 } from "./qti-package-xml.js";
 import type { QtiPackageEntry } from "./qti-package-zip.js";
 import type { QtiDiagnostic } from "./types.js";
+import { QTI_ASI_NAMESPACE } from "./qti-namespaces.js";
 
 export interface PackageItemReference {
   readonly href: string;
@@ -83,13 +84,18 @@ export function parseAssessmentTestPackageModel(
   const xmlFile = xmlFilesByPath.get(href) ?? parsePackageXml(entry);
   const testDiagnostics: QtiDiagnostic[] = [];
   pushXmlDiagnostics(xmlFile, testDiagnostics);
-  const root = xmlFile.root?.localName === "qti-assessment-test" ? xmlFile.root : undefined;
+  const root =
+    xmlFile.root?.localName === "qti-assessment-test" && xmlFile.root.uri === QTI_ASI_NAMESPACE
+      ? xmlFile.root
+      : undefined;
   if (xmlFile.root && !root) {
     pushPackageDiagnostic(
       testDiagnostics,
       "package.assessmentTest.root",
       "error",
-      `Expected qti-assessment-test root, found ${xmlFile.root.localName}.`,
+      xmlFile.root.localName === "qti-assessment-test"
+        ? `Expected qti-assessment-test in namespace ${QTI_ASI_NAMESPACE}, found ${xmlFile.root.uri ?? "(none)"}.`
+        : `Expected qti-assessment-test root, found ${xmlFile.root.localName}.`,
       href,
     );
   }
@@ -98,7 +104,7 @@ export function parseAssessmentTestPackageModel(
   const itemRefs = testParts.flatMap(flattenTestPartItemRefs);
   const assetHrefs = root ? discoverContentAssetHrefs(xmlFile, testDiagnostics) : [];
   const timeLimits = root
-    ? parseTimeLimits(childPackageElements(root, "qti-time-limits")[0], href, testDiagnostics)
+    ? parseTimeLimits(qtiChildElements(root, "qti-time-limits")[0], href, testDiagnostics)
     : undefined;
   const timing = root ? parseTimingMetadata(root, href, testDiagnostics, timeLimits) : undefined;
   const scopedDiagnostics = testDiagnostics.map((diagnostic) =>
@@ -128,18 +134,18 @@ function parseAssessmentTestParts(
   sourcePath: string,
   diagnostics: QtiDiagnostic[],
 ): QtiTestPartPackageModel[] {
-  return childPackageElements(root, "qti-test-part").map((partNode) => {
+  return qtiChildElements(root, "qti-test-part").map((partNode) => {
     const identifier = partNode.attributes.identifier ?? "";
     return {
       identifier,
       navigationMode: parseNavigationMode(partNode, sourcePath, diagnostics),
       submissionMode: parseSubmissionMode(partNode, sourcePath, diagnostics),
       timeLimits: parseTimeLimits(
-        childPackageElements(partNode, "qti-time-limits")[0],
+        qtiChildElements(partNode, "qti-time-limits")[0],
         sourcePath,
         diagnostics,
       ),
-      sections: childPackageElements(partNode, "qti-assessment-section").map((sectionNode) =>
+      sections: qtiChildElements(partNode, "qti-assessment-section").map((sectionNode) =>
         parseAssessmentSection(sectionNode, identifier, undefined, sourcePath, diagnostics),
       ),
       attributes: { ...partNode.attributes },
@@ -156,43 +162,41 @@ function parseAssessmentSection(
 ): QtiAssessmentSectionPackageModel {
   const identifier = sectionNode.attributes.identifier ?? "";
   const visible = parseOptionalXmlBoolean(sectionNode, "visible", sourcePath, diagnostics);
-  const itemRefs = childPackageElements(sectionNode, "qti-assessment-item-ref").flatMap(
-    (refNode) => {
-      const rawHref = refNode.attributes.href;
-      if (!rawHref) {
-        pushPackageDiagnostic(
+  const itemRefs = qtiChildElements(sectionNode, "qti-assessment-item-ref").flatMap((refNode) => {
+    const rawHref = refNode.attributes.href;
+    if (!rawHref) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.assessmentTest.itemRef.href.missing",
+        "error",
+        "qti-assessment-item-ref is missing href.",
+        sourcePath,
+      );
+      return [];
+    }
+
+    const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
+    if (!href) return [];
+    return [
+      {
+        identifier: refNode.attributes.identifier,
+        href,
+        testPartIdentifier,
+        sectionIdentifier: identifier,
+        timeLimits: parseTimeLimits(
+          qtiChildElements(refNode, "qti-time-limits")[0],
+          sourcePath,
           diagnostics,
-          "package.assessmentTest.itemRef.href.missing",
-          "error",
-          "qti-assessment-item-ref is missing href.",
+        ),
+        itemSessionControl: parseItemSessionControl(
+          qtiChildElements(refNode, "qti-item-session-control")[0],
           sourcePath,
-        );
-        return [];
-      }
-
-      const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
-      if (!href) return [];
-      return [
-        {
-          identifier: refNode.attributes.identifier,
-          href,
-          testPartIdentifier,
-          sectionIdentifier: identifier,
-          timeLimits: parseTimeLimits(
-            childPackageElements(refNode, "qti-time-limits")[0],
-            sourcePath,
-            diagnostics,
-          ),
-          itemSessionControl: parseItemSessionControl(
-            childPackageElements(refNode, "qti-item-session-control")[0],
-            sourcePath,
-            diagnostics,
-          ),
-          attributes: { ...refNode.attributes },
-        },
-      ];
-    },
-  );
+          diagnostics,
+        ),
+        attributes: { ...refNode.attributes },
+      },
+    ];
+  });
 
   return {
     identifier,
@@ -201,12 +205,12 @@ function parseAssessmentSection(
     testPartIdentifier,
     parentSectionIdentifier,
     timeLimits: parseTimeLimits(
-      childPackageElements(sectionNode, "qti-time-limits")[0],
+      qtiChildElements(sectionNode, "qti-time-limits")[0],
       sourcePath,
       diagnostics,
     ),
     itemRefs,
-    sections: childPackageElements(sectionNode, "qti-assessment-section").map((child) =>
+    sections: qtiChildElements(sectionNode, "qti-assessment-section").map((child) =>
       parseAssessmentSection(child, testPartIdentifier, identifier, sourcePath, diagnostics),
     ),
     attributes: { ...sectionNode.attributes },
@@ -342,6 +346,55 @@ export function itemReferencesForPackageShape(
   return references;
 }
 
+export function parsePackageItem(
+  reference: PackageItemReference,
+  entry: QtiPackageEntry,
+  xmlFile: PackageXmlFile | undefined,
+  diagnostics: QtiDiagnostic[],
+): QtiPackageItem {
+  const resolvedXml = xmlFile ?? parsePackageXml(entry);
+  // Full QTI parse for document model; lightweight tree above supplies metadata and asset refs.
+  const parsed = parseQtiXml(resolvedXml.xml);
+  const itemDiagnostics = parsed.diagnostics.map((diagnostic) =>
+    scopeDiagnosticToPackagePath(reference.href, diagnostic),
+  );
+  diagnostics.push(...itemDiagnostics);
+
+  const assetHrefs = resolvedXml.root ? discoverContentAssetHrefs(resolvedXml, diagnostics) : [];
+  const root =
+    resolvedXml.root?.localName === "qti-assessment-item" &&
+    resolvedXml.root.uri === QTI_ASI_NAMESPACE
+      ? resolvedXml.root
+      : undefined;
+  const item = parsed.document?.item;
+  const timeLimits = root
+    ? parseTimeLimits(qtiChildElements(root, "qti-time-limits")[0], reference.href, diagnostics)
+    : undefined;
+
+  return {
+    href: reference.href,
+    source: reference.source,
+    manifestResourceIdentifier: reference.manifestResourceIdentifier,
+    assessmentItemRefIdentifier: reference.assessmentItemRefIdentifier,
+    identifier: item?.identifier,
+    title: item?.title,
+    document: parsed.document,
+    timing: root ? parseTimingMetadata(root, reference.href, diagnostics, timeLimits) : undefined,
+    timeLimits,
+    standards: uniqueStandards([
+      ...reference.standards.filter(
+        (standard) =>
+          standard.resourcePartIdentifier === undefined ||
+          standard.resourcePartIdentifier === item?.identifier,
+      ),
+      ...(root ? parseStandardAlignments(root, reference.href) : []),
+    ]),
+    assetHrefs,
+    diagnostics: itemDiagnostics,
+    xml: resolvedXml.xml,
+  };
+}
+
 export function parsePackageItems(
   references: readonly PackageItemReference[],
   entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
@@ -376,48 +429,12 @@ export function parsePackageItems(
       continue;
     }
 
-    const xmlFile = xmlFilesByPath.get(reference.href) ?? parsePackageXml(entry);
-    // Full QTI parse for document model; lightweight tree above supplies metadata and asset refs.
-    const parsed = parseQtiXml(xmlFile.xml);
-    const itemDiagnostics = parsed.diagnostics.map((diagnostic) =>
-      scopeDiagnosticToPackagePath(reference.href, diagnostic),
-    );
-    diagnostics.push(...itemDiagnostics);
-
-    const assetHrefs = xmlFile.root ? discoverContentAssetHrefs(xmlFile, diagnostics) : [];
-    const root = xmlFile.root?.localName === "qti-assessment-item" ? xmlFile.root : undefined;
-    const item = parsed.document?.item;
-    const timeLimits = root
-      ? parseTimeLimits(
-          childPackageElements(root, "qti-time-limits")[0],
-          reference.href,
-          diagnostics,
-        )
-      : undefined;
-
-    items.push({
-      href: reference.href,
-      source: reference.source,
-      manifestResourceIdentifier: reference.manifestResourceIdentifier,
-      assessmentItemRefIdentifier: reference.assessmentItemRefIdentifier,
-      identifier: item?.identifier,
-      title: item?.title,
-      document: parsed.document,
-      timing: root ? parseTimingMetadata(root, reference.href, diagnostics, timeLimits) : undefined,
-      timeLimits,
-      standards: uniqueStandards([
-        ...reference.standards.filter(
-          (standard) =>
-            standard.resourcePartIdentifier === undefined ||
-            standard.resourcePartIdentifier === item?.identifier,
-        ),
-        ...(root ? parseStandardAlignments(root, reference.href) : []),
-      ]),
-      assetHrefs,
-      diagnostics: itemDiagnostics,
-      xml: xmlFile.xml,
-    });
+    items.push(parsePackageItem(reference, entry, xmlFilesByPath.get(reference.href), diagnostics));
   }
 
   return items;
 }
+
+function qtiChildElements(node: QtiPackageXmlNode, localName: string): QtiPackageXmlNode[] {
+  return childPackageElements(node, localName, QTI_ASI_NAMESPACE);
+}