@longsightgroup/qti3-core 0.6.0 → 0.7.1

package/src/shared-vocabulary-support.ts

@@ -0,0 +1,340 @@
+import {
+  SHARED_VOCABULARY_CHOICE_WRITING_ORIENTATIONS,
+  SHARED_VOCABULARY_CONTENT_ALIGNMENTS,
+  SHARED_VOCABULARY_CONTENT_FLOAT_SUFFIXES,
+  SHARED_VOCABULARY_CONTENT_LIST_STYLE_TYPES,
+  SHARED_VOCABULARY_CONTENT_TEXT_INDENT_SUFFIXES,
+  SHARED_VOCABULARY_CONTENT_VALIGNS,
+  SHARED_VOCABULARY_CONTENT_WRITING_MODES,
+  SHARED_VOCABULARY_LAYOUT_COLUMN_SPAN_COUNT,
+  SHARED_VOCABULARY_LAYOUT_OFFSET_COUNT,
+} from "./shared-vocabulary-generated-families.js";
+import {
+  SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES,
+  SHARED_VOCABULARY_EXTENDED_TEXT_HEIGHT_LINES,
+  SHARED_VOCABULARY_INPUT_WIDTHS,
+} from "./shared-vocabulary.js";
+import type { QtiInteractionType, SharedVocabularyClassSupport } from "./types.js";
+
+const sharedVocabularyFixture = [
+  "packages/fixtures/packages/basic-item-player/valid-item-only/items/shared-vocabulary.xml",
+];
+const fixtureTests = ["packages/fixtures/src/fixtures.test.ts", "packages/cli/src/index.test.ts"];
+const sharedVocabularyMatrixTests = ["tests/browser/player-shared-vocabulary.spec.ts"];
+const contentTests = [
+  ...fixtureTests,
+  "packages/core/src/core.test.ts",
+  "tests/browser/player-dom-behavior.spec.ts",
+  ...sharedVocabularyMatrixTests,
+];
+const sharedVocabularyUnitTests = [
+  "packages/core/src/shared-vocabulary.test.ts",
+  "packages/player/src/interactions/shared-vocabulary.test.ts",
+];
+const sharedVocabularyValidationTests = [
+  "packages/core/src/core.test.ts",
+  "packages/core/src/shared-vocabulary-validation.test.ts",
+];
+const browserBehaviorTests = [
+  "tests/browser/player-dom-behavior.spec.ts",
+  ...sharedVocabularyMatrixTests,
+];
+const graphicBrowserTests = ["tests/browser/player-graphic.spec.ts"];
+const mediaBrowserTests = ["tests/browser/player.spec.ts", ...sharedVocabularyMatrixTests];
+const mediaPlayerFixture =
+  "packages/fixtures/packages/sv-matrix/items/media-controls-and-pause.xml";
+const interactionInputWidthFixtures = [
+  "packages/fixtures/packages/sv-matrix/items/interaction-input-width-standalone.xml",
+  "packages/fixtures/packages/sv-matrix/items/interaction-input-width-embedded.xml",
+];
+const orderMinMaxMessagesFixture =
+  "packages/fixtures/packages/sv-matrix/items/order-min-max-messages.xml";
+
+const choiceAndOrder: QtiInteractionType[] = ["choice", "order"];
+const choicesLayoutInteractions: QtiInteractionType[] = [
+  "match",
+  "gapMatch",
+  "graphicGapMatch",
+  "order",
+];
+const selectionPresentationInteractions: QtiInteractionType[] = [
+  "choice",
+  "hottext",
+  "hotspot",
+  "graphicGapMatch",
+];
+
+function svEntry(
+  className: string,
+  scope: SharedVocabularyClassSupport["scope"],
+  level: SharedVocabularyClassSupport["level"],
+  options: Omit<SharedVocabularyClassSupport, "className" | "scope" | "level"> = {},
+): SharedVocabularyClassSupport {
+  return {
+    className,
+    scope,
+    level,
+    ...options,
+  };
+}
+
+function contentStylesheetEntry(className: string, notes?: string): SharedVocabularyClassSupport {
+  return svEntry(className, "content", "stylesheet", {
+    fixtures: sharedVocabularyFixture,
+    tests: contentTests,
+    notes,
+  });
+}
+
+function interactionFullEntry(
+  className: string,
+  interactions: QtiInteractionType[],
+  tests: string[],
+  notes?: string,
+): SharedVocabularyClassSupport {
+  return svEntry(className, "interaction", "full", {
+    interactions,
+    fixtures: sharedVocabularyFixture,
+    tests,
+    notes,
+  });
+}
+
+function interactionStylesheetEntry(
+  className: string,
+  interactions: QtiInteractionType[],
+  tests: string[],
+  notes?: string,
+): SharedVocabularyClassSupport {
+  return svEntry(className, "interaction", "stylesheet", {
+    interactions,
+    fixtures: sharedVocabularyFixture,
+    tests,
+    notes,
+  });
+}
+
+function mediaPlayerSvEntry(
+  className: string,
+  notes: string,
+  tests: string[] = mediaBrowserTests,
+): SharedVocabularyClassSupport {
+  return svEntry(className, "interaction", "full", {
+    interactions: ["media"],
+    fixtures: [mediaPlayerFixture],
+    tests,
+    notes,
+  });
+}
+
+export const sharedVocabularyClassSupport: SharedVocabularyClassSupport[] = [
+  contentStylesheetEntry(
+    "qti-layout-row",
+    "Twelve-column content layout row; validated for supported child column spans and offsets.",
+  ),
+  ...Array.from(
+    { length: SHARED_VOCABULARY_LAYOUT_COLUMN_SPAN_COUNT },
+    (_, index) => index + 1,
+  ).flatMap((span) => [
+    contentStylesheetEntry(`qti-layout-col${span}`),
+    contentStylesheetEntry(`qti-layout-col-${span}`),
+  ]),
+  ...Array.from({ length: SHARED_VOCABULARY_LAYOUT_OFFSET_COUNT }, (_, index) => index + 1).flatMap(
+    (offset) => [
+      contentStylesheetEntry(`qti-layout-offset${offset}`),
+      contentStylesheetEntry(`qti-layout-offset-${offset}`),
+    ],
+  ),
+  ...SHARED_VOCABULARY_CONTENT_ALIGNMENTS.map((alignment) =>
+    contentStylesheetEntry(`qti-align-${alignment}`),
+  ),
+  ...SHARED_VOCABULARY_CONTENT_VALIGNS.map((alignment) =>
+    contentStylesheetEntry(`qti-valign-${alignment}`),
+  ),
+  contentStylesheetEntry("qti-fullwidth"),
+  contentStylesheetEntry("qti-width-full"),
+  contentStylesheetEntry("qti-hidden", "Hides content from visual and assistive output."),
+  contentStylesheetEntry(
+    "qti-visually-hidden",
+    "Keeps content available to assistive technology while removing it from visual flow.",
+  ),
+  svEntry("qti-keyword-emphasis", "content", "conditional", {
+    fixtures: ["packages/fixtures/packages/sv-matrix/items/content-keyword-emphasis.xml"],
+    tests: sharedVocabularyMatrixTests,
+    notes:
+      "Rendered with additional emphasis only when candidate PNP keyword-emphasis support is enabled by the host.",
+  }),
+  ...SHARED_VOCABULARY_CONTENT_TEXT_INDENT_SUFFIXES.map((suffix) =>
+    contentStylesheetEntry(`qti-text-indent-${suffix}`),
+  ),
+  ...SHARED_VOCABULARY_CONTENT_WRITING_MODES.map((mode) =>
+    contentStylesheetEntry(`qti-writing-mode-${mode}`),
+  ),
+  contentStylesheetEntry("qti-text-orientation-upright"),
+  contentStylesheetEntry("qti-text-combine-upright-all"),
+  ...SHARED_VOCABULARY_CONTENT_FLOAT_SUFFIXES.map((floatClass) =>
+    contentStylesheetEntry(`qti-float-${floatClass}`),
+  ),
+  contentStylesheetEntry("qti-bordered"),
+  contentStylesheetEntry("qti-well"),
+  ...SHARED_VOCABULARY_CONTENT_LIST_STYLE_TYPES.map((styleType) =>
+    contentStylesheetEntry(`qti-list-style-type-${styleType}`),
+  ),
+  contentStylesheetEntry("qti-underline"),
+  contentStylesheetEntry("qti-italic"),
+  contentStylesheetEntry("qti-display-inline-block"),
+
+  ...["none", "decimal", "cjk-ideographic", "lower-alpha", "upper-alpha"].map((labelStyle) =>
+    interactionFullEntry(`qti-labels-${labelStyle}`, choiceAndOrder, [
+      ...sharedVocabularyUnitTests,
+      ...browserBehaviorTests,
+    ]),
+  ),
+  ...["none", "period", "parenthesis"].map((suffix) =>
+    interactionFullEntry(`qti-labels-suffix-${suffix}`, choiceAndOrder, [
+      ...sharedVocabularyUnitTests,
+      ...browserBehaviorTests,
+    ]),
+  ),
+  ...["horizontal", "vertical"].map((orientation) =>
+    interactionFullEntry(
+      `qti-orientation-${orientation}`,
+      ["choice", "order"],
+      [
+        "packages/player/src/interactions/choice-layout.test.ts",
+        ...sharedVocabularyUnitTests,
+        ...browserBehaviorTests,
+      ],
+    ),
+  ),
+  ...Array.from({ length: 5 }, (_, index) => index + 1).map((stacking) =>
+    interactionFullEntry(
+      `qti-choices-stacking-${stacking}`,
+      ["choice"],
+      [
+        "packages/player/src/interactions/choice-layout.test.ts",
+        "packages/core/src/core.test.ts",
+        ...browserBehaviorTests,
+      ],
+    ),
+  ),
+  interactionStylesheetEntry(
+    "qti-input-control-hidden",
+    ["choice", "hottext"],
+    [...browserBehaviorTests, "tests/browser/player-keyboard-a11y.spec.ts"],
+  ),
+  ...SHARED_VOCABULARY_CHOICE_WRITING_ORIENTATIONS.map((orientation) =>
+    interactionStylesheetEntry(
+      `qti-writing-orientation-${orientation}`,
+      ["choice"],
+      [...browserBehaviorTests],
+    ),
+  ),
+  ...["light", "dark"].map((tone) =>
+    interactionStylesheetEntry(`qti-selections-${tone}`, selectionPresentationInteractions, [
+      ...browserBehaviorTests,
+      ...graphicBrowserTests,
+    ]),
+  ),
+  interactionStylesheetEntry("qti-unselected-hidden", selectionPresentationInteractions, [
+    ...browserBehaviorTests,
+    ...graphicBrowserTests,
+  ]),
+  ...["top", "bottom", "left", "right"].map((position) =>
+    interactionFullEntry(`qti-choices-${position}`, choicesLayoutInteractions, [
+      ...sharedVocabularyUnitTests,
+      ...browserBehaviorTests,
+      ...graphicBrowserTests,
+    ]),
+  ),
+  svEntry("data-min-selections-message", "interaction", "full", {
+    interactions: ["order"],
+    fixtures: [orderMinMaxMessagesFixture],
+    tests: sharedVocabularyMatrixTests,
+    notes: "Overrides minimum response validation text for order interactions.",
+  }),
+  svEntry("data-max-selections-message", "interaction", "full", {
+    interactions: ["choice", "order"],
+    fixtures: [orderMinMaxMessagesFixture],
+    tests: ["tests/browser/player-validation.spec.ts", ...sharedVocabularyMatrixTests],
+    notes: "Overrides maximum response validation text for choice and order interactions.",
+  }),
+  interactionFullEntry(
+    "qti-match-tabular",
+    ["match"],
+    [
+      "packages/core/src/core.test.ts",
+      ...browserBehaviorTests,
+      "tests/browser/player-keyboard-a11y.spec.ts",
+    ],
+  ),
+  svEntry("qti-header-hidden", "interaction", "conditional", {
+    interactions: ["match"],
+    fixtures: sharedVocabularyFixture,
+    tests: ["packages/core/src/core.test.ts", ...browserBehaviorTests],
+    notes: "Applied when qti-match-tabular selects the tabular match renderer.",
+  }),
+  interactionFullEntry(
+    "qti-gap-placement",
+    ["gapMatch"],
+    [...sharedVocabularyUnitTests, "packages/core/src/core.test.ts", ...browserBehaviorTests],
+  ),
+  ...SHARED_VOCABULARY_INPUT_WIDTHS.map((width) =>
+    svEntry(`qti-input-width-${width}`, "interaction", "full", {
+      interactions: ["textEntry", "inlineChoice"],
+      fixtures: interactionInputWidthFixtures,
+      tests: [
+        "packages/core/src/shared-vocabulary.test.ts",
+        "packages/core/src/core.test.ts",
+        ...sharedVocabularyMatrixTests,
+      ],
+    }),
+  ),
+  ...SHARED_VOCABULARY_INPUT_WIDTHS.map((width) =>
+    svEntry(`qti-input-width-${width}`, "gap", "full", {
+      interactions: ["gapMatch"],
+      fixtures: sharedVocabularyFixture,
+      tests: [
+        "packages/core/src/shared-vocabulary.test.ts",
+        "packages/core/src/core.test.ts",
+        ...browserBehaviorTests,
+      ],
+      notes: "Supported on qti-gap targets when gap placement is authored.",
+    }),
+  ),
+  ...SHARED_VOCABULARY_EXTENDED_TEXT_HEIGHT_LINES.map((lines) =>
+    interactionFullEntry(
+      `qti-height-lines-${lines}`,
+      ["extendedText"],
+      [
+        ...sharedVocabularyValidationTests,
+        "packages/core/src/shared-vocabulary.test.ts",
+        ...browserBehaviorTests,
+      ],
+    ),
+  ),
+  ...SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES.map((className) =>
+    interactionFullEntry(
+      className,
+      ["extendedText"],
+      [
+        ...sharedVocabularyValidationTests,
+        "packages/core/src/shared-vocabulary.test.ts",
+        ...browserBehaviorTests,
+      ],
+    ),
+  ),
+  mediaPlayerSvEntry(
+    "data-qti-media-player-controls",
+    "Supports tokens none, default, play, rewind, captions, and audioDescription on media interactions and rendered media assets.",
+    [...mediaBrowserTests, "packages/core/src/shared-vocabulary-validation.test.ts"],
+  ),
+  mediaPlayerSvEntry(
+    "data-qti-media-player-pause-delay",
+    "Reflects authored pause-delay values on rendered media assets. Pause timer behavior is covered in tests/browser/player.spec.ts.",
+  ),
+  mediaPlayerSvEntry(
+    "data-qti-media-player-pause-duration",
+    "Reflects authored pause-duration values on rendered media assets. Pause timer behavior is covered in tests/browser/player.spec.ts.",
+  ),
+];

package/src/shared-vocabulary-validation.ts

@@ -0,0 +1,182 @@
+import {
+  formatSupportedExtendedTextCounterClasses,
+  formatSupportedExtendedTextHeightLinesClasses,
+  formatSupportedInputWidthClasses,
+  formatSupportedMediaPlayerControlsTokens,
+  isSupportedExtendedTextCounterClassName,
+  isSupportedExtendedTextHeightLinesClassName,
+  isSupportedInputWidthClassName,
+  supportedExtendedTextCounterClassNames,
+  supportedExtendedTextHeightLinesClassNames,
+  supportedInputWidthClassNames,
+  unsupportedMediaPlayerControlsTokens,
+} from "./shared-vocabulary.js";
+import type { QtiDiagnostic, QtiSourceLocation } from "./types.js";
+
+export interface SharedVocabularyNumericPrefixValidationOptions {
+  classNames: string[];
+  subjectQtiName: string;
+  path?: string | undefined;
+  source?: QtiSourceLocation | undefined;
+  classPrefix: string;
+  supportedClassNames: (classNames: string[]) => string[];
+  isSupportedClassName: (className: string) => boolean;
+  formatSupportedClasses: () => string;
+  conflictCode: string;
+  invalidCode: string;
+}
+
+export function validateSharedVocabularyNumericPrefix(
+  options: SharedVocabularyNumericPrefixValidationOptions,
+): QtiDiagnostic[] {
+  const {
+    classNames,
+    subjectQtiName,
+    path,
+    source,
+    classPrefix,
+    supportedClassNames,
+    isSupportedClassName,
+    formatSupportedClasses,
+    conflictCode,
+    invalidCode,
+  } = options;
+  const diagnostics: QtiDiagnostic[] = [];
+  const supported = supportedClassNames(classNames);
+  if (new Set(supported).size > 1) {
+    diagnostics.push({
+      code: conflictCode,
+      severity: "warning",
+      message: `${subjectQtiName} should not include multiple supported ${classPrefix}* classes: ${[...new Set(supported)].join(", ")}. The first class in class attribute order takes precedence at runtime.`,
+      path,
+      source,
+    });
+  }
+
+  for (const className of classNames) {
+    if (!className.startsWith(classPrefix)) continue;
+    if (isSupportedClassName(className)) continue;
+    diagnostics.push({
+      code: invalidCode,
+      severity: "warning",
+      message: `${subjectQtiName} shared vocabulary class ${className} is not supported; expected ${formatSupportedClasses()}.`,
+      path,
+      source,
+    });
+  }
+  return diagnostics;
+}
+
+export interface SharedVocabularyInputWidthValidationOptions {
+  classNames: string[];
+  subjectQtiName: string;
+  path?: string | undefined;
+  source?: QtiSourceLocation | undefined;
+  conflictCode: string;
+  invalidCode: string;
+}
+
+export function validateSharedVocabularyInputWidth(
+  options: SharedVocabularyInputWidthValidationOptions,
+): QtiDiagnostic[] {
+  const { classNames, subjectQtiName, path, source, conflictCode, invalidCode } = options;
+  return validateSharedVocabularyNumericPrefix({
+    classNames,
+    subjectQtiName,
+    path,
+    source,
+    classPrefix: "qti-input-width-",
+    supportedClassNames: supportedInputWidthClassNames,
+    isSupportedClassName: isSupportedInputWidthClassName,
+    formatSupportedClasses: formatSupportedInputWidthClasses,
+    conflictCode,
+    invalidCode,
+  });
+}
+
+export interface SharedVocabularyExtendedTextValidationOptions {
+  classNames: string[];
+  subjectQtiName: string;
+  path?: string | undefined;
+  source?: QtiSourceLocation | undefined;
+}
+
+export function validateSharedVocabularyExtendedTextHeightLines(
+  options: SharedVocabularyExtendedTextValidationOptions,
+): QtiDiagnostic[] {
+  const { classNames, subjectQtiName, path, source } = options;
+  return validateSharedVocabularyNumericPrefix({
+    classNames,
+    subjectQtiName,
+    path,
+    source,
+    classPrefix: "qti-height-lines-",
+    supportedClassNames: supportedExtendedTextHeightLinesClassNames,
+    isSupportedClassName: isSupportedExtendedTextHeightLinesClassName,
+    formatSupportedClasses: formatSupportedExtendedTextHeightLinesClasses,
+    conflictCode: "interaction.sharedVocabulary.extendedTextHeightLinesConflict",
+    invalidCode: "interaction.sharedVocabulary.extendedTextHeightLinesInvalid",
+  });
+}
+
+export function validateSharedVocabularyExtendedTextCounter(
+  options: SharedVocabularyExtendedTextValidationOptions,
+): QtiDiagnostic[] {
+  const { classNames, subjectQtiName, path, source } = options;
+  const diagnostics: QtiDiagnostic[] = [];
+  const counterClasses = supportedExtendedTextCounterClassNames(classNames);
+  if (new Set(counterClasses).size > 1) {
+    diagnostics.push({
+      code: "interaction.sharedVocabulary.extendedTextCounterConflict",
+      severity: "warning",
+      message: `${subjectQtiName} should not include multiple qti-counter-* classes: ${[...new Set(counterClasses)].join(", ")}. The first class in class attribute order takes precedence at runtime.`,
+      path,
+      source,
+    });
+  }
+
+  for (const className of classNames) {
+    if (!className.startsWith("qti-counter-")) continue;
+    if (isSupportedExtendedTextCounterClassName(className)) continue;
+    diagnostics.push({
+      code: "interaction.sharedVocabulary.extendedTextCounterInvalid",
+      severity: "warning",
+      message: `${subjectQtiName} shared vocabulary class ${className} is not supported; expected ${formatSupportedExtendedTextCounterClasses()}.`,
+      path,
+      source,
+    });
+  }
+  return diagnostics;
+}
+
+export function validateSharedVocabularyExtendedText(
+  options: SharedVocabularyExtendedTextValidationOptions,
+): QtiDiagnostic[] {
+  return [
+    ...validateSharedVocabularyExtendedTextHeightLines(options),
+    ...validateSharedVocabularyExtendedTextCounter(options),
+  ];
+}
+
+export interface SharedVocabularyMediaPlayerControlsValidationOptions {
+  value: string | undefined;
+  subjectQtiName: string;
+  path?: string | undefined;
+  source?: QtiSourceLocation | undefined;
+}
+
+export function validateSharedVocabularyMediaPlayerControls(
+  options: SharedVocabularyMediaPlayerControlsValidationOptions,
+): QtiDiagnostic[] {
+  const unsupported = unsupportedMediaPlayerControlsTokens(options.value);
+  if (unsupported.length === 0) return [];
+  return [
+    {
+      code: "interaction.sharedVocabulary.mediaPlayerControlsInvalid",
+      severity: "warning",
+      message: `${options.subjectQtiName} data-qti-media-player-controls token ${[...new Set(unsupported)].join(", ")} is not supported; expected ${formatSupportedMediaPlayerControlsTokens()}.`,
+      path: options.path,
+      source: options.source,
+    },
+  ];
+}

package/src/shared-vocabulary.ts

@@ -0,0 +1,177 @@
+import type { QtiInteraction } from "./types.js";
+
+/** Normative QTI 3 shared vocabulary input-width token values (1EdTech vocab). */
+export const SHARED_VOCABULARY_INPUT_WIDTHS = [
+  1, 2, 3, 4, 6, 10, 15, 20, 25, 30, 35, 40, 45, 50, 72,
+] as const;
+
+export const SHARED_VOCABULARY_GAP_INPUT_WIDTHS = SHARED_VOCABULARY_INPUT_WIDTHS;
+
+/** Normative QTI 3 shared vocabulary extended text height token values (1EdTech vocab). */
+export const SHARED_VOCABULARY_EXTENDED_TEXT_HEIGHT_LINES = [3, 6, 15] as const;
+
+export const SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES = [
+  "qti-counter-up",
+  "qti-counter-down",
+] as const;
+
+export type SharedVocabularyExtendedTextCounterPosition = "up" | "down";
+
+export const SHARED_VOCABULARY_MEDIA_PLAYER_CONTROLS = [
+  "none",
+  "default",
+  "play",
+  "rewind",
+  "captions",
+  "audioDescription",
+] as const;
+
+export type SharedVocabularyMediaPlayerControls =
+  (typeof SHARED_VOCABULARY_MEDIA_PLAYER_CONTROLS)[number];
+
+const inputWidthSet = new Set<number>(SHARED_VOCABULARY_INPUT_WIDTHS);
+const extendedTextHeightLinesSet = new Set<number>(SHARED_VOCABULARY_EXTENDED_TEXT_HEIGHT_LINES);
+const extendedTextCounterClassSet = new Set<string>(
+  SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES,
+);
+const mediaPlayerControlsSet = new Set<string>(SHARED_VOCABULARY_MEDIA_PLAYER_CONTROLS);
+
+const inputWidthClassPattern = /^qti-input-width-(\d+)$/;
+const extendedTextHeightLinesClassPattern = /^qti-height-lines-(\d+)$/;
+
+const extendedTextCounterPositionByClass: Record<
+  (typeof SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES)[number],
+  SharedVocabularyExtendedTextCounterPosition
+> = {
+  "qti-counter-up": "up",
+  "qti-counter-down": "down",
+};
+
+export function sharedVocabularyClassNames(attributes: Record<string, string>): string[] {
+  return (attributes.class ?? "").split(/\s+/).filter(Boolean);
+}
+
+export function firstMatchingSharedVocabularyClass<T extends string>(
+  classNames: string[],
+  tokens: readonly T[],
+): T | undefined {
+  const tokenSet = new Set<string>(tokens);
+  for (const className of classNames) {
+    if (tokenSet.has(className)) return className as T;
+  }
+  return undefined;
+}
+
+export function inputWidthFromAttributes(attributes: Record<string, string>): number | undefined {
+  for (const className of sharedVocabularyClassNames(attributes)) {
+    const value = inputWidthClassPattern.exec(className)?.[1];
+    if (value === undefined) continue;
+    const width = Number(value);
+    if (inputWidthSet.has(width)) return width;
+  }
+  return undefined;
+}
+
+export const gapInputWidthFromAttributes = inputWidthFromAttributes;
+
+export function extendedTextHeightLinesFromAttributes(
+  attributes: Record<string, string>,
+): number | undefined {
+  for (const className of sharedVocabularyClassNames(attributes)) {
+    const value = extendedTextHeightLinesClassPattern.exec(className)?.[1];
+    if (value === undefined) continue;
+    const lines = Number(value);
+    if (extendedTextHeightLinesSet.has(lines)) return lines;
+  }
+  return undefined;
+}
+
+export function extendedTextHeightLines(interaction: QtiInteraction): number | undefined {
+  return extendedTextHeightLinesFromAttributes(interaction.attributes);
+}
+
+export function extendedTextCounterPositionFromAttributes(
+  attributes: Record<string, string>,
+): SharedVocabularyExtendedTextCounterPosition | undefined {
+  const matched = firstMatchingSharedVocabularyClass(
+    sharedVocabularyClassNames(attributes),
+    SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES,
+  );
+  return matched === undefined ? undefined : extendedTextCounterPositionByClass[matched];
+}
+
+export function extendedTextCounterPosition(
+  interaction: QtiInteraction,
+): SharedVocabularyExtendedTextCounterPosition | undefined {
+  return extendedTextCounterPositionFromAttributes(interaction.attributes);
+}
+
+export function supportedInputWidthClassNames(classNames: string[]): string[] {
+  return classNames.filter((className) => {
+    const value = inputWidthClassPattern.exec(className)?.[1];
+    return value !== undefined && inputWidthSet.has(Number(value));
+  });
+}
+
+export const supportedGapInputWidthClassNames = supportedInputWidthClassNames;
+
+export function supportedExtendedTextHeightLinesClassNames(classNames: string[]): string[] {
+  return classNames.filter((className) => {
+    const value = extendedTextHeightLinesClassPattern.exec(className)?.[1];
+    return value !== undefined && extendedTextHeightLinesSet.has(Number(value));
+  });
+}
+
+export function supportedExtendedTextCounterClassNames(classNames: string[]): string[] {
+  return classNames.filter((className) => extendedTextCounterClassSet.has(className));
+}
+
+export function mediaPlayerControlsTokens(value: string | undefined): string[] {
+  return (value ?? "").split(/\s+/).filter(Boolean);
+}
+
+export function unsupportedMediaPlayerControlsTokens(value: string | undefined): string[] {
+  return mediaPlayerControlsTokens(value).filter((token) => !mediaPlayerControlsSet.has(token));
+}
+
+export function isSupportedMediaPlayerControlsToken(token: string): boolean {
+  return mediaPlayerControlsSet.has(token);
+}
+
+export function formatSupportedMediaPlayerControlsTokens(): string {
+  return SHARED_VOCABULARY_MEDIA_PLAYER_CONTROLS.join(", ");
+}
+
+export function isSupportedInputWidthClassName(className: string): boolean {
+  if (!className.startsWith("qti-input-width-")) return false;
+  const value = inputWidthClassPattern.exec(className)?.[1];
+  return value !== undefined && inputWidthSet.has(Number(value));
+}
+
+export const isSupportedGapInputWidthClassName = isSupportedInputWidthClassName;
+
+export function isSupportedExtendedTextHeightLinesClassName(className: string): boolean {
+  if (!className.startsWith("qti-height-lines-")) return false;
+  const value = extendedTextHeightLinesClassPattern.exec(className)?.[1];
+  return value !== undefined && extendedTextHeightLinesSet.has(Number(value));
+}
+
+export function isSupportedExtendedTextCounterClassName(className: string): boolean {
+  return extendedTextCounterClassSet.has(className);
+}
+
+export function formatSupportedInputWidthClasses(): string {
+  return SHARED_VOCABULARY_INPUT_WIDTHS.map((width) => `qti-input-width-${width}`).join(", ");
+}
+
+export const formatSupportedGapInputWidthClasses = formatSupportedInputWidthClasses;
+
+export function formatSupportedExtendedTextHeightLinesClasses(): string {
+  return SHARED_VOCABULARY_EXTENDED_TEXT_HEIGHT_LINES.map(
+    (lines) => `qti-height-lines-${lines}`,
+  ).join(", ");
+}
+
+export function formatSupportedExtendedTextCounterClasses(): string {
+  return SHARED_VOCABULARY_EXTENDED_TEXT_COUNTER_CLASSES.join(", ");
+}