@citolab/qti-components 7.28.1 → 8.0.1

package/dist/qti-components-jsx.js

@@ -0,0 +1 @@
+export {};

package/dist/qti-condition-expression.d-aMvBvpc6.d.ts

@@ -0,0 +1,8 @@
+import { Q as QtiExpression } from './qti-expression.d-BietT_8b.js';
+
+declare abstract class QtiConditionExpression extends QtiExpression<boolean> {
+    calculate(): Readonly<boolean>;
+    getResult(): Readonly<boolean>;
+}
+
+export { QtiConditionExpression as Q };

package/dist/{qti-condition-expression-Dam-RER6.d.ts → qti-expression.d-BietT_8b.d.ts}

@@ -1,8 +1,18 @@
+import { I as ItemContext, V as VariableDeclaration, f as ResponseVariable } from './item.types.d-QU7LljEK.js';
 import * as lit from 'lit';
 import { LitElement } from 'lit';
-import { Q as QtiContext, a as QtiContextType } from './qti.context-CejJMlfZ.js';
-import { f as ResponseVariable, V as VariableDeclaration } from './variables-CMYcDbyW.js';
-import { I as ItemContext } from './item.context-CkUeDcaO.js';
+import { Q as QtiContext, a as QtiContextType } from './qti.context.d-CejJMlfZ.js';
+
+interface TestContext {
+    items: (ItemContext & {
+        category?: string;
+    })[];
+    testOutcomeVariables?: VariableDeclaration<string | string[] | null>[];
+}
+declare const INITIAL_TEST_CONTEXT: Readonly<TestContext>;
+declare const testContext: {
+    __context__: Readonly<TestContext>;
+};
 
 interface QtiExpressionBase<T> {
     calculate(): Readonly<T>;
@@ -18,9 +28,4 @@ declare abstract class QtiExpression<T> extends LitElement implements QtiExpress
     getVariables: () => (ResponseVariable | VariableDeclaration<QtiContextType>)[];
 }
 
-declare abstract class QtiConditionExpression extends QtiExpression<boolean> {
-    calculate(): Readonly<boolean>;
-    getResult(): Readonly<boolean>;
-}
-
-export { QtiConditionExpression as Q, QtiExpression as a, type QtiExpressionBase as b };
+export { INITIAL_TEST_CONTEXT as I, QtiExpression as Q, type TestContext as T, type QtiExpressionBase as a, testContext as t };

package/dist/{qti-feedback-ChmXhZuf.d.ts → qti-feedback.d-DZbad0RN.d.ts}

@@ -1,6 +1,6 @@
 import * as lit from 'lit';
 import { LitElement } from 'lit';
-import { a as Cardinality } from './variables-CMYcDbyW.js';
+import { a as Cardinality } from './item.types.d-QU7LljEK.js';
 
 declare abstract class QtiVariableDeclaration extends LitElement {
     render(): lit.TemplateResult<1>;

package/dist/{qti-transform-test-DoZaWItm.d.ts → qti-transform-test.d-BL7GGFJj.d.ts}

@@ -29,7 +29,7 @@ type transformItemApi = {
     stripStyleSheets: () => transformItemApi;
     html: () => string;
     xml: () => string;
-    htmlDoc: () => DocumentFragment;
+    htmlDoc: (registry?: CustomElementRegistry) => DocumentFragment;
     xmlDoc: () => XMLDocument;
 };
 declare const qtiTransformItem: () => transformItemApi;
@@ -62,7 +62,7 @@ type transformTestApi = {
     }[];
     html: () => string;
     xml: () => string;
-    htmlDoc: () => DocumentFragment;
+    htmlDoc: (registry?: CustomElementRegistry) => DocumentFragment;
     xmlDoc: () => XMLDocument;
 };
 declare const qtiTransformTest: () => transformTestApi;

package/dist/response.d-_8y4kjGP.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Canonical `response="..."` / `correct-response="..."` attribute codec.
+ *
+ * Authors put a single string on an interaction element. This module is the
+ * single source of truth for how that string parses into the runtime's
+ * internal value AND how an editor serializes the internal value back to the
+ * attribute. Both `@qti-components/*` interactions and `@citolab/prose-qti`
+ * (the editor) import from here — no per-codebase parsers, no drift.
+ *
+ * The two attributes share the same grammar; the codec is agnostic about
+ * which of them is being parsed.
+ *
+ * ---
+ *
+ * Format reference (per interaction):
+ *
+ * | Interaction          | base-type     | cardinality          | attribute value           |
+ * |----------------------|---------------|----------------------|---------------------------|
+ * | choice               | identifier    | single / multiple    | "A"  /  "A,B,C"           |
+ * | inline-choice        | identifier    | single               | "Y"                       |
+ * | hottext              | identifier    | single / multiple    | "h1"  /  "h1,h2"          |
+ * | hotspot              | identifier    | single / multiple    | "spot1"  /  "spot1,spot2" |
+ * | order                | identifier    | ordered              | "a,b,c"  (order matters)  |
+ * | graphic-order        | identifier    | ordered              | "spot1,spot2,spot3"       |
+ * | match                | directedPair  | multiple             | "src1 tgt1,src2 tgt2"     |
+ * | associate            | directedPair  | multiple             | "A B,C D"                 |
+ * | gap-match            | directedPair  | multiple             | "gtext1 gap1,..."         |
+ * | graphic-associate    | directedPair  | multiple             | "spot1 spot2,..."         |
+ * | graphic-gap-match    | directedPair  | multiple             | "gimg1 spot1,..."         |
+ * | select-point         | point         | single / multiple    | "100 150"  /  "100 150,…" |
+ * | slider               | integer       | single               | "50"                      |
+ * | text-entry           | string        | single               | "paris"                   |
+ *
+ * Rules:
+ *  - Comma `,` separates VALUES (different identifiers / pairs / points).
+ *  - Space ` ` separates PARTS within one value (pair members or point coords).
+ *  - Each value is trimmed on parse.
+ *  - No escape mechanism. Identifiers that contain commas cannot round-trip.
+ */
+/** Canonical parsed value of a `response` / `correct-response` attribute. */
+type ResponseValue = string | string[] | null;
+/** Identifier literal — opaque QTI identifier (e.g. `"choice1"`). */
+type Identifier = string;
+/** Directed pair literal — `"sourceId targetId"`. Used by match / associate / gap-match. */
+type DirectedPair = `${string} ${string}`;
+/** Point literal — `"x y"` integer coordinates. Used by select-point / graphic-*. */
+type Point = `${number} ${number}`;
+/**
+ * Parse a raw `response` / `correct-response` attribute string into the
+ * canonical value.
+ *
+ *  - `null` / `undefined` / empty → `null`
+ *  - no comma                     → trimmed string
+ *  - one or more commas           → trimmed array (single-element collapses to a string)
+ */
+declare function parseResponseAttribute(raw: string | null | undefined): ResponseValue;
+/**
+ * Serialize a canonical value back to the attribute string. Returns `null` for
+ * empty inputs so a Lit `@property({ reflect: true })` drops the attribute.
+ */
+declare function serializeResponseAttribute(value: ResponseValue): string | null;
+/**
+ * Iterate over the comma-separated entries in a response value, regardless of
+ * whether the caller has the raw string, the parsed string, or a string[].
+ * Yields trimmed non-empty entries.
+ */
+declare function iterResponseValues(raw: ResponseValue): Generator<string>;
+/** Parse a directed-pair value into `{ source, target }`. Throws on malformed input. */
+declare function parsePair(value: string): {
+    source: string;
+    target: string;
+};
+/** Serialize a directed pair to canonical `"source target"` form. */
+declare function serializePair(source: string, target: string): DirectedPair;
+/** Parse a point value into `{ x, y }`. Throws on malformed input. */
+declare function parsePoint(value: string): {
+    x: number;
+    y: number;
+};
+/** Serialize a point to canonical `"x y"` form. */
+declare function serializePoint(x: number, y: number): Point;
+/**
+ * Ready-to-use Lit `converter` for `response` / `correct-response` attributes.
+ * Assign to the `converter` option:
+ *
+ *   @property({ attribute: 'response', converter: responseAttributeConverter({ emptyAs: [] }) })
+ *
+ * `emptyAs` picks the sentinel returned when the attribute is absent / blank.
+ * Three sentinels exist across the codebase — match the one your call site
+ * already uses. Future work may normalize to a single sentinel.
+ *
+ *   - '' (empty string)   — ChoicesMixin convention
+ *   - []                  — DragDropSlottedMixin / graphic-associate convention
+ *   - null                — base interaction / select-point convention
+ *
+ * On the serialize side, the `emptyAs` value roundtrips back to `null` so a
+ * `reflect: true` property drops the attribute rather than emitting `""`.
+ */
+declare function responseAttributeConverter<E extends '' | null | readonly unknown[]>(opts: {
+    emptyAs: E;
+}): {
+    fromAttribute: (value: string | null) => ResponseValue | E;
+    toAttribute: (value: ResponseValue | E) => string | null;
+};
+
+export { type DirectedPair as D, type Identifier as I, type Point as P, type ResponseValue as R, parsePoint as a, parseResponseAttribute as b, serializePoint as c, serializeResponseAttribute as d, iterResponseValues as i, parsePair as p, responseAttributeConverter as r, serializePair as s };

package/dist/test.d.ts

@@ -1,17 +1,18 @@
 import * as lit from 'lit';
 import { LitElement, PropertyValues, nothing } from 'lit';
-import { QtiAssessmentItem, QtiModalFeedback } from './elements.js';
+import { QtiAssessmentItem } from './elements.js';
 import { TemplateFunction } from '@heximal/templates';
-import { T as TestContext } from './test.context-CByZZjkR.js';
-import { g as VariableValue, b as OutcomeVariable, V as VariableDeclaration } from './variables-CMYcDbyW.js';
-import { S as SessionContext, C as ComputedContext, a as ComputedItem, V as View } from './computed.context-DHbxad0N.js';
-import { C as ConfigContext } from './config.context-BjZ2bZSY.js';
-import { Q as QtiContext } from './qti.context-CejJMlfZ.js';
-import { t as transformItemApi, b as transformTestApi } from './qti-transform-test-DoZaWItm.js';
-import './item.context-CkUeDcaO.js';
-import './qti-feedback-ChmXhZuf.js';
-import './qti-rule-base-ajOnfGXY.js';
-import './computed-item.context-DfsW_96S.js';
+import { T as TestContext, Q as QtiExpression, a as QtiExpressionBase } from './qti-expression.d-BietT_8b.js';
+import { g as VariableValue, b as OutcomeVariable, V as VariableDeclaration } from './item.types.d-QU7LljEK.js';
+import { S as SessionContext, V as View, C as ComputedContext, a as ComputedItem } from './computed.types.d-rKLSPvVG.js';
+import { C as ConfigContext } from './config.context.d-BvU9r-Mg.js';
+import { QtiModalFeedback } from '@qti-components/elements/elements';
+import { Q as QtiRuleBase } from './qti-rule-base.d-ajOnfGXY.js';
+import { Q as QtiContext } from './qti.context.d-CejJMlfZ.js';
+import { t as transformItemApi, b as transformTestApi } from './qti-transform-test.d-BL7GGFJj.js';
+import './interaction.interface.d-CvjHM2bi.js';
+import './qti-feedback.d-DZbad0RN.js';
+import './computed-item.types.d-BKZdSLLJ.js';
 
 declare class QtiAssessmentItemRef extends LitElement {
     category?: string;
@@ -59,7 +60,9 @@ interface TestBaseInterface extends LitElement {
 type PostLoadTransformCallback = (transformer: transformItemApi, itemRef: QtiAssessmentItemRef) => transformItemApi | Promise<transformItemApi>;
 type PostLoadTestTransformCallback = (transformer: transformTestApi, testElement: QtiAssessmentTest) => transformTestApi | Promise<transformTestApi>;
 
-declare const QtiTest_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => {
+declare const QtiTest_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => {
+    updateAssessmentItemView(assessmentItem: QtiAssessmentItem, view: View): void;
+}) & (abstract new (...args: any[]) => {
     updateOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
     getOutcome(identifier: string): Readonly<OutcomeVariable>;
     getVariable(identifier: string): Readonly<VariableDeclaration<string | string[] | null>>;
@@ -174,11 +177,45 @@ declare global {
     }
 }
 
+declare class QtiOutcomeProcessing extends LitElement {
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    process(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-outcome-processing': QtiOutcomeProcessing;
+    }
+}
+declare class QtiOutcomeProcessingProcessor {
+    process(rules: QtiRuleBase[]): void;
+}
+
+declare class QtiTestVariables extends QtiExpression<number> {
+    #private;
+    _testContext?: TestContext;
+    constructor();
+    getResult(): number;
+    calculate(): number;
+}
+declare class QtiTestVariablesExpression implements QtiExpressionBase<number> {
+    private testContext;
+    private itemVariable;
+    private includedItems;
+    constructor(testContext: TestContext, itemVariable: string, includedItems: {
+        item: string;
+        weight: number;
+    }[]);
+    calculate(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test-variables': QtiTestVariables;
+    }
+}
+
 type CustomEventMap = {
     'test-end-attempt': CustomEvent;
-    'test-show-correct-response': CustomEvent<{
-        value: boolean;
-    }>;
 };
 declare global {
     interface GlobalEventHandlersEventMap extends CustomEventMap {
@@ -198,9 +235,16 @@ declare class TestNavigation extends LitElement {
     protected computedContext: ComputedContext;
     autoScoreItems: boolean;
     constructor();
+    /** The currently active assessment item, exposed for optional presentation extensions. */
+    protected get activeAssessmentItem(): QtiAssessmentItem | undefined;
     render(): lit.TemplateResult<1>;
     protected willUpdate(_changedProperties: PropertyValues): void;
 }
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-navigation': TestNavigation;
+    }
+}
 
 /**
  * Represents a custom element for navigating to the next test item.
@@ -260,7 +304,7 @@ declare class TestPrev extends LitElement {
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'test-previous': TestPrev;
+        'test-prev': TestPrev;
     }
 }
 
@@ -308,27 +352,6 @@ declare global {
     }
 }
 
-/**
- * @deprecated test-show-correct-response is deprecated and will be removed in the future.
- */
-declare class TestShowCorrectResponse extends LitElement {
-    #private;
-    computedContext?: ComputedContext;
-    static styles: lit.CSSResult;
-    shown: boolean;
-    disabled: boolean;
-    showCorrectText: string;
-    hideCorrectText: string;
-    noCorrectResponseText: string;
-    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
-    render(): lit.TemplateResult<1>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'test-show-correct-response': TestShowCorrectResponse;
-    }
-}
-
 /**
  * @deprecated test-paging-buttons-stamp is deprecated and will be removed in the future.
  */
@@ -362,6 +385,8 @@ declare global {
  */
 declare class TestContainer extends LitElement {
     #private;
+    /** Scoped registry used by the test shadow root. Must be set before connection. */
+    customElementRegistry: CustomElementRegistry | null;
     /** URL of the item to load */
     testURL: string;
     /** A parsed HTML document */
@@ -369,6 +394,7 @@ declare class TestContainer extends LitElement {
     /** The raw XML string */
     testXML: string;
     protected qtiContext: QtiContext;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
     /** Callback function to transform the test after loading */
     protected handleTestURLChange(): Promise<void>;
     protected handleTestXMLChange(): void;
@@ -467,7 +493,7 @@ declare class TestScoringButtons extends LitElement {
     protected createRenderRoot(): HTMLElement | DocumentFragment;
     connectedCallback(): void;
     protected computedContext?: ComputedContext;
-    render(): typeof nothing | lit.TemplateResult<1>;
+    render(): lit.TemplateResult<1> | typeof nothing;
     constructor();
 }
 declare global {
@@ -513,11 +539,145 @@ declare global {
     }
 }
 
+type SpeechState = 'idle' | 'playing' | 'paused';
+interface TtsContext {
+    state: SpeechState;
+    /** Index of the currently highlighted reading element (0-based). */
+    currentElementIndex: number;
+    /** Total number of navigable reading elements in the current item. */
+    elementCount: number;
+    play(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    prevElement(): void;
+    nextElement(): void;
+}
+
+declare const ttsContext: {
+    __context__: TtsContext;
+};
+/**
+ * Base class shared by all TTS control elements. Consumes `ttsContext` and
+ * mirrors the current speech state onto CSS custom states so each child can
+ * be styled with `:state(playing)`, `:state(paused)`, `:state(idle)`.
+ */
+declare abstract class TtsButtonBase extends LitElement {
+    #private;
+    static styles: lit.CSSResult;
+    protected _tts?: TtsContext;
+    updated(changed: PropertyValues): void;
+}
+/**
+ * `<test-item-to-speech>` is the controller and context provider. It manages
+ * speech synthesis, word highlighting, and item element lookup. Compose your
+ * own player by placing control elements as children.
+ *
+ * @example
+ * ```html
+ * <test-item-to-speech language="nl-NL">
+ *   <test-tts-play></test-tts-play>
+ *   <test-tts-prev>◀◀</test-tts-prev>
+ *   <test-tts-next>▶▶</test-tts-next>
+ *   <test-tts-stop>■</test-tts-stop>
+ * </test-item-to-speech>
+ * ```
+ *
+ * @cssstate idle    - No speech active
+ * @cssstate playing - Speech is playing
+ * @cssstate paused  - Speech is paused
+ */
+declare class TestItemToSpeech extends LitElement {
+    #private;
+    language: string;
+    protected _sessionContext?: SessionContext;
+    _ttsContext: TtsContext;
+    constructor();
+    willUpdate(changed: PropertyValues): void;
+    updated(_changed: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Play/pause/resume toggle button — always enabled, cycles through states.
+ * Use named slots `play` and `pause` to customise the icons/labels independently.
+ *
+ * @example
+ * ```html
+ * <test-tts-play>
+ *   <span slot="play">▶ Play</span>
+ *   <span slot="pause">⏸ Pause</span>
+ * </test-tts-play>
+ * ```
+ *
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsPlay extends TtsButtonBase {
+    #private;
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Pause button — enabled only when playing.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsPause extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Resume button — enabled only when paused.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsResume extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Stop button — enabled when playing or paused.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsStop extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Prev-element button — moves cursor to the previous reading element and pauses.
+ * Disabled at the first element or when no elements are loaded.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsPrev extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Next-element button — moves cursor to the next reading element and pauses.
+ * Disabled at the last element or when no elements are loaded.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsNext extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-item-to-speech': TestItemToSpeech;
+        'test-tts-play': TestTtsPlay;
+        'test-tts-pause': TestTtsPause;
+        'test-tts-resume': TestTtsResume;
+        'test-tts-stop': TestTtsStop;
+        'test-tts-prev': TestTtsPrev;
+        'test-tts-next': TestTtsNext;
+    }
+}
+
 interface IQtiTest extends LitElement, ITestNavigationMixin, ITestProcessingMixin, IMyQtiTest {
 }
 interface IMyQtiTest {
     testContext: Readonly<TestContext>;
     sessionContext: Readonly<SessionContext>;
+    configContext: ConfigContext;
     updateItemVariables(itemRefID: string, variables: VariableValue<string | string[] | null>[]): void;
 }
 interface ITestNavigationMixin {
@@ -536,4 +696,4 @@ interface ITestProcessingMixin {
     outcomeProcessing(): boolean;
 }
 
-export { type IMyQtiTest, type IQtiTest, type ITestNavigationMixin, type ITestProcessingMixin, QtiAssessmentItemRef, QtiAssessmentSection, QtiAssessmentTest, QtiTest, QtiTestFeedback, QtiTestPart, TestCheckItem, TestContainer, TestEndAttempt, TestItemLink, TestNavigation, TestNext, TestPagingButtonsStamp, TestPrev, TestPrintContext, TestPrintVariables, TestScoringButtons, TestScoringFeedback, TestSectionButtonsStamp, TestSectionLink, TestShowCorrectResponse, TestStamp, TestView, TestViewToggle };
+export { type IMyQtiTest, type IQtiTest, type ITestNavigationMixin, type ITestProcessingMixin, QtiAssessmentItemRef, QtiAssessmentSection, QtiAssessmentTest, QtiOutcomeProcessing, QtiOutcomeProcessingProcessor, QtiTest, QtiTestFeedback, QtiTestPart, QtiTestVariables, QtiTestVariablesExpression, type SpeechState, TestCheckItem, TestContainer, TestEndAttempt, TestItemLink, TestItemToSpeech, TestNavigation, TestNext, TestPagingButtonsStamp, TestPrev, TestPrintContext, TestPrintVariables, TestScoringButtons, TestScoringFeedback, TestSectionButtonsStamp, TestSectionLink, TestStamp, TestTtsNext, TestTtsPause, TestTtsPlay, TestTtsPrev, TestTtsResume, TestTtsStop, TestView, TestViewToggle, type TtsContext, ttsContext };

package/dist/test.js

@@ -1,14 +1,20 @@
+import "./chunk-CAO4JRLY.js";
 import {
   QtiAssessmentItemRef,
   QtiAssessmentSection,
   QtiAssessmentTest,
+  QtiOutcomeProcessing,
+  QtiOutcomeProcessingProcessor,
   QtiTest,
   QtiTestFeedback,
   QtiTestPart,
+  QtiTestVariables,
+  QtiTestVariablesExpression,
   TestCheckItem,
   TestContainer,
   TestEndAttempt,
   TestItemLink,
+  TestItemToSpeech,
   TestNavigation,
   TestNext,
   TestPagingButtonsStamp,
@@ -19,28 +25,39 @@ import {
   TestScoringFeedback,
   TestSectionButtonsStamp,
   TestSectionLink,
-  TestShowCorrectResponse,
   TestStamp,
+  TestTtsNext,
+  TestTtsPause,
+  TestTtsPlay,
+  TestTtsPrev,
+  TestTtsResume,
+  TestTtsStop,
   TestView,
-  TestViewToggle
-} from "./chunk-HFCZFWSH.js";
-import "./chunk-WDO2TRFM.js";
-import "./chunk-FLJAKWXL.js";
-import "./chunk-AQ5RJFM6.js";
-import "./chunk-3WBG257S.js";
-import "./chunk-3XV26R5M.js";
-import "./chunk-QXBXORM3.js";
+  TestViewToggle,
+  ttsContext
+} from "./chunk-RXGDQDOV.js";
+import "./chunk-WVVMNF74.js";
+import "./chunk-X3E5HXG2.js";
+import "./chunk-7HC5SMCU.js";
+import "./chunk-64XSIBGO.js";
+import "./chunk-IJD53WY6.js";
+import "./chunk-H3J7LFRO.js";
 export {
   QtiAssessmentItemRef,
   QtiAssessmentSection,
   QtiAssessmentTest,
+  QtiOutcomeProcessing,
+  QtiOutcomeProcessingProcessor,
   QtiTest,
   QtiTestFeedback,
   QtiTestPart,
+  QtiTestVariables,
+  QtiTestVariablesExpression,
   TestCheckItem,
   TestContainer,
   TestEndAttempt,
   TestItemLink,
+  TestItemToSpeech,
   TestNavigation,
   TestNext,
   TestPagingButtonsStamp,
@@ -51,9 +68,15 @@ export {
   TestScoringFeedback,
   TestSectionButtonsStamp,
   TestSectionLink,
-  TestShowCorrectResponse,
   TestStamp,
+  TestTtsNext,
+  TestTtsPause,
+  TestTtsPlay,
+  TestTtsPrev,
+  TestTtsResume,
+  TestTtsStop,
   TestView,
-  TestViewToggle
+  TestViewToggle,
+  ttsContext
 };
 //# sourceMappingURL=test.js.map

package/dist/transformers.d.ts

@@ -1,4 +1,4 @@
-export { M as ModuleResolutionConfig, q as qtiTransformItem, a as qtiTransformTest, t as transformItemApi, b as transformTestApi } from './qti-transform-test-DoZaWItm.js';
+export { M as ModuleResolutionConfig, q as qtiTransformItem, a as qtiTransformTest, t as transformItemApi, b as transformTestApi } from './qti-transform-test.d-BL7GGFJj.js';
 
 declare const qtiTransformManifest: () => {
     load: (uri: string, signal?: AbortSignal) => Promise<{

package/dist/transformers.js

@@ -2,8 +2,7 @@ import {
   qtiTransformItem,
   qtiTransformManifest,
   qtiTransformTest
-} from "./chunk-3WBG257S.js";
-import "./chunk-QXBXORM3.js";
+} from "./chunk-IJD53WY6.js";
 export {
   qtiTransformItem,
   qtiTransformManifest,