@longsightgroup/qti3-core 0.10.2 → 0.10.3

package/src/content-text.ts

@@ -1,8 +1,10 @@
 import type { QtiChoice, QtiContentNode, QtiSourceLocation } from "./types.js";
 import { assertNever } from "./assert-never.js";
+import type { XmlNode } from "./xml.js";
 
 export interface FlatTextFromContentOptions {
   excludeAnnotations?: boolean;
+  interactionText?: ((interactionIndex: number) => string) | undefined;
 }
 
 export function normalizeFlatText(text: string): string {
@@ -32,13 +34,14 @@ export function flatTextFromContent(
   nodes: QtiContentNode[],
   options: FlatTextFromContentOptions = {},
 ): string {
-  const excludeAnnotations = options.excludeAnnotations ?? false;
-  return normalizeFlatText(
-    nodes.map((node) => flatTextFromContentNode(node, excludeAnnotations)).join(" "),
-  );
+  return normalizeFlatText(nodes.map((node) => flatTextFromContentNode(node, options)).join(""));
 }
 
-function flatTextFromContentNode(node: QtiContentNode, excludeAnnotations: boolean): string {
+function flatTextFromContentNode(
+  node: QtiContentNode,
+  options: FlatTextFromContentOptions,
+): string {
+  const excludeAnnotations = options.excludeAnnotations ?? false;
   switch (node.kind) {
     case "text":
       return node.text;
@@ -54,14 +57,26 @@ function flatTextFromContentNode(node: QtiContentNode, excludeAnnotations: boole
       if (node.qtiName === "object" && node.attributes["object-label"]) {
         return node.attributes["object-label"];
       }
-      return node.children
-        .map((child) => flatTextFromContentNode(child, excludeAnnotations))
-        .join(" ");
+      if (node.qtiName === "math") {
+        return withVisibleBoundary(
+          node.qtiName,
+          node.children
+            .map((child) => flatMathText(child, excludeAnnotations))
+            .filter(Boolean)
+            .join(" "),
+        );
+      }
+      return withVisibleBoundary(
+        node.qtiName,
+        node.children.map((child) => flatTextFromContentNode(child, options)).join(""),
+      );
     case "feedback":
-      return node.children
-        .map((child) => flatTextFromContentNode(child, excludeAnnotations))
-        .join(" ");
+      return withVisibleBoundary(
+        node.feedbackType === "block" ? "qti-feedback-block" : "qti-feedback-inline",
+        node.children.map((child) => flatTextFromContentNode(child, options)).join(""),
+      );
     case "interaction":
+      return options.interactionText?.(node.interactionIndex) ?? "";
     case "printedVariable":
       return "";
     default:
@@ -69,6 +84,115 @@ function flatTextFromContentNode(node: QtiContentNode, excludeAnnotations: boole
   }
 }
 
+function flatMathText(node: QtiContentNode, excludeAnnotations: boolean): string {
+  if (
+    node.kind === "element" &&
+    excludeAnnotations &&
+    (node.qtiName === "annotation" || node.qtiName === "annotation-xml")
+  ) {
+    return "";
+  }
+  if (node.kind === "text") return node.text;
+  if (node.kind === "element" || node.kind === "feedback") {
+    return node.children
+      .map((child) => flatMathText(child, excludeAnnotations))
+      .filter(Boolean)
+      .join(" ");
+  }
+  return "";
+}
+
+/** Flatten rendered XML text without inventing separators at inline element boundaries. */
+export function visibleTextContent(node: XmlNode): string {
+  return normalizeFlatText(visibleTextFromXmlNode(node));
+}
+
+function visibleTextFromXmlNode(node: XmlNode): string {
+  const accessibleLabel = accessibleXmlLabel(node);
+  const text =
+    accessibleLabel ??
+    (node.localName === "math"
+      ? flatMathXmlText(node)
+      : node.content
+          .map((entry) => (typeof entry === "string" ? entry : visibleTextFromXmlNode(entry)))
+          .join(""));
+  return withVisibleBoundary(node.localName, text);
+}
+
+function flatMathXmlText(node: XmlNode): string {
+  return node.content
+    .map((entry) =>
+      typeof entry === "string"
+        ? entry
+        : entry.localName === "annotation" || entry.localName === "annotation-xml"
+          ? ""
+          : flatMathXmlText(entry),
+    )
+    .filter(Boolean)
+    .join(" ");
+}
+
+function accessibleXmlLabel(node: XmlNode): string | undefined {
+  if (node.localName === "math" && node.attributes.alttext) return node.attributes.alttext;
+  if (node.localName === "img" && node.attributes.alt) return node.attributes.alt;
+  if (node.localName === "object" && node.attributes["object-label"]) {
+    return node.attributes["object-label"];
+  }
+  return undefined;
+}
+
+function withVisibleBoundary(qtiName: string, text: string): string {
+  return visibleBoundaryNames.has(qtiName) ? ` ${text} ` : text;
+}
+
+const visibleBoundaryNames = new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "br",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "li",
+  "main",
+  "math",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "qti-feedback-block",
+  "qti-gap-img",
+  "qti-gap-text",
+  "qti-inline-choice",
+  "qti-simple-associable-choice",
+  "qti-simple-choice",
+  "section",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul",
+]);
+
 export function choiceAccessibleLabel(
   choice: QtiChoice | undefined,
   fallbackIdentifier?: string,

package/src/index.ts

@@ -85,7 +85,32 @@ export {
 export { detectPackageMediaType } from "./qti-package-assets.js";
 export { parseQtiXml } from "./parser.js";
 export { numericTuple3, numericTuple4, parseXmlBoolean } from "./parser-values.js";
+export { escapeXmlAttribute, escapeXmlText } from "./xml.js";
+export {
+  applyQtiMediaPlaybackEvent,
+  parseQtiMediaDefinition,
+  QTI_MEDIA_RESTART_THRESHOLD_SECONDS,
+  type QtiMediaDefinition,
+  type QtiMediaDefinitionResult,
+  type QtiMediaPlaybackEvent,
+  type QtiMediaPlaybackResult,
+  type QtiMediaPlaySession,
+} from "./media-definition.js";
+export {
+  parseQtiSliderDefinition,
+  parseQtiSliderValue,
+  qtiSliderDiscreteValue,
+  qtiSliderRatio,
+  snapQtiSliderValue,
+  type QtiSliderDefinition,
+  type QtiSliderDefinitionResult,
+  type QtiSliderOrientation,
+  type QtiSliderStep,
+  type QtiSliderValueFailureReason,
+  type QtiSliderValueResult,
+} from "./slider-definition.js";
 export { collectQtiResponseProcessingExpressions } from "./processing-expression-collection.js";
+export { MAX_QTI_REPEAT_RESULT_ELEMENTS } from "./processing-limits.js";
 export { isConformanceParseDiagnostic } from "./parse-diagnostics.js";
 export {
   scoreQtiItemServerSide,

package/src/media-definition.ts

@@ -0,0 +1,174 @@
+import { assertNever } from "./assert-never.js";
+import { parseXmlBoolean } from "./parser-values.js";
+import type { QtiDiagnostic, QtiInteraction } from "./types.js";
+import { isNonNegativeInteger } from "./validation-primitives.js";
+
+/** A validated media play-count domain and native playback policy. */
+export interface QtiMediaDefinition {
+  readonly minPlays: number;
+  readonly maxPlays: number | undefined;
+  readonly autostart: boolean;
+  readonly nativeLoop: boolean;
+}
+
+/** The typed result of refining raw media interaction attributes. */
+export type QtiMediaDefinitionResult =
+  | { readonly ok: true; readonly value: QtiMediaDefinition }
+  | { readonly ok: false; readonly diagnostics: readonly QtiDiagnostic[] };
+
+/** Seconds from the start within which a play event counts as a new play experience. */
+export const QTI_MEDIA_RESTART_THRESHOLD_SECONDS = 0.25;
+
+/** The play-experience session used to decide whether a native media event counts. */
+export type QtiMediaPlaySession =
+  | { readonly status: "idle"; readonly playCount: number }
+  | { readonly status: "playing"; readonly playCount: number }
+  | { readonly status: "ended"; readonly playCount: number };
+
+/** A native media event projected into the QTI play-count machine. */
+export type QtiMediaPlaybackEvent =
+  | { readonly kind: "play"; readonly currentTime: number }
+  | { readonly kind: "ended" }
+  | { readonly kind: "seeked"; readonly currentTime: number; readonly paused: boolean };
+
+/** The session update and any player-side block from one playback event. */
+export type QtiMediaPlaybackResult =
+  | { readonly kind: "applied"; readonly session: QtiMediaPlaySession }
+  | { readonly kind: "blocked"; readonly session: QtiMediaPlaySession };
+
+function diagnostic(interaction: QtiInteraction, code: string, message: string): QtiDiagnostic {
+  return {
+    code,
+    severity: "error",
+    message,
+    path: interaction.source?.path,
+    source: interaction.source,
+  };
+}
+
+function optionalBoolean(
+  interaction: QtiInteraction,
+  attribute: "autostart" | "loop",
+  diagnostics: QtiDiagnostic[],
+): boolean {
+  const raw = interaction.attributes[attribute];
+  if (raw === undefined) return false;
+  const value = parseXmlBoolean(raw);
+  if (value !== undefined) return value;
+  diagnostics.push(
+    diagnostic(
+      interaction,
+      "interaction.booleanAttribute",
+      `${interaction.qtiName} requires boolean ${attribute}, got ${raw}.`,
+    ),
+  );
+  return false;
+}
+
+function optionalNonNegativeInteger(
+  interaction: QtiInteraction,
+  attribute: "min-plays" | "max-plays",
+  diagnostics: QtiDiagnostic[],
+): number | undefined {
+  const raw = interaction.attributes[attribute];
+  if (raw === undefined) return undefined;
+  if (!isNonNegativeInteger(raw)) {
+    diagnostics.push(
+      diagnostic(
+        interaction,
+        "interaction.integerAttribute",
+        `${interaction.qtiName} requires non-negative integer ${attribute}, got ${raw}.`,
+      ),
+    );
+    return undefined;
+  }
+  return Number(raw);
+}
+
+function atMaximumPlays(session: QtiMediaPlaySession, maxPlays: number | undefined): boolean {
+  return maxPlays !== undefined && session.playCount >= maxPlays;
+}
+
+/**
+ * Refines raw QTI media attributes into the play-count domain shared by validation and players.
+ */
+export function parseQtiMediaDefinition(interaction: QtiInteraction): QtiMediaDefinitionResult {
+  const diagnostics: QtiDiagnostic[] = [];
+  const minPlaysAttribute = optionalNonNegativeInteger(interaction, "min-plays", diagnostics);
+  const maxPlaysAttribute = optionalNonNegativeInteger(interaction, "max-plays", diagnostics);
+  const autostart = optionalBoolean(interaction, "autostart", diagnostics);
+  const loop = optionalBoolean(interaction, "loop", diagnostics);
+  const required = parseXmlBoolean(interaction.attributes.required) === true;
+  const maxPlays =
+    maxPlaysAttribute === undefined || maxPlaysAttribute <= 0 ? undefined : maxPlaysAttribute;
+
+  if (minPlaysAttribute !== undefined && maxPlays !== undefined && minPlaysAttribute > maxPlays) {
+    diagnostics.push(
+      diagnostic(
+        interaction,
+        "interaction.minMax",
+        `${interaction.qtiName} requires min-plays to be less than or equal to max-plays, unless max-plays is 0 for unlimited.`,
+      ),
+    );
+  }
+
+  if (diagnostics.length > 0) return { ok: false, diagnostics };
+
+  return {
+    ok: true,
+    value: {
+      minPlays: minPlaysAttribute ?? (required ? 1 : 0),
+      maxPlays,
+      autostart,
+      nativeLoop: loop && maxPlays === undefined,
+    },
+  };
+}
+
+function applyPlayEvent(
+  session: QtiMediaPlaySession,
+  event: Extract<QtiMediaPlaybackEvent, { kind: "play" }>,
+  maxPlays: number | undefined,
+): QtiMediaPlaybackResult {
+  if (session.status !== "playing" && atMaximumPlays(session, maxPlays)) {
+    return { kind: "blocked", session };
+  }
+  const counts =
+    session.status === "ended" ||
+    (session.status === "idle" && event.currentTime <= QTI_MEDIA_RESTART_THRESHOLD_SECONDS);
+  return {
+    kind: "applied",
+    session: {
+      status: "playing",
+      playCount: session.playCount + (counts ? 1 : 0),
+    },
+  };
+}
+
+function applySeekedEvent(
+  session: QtiMediaPlaySession,
+  event: Extract<QtiMediaPlaybackEvent, { kind: "seeked" }>,
+): QtiMediaPlaybackResult {
+  if (!event.paused || event.currentTime > QTI_MEDIA_RESTART_THRESHOLD_SECONDS) {
+    return { kind: "applied", session };
+  }
+  return { kind: "applied", session: { status: "idle", playCount: session.playCount } };
+}
+
+/** Applies one native media event to the QTI play-experience session. */
+export function applyQtiMediaPlaybackEvent(
+  session: QtiMediaPlaySession,
+  event: QtiMediaPlaybackEvent,
+  maxPlays: number | undefined,
+): QtiMediaPlaybackResult {
+  switch (event.kind) {
+    case "play":
+      return applyPlayEvent(session, event, maxPlays);
+    case "ended":
+      return { kind: "applied", session: { status: "ended", playCount: session.playCount } };
+    case "seeked":
+      return applySeekedEvent(session, event);
+    default:
+      return assertNever(event);
+  }
+}

package/src/parser-declarations.ts

@@ -4,11 +4,13 @@ import {
   parseBaseType,
   parseCardinality,
   parseCoords,
+  parseFiniteNumber,
   parseShape,
   parseXmlBoolean,
 } from "./parser-values.js";
 import type {
   QtiBaseType,
+  QtiDiagnostic,
   QtiLookupTable,
   QtiOutcomeDeclaration,
   QtiResponseDeclaration,
@@ -16,9 +18,17 @@ import type {
   QtiTemplateDeclaration,
   QtiValue,
 } from "./types.js";
+import {
+  validateAreaMapEntryAttributes,
+  validateLookupTableEntryAttributes,
+  validateMapEntryAttributes,
+} from "./validation-declaration-entries.js";
 import { childElements, textContent, type XmlNode } from "./xml.js";
 
-export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration {
+export function parseResponseDeclaration(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiResponseDeclaration {
   const cardinality = parseCardinality(node.attributes.cardinality);
   const baseType = parseBaseType(node.attributes["base-type"]);
   return {
@@ -26,40 +36,66 @@ export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration
     identifier: node.attributes.identifier ?? "",
     cardinality,
     baseType,
-    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    defaultValue: parseVariableValue(
+      childElements(node, "qti-default-value")[0],
+      baseType,
+      diagnostics,
+    ),
     correctResponse: normalizeValueForCardinality(
-      parseVariableValue(childElements(node, "qti-correct-response")[0], baseType),
+      parseVariableValue(childElements(node, "qti-correct-response")[0], baseType, diagnostics),
       cardinality,
     ),
-    mapping: parseMapping(childElements(node, "qti-mapping")[0]),
-    areaMapping: parseAreaMapping(childElements(node, "qti-area-mapping")[0]),
+    mapping: parseMapping(
+      childElements(node, "qti-mapping")[0],
+      node.attributes.identifier ?? "",
+      diagnostics,
+    ),
+    areaMapping: parseAreaMapping(
+      childElements(node, "qti-area-mapping")[0],
+      node.attributes.identifier ?? "",
+      diagnostics,
+    ),
     attributes: node.attributes,
     source: node.source,
   };
 }
 
-export function parseOutcomeDeclaration(node: XmlNode): QtiOutcomeDeclaration {
+export function parseOutcomeDeclaration(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiOutcomeDeclaration {
   const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "outcome",
     identifier: node.attributes.identifier ?? "",
     cardinality: parseCardinality(node.attributes.cardinality),
     baseType,
-    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
-    lookupTable: parseLookupTable(node, baseType),
+    defaultValue: parseVariableValue(
+      childElements(node, "qti-default-value")[0],
+      baseType,
+      diagnostics,
+    ),
+    lookupTable: parseLookupTable(node, baseType, diagnostics),
     attributes: node.attributes,
     source: node.source,
   };
 }
 
-export function parseTemplateDeclaration(node: XmlNode): QtiTemplateDeclaration {
+export function parseTemplateDeclaration(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiTemplateDeclaration {
   const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "template",
     identifier: node.attributes.identifier ?? "",
     cardinality: parseCardinality(node.attributes.cardinality),
     baseType,
-    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    defaultValue: parseVariableValue(
+      childElements(node, "qti-default-value")[0],
+      baseType,
+      diagnostics,
+    ),
     attributes: node.attributes,
     source: node.source,
   };
@@ -68,6 +104,7 @@ export function parseTemplateDeclaration(node: XmlNode): QtiTemplateDeclaration
 function parseVariableValue(
   node: XmlNode | undefined,
   baseType: QtiBaseType | undefined,
+  diagnostics: QtiDiagnostic[],
 ): QtiValue {
   if (!node) return null;
   const valueNodes = childElements(node, "qti-value");
@@ -79,6 +116,16 @@ function parseVariableValue(
     (entry): entry is { fieldIdentifier: string; value: QtiScalarValue } =>
       Boolean(entry.fieldIdentifier),
   );
+  const fieldedEntryCount = entries.filter((entry) => entry.fieldIdentifier !== undefined).length;
+  if (fieldedEntryCount > 0 && fieldedEntryCount < entries.length) {
+    diagnostics.push({
+      code: "declaration.value.fieldIdentifier.mixed",
+      severity: "error",
+      message: `${node.localName} must not mix qti-value children with and without field-identifier.`,
+      path: node.source.path,
+      source: node.source,
+    });
+  }
   if (recordEntries.length > 0) {
     return Object.fromEntries(recordEntries.map((entry) => [entry.fieldIdentifier, entry.value]));
   }
@@ -90,87 +137,134 @@ function parseVariableValue(
   return entries.map((entry) => entry.value);
 }
 
-function parseMapping(node: XmlNode | undefined): QtiResponseDeclaration["mapping"] | undefined {
+function parseMapping(
+  node: XmlNode | undefined,
+  declarationIdentifier: string,
+  diagnostics: QtiDiagnostic[],
+): QtiResponseDeclaration["mapping"] | undefined {
   if (!node) return undefined;
-  return {
-    defaultValue: Number(node.attributes["default-value"] ?? 0),
-    attributes: node.attributes,
-    source: node.source,
-    entries: childElements(node, "qti-map-entry").map((entry) => ({
+  const defaultValue = parseFiniteNumber(node.attributes["default-value"]);
+  const entries: NonNullable<QtiResponseDeclaration["mapping"]>["entries"] = [];
+  for (const entry of childElements(node, "qti-map-entry")) {
+    const mappedValue = parseFiniteNumber(entry.attributes["mapped-value"]);
+    if (mappedValue === undefined) {
+      validateMapEntryAttributes(declarationIdentifier, entry, diagnostics);
+      continue;
+    }
+    entries.push({
       mapKey: entry.attributes["map-key"],
-      mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+      mappedValue,
       attributes: entry.attributes,
       source: entry.source,
-    })),
+    });
+  }
+  return {
+    defaultValue: defaultValue ?? 0,
+    attributes: node.attributes,
+    source: node.source,
+    entries,
   };
 }
 
 function parseAreaMapping(
   node: XmlNode | undefined,
+  declarationIdentifier: string,
+  diagnostics: QtiDiagnostic[],
 ): QtiResponseDeclaration["areaMapping"] | undefined {
   if (!node) return undefined;
-  return {
-    defaultValue: Number(node.attributes["default-value"] ?? 0),
-    attributes: node.attributes,
-    source: node.source,
-    entries: childElements(node, "qti-area-map-entry").map((entry) => ({
+  const defaultValue = parseFiniteNumber(node.attributes["default-value"]);
+  const entries: NonNullable<QtiResponseDeclaration["areaMapping"]>["entries"] = [];
+  for (const entry of childElements(node, "qti-area-map-entry")) {
+    const mappedValue = parseFiniteNumber(entry.attributes["mapped-value"]);
+    if (mappedValue === undefined) {
+      validateAreaMapEntryAttributes(declarationIdentifier, entry, diagnostics);
+      continue;
+    }
+    entries.push({
       shape: parseShape(entry.attributes.shape),
       coords: parseCoords(entry.attributes.coords),
-      mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+      mappedValue,
       attributes: entry.attributes,
       source: entry.source,
-    })),
+    });
+  }
+  return {
+    defaultValue: defaultValue ?? 0,
+    attributes: node.attributes,
+    source: node.source,
+    entries,
   };
 }
 
 function parseLookupTable(
   node: XmlNode,
   baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
 ): QtiLookupTable | undefined {
   const matchTable = childElements(node, "qti-match-table")[0];
-  if (matchTable) return parseMatchTable(matchTable, baseType);
+  if (matchTable) return parseMatchTable(matchTable, baseType, diagnostics);
   const interpolationTable = childElements(node, "qti-interpolation-table")[0];
-  if (interpolationTable) return parseInterpolationTable(interpolationTable, baseType);
+  if (interpolationTable) return parseInterpolationTable(interpolationTable, baseType, diagnostics);
   return undefined;
 }
 
 function parseMatchTable(
   node: XmlNode,
   baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
 ): QtiLookupTable {
   return {
     type: "match",
     defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
     attributes: node.attributes,
     source: node.source,
-    entries: childElements(node, "qti-match-table-entry").map((entry) => ({
-      sourceValue: Number(entry.attributes["source-value"]),
-      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
-      attributes: entry.attributes,
-      source: entry.source,
-    })),
+    entries: parseLookupEntries(node, "match", baseType, diagnostics),
   };
 }
 
 function parseInterpolationTable(
   node: XmlNode,
   baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
 ): QtiLookupTable {
   return {
     type: "interpolation",
     defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
     attributes: node.attributes,
     source: node.source,
-    entries: childElements(node, "qti-interpolation-table-entry").map((entry) => ({
-      sourceValue: Number(entry.attributes["source-value"]),
-      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
-      includeBoundary: parseXmlBoolean(entry.attributes["include-boundary"]) ?? true,
-      attributes: entry.attributes,
-      source: entry.source,
-    })),
+    entries: parseLookupEntries(node, "interpolation", baseType, diagnostics),
   };
 }
 
 function parseLookupValue(value: string | undefined, baseType: string | undefined): QtiValue {
   return value === undefined ? null : coerceValue(value, baseType);
 }
+
+function parseLookupEntries(
+  node: XmlNode,
+  tableType: QtiLookupTable["type"],
+  baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
+): QtiLookupTable["entries"] {
+  const entryName =
+    tableType === "match" ? "qti-match-table-entry" : "qti-interpolation-table-entry";
+  const entries: QtiLookupTable["entries"] = [];
+  for (const entry of childElements(node, entryName)) {
+    const sourceValue = parseFiniteNumber(entry.attributes["source-value"]);
+    if (sourceValue === undefined) {
+      validateLookupTableEntryAttributes(tableType, entry, diagnostics);
+      continue;
+    }
+    entries.push({
+      sourceValue,
+      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
+      includeBoundary:
+        tableType === "interpolation"
+          ? (parseXmlBoolean(entry.attributes["include-boundary"]) ?? true)
+          : undefined,
+      attributes: entry.attributes,
+      source: entry.source,
+    });
+  }
+  return entries;
+}