@citolab/qti-components 7.3.23 → 7.4.0

package/dist/chunks/chunk-TJ6ZOT7A.js

@@ -0,0 +1,2235 @@
+import {
+  item_default
+} from "./chunk-LSEB52SP.js";
+import {
+  INITIAL_TEST_CONTEXT,
+  QtiModalFeedback,
+  qtiContext,
+  testContext
+} from "./chunk-GUDRSXIP.js";
+import {
+  configContext,
+  watch
+} from "./chunk-O5N4DCU6.js";
+import {
+  __decorateClass,
+  qtiTransformItem,
+  qtiTransformTest
+} from "./chunk-JDY5GL7E.js";
+
+// src/lib/qti-test/core/qti-test.ts
+import { html } from "lit";
+import { customElement } from "lit/decorators.js";
+
+// src/lib/qti-test/core/mixins/test-navigation.mixin.ts
+import { property } from "lit/decorators.js";
+var NavigationErrorType = /* @__PURE__ */ ((NavigationErrorType2) => {
+  NavigationErrorType2["ITEM_NOT_FOUND"] = "item-not-found";
+  NavigationErrorType2["SECTION_NOT_FOUND"] = "section-not-found";
+  NavigationErrorType2["LOAD_ERROR"] = "load-error";
+  NavigationErrorType2["NETWORK_ERROR"] = "network-error";
+  NavigationErrorType2["TIMEOUT_ERROR"] = "timeout-error";
+  return NavigationErrorType2;
+})(NavigationErrorType || {});
+var TestNavigationMixin = (superClass) => {
+  class TestNavigationClass extends superClass {
+    constructor(...args) {
+      super(...args);
+      this.navigate = null;
+      this.cacheTransform = false;
+      this.requestTimeout = 3e4;
+      this.showLoadingIndicators = true;
+      this.postLoadTransformCallback = null;
+      this._navigationInProgress = false;
+      this._activeRequests = [];
+      this._lastError = null;
+      this._lastNavigationRequestId = null;
+      this._targetNavigation = null;
+      this.addEventListener(
+        "qti-request-navigation",
+        async ({ detail }) => {
+          if (!detail?.id) return;
+          const navigationRequestId = `nav_${Date.now()}_${Math.random()}`;
+          this._lastNavigationRequestId = navigationRequestId;
+          try {
+            this._navigationInProgress = true;
+            this._lastError = null;
+            this._dispatchStatusEvent({ loading: true, type: detail.type, id: detail.id });
+            this._cancelActiveRequests();
+            this._targetNavigation = { type: detail.type, id: detail.id };
+            if (detail.type === "item") {
+              await this._navigateToItem(detail.id);
+            } else if (detail.type === "section") {
+              await this._navigateToSection(detail.id);
+            }
+            if (this._lastNavigationRequestId !== navigationRequestId) {
+              console.log("Navigation was superseded by a newer request");
+              return;
+            }
+          } catch (error) {
+            if (this._lastNavigationRequestId === navigationRequestId) {
+              const navError = this._normalizeError(error, detail.type, detail.id);
+              this._lastError = navError;
+              this._dispatchErrorEvent(navError);
+              console.error(`Navigation error (${navError.type}):`, navError.message, navError.details);
+            }
+          } finally {
+            if (this._lastNavigationRequestId === navigationRequestId) {
+              this._navigationInProgress = false;
+              this._dispatchStatusEvent({ loading: false, type: detail.type, id: detail.id });
+            }
+          }
+        }
+      );
+      this.addEventListener("qti-assessment-test-connected", (e) => {
+        this._testElement = e.detail;
+        this._initializeNavigation();
+      });
+    }
+    /**
+     * Initialize navigation when test is first connected
+     */
+    _initializeNavigation() {
+      let id;
+      if (this.navigate === "section") {
+        id = this._testElement.querySelector("qti-assessment-section")?.identifier;
+      }
+      if (this.navigate === "item") {
+        id = this.sessionContext.navItemRefId ?? this._testElement.querySelector("qti-assessment-item-ref")?.identifier;
+      }
+      if (id) {
+        this.dispatchEvent(
+          new CustomEvent("qti-request-navigation", {
+            detail: { type: this.navigate === "section" ? "section" : "item", id },
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    }
+    navigateTo(type, id) {
+      if (!id) {
+        if (type === "section") {
+          id = this._testElement?.querySelector("qti-assessment-section")?.identifier;
+        }
+        if (type === "item") {
+          id = this._testElement?.querySelector("qti-assessment-item-ref")?.identifier;
+        }
+      }
+      this.dispatchEvent(
+        new CustomEvent("qti-request-navigation", {
+          detail: { type, id },
+          bubbles: true,
+          composed: true
+        })
+      );
+    }
+    /**
+     * Navigates to a specific item
+     */
+    async _navigateToItem(itemId) {
+      const itemRefEl = this._testElement?.querySelector(
+        `qti-assessment-item-ref[identifier="${itemId}"]`
+      );
+      if (!itemRefEl) {
+        throw {
+          type: "item-not-found" /* ITEM_NOT_FOUND */,
+          message: `Item with identifier "${itemId}" not found.`,
+          itemId
+        };
+      }
+      const navPartId = itemRefEl.closest("qti-test-part")?.identifier;
+      const navSectionId = itemRefEl.closest("qti-assessment-section")?.identifier;
+      this.sessionContext = {
+        ...this.sessionContext,
+        navPartId,
+        navSectionId,
+        navItemRefId: itemId,
+        navItemLoading: true
+      };
+      try {
+        await this._loadItems([itemId]);
+      } finally {
+        this.sessionContext = {
+          ...this.sessionContext,
+          navItemLoading: false
+        };
+      }
+    }
+    /**
+     * Navigates to a specific section
+     */
+    async _navigateToSection(sectionId) {
+      const sectionRefEl = this._testElement?.querySelector(
+        `qti-assessment-section[identifier="${sectionId}"]`
+      );
+      if (!sectionRefEl) {
+        throw {
+          type: "section-not-found" /* SECTION_NOT_FOUND */,
+          message: `Section with identifier "${sectionId}" not found.`,
+          sectionId
+        };
+      }
+      const navPartId = sectionRefEl.closest("qti-test-part")?.identifier;
+      this.sessionContext = {
+        ...this.sessionContext,
+        navPartId,
+        navSectionId: sectionId,
+        navItemRefId: null,
+        navItemLoading: true
+      };
+      try {
+        const itemIds = this._getSectionItemIds(sectionId);
+        await this._loadItems(itemIds);
+      } finally {
+        this.sessionContext = {
+          ...this.sessionContext,
+          navItemLoading: false
+        };
+      }
+    }
+    /**
+     * Normalize different error types into a consistent NavigationError format
+     */
+    _normalizeError(error, navigationType, id) {
+      if (error && error.type && Object.values(NavigationErrorType).includes(error.type)) {
+        return error;
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        return {
+          type: "network-error" /* NETWORK_ERROR */,
+          message: "Navigation was cancelled because a new navigation was requested.",
+          details: error
+        };
+      }
+      if (error.name === "TimeoutError" || error.message && error.message.includes("timeout")) {
+        return {
+          type: "timeout-error" /* TIMEOUT_ERROR */,
+          message: "Request timed out. Please check your network connection.",
+          details: error
+        };
+      }
+      if (error instanceof TypeError && error.message.includes("network")) {
+        return {
+          type: "network-error" /* NETWORK_ERROR */,
+          message: "A network error occurred. Please check your connection.",
+          details: error
+        };
+      }
+      return {
+        type: "load-error" /* LOAD_ERROR */,
+        message: `Failed to load ${navigationType}: ${id}`,
+        details: error,
+        itemId: navigationType === "item" ? id : void 0,
+        sectionId: navigationType === "section" ? id : void 0
+      };
+    }
+    /**
+     * Dispatch error event to notify the UI
+     */
+    _dispatchErrorEvent(error) {
+      this.dispatchEvent(
+        new CustomEvent("qti-navigation-error", {
+          detail: error,
+          bubbles: true,
+          composed: true
+        })
+      );
+    }
+    /**
+     * Dispatch status event to indicate loading state
+     */
+    _dispatchStatusEvent(status) {
+      if (this.showLoadingIndicators) {
+        this.dispatchEvent(
+          new CustomEvent("qti-navigation-status", {
+            detail: status,
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    }
+    /**
+     * Cancels all active HTTP requests
+     */
+    _cancelActiveRequests() {
+      if (this._activeRequests.length > 0) {
+        console.info(`Cancelling ${this._activeRequests.length} pending requests`);
+        this._activeRequests.forEach((request) => {
+          if (request && request.readyState !== 4) {
+            request.abort();
+          }
+        });
+        this._activeRequests = [];
+      }
+    }
+    /**
+     * Load items with improved error handling and timeout
+     */
+    async _loadItems(itemIds) {
+      if (!this._testElement || itemIds.length === 0) return;
+      const itemRefEls = itemIds.map(
+        (id) => this._testElement.querySelector(`qti-assessment-item-ref[identifier="${id}"]`)
+      );
+      const missingItems = itemRefEls.reduce((missing, el, index) => {
+        if (!el) missing.push(itemIds[index]);
+        return missing;
+      }, []);
+      if (missingItems.length > 0) {
+        const error = {
+          type: "item-not-found" /* ITEM_NOT_FOUND */,
+          message: `One or more items not found: ${missingItems.join(", ")}`,
+          details: { missingItems }
+        };
+        throw error;
+      }
+      this._clearLoadedItems();
+      const itemLoadPromises = itemRefEls.map(async (itemRef) => {
+        if (!itemRef) return null;
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject({
+              name: "TimeoutError",
+              message: `Request for item ${itemRef.identifier} timed out after ${this.requestTimeout}ms`
+            });
+          }, this.requestTimeout);
+        });
+        try {
+          const { promise, request } = qtiTransformItem(this.cacheTransform).load(itemRef.href);
+          if (request instanceof XMLHttpRequest) {
+            this._activeRequests.push(request);
+          }
+          const loadedTransformer = await Promise.race([promise, timeoutPromise]);
+          let finalTransformer = loadedTransformer;
+          console.log(`Loaded item 123: ${itemRef.identifier}`);
+          if (this.postLoadTransformCallback) {
+            finalTransformer = await this.postLoadTransformCallback(loadedTransformer, itemRef);
+          }
+          return {
+            itemRef,
+            doc: finalTransformer.htmlDoc(),
+            request
+          };
+        } catch (error) {
+          if (error instanceof DOMException && error.name === "AbortError" || error && error.name === "TimeoutError") {
+            console.log(
+              `Request for item ${itemRef.identifier} was ${error.name === "TimeoutError" ? "timed out" : "aborted"}`
+            );
+            return null;
+          }
+          error.itemId = itemRef.identifier;
+          throw error;
+        }
+      });
+      try {
+        const results = await Promise.all(itemLoadPromises);
+        const validResults = results.filter((result) => result !== null);
+        validResults.forEach(({ itemRef, doc }) => {
+          if (itemRef && doc) itemRef.xmlDoc = doc;
+        });
+        this._activeRequests = [];
+        requestAnimationFrame(() => {
+          this.dispatchEvent(
+            new CustomEvent("qti-test-loaded", {
+              detail: validResults.map(({ itemRef }) => ({
+                identifier: itemRef?.identifier,
+                element: itemRef
+              })),
+              bubbles: true,
+              composed: true
+            })
+          );
+        });
+        if (validResults.length === 0 && itemIds.length > 0) {
+          throw {
+            type: "load-error" /* LOAD_ERROR */,
+            message: "All item requests failed to load",
+            details: { itemIds }
+          };
+        }
+        return validResults;
+      } catch (error) {
+        console.error("Error loading items:", error);
+        throw error;
+      }
+    }
+    /**
+     * Gets all item IDs in a section
+     */
+    _getSectionItemIds(navSectionId) {
+      const sectionRefEl = this._testElement?.querySelector(
+        `qti-assessment-section[identifier="${navSectionId}"]`
+      );
+      if (!sectionRefEl) {
+        throw {
+          type: "section-not-found" /* SECTION_NOT_FOUND */,
+          message: `Section with identifier "${navSectionId}" not found.`,
+          sectionId: navSectionId
+        };
+      }
+      return Array.from(
+        this._testElement.querySelectorAll(
+          `qti-assessment-section[identifier="${navSectionId}"] > qti-assessment-item-ref`
+        )
+      ).map((itemRef) => itemRef.identifier);
+    }
+    /**
+     * Clears all loaded items
+     */
+    _clearLoadedItems() {
+      const itemRefEls = this._testElement?.querySelectorAll(
+        `qti-assessment-test qti-assessment-item-ref`
+      );
+      Array.from(itemRefEls || []).forEach((itemElement) => {
+        itemElement.xmlDoc = null;
+      });
+    }
+    /**
+     * Retry the last failed navigation
+     */
+    retryNavigation() {
+      if (this._lastError) {
+        const type = this._lastError.itemId ? "item" : "section";
+        const id = this._lastError.itemId || this._lastError.sectionId;
+        if (id) {
+          this.dispatchEvent(
+            new CustomEvent("qti-request-navigation", {
+              detail: { type, id },
+              bubbles: true,
+              composed: true
+            })
+          );
+        }
+      } else if (this._targetNavigation) {
+        this.dispatchEvent(
+          new CustomEvent("qti-request-navigation", {
+            detail: this._targetNavigation,
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    }
+  }
+  __decorateClass([
+    property({ type: String })
+  ], TestNavigationClass.prototype, "navigate", 2);
+  __decorateClass([
+    property({ type: Boolean, attribute: "cache-transform" })
+  ], TestNavigationClass.prototype, "cacheTransform", 2);
+  __decorateClass([
+    property({ type: Number })
+  ], TestNavigationClass.prototype, "requestTimeout", 2);
+  __decorateClass([
+    property({ type: Boolean })
+  ], TestNavigationClass.prototype, "showLoadingIndicators", 2);
+  __decorateClass([
+    property({ type: Function })
+  ], TestNavigationClass.prototype, "postLoadTransformCallback", 2);
+  return TestNavigationClass;
+};
+
+// src/lib/qti-test/core/mixins/test-view.mixin.ts
+var TestViewMixin = (superClass) => {
+  class TestViewClass extends superClass {
+    constructor(...args) {
+      super(...args);
+      this.sessionContext = { ...this.sessionContext, view: "candidate" };
+      this.addEventListener("on-test-switch-view", (e) => {
+        this.sessionContext = { ...this.sessionContext, view: e.detail };
+        this._updateElementView();
+      });
+      this.addEventListener("qti-assessment-test-connected", () => {
+        this._updateElementView();
+      });
+      this.addEventListener("qti-assessment-item-connected", (e) => {
+        this._updateElementView();
+        this._setCorrectResponseVisibility(e.detail);
+      });
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("sessionContext")) {
+        this._updateElementView();
+      }
+    }
+    // Method to handle view updates for elements based on the current context view
+    _updateElementView() {
+      if (this._testElement) {
+        const viewElements = Array.from(this._testElement.querySelectorAll("[view]"));
+        viewElements.forEach((element) => {
+          element.classList.toggle("show", element.getAttribute("view") === this.sessionContext.view);
+        });
+        const assessmentItemRef = this._testElement.querySelector(
+          `qti-assessment-item-ref[identifier="${this.sessionContext.navItemRefId}"]`
+        );
+        const assessmentItem = assessmentItemRef?.assessmentItem;
+        if (assessmentItem) {
+          assessmentItem.showCorrectResponse(this.sessionContext.view === "scorer");
+        }
+      }
+    }
+    // Event handler for connected QTI assessment items
+    _setCorrectResponseVisibility(assessmentItem) {
+      assessmentItem.showCorrectResponse(this.sessionContext.view === "scorer");
+    }
+  }
+  return TestViewClass;
+};
+
+// src/lib/qti-test/core/test-base.ts
+import { provide } from "@lit/context";
+import { LitElement } from "lit";
+import { property as property2 } from "lit/decorators.js";
+
+// src/lib/exports/session.context.ts
+import { createContext } from "@lit/context";
+var INITIAL_SESSION_CONTEXT = { view: "candidate" };
+var sessionContext = createContext(Symbol("testContext"));
+
+// src/lib/qti-test/core/test-base.ts
+var TestBase = class extends LitElement {
+  constructor() {
+    super();
+    this.testContext = INITIAL_TEST_CONTEXT;
+    this.sessionContext = INITIAL_SESSION_CONTEXT;
+    /**
+     * Updates the variables of an assessment item in the test context.
+     * - Matches the assessment item with the corresponding test context item.
+     * - If the item is not found, logs a warning.
+     * - Updates variables in the test context if exactly one variable exists.
+     * - Otherwise, syncs the assessment item's variables with the test context.
+     *
+     * @param assessmentItem - The assessment item to update.
+     */
+    this._updateItemInTestContext = (assessmentItem) => {
+      const context = assessmentItem._context;
+      const identifier = context.identifier;
+      const fullVariables = context.variables;
+      const itemContext = this.testContext.items.find((i) => i?.identifier === identifier);
+      if (!itemContext) {
+        console.warn(`Item IDs between assessment.xml and item.xml should match: ${identifier} is not found!`);
+        return;
+      }
+      if (itemContext.variables?.length === 1) {
+        this._updateItemVariablesInTestContext(identifier, fullVariables);
+      } else {
+        assessmentItem.variables = [...itemContext.variables || []];
+      }
+    };
+    this.addEventListener("qti-assessment-test-connected", (e) => {
+      this.testContext = INITIAL_TEST_CONTEXT;
+      this.sessionContext = INITIAL_SESSION_CONTEXT;
+      if (this.testContext && this.testContext.items.length > 0) return;
+      this._testElement = e.detail;
+      const items = Array.from(this._testElement.querySelectorAll("qti-assessment-item-ref")).map((itemRef) => {
+        return {
+          href: itemRef.href,
+          identifier: itemRef.identifier,
+          category: itemRef.category,
+          variables: [
+            {
+              identifier: "completionStatus",
+              value: "not_attempted",
+              type: "outcome"
+            }
+          ]
+        };
+      });
+      this.testContext = { ...this.testContext, items };
+    });
+    this.addEventListener("qti-assessment-item-connected", (e) => {
+      const assessmentItem = e.detail;
+      const assessmentRefId = assessmentItem.closest("qti-assessment-item-ref")?.identifier;
+      if (assessmentRefId) {
+        assessmentItem.assessmentItemRefId = assessmentRefId;
+      }
+      this._updateItemInTestContext(e.detail);
+    });
+    this.addEventListener("qti-item-context-updated", (e) => {
+      this._updateItemVariablesInTestContext(e.detail.itemContext.identifier, e.detail.itemContext.variables);
+    });
+  }
+  updateItemVariables(itemRefID, variables) {
+    const itemContext = this.testContext.items.find((item) => item.identifier === itemRefID);
+    if (itemContext) {
+      itemContext.variables = itemContext.variables.map((variable) => {
+        const updatedVariable = variables.find((v) => v.identifier === variable.identifier);
+        return updatedVariable ? { ...variable, ...updatedVariable } : variable;
+      });
+    }
+    const itemRef = this._testElement.querySelector(
+      `qti-assessment-item-ref[identifier="${itemRefID}"]`
+    );
+    if (itemRef && itemRef.assessmentItem) {
+      if (itemRef.assessmentItem) {
+        itemRef.assessmentItem.variables = variables;
+      }
+    }
+  }
+  _updateItemVariablesInTestContext(identifier, variables) {
+    this.testContext = {
+      ...this.testContext,
+      // Spread existing test context properties
+      items: this.testContext.items.map((itemContext) => {
+        if (itemContext.identifier !== identifier) {
+          return itemContext;
+        }
+        return {
+          ...itemContext,
+          // Keep other properties of the item context
+          variables: variables.map((variable) => {
+            const matchingVariable = itemContext.variables.find((v) => v.identifier === variable.identifier);
+            return matchingVariable ? { ...matchingVariable, ...variable } : variable;
+          })
+        };
+      })
+    };
+    this.dispatchEvent(
+      new CustomEvent("qti-test-context-updated", { detail: this.testContext, bubbles: false, composed: false })
+    );
+  }
+};
+__decorateClass([
+  property2({ attribute: false, type: Object }),
+  provide({ context: testContext })
+], TestBase.prototype, "testContext", 2);
+__decorateClass([
+  property2({ attribute: false, type: Object }),
+  provide({ context: sessionContext })
+], TestBase.prototype, "sessionContext", 2);
+
+// src/lib/qti-test/core/mixins/test-processing.mixin.ts
+var TestProcessingMixin = (superClass) => {
+  class TestProcessingElement extends superClass {
+    constructor(...args) {
+      super(...args);
+      this.addEventListener("qti-register-variable", (e) => {
+        this.testContext = {
+          ...this.testContext,
+          testOutcomeVariables: [...this.testContext.testOutcomeVariables || [], e.detail.variable]
+        };
+        e.stopPropagation();
+      });
+      this.addEventListener(
+        "qti-set-outcome-value",
+        (e) => {
+          const { outcomeIdentifier, value } = e.detail;
+          this.updateOutcomeVariable(outcomeIdentifier, value);
+          e.stopPropagation();
+        }
+      );
+    }
+    outcomeProcessing() {
+      const outcomeProcessor = this.querySelector("qti-outcome-processing");
+      if (!outcomeProcessor) return false;
+      outcomeProcessor?.process();
+      return true;
+    }
+    /* --------------------------- ENABLED WHEN UNIT TESTING OUTCOME PROCESSING ------------------------------------ */
+    updateOutcomeVariable(identifier, value) {
+      const outcomeVariable = this.getOutcome(identifier);
+      if (!outcomeVariable) {
+        console.warn(`Can not set qti-outcome-identifier: ${identifier}, it is not available`);
+        return;
+      }
+      this.testContext = {
+        ...this.testContext,
+        testOutcomeVariables: this.testContext.testOutcomeVariables?.map((v) => {
+          if (v.identifier !== identifier) {
+            return v;
+          }
+          return {
+            ...v,
+            value: outcomeVariable.cardinality === "single" ? value : [...v.value, value]
+          };
+        })
+      };
+    }
+    getOutcome(identifier) {
+      return this.getVariable(identifier);
+    }
+    getVariable(identifier) {
+      return this.testContext.testOutcomeVariables?.find((v) => v.identifier === identifier) || null;
+    }
+    /* --------------------------- ENABLED WHEN UNIT TESTING OUTCOME PROCESSING ------------------------------------ */
+  }
+  return TestProcessingElement;
+};
+
+// src/lib/qti-test/core/qti-test.ts
+var QtiTest = class extends TestNavigationMixin(TestViewMixin(TestProcessingMixin(TestBase))) {
+  // export class QtiTest extends TestLoaderMixin(TestNavigationMixin(TestViewMixin(TestBase))) {
+  /**
+   * Renders the component's template.
+   * Provides a default `<slot>` for content projection.
+   */
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(new CustomEvent("qti-test-connected", { detail: this }));
+  }
+  render() {
+    return html`<slot></slot>`;
+  }
+};
+QtiTest = __decorateClass([
+  customElement("qti-test")
+], QtiTest);
+
+// src/lib/qti-test/core/qti-assessment-test/qti-assessment-item-ref.ts
+import { LitElement as LitElement2 } from "lit";
+import { property as property3 } from "lit/decorators.js";
+import { prepareTemplate } from "@heximal/templates";
+var stringToBooleanConverter = {
+  fromAttribute(value) {
+    return value === "true";
+  },
+  toAttribute(value) {
+    return value ? "true" : "false";
+  }
+};
+var QtiAssessmentItemRef = class extends LitElement2 {
+  constructor() {
+    super(...arguments);
+    // @consume({ context: computedContext, subscribe: true })
+    // private computedContext: ComputedContext;
+    this.weigths = /* @__PURE__ */ new Map();
+  }
+  // the XMLDocument
+  createRenderRoot() {
+    return this;
+  }
+  get assessmentItem() {
+    return this.renderRoot?.querySelector("qti-assessment-item");
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.getRootNode().host.closest("qti-test").querySelector("template[item-ref]");
+    if (templateElement) this.myTemplate = prepareTemplate(templateElement);
+    await this.updateComplete;
+    this.dispatchEvent(
+      new CustomEvent("qti-assessment-item-ref-connected", {
+        bubbles: true,
+        composed: true,
+        detail: { identifier: this.identifier, href: this.href, category: this.category }
+      })
+    );
+  }
+  render() {
+    return this.myTemplate ? this.myTemplate({ xmlDoc: this.xmlDoc }) : this.xmlDoc;
+  }
+};
+__decorateClass([
+  property3({ type: String })
+], QtiAssessmentItemRef.prototype, "category", 2);
+__decorateClass([
+  property3({ type: String })
+], QtiAssessmentItemRef.prototype, "identifier", 2);
+__decorateClass([
+  property3({ type: Boolean, converter: stringToBooleanConverter })
+], QtiAssessmentItemRef.prototype, "required", 2);
+__decorateClass([
+  property3({ type: Boolean, converter: stringToBooleanConverter })
+], QtiAssessmentItemRef.prototype, "fixed", 2);
+__decorateClass([
+  property3({ type: String })
+], QtiAssessmentItemRef.prototype, "href", 2);
+__decorateClass([
+  property3({ type: Object, attribute: false })
+], QtiAssessmentItemRef.prototype, "xmlDoc", 2);
+if (!customElements.get("qti-assessment-item-ref")) {
+  customElements.define("qti-assessment-item-ref", QtiAssessmentItemRef);
+}
+
+// src/lib/qti-test/core/qti-assessment-test/qti-assessment-section.ts
+import { consume } from "@lit/context";
+import { html as html2, LitElement as LitElement3 } from "lit";
+import { property as property4 } from "lit/decorators.js";
+var stringToBooleanConverter2 = {
+  fromAttribute(value) {
+    return value === "true";
+  },
+  toAttribute(value) {
+    return value ? "true" : "false";
+  }
+};
+var QtiAssessmentSection = class extends LitElement3 {
+  constructor() {
+    super(...arguments);
+    this._title = "";
+  }
+  get title() {
+    return this._title;
+  }
+  set title(value) {
+    this._title = value;
+    this.removeAttribute("title");
+    this.setAttribute("data-title", value);
+  }
+  async connectedCallback() {
+    this._title = this.getAttribute("title") || "";
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(
+      new Event("qti-assessment-section-connected", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    return html2`<slot name="qti-rubric-block"></slot><slot></slot>`;
+  }
+};
+__decorateClass([
+  property4({ type: String })
+], QtiAssessmentSection.prototype, "identifier", 2);
+__decorateClass([
+  property4({ type: String })
+], QtiAssessmentSection.prototype, "required", 2);
+__decorateClass([
+  property4({ type: Boolean, converter: stringToBooleanConverter2 })
+], QtiAssessmentSection.prototype, "fixed", 2);
+__decorateClass([
+  property4({ type: Boolean, converter: stringToBooleanConverter2 })
+], QtiAssessmentSection.prototype, "visible", 2);
+__decorateClass([
+  property4({ type: Boolean, converter: stringToBooleanConverter2, attribute: "keep-together" })
+], QtiAssessmentSection.prototype, "keepTogether", 2);
+__decorateClass([
+  consume({ context: testContext, subscribe: true })
+], QtiAssessmentSection.prototype, "_testContext", 2);
+if (!customElements.get("qti-assessment-section")) {
+  customElements.define("qti-assessment-section", QtiAssessmentSection);
+}
+
+// src/lib/qti-test/core/qti-assessment-test/qti-assessment-test.ts
+import { consume as consume2 } from "@lit/context";
+import { html as html3, LitElement as LitElement4 } from "lit";
+import { customElement as customElement2, property as property5 } from "lit/decorators.js";
+var QtiAssessmentTest = class extends LitElement4 {
+  constructor() {
+    super(...arguments);
+    this._title = "";
+  }
+  get title() {
+    return this._title;
+  }
+  set title(value) {
+    this._title = value;
+    this.removeAttribute("title");
+    this.setAttribute("data-title", value);
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(
+      new CustomEvent("qti-assessment-test-connected", {
+        detail: this,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    return html3` <slot></slot>`;
+  }
+};
+__decorateClass([
+  property5({ type: String })
+], QtiAssessmentTest.prototype, "identifier", 2);
+__decorateClass([
+  property5({ type: String })
+], QtiAssessmentTest.prototype, "title", 1);
+__decorateClass([
+  consume2({ context: testContext, subscribe: true })
+], QtiAssessmentTest.prototype, "_testContext", 2);
+QtiAssessmentTest = __decorateClass([
+  customElement2("qti-assessment-test")
+], QtiAssessmentTest);
+
+// src/lib/qti-test/core/qti-assessment-test/qti-test-part.ts
+import { html as html4, LitElement as LitElement5 } from "lit";
+import { customElement as customElement3, property as property6 } from "lit/decorators.js";
+var QtiTestPart = class extends LitElement5 {
+  constructor() {
+    super(...arguments);
+    this.identifier = "";
+    this.class = "";
+    this.navigationMode = "nonlinear";
+    this.submissionMode = "individual";
+    this._title = "";
+  }
+  get title() {
+    return this._title;
+  }
+  set title(value) {
+    this._title = value;
+    this.removeAttribute("title");
+    this.setAttribute("data-title", value);
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(
+      new Event("qti-test-part-connected", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    return html4` <slot></slot>`;
+  }
+};
+__decorateClass([
+  property6({ type: String })
+], QtiTestPart.prototype, "identifier", 2);
+__decorateClass([
+  property6({ type: String })
+], QtiTestPart.prototype, "class", 2);
+__decorateClass([
+  property6({ type: String, attribute: "navigation-mode" })
+], QtiTestPart.prototype, "navigationMode", 2);
+__decorateClass([
+  property6({ type: String, attribute: "submission-mode" })
+], QtiTestPart.prototype, "submissionMode", 2);
+QtiTestPart = __decorateClass([
+  customElement3("qti-test-part")
+], QtiTestPart);
+if (!customElements.get("qti-test-part")) {
+  customElements.define("qti-test-part", QtiTestPart);
+}
+
+// src/lib/qti-test/core/qti-assessment-test/qti-test-feedback.ts
+import { customElement as customElement4 } from "lit/decorators.js";
+import { css, html as html5 } from "lit";
+var QtiTestFeedback = class extends QtiModalFeedback {
+  render() {
+    return html5``;
+  }
+};
+QtiTestFeedback.styles = css`
+    :host {
+      color: gray;
+    }
+  `;
+QtiTestFeedback = __decorateClass([
+  customElement4("qti-test-feedback")
+], QtiTestFeedback);
+
+// src/lib/qti-test/components/test-navigation.ts
+import { consume as consume3, provide as provide2 } from "@lit/context";
+import { html as html6, LitElement as LitElement6 } from "lit";
+import { customElement as customElement5, property as property7, state } from "lit/decorators.js";
+
+// src/lib/exports/computed.context.ts
+import { createContext as createContext2 } from "@lit/context";
+var computedContext = createContext2(Symbol("computedContext"));
+
+// src/lib/qti-test/components/test-navigation.ts
+var TestNavigation = class extends LitElement6 {
+  constructor() {
+    super();
+    this.identifier = void 0;
+    this.initContext = [];
+    this.qtiContext = {
+      QTI_CONTEXT: {
+        testIdentifier: "",
+        candidateIdentifier: "",
+        environmentIdentifier: "default"
+      }
+    };
+    this.configContext = {};
+    this.autoScoreItems = false;
+    this.addEventListener("qti-assessment-test-connected", this._handleTestConnected.bind(this));
+    this.addEventListener("qti-assessment-item-connected", this._handleItemConnected.bind(this));
+    this.addEventListener("qti-interaction-changed", this._handleInteractionChanged.bind(this));
+    this.addEventListener("test-end-attempt", this._handleTestEndAttempt.bind(this));
+    this.addEventListener("test-show-correct-response", this._handleTestShowCorrectResponse.bind(this));
+    this.addEventListener("test-show-candidate-correction", this._handleTestShowCandidateCorrection.bind(this));
+    this.addEventListener("test-update-outcome-variable", this._handleTestUpdateOutcomeVariable.bind(this));
+  }
+  /**
+   * Handles the 'test-end-attempt' event.
+   * @private
+   * @listens TestNavigation#test-end-attempt
+   * @param {CustomEvent} event - The custom event object.
+   */
+  _handleTestEndAttempt(_event) {
+    const qtiItemEl = this._testElement.querySelector(
+      `qti-assessment-item-ref[identifier="${this._sessionContext.navItemRefId}"]`
+    );
+    const qtiAssessmentItemEl = qtiItemEl.assessmentItem;
+    const reportValidityAfterScoring = this.configContext?.reportValidityAfterScoring === true ? true : false;
+    qtiAssessmentItemEl.processResponse(true, reportValidityAfterScoring);
+  }
+  // protected createRenderRoot(): HTMLElement | DocumentFragment {
+  //   return this;
+  // }
+  // myTemplate: TemplateFunction;
+  // connectedCallback(): void {
+  //   super.connectedCallback();
+  //   const templateElement = this.querySelector<HTMLTemplateElement>('template');
+  //   if (!templateElement) {
+  //     this.myTemplate = null;
+  //     return;
+  //   }
+  //   this.myTemplate = prepareTemplate(templateElement);
+  // }
+  /**
+   * Handles the 'test-show-correct-response' event.
+   * @private
+   * @listens TestNavigation#test-show-correct-response
+   * @param {CustomEvent} event - The custom event object.
+   */
+  _handleTestShowCorrectResponse(event) {
+    const qtiItemEl = this._testElement.querySelector(
+      `qti-assessment-item-ref[identifier="${this._sessionContext.navItemRefId}"]`
+    );
+    const qtiAssessmentItemEl = qtiItemEl.assessmentItem;
+    if (!qtiAssessmentItemEl) return;
+    qtiAssessmentItemEl.showCorrectResponse(event.detail);
+  }
+  /**
+   * Handles the 'test-show-candidate-correction' event.
+   * @private
+   * @listens TestNavigation#test-show-candidate-correction
+   * @param {CustomEvent} event - The custom event object.
+   */
+  _handleTestShowCandidateCorrection(event) {
+    const qtiItemEl = this._testElement.querySelector(
+      `qti-assessment-item-ref[identifier="${this._sessionContext.navItemRefId}"]`
+    );
+    const qtiAssessmentItemEl = qtiItemEl.assessmentItem;
+    qtiAssessmentItemEl.showCandidateCorrection(event.detail);
+  }
+  _handleTestUpdateOutcomeVariable(event) {
+    const qtiItemEl = this._testElement.querySelector(
+      `qti-assessment-item-ref[identifier="${event.detail.assessmentItemRefId}"]`
+    );
+    const qtiAssessmentItemEl = qtiItemEl.assessmentItem;
+    qtiAssessmentItemEl.setOutcomeVariable(event.detail.outcomeVariableId, event.detail.value);
+  }
+  _handleInteractionChanged(_event) {
+    if (this.autoScoreItems) {
+      const assessmentItem = _event.composedPath()[0].closest("qti-assessment-item");
+      const scoreOutcomeIdentifier = assessmentItem.variables.find((v) => v.identifier === "SCORE");
+      if (scoreOutcomeIdentifier && scoreOutcomeIdentifier.externalScored === null && assessmentItem.adaptive === "false") {
+        const reportValidityAfterScoring = this.configContext?.reportValidityAfterScoring === true ? true : false;
+        assessmentItem.processResponse(true, reportValidityAfterScoring);
+      }
+    }
+  }
+  render() {
+    return html6`<slot></slot>`;
+  }
+  /* PK: on test connected we can build the computed context */
+  _handleTestConnected(event) {
+    this._testElement = event.detail;
+    if (!this.qtiContext.QTI_CONTEXT?.testIdentifier) {
+      const currentContext = this.qtiContext.QTI_CONTEXT || {
+        testIdentifier: "",
+        candidateIdentifier: "not set",
+        environmentIdentifier: "default"
+      };
+      this.qtiContext = {
+        QTI_CONTEXT: {
+          ...currentContext,
+          testIdentifier: this._testElement.identifier,
+          environmentIdentifier: currentContext.environmentIdentifier || "default"
+        }
+      };
+    }
+    const contextDeclarations = this._testElement.querySelectorAll('qti-context-declaration[identifier="QTI_CONTEXT"]');
+    contextDeclarations.forEach((declaration) => {
+      const defaultValues = this._extractDefaultValues(declaration);
+      if (Object.keys(defaultValues).length > 0) {
+        this.qtiContext = {
+          QTI_CONTEXT: {
+            ...defaultValues,
+            // Default values first
+            ...this.qtiContext.QTI_CONTEXT
+            // Runtime values override defaults
+          }
+        };
+      }
+    });
+    const testPartElements = Array.from(this._testElement?.querySelectorAll(`qti-test-part`) || []);
+    this.computedContext = {
+      identifier: this._testElement.identifier,
+      title: this._testElement.title,
+      view: this._sessionContext?.view,
+      testParts: testPartElements.map((testPart) => {
+        const sectionElements = [...testPart.querySelectorAll(`qti-assessment-section`)];
+        return {
+          active: false,
+          identifier: testPart.identifier,
+          navigationMode: testPart.navigationMode,
+          submissionMode: testPart.submissionMode,
+          sections: sectionElements.map((section) => {
+            const itemElements = [...section.querySelectorAll(`qti-assessment-item-ref`)];
+            return {
+              active: false,
+              identifier: section.identifier,
+              title: section.title,
+              items: itemElements.map((item) => ({
+                ...this.initContext?.find((i) => i.identifier === item.identifier),
+                active: false,
+                identifier: item.identifier,
+                categories: item.category ? item.category?.split(" ") : [],
+                href: item.href,
+                variables: []
+              }))
+            };
+          })
+        };
+      })
+    };
+  }
+  /**
+   * Extract default values from a qti-context-declaration element
+   */
+  _extractDefaultValues(declaration) {
+    const defaultValues = {};
+    const defaultValueElement = declaration.querySelector("qti-default-value");
+    if (!defaultValueElement) {
+      return defaultValues;
+    }
+    const valueElements = defaultValueElement.querySelectorAll("qti-value[field-identifier]");
+    valueElements.forEach((valueElement) => {
+      const fieldIdentifier = valueElement.getAttribute("field-identifier");
+      const baseType = valueElement.getAttribute("base-type") || "string";
+      const textContent = valueElement.textContent?.trim() || "";
+      if (fieldIdentifier) {
+        let value = textContent;
+        switch (baseType) {
+          case "integer":
+            value = parseInt(textContent, 10);
+            break;
+          case "float":
+          case "duration":
+            value = parseFloat(textContent);
+            break;
+          case "boolean":
+            value = textContent.toLowerCase() === "true";
+            break;
+          case "string":
+          default:
+            value = textContent;
+            break;
+        }
+        defaultValues[fieldIdentifier] = value;
+      }
+    });
+    return defaultValues;
+  }
+  /* PK: on item connected we can add item only properties in the xml */
+  _handleItemConnected(event) {
+    const itemElement = event.detail;
+    this.computedContext = {
+      ...this.computedContext,
+      testParts: this.computedContext.testParts.map((testPart) => {
+        return {
+          ...testPart,
+          sections: testPart.sections.map((section) => {
+            return {
+              ...section,
+              items: section.items.map((item) => {
+                if (item.identifier !== itemElement.parentElement.getAttribute("identifier")) {
+                  return item;
+                }
+                const scoreOutcome = itemElement.querySelector(
+                  "qti-outcome-declaration[identifier='SCORE']"
+                );
+                const externalScored = scoreOutcome?.getAttribute("externalScored");
+                const responseDeclarations = itemElement.querySelectorAll("qti-response-declaration");
+                const containsCorrectResponse = Array.from(responseDeclarations).some(
+                  (r) => r.querySelector("qti-correct-response")
+                );
+                const containsMapping = Array.from(responseDeclarations).some((r) => {
+                  const mapping = r.querySelector("qti-mapping");
+                  const areaMapping = r.querySelector("qti-area-mapping");
+                  return mapping?.querySelector("qti-map-entry") || areaMapping?.querySelector("qti-area-map-entry");
+                });
+                const hasCorrectResponse = containsCorrectResponse || containsMapping;
+                const hasResponseProcessing = itemElement.querySelector("qti-response-processing") ? true : false;
+                return {
+                  ...item,
+                  assessmentItemIdentifier: itemElement.getAttribute("identifier"),
+                  label: itemElement.getAttribute("label"),
+                  title: itemElement.title,
+                  externalScored,
+                  adaptive: itemElement.adaptive == "true" || false,
+                  timeDependent: itemElement.timeDependent == "true" || false,
+                  variables: itemElement.variables,
+                  hasCorrectResponse,
+                  hasResponseProcessing
+                };
+              })
+            };
+          })
+        };
+      })
+    };
+  }
+  /* PK: on every change of the candidate we will recomputed the computedContext */
+  willUpdate(_changedProperties) {
+    if (!this.computedContext) return;
+    let itemIndex = 1;
+    this.computedContext = {
+      ...this.computedContext,
+      view: this._sessionContext?.view,
+      testParts: this.computedContext.testParts.map((testPart) => {
+        return {
+          ...testPart,
+          active: this._sessionContext?.navPartId === testPart.identifier || false,
+          sections: testPart.sections.map((section) => {
+            return {
+              ...section,
+              active: this._sessionContext?.navSectionId === section.identifier || false,
+              completed: section.items.every(
+                (item) => this._testContext.items.find((i) => i.identifier === item.identifier)?.variables.find((v) => v.identifier === "completionStatus").value === "completed"
+              ),
+              items: section.items.map((item) => {
+                const itemContext = this._testContext?.items.find((i) => i.identifier === item.identifier);
+                const computedItem = {
+                  ...item,
+                  ...itemContext,
+                  ...this.initContext?.find((i) => i.identifier === item.identifier)
+                };
+                const rawscore = computedItem.variables?.find((vr) => vr.identifier == "SCORE")?.value;
+                const score = rawscore === void 0 || rawscore === null ? null : parseFloat(rawscore?.toString());
+                const completionStatus = computedItem.variables?.find((v) => v.identifier === "completionStatus")?.value;
+                const response = computedItem.variables?.find((v) => v.identifier === "RESPONSE")?.value || "";
+                const numAttempts = computedItem.variables?.find((v) => v.identifier === "numAttempts")?.value || 0;
+                const active = this._sessionContext?.navItemRefId === computedItem.identifier || false;
+                const index = item.categories.includes(this.configContext?.infoItemCategory) ? null : itemIndex++;
+                const rawMaxScore = item.variables?.find((vr) => vr.identifier == "MAXSCORE")?.value;
+                const maxScore = rawMaxScore === void 0 || rawMaxScore === null ? null : parseFloat(rawMaxScore?.toString());
+                return {
+                  ...computedItem,
+                  completionStatus,
+                  numAttempts,
+                  score,
+                  response,
+                  index,
+                  // type,
+                  active,
+                  // correct,
+                  maxScore
+                  // incorrect,
+                  // completed
+                };
+              })
+            };
+          })
+        };
+      })
+    };
+    this.dispatchEvent(
+      new CustomEvent("qti-computed-context-updated", {
+        detail: this.computedContext,
+        bubbles: true
+      })
+    );
+  }
+};
+__decorateClass([
+  property7({ type: String })
+], TestNavigation.prototype, "identifier", 2);
+__decorateClass([
+  state()
+], TestNavigation.prototype, "initContext", 2);
+__decorateClass([
+  state(),
+  provide2({ context: qtiContext })
+], TestNavigation.prototype, "qtiContext", 2);
+__decorateClass([
+  state(),
+  provide2({ context: configContext })
+], TestNavigation.prototype, "configContext", 2);
+__decorateClass([
+  state(),
+  consume3({ context: testContext, subscribe: true })
+], TestNavigation.prototype, "_testContext", 2);
+__decorateClass([
+  state(),
+  consume3({ context: sessionContext, subscribe: true })
+], TestNavigation.prototype, "_sessionContext", 2);
+__decorateClass([
+  state(),
+  provide2({ context: computedContext })
+], TestNavigation.prototype, "computedContext", 2);
+__decorateClass([
+  property7({ type: Boolean, attribute: "auto-score-items" })
+], TestNavigation.prototype, "autoScoreItems", 2);
+TestNavigation = __decorateClass([
+  customElement5("test-navigation")
+], TestNavigation);
+
+// src/lib/qti-test/components/test-next.ts
+import { css as css3, html as html7, LitElement as LitElement7 } from "lit";
+import { customElement as customElement6, property as property8 } from "lit/decorators.js";
+import { consume as consume4 } from "@lit/context";
+
+// src/lib/qti-test/components/styles.ts
+import { css as css2 } from "lit";
+var form = css2`
+  display: inline-flex;
+  align-items: center;
+  cursor: pointer;
+  padding: 0.5rem 1rem;
+  border-radius: 0.25rem;
+  user-select: none;
+`;
+var btn = css2`
+  background-color: lightgray;
+  ${form};
+`;
+var dis = css2`
+  cursor: not-allowed;
+  opacity: 0.8;
+`;
+var ind = css2`
+  ${form};
+  border: 1px solid gray;
+`;
+
+// src/lib/qti-test/components/test-next.ts
+var TestNext = class extends LitElement7 {
+  constructor() {
+    super();
+    this._internalDisabled = true;
+    this._internals = this.attachInternals();
+    this._internals.role = "button";
+    this._internals.ariaLabel = "Next item";
+    this.addEventListener("click", (e) => {
+      e.preventDefault();
+      if (!this._internalDisabled) this._requestItem(this.sectionItems[this.itemIndex + 1].identifier);
+    });
+  }
+  _handleTestElementChange(_oldValue, newValue) {
+    if (newValue) {
+      this._internalDisabled = false;
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.checkDisabled();
+  }
+  willUpdate(_changedProperties) {
+    if (!this.computedContext) return;
+    const testPart = this.computedContext?.testParts.find((testPart2) => testPart2.active);
+    if (!testPart) return;
+    this.sectionItems = testPart.sections.flatMap((section) => section.items);
+    this.itemIndex = this.sectionItems.findIndex((item) => item.active);
+    this.checkDisabled();
+  }
+  checkDisabled() {
+    this._internalDisabled = !this.computedContext || this.itemIndex < 0 || this.itemIndex >= this.sectionItems?.length - 1;
+  }
+  _requestItem(identifier) {
+    this.dispatchEvent(
+      new CustomEvent("qti-request-navigation", {
+        composed: true,
+        bubbles: true,
+        detail: {
+          type: "item",
+          id: identifier
+        }
+      })
+    );
+  }
+  render() {
+    return html7`<slot></slot>`;
+  }
+};
+TestNext.styles = css3`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+__decorateClass([
+  property8({ type: Boolean, reflect: true, attribute: "disabled" })
+], TestNext.prototype, "_internalDisabled", 2);
+__decorateClass([
+  consume4({ context: computedContext, subscribe: true })
+], TestNext.prototype, "computedContext", 2);
+__decorateClass([
+  watch("computedContext")
+], TestNext.prototype, "_handleTestElementChange", 1);
+TestNext = __decorateClass([
+  customElement6("test-next")
+], TestNext);
+
+// src/lib/qti-test/components/test-prev.ts
+import { css as css4, html as html8, LitElement as LitElement8 } from "lit";
+import { customElement as customElement7, property as property9 } from "lit/decorators.js";
+import { consume as consume5 } from "@lit/context";
+var TestPrev = class extends LitElement8 {
+  constructor() {
+    super();
+    this._internalDisabled = true;
+    this.addEventListener("click", (e) => {
+      e.preventDefault();
+      if (!this._internalDisabled) this._requestItem(this.sectionItems[this.itemIndex - 1].identifier);
+    });
+  }
+  _handleTestElementChange(_oldValue, newValue) {
+    if (newValue) {
+      this._internalDisabled = false;
+    }
+  }
+  willUpdate(_changedProperties) {
+    if (!this.computedContext) return;
+    const testPart = this.computedContext?.testParts.find((testPart2) => testPart2.active);
+    if (!testPart) return;
+    this.sectionItems = testPart.sections.flatMap((section) => section.items);
+    this.itemIndex = this.sectionItems.findIndex((item) => item.active);
+    this.checkDisabled();
+  }
+  checkDisabled() {
+    this._internalDisabled = !this.computedContext || this.itemIndex === 0 || this.itemIndex === -1;
+  }
+  _requestItem(identifier) {
+    this.dispatchEvent(
+      new CustomEvent("qti-request-navigation", {
+        composed: true,
+        bubbles: true,
+        detail: {
+          type: "item",
+          id: identifier
+        }
+      })
+    );
+  }
+  render() {
+    return html8`<slot></slot>`;
+  }
+};
+TestPrev.styles = css4`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+__decorateClass([
+  property9({ type: Boolean, reflect: true, attribute: "disabled" })
+], TestPrev.prototype, "_internalDisabled", 2);
+__decorateClass([
+  consume5({ context: computedContext, subscribe: true })
+], TestPrev.prototype, "computedContext", 2);
+__decorateClass([
+  watch("computedContext")
+], TestPrev.prototype, "_handleTestElementChange", 1);
+TestPrev = __decorateClass([
+  customElement7("test-prev")
+], TestPrev);
+
+// src/lib/qti-test/components/test-view.ts
+import { html as html9, LitElement as LitElement9 } from "lit";
+import { customElement as customElement8, property as property10, state as state2 } from "lit/decorators.js";
+import { consume as consume6 } from "@lit/context";
+var TestView = class extends LitElement9 {
+  constructor() {
+    super(...arguments);
+    this.label = "view";
+    this._handleViewOptionsChange = () => {
+      this.updateViewOptions();
+    };
+    this._viewOptions = TestView.DEFAULT_VIEW_OPTIONS;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.updateViewOptions();
+  }
+  updateViewOptions() {
+    if (this.viewOptions) {
+      const options = this.viewOptions.split(",").map((opt) => opt.trim());
+      this._viewOptions = options.filter((opt) => TestView.DEFAULT_VIEW_OPTIONS.includes(opt));
+    } else {
+      this._viewOptions = TestView.DEFAULT_VIEW_OPTIONS;
+    }
+  }
+  _switchView(view) {
+    this.dispatchEvent(
+      new CustomEvent("on-test-switch-view", {
+        composed: true,
+        bubbles: true,
+        detail: view
+      })
+    );
+  }
+  render() {
+    return html9`
+      <label part="label" for="viewSelect">${this.label}</label>
+      <select
+        part="select"
+        id="viewSelect"
+        @change=${(e) => {
+      const el = e.target;
+      this._switchView(el.value);
+    }}
+      >
+        ${this._viewOptions.map(
+      (v) => html9`<option value="${v}" ?selected=${v === this.sessionContext.view}>${v}</option>`
+    )}
+      </select>
+    `;
+  }
+};
+TestView.DEFAULT_VIEW_OPTIONS = ["author", "candidate", "proctor", "scorer", "testConstructor", "tutor"];
+__decorateClass([
+  consume6({ context: sessionContext, subscribe: true })
+], TestView.prototype, "sessionContext", 2);
+__decorateClass([
+  property10({ type: String })
+], TestView.prototype, "label", 2);
+__decorateClass([
+  property10({ type: String, attribute: "view-options" })
+], TestView.prototype, "viewOptions", 2);
+__decorateClass([
+  watch("viewOptions", { waitUntilFirstUpdate: true })
+], TestView.prototype, "_handleViewOptionsChange", 2);
+__decorateClass([
+  state2()
+], TestView.prototype, "_viewOptions", 2);
+TestView = __decorateClass([
+  customElement8("test-view")
+], TestView);
+
+// src/lib/qti-test/components/test-item-link.ts
+import { css as css5, html as html10, LitElement as LitElement10 } from "lit";
+import { customElement as customElement9, property as property11 } from "lit/decorators.js";
+var TestItemLink = class extends LitElement10 {
+  constructor() {
+    super();
+    this.itemId = null;
+    this.addEventListener("click", () => this._requestItem(this.itemId));
+  }
+  _requestItem(identifier) {
+    this.dispatchEvent(
+      new CustomEvent("qti-request-navigation", {
+        composed: true,
+        bubbles: true,
+        detail: {
+          type: "item",
+          id: identifier
+        }
+      })
+    );
+  }
+  render() {
+    return html10` <slot></slot> `;
+  }
+};
+TestItemLink.styles = css5`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+__decorateClass([
+  property11({ type: String, attribute: "item-id" })
+], TestItemLink.prototype, "itemId", 2);
+TestItemLink = __decorateClass([
+  customElement9("test-item-link")
+], TestItemLink);
+
+// src/lib/qti-test/components/test-end-attempt.ts
+import { css as css6, html as html11, LitElement as LitElement11 } from "lit";
+import { customElement as customElement10 } from "lit/decorators.js";
+var TestEndAttempt = class extends LitElement11 {
+  constructor() {
+    super();
+    this.addEventListener("click", () => this.dispatchEvent(new CustomEvent("test-end-attempt", { bubbles: true })));
+  }
+  render() {
+    return html11` <slot></slot> `;
+  }
+};
+TestEndAttempt.styles = css6`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+TestEndAttempt = __decorateClass([
+  customElement10("test-end-attempt")
+], TestEndAttempt);
+
+// src/lib/qti-test/components/test-show-correct-response.ts
+import { css as css7, html as html12, LitElement as LitElement12 } from "lit";
+import { customElement as customElement11, property as property12 } from "lit/decorators.js";
+import { consume as consume7 } from "@lit/context";
+var TestShowCorrectResponse = class extends LitElement12 {
+  constructor() {
+    super(...arguments);
+    this.shown = false;
+    this.disabled = false;
+    this.showCorrectText = "Show correct response";
+    this.hideCorrectText = "Hide correct response";
+    this.noCorrectResponseText = "No correct response specified";
+  }
+  // Store previous active item reference
+  willUpdate(_changedProperties) {
+    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
+    if (this._previousActiveItem !== activeItem) {
+      this.shown = false;
+      this._previousActiveItem = activeItem;
+    }
+    if (activeItem) {
+      const containsCorrectResponse = !!activeItem?.variables?.some((v) => v["correctResponse"]);
+      const containsMapping = !!activeItem?.variables?.some((v) => {
+        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+      });
+      this.disabled = !containsCorrectResponse && !containsMapping;
+    } else {
+      this.disabled = true;
+    }
+  }
+  _toggleState() {
+    if (this.disabled) return;
+    this.shown = !this.shown;
+    this.dispatchEvent(
+      new CustomEvent("test-show-correct-response", {
+        detail: this.shown,
+        bubbles: true
+      })
+    );
+  }
+  _getDisplayedText() {
+    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
+  }
+  render() {
+    return html12` <div @click="${this._toggleState}">${this._getDisplayedText()}</div> `;
+  }
+};
+TestShowCorrectResponse.styles = css7`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+__decorateClass([
+  consume7({ context: computedContext, subscribe: true })
+], TestShowCorrectResponse.prototype, "computedContext", 2);
+__decorateClass([
+  property12({ type: Boolean, reflect: true })
+], TestShowCorrectResponse.prototype, "shown", 2);
+__decorateClass([
+  property12({ type: Boolean, reflect: true })
+], TestShowCorrectResponse.prototype, "disabled", 2);
+__decorateClass([
+  property12({ type: String })
+], TestShowCorrectResponse.prototype, "showCorrectText", 2);
+__decorateClass([
+  property12({ type: String })
+], TestShowCorrectResponse.prototype, "hideCorrectText", 2);
+__decorateClass([
+  property12({ type: String })
+], TestShowCorrectResponse.prototype, "noCorrectResponseText", 2);
+TestShowCorrectResponse = __decorateClass([
+  customElement11("test-show-correct-response")
+], TestShowCorrectResponse);
+
+// src/lib/qti-test/components/test-paging-buttons-stamp.ts
+import { html as html13, LitElement as LitElement13 } from "lit";
+import { customElement as customElement12 } from "lit/decorators.js";
+import { prepareTemplate as prepareTemplate2 } from "@heximal/templates";
+import { consume as consume8 } from "@lit/context";
+var TestPagingButtonsStamp = class extends LitElement13 {
+  createRenderRoot() {
+    return this;
+  }
+  constructor() {
+    super();
+    this._internals = this.attachInternals();
+    this._internals.ariaLabel = "pagination";
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.querySelector("template");
+    this.myTemplate = prepareTemplate2(templateElement);
+  }
+  render() {
+    if (!this.computedContext) return html13``;
+    const items = this.computedContext.testParts.flatMap(
+      (testPart) => testPart.sections.flatMap((section) => section.items)
+    );
+    return html13` ${items.map((item) => this.myTemplate({ item, view: this.computedContext.view }))} `;
+  }
+};
+__decorateClass([
+  consume8({ context: computedContext, subscribe: true })
+], TestPagingButtonsStamp.prototype, "computedContext", 2);
+TestPagingButtonsStamp = __decorateClass([
+  customElement12("test-paging-buttons-stamp")
+], TestPagingButtonsStamp);
+
+// src/lib/qti-test/components/test-container.ts
+import { LitElement as LitElement14, html as html14 } from "lit";
+import { customElement as customElement13, property as property13, state as state3 } from "lit/decorators.js";
+import { until } from "lit/directives/until.js";
+var TestContainer = class extends LitElement14 {
+  constructor() {
+    super(...arguments);
+    this.testURL = null;
+    this.testDoc = null;
+    this.testXML = null;
+    /** Template content if provided */
+    this.templateContent = null;
+  }
+  async handleTestURLChange() {
+    if (!this.testURL) return;
+    try {
+      const api = await qtiTransformTest().load(this.testURL);
+      this.testDoc = api.htmlDoc();
+    } catch (error) {
+      console.error("Error loading or parsing XML:", error);
+    }
+  }
+  handleTestXMLChange() {
+    if (!this.testXML) return;
+    try {
+      this.testDoc = qtiTransformTest().parse(this.testXML).htmlDoc();
+    } catch (error) {
+      console.error("Error parsing XML:", error);
+    }
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    this.initializeTemplateContent();
+    this.applyStyles();
+    if (this.testURL) {
+      this.handleTestURLChange();
+    }
+    if (this.testXML) {
+      this.handleTestXMLChange();
+    }
+  }
+  initializeTemplateContent() {
+    const template = this.querySelector("template");
+    this.templateContent = template ? template.content : html14``;
+  }
+  applyStyles() {
+    const sheet = new CSSStyleSheet();
+    sheet.replaceSync(item_default);
+    this.shadowRoot.adoptedStyleSheets = [sheet];
+  }
+  render() {
+    return html14`
+      ${this.templateContent}
+      <slot></slot>
+      ${until(this.testDoc, html14`<span>Loading...</span>`)}
+    `;
+  }
+};
+__decorateClass([
+  property13({ type: String, attribute: "test-url" })
+], TestContainer.prototype, "testURL", 2);
+__decorateClass([
+  state3()
+], TestContainer.prototype, "testDoc", 2);
+__decorateClass([
+  state3()
+], TestContainer.prototype, "testXML", 2);
+__decorateClass([
+  watch("testURL", { waitUntilFirstUpdate: true })
+], TestContainer.prototype, "handleTestURLChange", 1);
+__decorateClass([
+  watch("testXML", { waitUntilFirstUpdate: true })
+], TestContainer.prototype, "handleTestXMLChange", 1);
+TestContainer = __decorateClass([
+  customElement13("test-container")
+], TestContainer);
+
+// src/lib/qti-test/components/test-print-item-variables.ts
+import { html as html15, css as css8, LitElement as LitElement15 } from "lit";
+import { consume as consume9 } from "@lit/context";
+import { customElement as customElement14 } from "lit/decorators.js";
+var TestPrintVariables = class extends LitElement15 {
+  render() {
+    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
+    if (!activeItem || !activeItem.variables) return html15``;
+    const responseVariables = activeItem.variables.filter((v) => v.type === "response");
+    const outcomeVariables = activeItem.variables.filter((v) => v.type === "outcome");
+    const renderTable = (variables, title) => html15`
+      <h3>${title}</h3>
+      <table>
+        <thead>
+          <tr>
+            <th>Identifier</th>
+            <th>Value</th>
+            <th>Cardinality</th>
+            <th>Base Type</th>
+            <th>Correct Response / Mappings</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${variables.map((v) => {
+      const correctResponse = v.correctResponse ? Array.isArray(v.correctResponse) ? v.correctResponse.join(", ") : v.correctResponse : "";
+      const mapEntries = v.mapping?.mapEntries?.map((m) => `${m.mapKey}=${m.mappedValue}pt`).join(", ") || "";
+      const areaMapEntries = v.areaMapping?.areaMapEntries?.map((m) => `${m.shape}(${m.coords})=${m.mappedValue}pt`).join(", ") || "";
+      return html15`
+              <tr>
+                <td>${v.identifier}</td>
+                <td>${Array.isArray(v.value) ? v.value.join(", ") : v.value}</td>
+                <td>${v.cardinality}</td>
+                <td>${v.baseType}</td>
+                <td>${correctResponse || mapEntries || areaMapEntries}</td>
+              </tr>
+            `;
+    })}
+        </tbody>
+      </table>
+    `;
+    return html15`
+      ${renderTable(responseVariables, "Response Variables")} ${renderTable(outcomeVariables, "Outcome Variables")}
+    `;
+  }
+};
+TestPrintVariables.styles = css8`
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 20px 0;
+      font-size: 14px;
+      text-align: left;
+    }
+    th,
+    td {
+      border: 1px solid #ddd;
+      padding: 8px;
+    }
+    th {
+      background-color: #f4f4f4;
+      font-weight: bold;
+    }
+    h3 {
+      margin-top: 20px;
+      font-size: 16px;
+    }
+  `;
+__decorateClass([
+  consume9({ context: computedContext, subscribe: true })
+], TestPrintVariables.prototype, "computedContext", 2);
+TestPrintVariables = __decorateClass([
+  customElement14("test-print-item-variables")
+], TestPrintVariables);
+
+// src/lib/qti-test/components/test-section-buttons-stamp.ts
+import { html as html16, LitElement as LitElement16 } from "lit";
+import { customElement as customElement15 } from "lit/decorators.js";
+import { prepareTemplate as prepareTemplate3 } from "@heximal/templates";
+import { consume as consume10 } from "@lit/context";
+var TestSectionButtonsStamp = class extends LitElement16 {
+  createRenderRoot() {
+    return this;
+  }
+  constructor() {
+    super();
+    this._internals = this.attachInternals();
+    this._internals.ariaLabel = "pagination";
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.querySelector("template");
+    this.myTemplate = prepareTemplate3(templateElement);
+  }
+  render() {
+    if (!this.computedContext) return html16``;
+    const sections = this.computedContext.testParts.flatMap((testPart) => testPart.sections);
+    return html16` ${sections.map((item) => this.myTemplate({ item }))} `;
+  }
+};
+__decorateClass([
+  consume10({ context: computedContext, subscribe: true })
+], TestSectionButtonsStamp.prototype, "computedContext", 2);
+TestSectionButtonsStamp = __decorateClass([
+  customElement15("test-section-buttons-stamp")
+], TestSectionButtonsStamp);
+
+// src/lib/qti-test/components/test-section-link.ts
+import { css as css9, html as html17, LitElement as LitElement17 } from "lit";
+import { customElement as customElement16, property as property14 } from "lit/decorators.js";
+var TestSectionLink = class extends LitElement17 {
+  constructor() {
+    super();
+    this.sectionId = null;
+    this.addEventListener("click", () => this._requestItem(this.sectionId));
+  }
+  _requestItem(identifier) {
+    this.dispatchEvent(
+      new CustomEvent("qti-request-navigation", {
+        composed: true,
+        bubbles: true,
+        detail: {
+          type: "section",
+          id: identifier
+        }
+      })
+    );
+  }
+  render() {
+    return html17` <slot></slot> `;
+  }
+};
+TestSectionLink.styles = css9`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+__decorateClass([
+  property14({ type: String, attribute: "section-id" })
+], TestSectionLink.prototype, "sectionId", 2);
+TestSectionLink = __decorateClass([
+  customElement16("test-section-link")
+], TestSectionLink);
+
+// src/lib/qti-test/components/test-print-context.ts
+import { html as html18, LitElement as LitElement18 } from "lit";
+import { consume as consume11 } from "@lit/context";
+import { customElement as customElement17, state as state4 } from "lit/decorators.js";
+var TestPrintContext = class extends LitElement18 {
+  render() {
+    return html18` <small><pre>${JSON.stringify(this.computedContext, null, 2)}</pre></small> `;
+  }
+};
+__decorateClass([
+  state4(),
+  consume11({ context: computedContext, subscribe: true })
+], TestPrintContext.prototype, "computedContext", 2);
+TestPrintContext = __decorateClass([
+  customElement17("test-print-context")
+], TestPrintContext);
+
+// src/lib/qti-test/components/test-stamp.ts
+import { html as html19, LitElement as LitElement19, nothing } from "lit";
+import { customElement as customElement18, property as property15, state as state5 } from "lit/decorators.js";
+import { prepareTemplate as prepareTemplate4 } from "@heximal/templates";
+import { consume as consume12 } from "@lit/context";
+var TestStamp = class extends LitElement19 {
+  constructor() {
+    super(...arguments);
+    this.debug = false;
+    this.stampContext = {
+      view: "candidate",
+      activeItem: {},
+      activeSection: {
+        items: []
+      },
+      activeTestpart: {
+        items: [],
+        sections: []
+      },
+      test: {}
+    };
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.querySelector("template");
+    if (!templateElement) {
+      this.myTemplate = null;
+      return;
+    }
+    this.myTemplate = prepareTemplate4(templateElement);
+  }
+  willUpdate(_changedProperties) {
+    if (!this.computedContext) {
+      return;
+    }
+    const activeTestPart = this.computedContext.testParts.find((testPart) => testPart.active);
+    const activeSection = activeTestPart?.sections.find((section) => section.active);
+    const activeItem = activeSection?.items.find((item) => item.active);
+    const { variables, ...augmentedItem } = activeItem || {};
+    if (!activeTestPart || !activeSection || !activeItem) {
+      return;
+    }
+    const augmentedTestPart = {
+      ...activeTestPart,
+      items: activeTestPart.sections.flatMap((section) => section.items.map(({ variables: variables2, ...rest }) => rest)),
+      sections: activeTestPart.sections.map((section) => ({
+        ...section,
+        items: section.items.map(({ variables: variables2, ...rest }) => rest)
+      }))
+    };
+    const augmentedSection = { ...activeSection, items: activeSection.items.map(({ variables: variables2, ...rest }) => rest) };
+    const { testParts, ...activeTest } = this.computedContext;
+    this.stampContext = {
+      view: this.computedContext.view,
+      activeItem: augmentedItem,
+      activeSection: augmentedSection,
+      activeTestpart: augmentedTestPart,
+      test: activeTest
+    };
+  }
+  render() {
+    return html19` ${this.debug ? html19`<small><pre>${JSON.stringify(this.stampContext, null, 2)}</pre></small>` : nothing}
+    ${this.myTemplate ? this.myTemplate(this.stampContext) : nothing}`;
+  }
+};
+__decorateClass([
+  property15({ type: Boolean, reflect: true })
+], TestStamp.prototype, "debug", 2);
+__decorateClass([
+  state5(),
+  consume12({ context: computedContext, subscribe: true })
+], TestStamp.prototype, "computedContext", 2);
+__decorateClass([
+  state5()
+], TestStamp.prototype, "stampContext", 2);
+TestStamp = __decorateClass([
+  customElement18("test-stamp")
+], TestStamp);
+
+// src/lib/qti-test/components/test-scoring-buttons.ts
+import { html as html20, LitElement as LitElement20, nothing as nothing2 } from "lit";
+import { consume as consume13 } from "@lit/context";
+import { customElement as customElement19, property as property16 } from "lit/decorators.js";
+import { prepareTemplate as prepareTemplate5 } from "@heximal/templates";
+var TestScoringButtons = class extends LitElement20 {
+  constructor() {
+    super();
+    this.view = "";
+    this.disabled = false;
+    this.myTemplate = null;
+    this.addEventListener("click", (e) => {
+      const target = e.target;
+      const value = parseFloat(target.value);
+      if (target.tagName === "INPUT") {
+        this._changeOutcomeScore(value);
+      }
+    });
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.querySelector("template");
+    if (!templateElement) {
+      this.myTemplate = null;
+      return;
+    }
+    this.myTemplate = prepareTemplate5(templateElement);
+  }
+  _changeOutcomeScore(value) {
+    const testPart = this.computedContext?.testParts.find((testPart2) => testPart2.active);
+    const sectionItems = testPart.sections.flatMap((section) => section.items);
+    const currentItemIdentifier = sectionItems.find((item) => item.active)?.identifier;
+    this.dispatchEvent(
+      new CustomEvent("test-update-outcome-variable", {
+        detail: {
+          assessmentItemRefId: currentItemIdentifier,
+          outcomeVariableId: "SCORE",
+          value
+        },
+        bubbles: true
+      })
+    );
+  }
+  render() {
+    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
+    if (!activeItem || !activeItem.variables) return html20``;
+    const maxScore = activeItem.variables.find((vr) => vr.identifier == "MAXSCORE")?.value;
+    const scoreOutcome = activeItem.variables.find((vr) => vr.identifier == "SCORE");
+    const score = scoreOutcome?.value;
+    const disabled = !(scoreOutcome?.externalScored === "human");
+    if (!maxScore || !scoreOutcome) return nothing2;
+    const scores = [...Array(Number(maxScore) + 1).keys()];
+    return html20`${this.myTemplate ? this.myTemplate({ scores, score, disabled }) : nothing2}`;
+  }
+};
+__decorateClass([
+  property16({ type: String, attribute: "view" })
+], TestScoringButtons.prototype, "view", 2);
+__decorateClass([
+  property16({ type: Boolean })
+], TestScoringButtons.prototype, "disabled", 2);
+__decorateClass([
+  consume13({ context: computedContext, subscribe: true })
+], TestScoringButtons.prototype, "computedContext", 2);
+TestScoringButtons = __decorateClass([
+  customElement19("test-scoring-buttons")
+], TestScoringButtons);
+
+// src/lib/qti-test/components/test-view-toggle.ts
+import { consume as consume14 } from "@lit/context";
+import { html as html21, LitElement as LitElement21, nothing as nothing3 } from "lit";
+import { customElement as customElement20 } from "lit/decorators.js";
+import { prepareTemplate as prepareTemplate6 } from "@heximal/templates";
+var TestViewToggle = class extends LitElement21 {
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.querySelector("template");
+    if (!templateElement) {
+      this.myTemplate = null;
+      return;
+    }
+    this.myTemplate = prepareTemplate6(templateElement);
+  }
+  _switchView(view) {
+    this.dispatchEvent(
+      new CustomEvent("on-test-switch-view", {
+        composed: true,
+        bubbles: true,
+        detail: view
+      })
+    );
+  }
+  firstUpdated(_changedProperties) {
+    this.addEventListener("click", () => {
+      if (this.sessionContext?.view === "scorer") {
+        this._switchView("candidate");
+      } else {
+        this._switchView("scorer");
+      }
+    });
+  }
+  render() {
+    return html21`${this.myTemplate ? this.myTemplate({
+      view: this.sessionContext?.view
+    }) : nothing3}`;
+  }
+};
+__decorateClass([
+  consume14({ context: sessionContext, subscribe: true })
+], TestViewToggle.prototype, "sessionContext", 2);
+TestViewToggle = __decorateClass([
+  customElement20("test-view-toggle")
+], TestViewToggle);
+
+// src/lib/qti-test/components/test-scoring-feedback.ts
+import { consume as consume15 } from "@lit/context";
+import { html as html22, LitElement as LitElement22 } from "lit";
+import { customElement as customElement21, property as property17 } from "lit/decorators.js";
+var TestScoringFeedback = class extends LitElement22 {
+  constructor() {
+    super(...arguments);
+    this.view = null;
+  }
+  render() {
+    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
+    if (!activeItem || !activeItem.variables) return html22``;
+    if (activeItem["category"] === "dep-informational") return html22`<div>${this.dataset.informational}</div>`;
+    const completionStatus = activeItem?.variables.find((v) => v.identifier === "completionStatus")?.value;
+    const scoreOutcome = activeItem?.variables.find((vr) => vr.identifier == "SCORE");
+    const score = parseFloat(scoreOutcome?.value);
+    const externalScored = activeItem["externalScored"];
+    const feedbackText = () => {
+      if (completionStatus !== "completed") {
+        return this.dataset.textNoResponse;
+      }
+      if (!externalScored && score !== void 0 && !Number.isNaN(score)) {
+        return score > 0 ? this.dataset.textCorrect : this.dataset.textIncorrect;
+      }
+      if (externalScored === "externalMachine") {
+        return Number.isNaN(score) || score === void 0 ? this.dataset.scoreUnknown : `We hebben je antwoord ${score === 0 ? "geen punten" : score == 1 ? "\xE9\xE9n punt" : `${score} punten`} gegeven. Je kunt je score zelf aanpassen als je denkt dat dat niet klopt.`;
+      }
+      if (externalScored === "human") {
+        return Number.isNaN(score) ? "" : "Deze score heb je zelf toegekend.";
+      }
+      return this.dataset.inProgress;
+    };
+    return html22`<div>${feedbackText()}</div>`;
+  }
+};
+__decorateClass([
+  consume15({ context: computedContext, subscribe: true })
+], TestScoringFeedback.prototype, "computedContext", 2);
+__decorateClass([
+  property17({ type: String, attribute: "view" })
+], TestScoringFeedback.prototype, "view", 2);
+TestScoringFeedback = __decorateClass([
+  customElement21("test-scoring-feedback")
+], TestScoringFeedback);
+
+// src/lib/qti-test/components/test-check-item.ts
+import { css as css10, html as html23, LitElement as LitElement23 } from "lit";
+import { customElement as customElement22 } from "lit/decorators.js";
+var TestCheckItem = class extends LitElement23 {
+  constructor() {
+    super();
+    this.addEventListener("click", () => {
+      this.dispatchEvent(new CustomEvent("test-end-attempt", { bubbles: true }));
+      this.dispatchEvent(
+        new CustomEvent("test-show-correct-response", {
+          detail: true,
+          bubbles: true
+        })
+      );
+      const qtiTest = this.closest("qti-test");
+      const testContainer = qtiTest.querySelector("test-container");
+      const viewElements = Array.from(testContainer.shadowRoot.querySelectorAll("[view]"));
+      viewElements.forEach((element) => {
+        element.classList.toggle("show", true);
+      });
+    });
+  }
+  render() {
+    return html23` <slot></slot> `;
+  }
+};
+TestCheckItem.styles = css10`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+TestCheckItem = __decorateClass([
+  customElement22("test-check-item")
+], TestCheckItem);
+
+export {
+  QtiTest,
+  QtiAssessmentItemRef,
+  QtiAssessmentSection,
+  QtiAssessmentTest,
+  QtiTestPart,
+  QtiTestFeedback,
+  TestNavigation,
+  TestNext,
+  TestPrev,
+  TestView,
+  TestItemLink,
+  TestEndAttempt,
+  TestShowCorrectResponse,
+  TestPagingButtonsStamp,
+  TestContainer,
+  TestPrintVariables,
+  TestSectionButtonsStamp,
+  TestSectionLink,
+  TestPrintContext,
+  TestStamp,
+  TestScoringButtons,
+  TestViewToggle,
+  TestScoringFeedback,
+  TestCheckItem
+};
+//# sourceMappingURL=chunk-TJ6ZOT7A.js.map