@citolab/qti-components 7.15.1 → 7.16.0

package/dist/chunk-352OTVTY.js

@@ -1,3330 +0,0 @@
-import {
-  QtiModalFeedback
-} from "./chunk-O4XIWHTF.js";
-import {
-  item_default,
-  m
-} from "./chunk-W4SQRNWO.js";
-import {
-  watch
-} from "./chunk-2ZEJ3RR5.js";
-import {
-  qtiTransformItem,
-  qtiTransformTest
-} from "./chunk-INKI27D5.js";
-import {
-  E,
-  INITIAL_SESSION_CONTEXT,
-  INITIAL_TEST_CONTEXT,
-  W,
-  c,
-  computedContext,
-  configContext,
-  e,
-  i,
-  i2,
-  n,
-  qtiContext,
-  r,
-  sessionContext,
-  t,
-  testContext,
-  w,
-  x
-} from "./chunk-JEUY3MYB.js";
-import {
-  __decorateClass
-} from "./chunk-EUXUH3YW.js";
-
-// ../qti-test/src/mixins/test-navigation.mixin.ts
-var TestNavigationMixin = (superClass) => {
-  class TestNavigationClass extends superClass {
-    constructor(...args) {
-      super(...args);
-      this.navigate = null;
-      this.cacheTransform = false;
-      this.requestTimeout = 3e4;
-      this.postLoadTransformCallback = null;
-      this.postLoadTestTransformCallback = null;
-      // Navigation state tracking
-      this._activeController = null;
-      this._loadResults = [];
-      // Simple loading progress tracking
-      this._loadingState = {
-        expectedItems: 0,
-        connectedItems: 0,
-        expectedStimulus: 0,
-        loadedStimulus: 0,
-        isComplete: false
-      };
-      // Track loaded/loading stimulus hrefs to prevent duplicates
-      this._loadedStimulusHrefs = /* @__PURE__ */ new Set();
-      this._loadingStimulusHrefs = /* @__PURE__ */ new Set();
-      this._bindEventHandlers();
-    }
-    // ===========================================
-    // PUBLIC API
-    // ===========================================
-    /**
-     * Navigate to a specific item or section
-     * @param type - Navigation type ('item' or 'section')
-     * @param id - Target identifier (optional, falls back to first available)
-     */
-    navigateTo(type, id) {
-      const targetId = id || this._getDefaultNavigationId(type);
-      if (targetId) {
-        this.dispatchEvent(
-          new CustomEvent("qti-request-navigation", {
-            detail: { type, id: targetId },
-            bubbles: true,
-            composed: true
-          })
-        );
-      }
-    }
-    // ===========================================
-    // EVENT HANDLER SETUP
-    // ===========================================
-    _bindEventHandlers() {
-      this.addEventListener("qti-request-navigation", this._handleNavigationRequest.bind(this));
-      this.addEventListener("qti-assessment-test-connected", this._handleTestConnected.bind(this));
-      this.addEventListener("qti-assessment-item-connected", this._handleItemConnected.bind(this));
-      this.addEventListener("qti-assessment-stimulus-ref-connected", this._handleStimulusRefConnected.bind(this));
-    }
-    _handleTestConnected(e2) {
-      this._testElement = e2.detail;
-      this._initializeNavigation();
-    }
-    /**
-     * Handle item connection events - track connected items and discover stimulus references
-     */
-    _handleItemConnected(e2) {
-      const itemRef = e2.detail;
-      this._loadingState.connectedItems++;
-      const stimulusRefs = itemRef.querySelectorAll("qti-assessment-stimulus-ref");
-      this._loadingState.expectedStimulus += stimulusRefs.length;
-      this._checkLoadingComplete();
-    }
-    /**
-     * Handle stimulus reference connection events with duplicate prevention
-     */
-    async _handleStimulusRefConnected(e2) {
-      e2.preventDefault();
-      const { element, item } = e2;
-      console.info("Stimulus ref connected:", {
-        identifier: element.identifier,
-        href: element.href,
-        item: item.identifier
-      });
-      if (this._loadedStimulusHrefs.has(element.href)) {
-        console.info("Stimulus already loaded, skipping:", element.href);
-        this._loadingState.loadedStimulus++;
-        this._checkLoadingComplete();
-        return;
-      }
-      if (this._loadingStimulusHrefs.has(element.href)) {
-        console.info("Stimulus already loading, skipping duplicate:", element.href);
-        this._loadingState.loadedStimulus++;
-        this._checkLoadingComplete();
-        return;
-      }
-      this._loadingStimulusHrefs.add(element.href);
-      console.info("Starting stimulus load:", element.href);
-      try {
-        await this._loadStimulusRef(element, item);
-        this._loadedStimulusHrefs.add(element.href);
-        this._loadingState.loadedStimulus++;
-        console.info("Stimulus loaded successfully:", element.href);
-        this._checkLoadingComplete();
-      } catch (error) {
-        if (error.name !== "AbortError") {
-          console.warn(`Failed to load stimulus ${element.identifier}:`, error);
-        }
-        this._loadingState.loadedStimulus++;
-        this._checkLoadingComplete();
-      } finally {
-        this._loadingStimulusHrefs.delete(element.href);
-      }
-    }
-    // ===========================================
-    // NAVIGATION FLOW
-    // ===========================================
-    _getDefaultNavigationId(type) {
-      if (type === "section") {
-        return this._testElement?.querySelector("qti-assessment-section")?.identifier;
-      }
-      return this.sessionContext?.navItemRefId ?? this._testElement?.querySelector("qti-assessment-item-ref")?.identifier;
-    }
-    _initializeNavigation() {
-      if (!this.navigate) return;
-      const id = this._getDefaultNavigationId(this.navigate);
-      if (id) {
-        this.navigateTo(this.navigate, id);
-      }
-    }
-    /**
-     * Main navigation request handler with proper lifecycle management
-     */
-    async _handleNavigationRequest({ detail }) {
-      if (!detail?.id) return;
-      this._cancelPreviousNavigation();
-      try {
-        this._dispatchLoadingStarted(detail.type, detail.id);
-        this._activeController = new AbortController();
-        await this._executeNavigation(detail.type, detail.id);
-      } catch (error) {
-        this._handleNavigationError(error, detail.type, detail.id);
-      } finally {
-        this._activeController = null;
-        this._dispatchLoadingEnded(detail.type, detail.id);
-      }
-    }
-    _handleNavigationError(error, type, id) {
-      if (error.name !== "AbortError") {
-        this._dispatchError(this._createNavigationError(error, type, id));
-      }
-    }
-    async _executeNavigation(type, id) {
-      if (type === "item") {
-        await this._navigateToItem(id);
-      } else {
-        await this._navigateToSection(id);
-      }
-    }
-    /**
-     * Navigate to specific item with simple state tracking
-     */
-    async _navigateToItem(itemId) {
-      const itemRef = this._findItemRef(itemId);
-      this._updateSessionContext(itemRef, itemId);
-      this._resetLoadingState();
-      this._loadingState.expectedItems = 1;
-      await this._loadItems([itemId]);
-      await this._waitForLoadingComplete();
-      this._dispatchTestLoaded(this._loadResults);
-    }
-    /**
-     * Navigate to section with simple state tracking
-     */
-    async _navigateToSection(sectionId) {
-      const sectionEl = this._findSection(sectionId);
-      const navPartId = sectionEl?.closest("qti-test-part")?.identifier;
-      this.sessionContext = {
-        ...this.sessionContext,
-        navPartId,
-        navSectionId: sectionId,
-        navItemRefId: null
-      };
-      const itemIds = this._getSectionItemIds(sectionId);
-      this._resetLoadingState();
-      this._loadingState.expectedItems = itemIds.length;
-      await this._loadItems(itemIds);
-      await this._waitForLoadingComplete();
-      this._dispatchTestLoaded(this._loadResults);
-    }
-    // ===========================================
-    // LOADING STATE MANAGEMENT
-    // ===========================================
-    /**
-     * Reset loading state for new navigation
-     */
-    _resetLoadingState() {
-      this._loadingState = {
-        expectedItems: 0,
-        connectedItems: 0,
-        expectedStimulus: 0,
-        loadedStimulus: 0,
-        isComplete: false
-      };
-      this._loadedStimulusHrefs.clear();
-      this._loadingStimulusHrefs.clear();
-    }
-    /**
-     * Check if loading is complete and dispatch events accordingly
-     */
-    _checkLoadingComplete() {
-      const allItemsConnected = this._loadingState.connectedItems >= this._loadingState.expectedItems;
-      const allStimulusLoaded = this._loadingState.loadedStimulus >= this._loadingState.expectedStimulus;
-      if (allItemsConnected && allStimulusLoaded && !this._loadingState.isComplete) {
-        this._loadingState.isComplete = true;
-      }
-    }
-    /**
-     * Wait for loading to complete with simple polling
-     */
-    async _waitForLoadingComplete() {
-      while (!this._loadingState.isComplete) {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-      }
-    }
-    /**
-     * Get current loading progress for external consumption
-     */
-    getLoadingProgress() {
-      return { ...this._loadingState };
-    }
-    /**
-     * Load stimulus reference with simple tracking
-     */
-    async _loadStimulusRef(element, item) {
-      console.info("Loading stimulus:", element.href);
-      const stimulus = await this._loadStimulus(element.href);
-      console.info("Stimulus loaded, applying content:", stimulus ? "has content" : "no content");
-      this._applyStimulusContent(stimulus, element, item);
-    }
-    _applyStimulusContent(stimulus, element, item) {
-      if (!stimulus) {
-        console.warn("No stimulus content to apply");
-        return;
-      }
-      const elements = stimulus.querySelectorAll("qti-stimulus-body, qti-stylesheet");
-      console.info(`Found ${elements.length} stimulus elements to apply for ${element.identifier}`);
-      if (elements.length === 0) {
-        console.warn("No qti-stimulus-body or qti-stylesheet elements found in stimulus");
-        return;
-      }
-      let targets = [];
-      const specificTarget = document.querySelector(
-        `qti-assessment-item[identifier="${item.identifier}"] [data-stimulus-idref="${element.identifier}"]`
-      );
-      if (specificTarget) {
-        targets.push(specificTarget);
-        console.info("Found specific target:", specificTarget);
-      } else {
-        const allTargetsWithId = Array.from(this.querySelectorAll(`[data-stimulus-idref="${element.identifier}"]`));
-        if (allTargetsWithId.length > 0) {
-          targets = allTargetsWithId;
-          console.info("Found targets by identifier:", allTargetsWithId.length);
-        } else {
-          const allStimulusTargets = Array.from(this.querySelectorAll("[data-stimulus-idref]"));
-          targets = allStimulusTargets;
-          console.info("Using fallback targets:", allStimulusTargets.length);
-        }
-      }
-      if (targets.length === 0) {
-        console.warn("No targets found for stimulus content");
-        return;
-      }
-      targets.forEach((target, index) => {
-        target.innerHTML = "";
-        const clonedElements = Array.from(elements).map((el) => el.cloneNode(true));
-        target.append(...clonedElements);
-        console.info(`Applied stimulus content to target ${index + 1}/${targets.length}`);
-      });
-    }
-    // ===========================================
-    // LOADING INFRASTRUCTURE
-    // ===========================================
-    /**
-     * Cancel previous navigation and clean up all state
-     */
-    _cancelPreviousNavigation() {
-      if (this._activeController) {
-        this._activeController.abort();
-        console.info("Previous navigation request cancelled");
-      }
-      this._clearNavigationState();
-    }
-    _clearNavigationState() {
-      this._clearLoadedItems();
-      this._resetLoadingState();
-      this._loadResults = [];
-    }
-    /**
-     * Load items with simple tracking
-     */
-    async _loadItems(itemIds) {
-      if (!this._testElement || itemIds.length === 0) return;
-      const itemRefs = itemIds.map((id) => this._findItemRef(id));
-      this._clearLoadedItems();
-      this._clearStimulusRef();
-      const results = await Promise.all(itemRefs.map((ref) => this._loadSingleItem(ref)));
-      const validResults = results.filter(Boolean);
-      validResults.forEach(({ itemRef, doc }) => {
-        if (itemRef && doc) itemRef.xmlDoc = doc;
-      });
-      this._loadResults = validResults;
-    }
-    async _loadSingleItem(itemRef) {
-      try {
-        let transformer = await qtiTransformItem(this.cacheTransform).load(
-          itemRef.href,
-          this._activeController?.signal
-        );
-        if (this.postLoadTransformCallback) {
-          transformer = await this.postLoadTransformCallback(transformer, itemRef);
-        }
-        return { itemRef, doc: transformer.htmlDoc() };
-      } catch (error) {
-        if (error.name === "AbortError") {
-          console.info(`Item load for ${itemRef.identifier} was aborted`);
-          throw error;
-        }
-        console.warn(`Failed to load item ${itemRef.identifier}:`, error);
-        return null;
-      }
-    }
-    async _loadStimulus(href) {
-      const transformer = await qtiTransformItem().load(href, this._activeController?.signal);
-      return transformer.htmlDoc();
-    }
-    // ===========================================
-    // UTILITIES
-    // ===========================================
-    _findItemRef(itemId) {
-      const itemRef = this._testElement?.querySelector(
-        `qti-assessment-item-ref[identifier="${itemId}"]`
-      );
-      if (!itemRef) {
-        throw new Error(`Item with identifier "${itemId}" not found`);
-      }
-      return itemRef;
-    }
-    _findSection(sectionId) {
-      return this._testElement?.querySelector(`qti-assessment-section[identifier="${sectionId}"]`) || null;
-    }
-    _updateSessionContext(itemRef, itemId) {
-      const navPartId = itemRef.closest("qti-test-part")?.identifier;
-      const navSectionId = itemRef.closest("qti-assessment-section")?.identifier;
-      this.sessionContext = {
-        ...this.sessionContext,
-        navPartId,
-        navSectionId,
-        navItemRefId: itemId
-      };
-    }
-    _getSectionItemIds(sectionId) {
-      return Array.from(
-        this._testElement.querySelectorAll(
-          `qti-assessment-section[identifier="${sectionId}"] > qti-assessment-item-ref`
-        )
-      ).map((ref) => ref.identifier).filter(Boolean);
-    }
-    _clearLoadedItems() {
-      const itemRefs = this._testElement?.querySelectorAll("qti-assessment-item-ref");
-      Array.from(itemRefs || []).forEach((element) => {
-        element.xmlDoc = null;
-      });
-    }
-    _clearStimulusRef() {
-      this.querySelectorAll("[data-stimulus-idref]").forEach((el) => el.innerHTML = "");
-    }
-    _createNavigationError(error, type, id) {
-      return {
-        message: error.message || `Failed to load ${type}: ${id}`,
-        details: error,
-        itemId: type === "item" ? id : void 0,
-        sectionId: type === "section" ? id : void 0
-      };
-    }
-    // ===========================================
-    // EVENT DISPATCHING
-    // ===========================================
-    _dispatchLoadingStarted(type, id) {
-      this.dispatchEvent(
-        new CustomEvent("qti-navigation-loading-started", {
-          detail: { type, id },
-          bubbles: true,
-          composed: true
-        })
-      );
-    }
-    _dispatchLoadingEnded(type, id) {
-      this.dispatchEvent(
-        new CustomEvent("qti-navigation-loading-ended", {
-          detail: { type, id },
-          bubbles: true,
-          composed: true
-        })
-      );
-    }
-    _dispatchError(error) {
-      this.dispatchEvent(
-        new CustomEvent("qti-navigation-error", {
-          detail: error,
-          bubbles: true,
-          composed: true
-        })
-      );
-    }
-    _dispatchTestLoaded(results) {
-      requestAnimationFrame(() => {
-        this.dispatchEvent(
-          new CustomEvent("qti-test-loaded", {
-            detail: results.map(({ itemRef }) => ({
-              identifier: itemRef?.identifier,
-              element: itemRef
-            })),
-            bubbles: true,
-            composed: true
-          })
-        );
-      });
-    }
-  }
-  __decorateClass([
-    n({ type: String })
-  ], TestNavigationClass.prototype, "navigate", 2);
-  __decorateClass([
-    n({ type: Boolean, attribute: "cache-transform" })
-  ], TestNavigationClass.prototype, "cacheTransform", 2);
-  __decorateClass([
-    n({ type: Number })
-  ], TestNavigationClass.prototype, "requestTimeout", 2);
-  __decorateClass([
-    n({ attribute: false })
-  ], TestNavigationClass.prototype, "postLoadTransformCallback", 2);
-  __decorateClass([
-    n({ attribute: false })
-  ], TestNavigationClass.prototype, "postLoadTestTransformCallback", 2);
-  return TestNavigationClass;
-};
-
-// ../qti-test/src/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", (e2) => {
-        this.sessionContext = { ...this.sessionContext, view: e2.detail };
-        this._updateElementView();
-      });
-      this.addEventListener("qti-assessment-test-connected", () => {
-        this._updateElementView();
-      });
-      this.addEventListener("qti-assessment-item-connected", (e2) => {
-        this._updateElementView();
-        this._setCorrectResponseVisibility(e2.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;
-};
-
-// ../qti-test/src/mixins/test-base.ts
-var TestBaseMixin = (superClass) => {
-  class TestBaseClass extends superClass {
-    constructor(...args) {
-      super(...args);
-      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((i4) => i4?.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 {
-          const newVariables = [...assessmentItem.variables];
-          for (const variable of itemContext.variables) {
-            const currentVariable = newVariables.find((v) => v.identifier === variable.identifier);
-            if (currentVariable) {
-              currentVariable.value = variable.value;
-            } else {
-              newVariables.push(variable);
-            }
-          }
-          assessmentItem.variables = newVariables;
-        }
-      };
-      this._initializeEventListeners();
-    }
-    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) {
-        itemRef.assessmentItem.variables = variables;
-      }
-    }
-    _initializeEventListeners() {
-      this.addEventListener("qti-assessment-test-connected", (e2) => {
-        this.testContext = INITIAL_TEST_CONTEXT;
-        this.sessionContext = INITIAL_SESSION_CONTEXT;
-        if (this.testContext && this.testContext.items.length > 0) return;
-        this._testElement = e2.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", (e2) => {
-        const assessmentItem = e2.detail;
-        const assessmentRefId = assessmentItem.closest("qti-assessment-item-ref")?.identifier;
-        if (assessmentRefId) {
-          assessmentItem.assessmentItemRefId = assessmentRefId;
-        }
-        this._updateItemInTestContext(e2.detail);
-      });
-      this.addEventListener("qti-item-context-updated", (e2) => {
-        this._updateItemVariablesInTestContext(e2.detail.itemContext.identifier, e2.detail.itemContext.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([
-    n({ attribute: false, type: Object }),
-    e({ context: testContext })
-  ], TestBaseClass.prototype, "testContext", 2);
-  __decorateClass([
-    n({ attribute: false, type: Object }),
-    e({ context: sessionContext })
-  ], TestBaseClass.prototype, "sessionContext", 2);
-  return TestBaseClass;
-};
-var TestBase = class extends TestBaseMixin(i2) {
-};
-
-// ../qti-test/src/mixins/test-processing.mixin.ts
-var TestProcessingMixin = (superClass) => {
-  class TestProcessingElement extends superClass {
-    constructor(...args) {
-      super(...args);
-      this.addEventListener("qti-register-variable", (e2) => {
-        this.testContext = {
-          ...this.testContext,
-          testOutcomeVariables: [...this.testContext.testOutcomeVariables || [], e2.detail.variable]
-        };
-        e2.stopPropagation();
-      });
-      this.addEventListener(
-        "qti-set-outcome-value",
-        (e2) => {
-          const { outcomeIdentifier, value } = e2.detail;
-          this.updateOutcomeVariable(outcomeIdentifier, value);
-          e2.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;
-};
-
-// ../qti-test/src/components/qti-test/qti-test.ts
-var QtiTest = class extends TestNavigationMixin(TestViewMixin(TestProcessingMixin(TestBaseMixin(i2)))) {
-  // TODO: Properly implement IQtiTest interface
-  // 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 x`<slot></slot>`;
-  }
-};
-QtiTest = __decorateClass([
-  t("qti-test")
-], QtiTest);
-
-// ../qti-test/src/components/qti-assessment-item-ref/qti-assessment-item-ref.ts
-var stringToBooleanConverter = {
-  fromAttribute(value) {
-    return value === "true";
-  },
-  toAttribute(value) {
-    return value ? "true" : "false";
-  }
-};
-var QtiAssessmentItemRef = class extends i2 {
-  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();
-    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([
-  n({ type: String })
-], QtiAssessmentItemRef.prototype, "category", 2);
-__decorateClass([
-  n({ type: String })
-], QtiAssessmentItemRef.prototype, "identifier", 2);
-__decorateClass([
-  n({ type: Boolean, converter: stringToBooleanConverter })
-], QtiAssessmentItemRef.prototype, "required", 2);
-__decorateClass([
-  n({ type: Boolean, converter: stringToBooleanConverter })
-], QtiAssessmentItemRef.prototype, "fixed", 2);
-__decorateClass([
-  n({ type: String })
-], QtiAssessmentItemRef.prototype, "href", 2);
-__decorateClass([
-  n({ type: Object, attribute: false })
-], QtiAssessmentItemRef.prototype, "xmlDoc", 2);
-if (!customElements.get("qti-assessment-item-ref")) {
-  customElements.define("qti-assessment-item-ref", QtiAssessmentItemRef);
-}
-
-// ../qti-test/src/components/qti-assessment-section/qti-assessment-section.ts
-var stringToBooleanConverter2 = {
-  fromAttribute(value) {
-    return value === "true";
-  },
-  toAttribute(value) {
-    return value ? "true" : "false";
-  }
-};
-var QtiAssessmentSection = class extends i2 {
-  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 x`<slot name="qti-rubric-block"></slot><slot></slot>`;
-  }
-};
-__decorateClass([
-  n({ type: String })
-], QtiAssessmentSection.prototype, "identifier", 2);
-__decorateClass([
-  n({ type: String })
-], QtiAssessmentSection.prototype, "required", 2);
-__decorateClass([
-  n({ type: Boolean, converter: stringToBooleanConverter2 })
-], QtiAssessmentSection.prototype, "fixed", 2);
-__decorateClass([
-  n({ type: Boolean, converter: stringToBooleanConverter2 })
-], QtiAssessmentSection.prototype, "visible", 2);
-__decorateClass([
-  n({ type: Boolean, converter: stringToBooleanConverter2, attribute: "keep-together" })
-], QtiAssessmentSection.prototype, "keepTogether", 2);
-__decorateClass([
-  c({ context: testContext, subscribe: true })
-], QtiAssessmentSection.prototype, "_testContext", 2);
-if (!customElements.get("qti-assessment-section")) {
-  customElements.define("qti-assessment-section", QtiAssessmentSection);
-}
-
-// ../qti-test/src/components/qti-assessment-test/qti-assessment-test.ts
-var QtiAssessmentTest = class extends i2 {
-  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 x` <slot></slot>`;
-  }
-};
-__decorateClass([
-  n({ type: String })
-], QtiAssessmentTest.prototype, "identifier", 2);
-__decorateClass([
-  n({ type: String })
-], QtiAssessmentTest.prototype, "title", 1);
-__decorateClass([
-  c({ context: testContext, subscribe: true })
-], QtiAssessmentTest.prototype, "_testContext", 2);
-QtiAssessmentTest = __decorateClass([
-  t("qti-assessment-test")
-], QtiAssessmentTest);
-
-// ../qti-test/src/components/qti-test-part/qti-test-part.ts
-var QtiTestPart = class extends i2 {
-  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 x` <slot></slot>`;
-  }
-};
-__decorateClass([
-  n({ type: String })
-], QtiTestPart.prototype, "identifier", 2);
-__decorateClass([
-  n({ type: String })
-], QtiTestPart.prototype, "class", 2);
-__decorateClass([
-  n({ type: String, attribute: "navigation-mode" })
-], QtiTestPart.prototype, "navigationMode", 2);
-__decorateClass([
-  n({ type: String, attribute: "submission-mode" })
-], QtiTestPart.prototype, "submissionMode", 2);
-QtiTestPart = __decorateClass([
-  t("qti-test-part")
-], QtiTestPart);
-if (!customElements.get("qti-test-part")) {
-  customElements.define("qti-test-part", QtiTestPart);
-}
-
-// ../qti-test/src/components/qti-test-feedback/qti-test-feedback.ts
-var QtiTestFeedback = class extends QtiModalFeedback {
-  render() {
-    return x``;
-  }
-};
-QtiTestFeedback.styles = i`
-    :host {
-      color: gray;
-    }
-  `;
-QtiTestFeedback = __decorateClass([
-  t("qti-test-feedback")
-], QtiTestFeedback);
-
-// ../qti-test/src/components/test-navigation/test-navigation.ts
-var TestNavigation = class extends i2 {
-  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 x`<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((i4) => i4.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(
-                  (r3) => r3.querySelector("qti-correct-response")
-                );
-                const containsMapping = Array.from(responseDeclarations).some((r3) => {
-                  const mapping = r3.querySelector("qti-mapping");
-                  const areaMapping = r3.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((i4) => i4.identifier === item.identifier)?.variables.find((v) => v.identifier === "completionStatus").value === "completed"
-              ),
-              items: section.items.map((item) => {
-                const itemContext = this._testContext?.items.find((i4) => i4.identifier === item.identifier);
-                const computedItem = {
-                  ...item,
-                  ...itemContext,
-                  ...this.initContext?.find((i4) => i4.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([
-  n({ type: String })
-], TestNavigation.prototype, "identifier", 2);
-__decorateClass([
-  r()
-], TestNavigation.prototype, "initContext", 2);
-__decorateClass([
-  r(),
-  e({ context: qtiContext })
-], TestNavigation.prototype, "qtiContext", 2);
-__decorateClass([
-  r(),
-  e({ context: configContext })
-], TestNavigation.prototype, "configContext", 2);
-__decorateClass([
-  r(),
-  c({ context: testContext, subscribe: true })
-], TestNavigation.prototype, "_testContext", 2);
-__decorateClass([
-  r(),
-  c({ context: sessionContext, subscribe: true })
-], TestNavigation.prototype, "_sessionContext", 2);
-__decorateClass([
-  r(),
-  e({ context: computedContext })
-], TestNavigation.prototype, "computedContext", 2);
-__decorateClass([
-  n({ type: Boolean, attribute: "auto-score-items" })
-], TestNavigation.prototype, "autoScoreItems", 2);
-TestNavigation = __decorateClass([
-  t("test-navigation")
-], TestNavigation);
-
-// ../qti-test/src/components/styles.ts
-var form = i`
-  display: inline-flex;
-  align-items: center;
-  cursor: pointer;
-  padding: 0.5rem 1rem;
-  border-radius: 0.25rem;
-  user-select: none;
-`;
-var btn = i`
-  background-color: lightgray;
-  ${form};
-`;
-var dis = i`
-  cursor: not-allowed;
-  opacity: 0.8;
-`;
-var ind = i`
-  ${form};
-  border: 1px solid gray;
-`;
-
-// ../qti-test/src/components/test-next/test-next.ts
-var TestNext = class extends i2 {
-  constructor() {
-    super();
-    this._internalDisabled = true;
-    this._internals = this.attachInternals();
-    this._internals.role = "button";
-    this._internals.ariaLabel = "Next item";
-    this.addEventListener("click", (e2) => {
-      e2.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 x`<slot></slot>`;
-  }
-};
-TestNext.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-__decorateClass([
-  n({ type: Boolean, reflect: true, attribute: "disabled" })
-], TestNext.prototype, "_internalDisabled", 2);
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestNext.prototype, "computedContext", 2);
-__decorateClass([
-  watch("computedContext")
-], TestNext.prototype, "_handleTestElementChange", 1);
-TestNext = __decorateClass([
-  t("test-next")
-], TestNext);
-
-// ../qti-test/src/components/test-prev/test-prev.ts
-var TestPrev = class extends i2 {
-  constructor() {
-    super();
-    this._internalDisabled = true;
-    this.addEventListener("click", (e2) => {
-      e2.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 x`<slot></slot>`;
-  }
-};
-TestPrev.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-__decorateClass([
-  n({ type: Boolean, reflect: true, attribute: "disabled" })
-], TestPrev.prototype, "_internalDisabled", 2);
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestPrev.prototype, "computedContext", 2);
-__decorateClass([
-  watch("computedContext")
-], TestPrev.prototype, "_handleTestElementChange", 1);
-TestPrev = __decorateClass([
-  t("test-prev")
-], TestPrev);
-
-// ../qti-test/src/components/test-view-toggle/test-view.ts
-var TestView = class extends i2 {
-  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 x`
-      <label part="label" for="viewSelect">${this.label}</label>
-      <select
-        part="select"
-        id="viewSelect"
-        @change=${(e2) => {
-      const el = e2.target;
-      this._switchView(el.value);
-    }}
-      >
-        ${this._viewOptions.map(
-      (v) => x`<option value="${v}" ?selected=${v === this.sessionContext.view}>${v}</option>`
-    )}
-      </select>
-    `;
-  }
-};
-TestView.DEFAULT_VIEW_OPTIONS = ["author", "candidate", "proctor", "scorer", "testConstructor", "tutor"];
-__decorateClass([
-  c({ context: sessionContext, subscribe: true })
-], TestView.prototype, "sessionContext", 2);
-__decorateClass([
-  n({ type: String })
-], TestView.prototype, "label", 2);
-__decorateClass([
-  n({ type: String, attribute: "view-options" })
-], TestView.prototype, "viewOptions", 2);
-__decorateClass([
-  watch("viewOptions", { waitUntilFirstUpdate: true })
-], TestView.prototype, "_handleViewOptionsChange", 2);
-__decorateClass([
-  r()
-], TestView.prototype, "_viewOptions", 2);
-TestView = __decorateClass([
-  t("test-view")
-], TestView);
-
-// ../qti-test/src/components/test-item-link/test-item-link.ts
-var TestItemLink = class extends i2 {
-  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 x` <slot></slot> `;
-  }
-};
-TestItemLink.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-__decorateClass([
-  n({ type: String, attribute: "item-id" })
-], TestItemLink.prototype, "itemId", 2);
-TestItemLink = __decorateClass([
-  t("test-item-link")
-], TestItemLink);
-
-// ../qti-test/src/components/test-end-attempt/test-end-attempt.ts
-var TestEndAttempt = class extends i2 {
-  constructor() {
-    super();
-    this.addEventListener("click", () => this.dispatchEvent(new CustomEvent("test-end-attempt", { bubbles: true })));
-  }
-  render() {
-    return x` <slot></slot> `;
-  }
-};
-TestEndAttempt.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-TestEndAttempt = __decorateClass([
-  t("test-end-attempt")
-], TestEndAttempt);
-
-// ../qti-test/src/components/test-show-correct-response/test-show-correct-response.ts
-var TestShowCorrectResponse = class extends i2 {
-  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 x` <div @click="${this._toggleState}">${this._getDisplayedText()}</div> `;
-  }
-};
-TestShowCorrectResponse.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestShowCorrectResponse.prototype, "computedContext", 2);
-__decorateClass([
-  n({ type: Boolean, reflect: true })
-], TestShowCorrectResponse.prototype, "shown", 2);
-__decorateClass([
-  n({ type: Boolean, reflect: true })
-], TestShowCorrectResponse.prototype, "disabled", 2);
-__decorateClass([
-  n({ type: String })
-], TestShowCorrectResponse.prototype, "showCorrectText", 2);
-__decorateClass([
-  n({ type: String })
-], TestShowCorrectResponse.prototype, "hideCorrectText", 2);
-__decorateClass([
-  n({ type: String })
-], TestShowCorrectResponse.prototype, "noCorrectResponseText", 2);
-TestShowCorrectResponse = __decorateClass([
-  t("test-show-correct-response")
-], TestShowCorrectResponse);
-
-// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/constants.js
-var KEYWORDS = ["this"];
-var UNARY_OPERATORS = ["+", "-", "!"];
-var BINARY_OPERATORS = [
-  "=",
-  "+",
-  "-",
-  "*",
-  "/",
-  "%",
-  "^",
-  "==",
-  "!=",
-  ">",
-  "<",
-  ">=",
-  "<=",
-  "||",
-  "&&",
-  "??",
-  "&",
-  "===",
-  "!==",
-  "|",
-  "|>"
-];
-var PRECEDENCE = {
-  "!": 0,
-  ":": 0,
-  ",": 0,
-  ")": 0,
-  "]": 0,
-  "}": 0,
-  "|>": 1,
-  "?": 2,
-  "??": 3,
-  "||": 4,
-  "&&": 5,
-  "|": 6,
-  "^": 7,
-  "&": 8,
-  // equality
-  "!=": 9,
-  "==": 9,
-  "!==": 9,
-  "===": 9,
-  // relational
-  ">=": 10,
-  ">": 10,
-  "<=": 10,
-  "<": 10,
-  // additive
-  "+": 11,
-  "-": 11,
-  // multiplicative
-  "%": 12,
-  "/": 12,
-  "*": 12,
-  // postfix
-  "(": 13,
-  "[": 13,
-  ".": 13,
-  "{": 13
-  // not sure this is correct
-};
-var POSTFIX_PRECEDENCE = 13;
-
-// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/tokenizer.js
-var TWO_CHAR_OPS = ["==", "!=", "<=", ">=", "||", "&&", "??", "|>"];
-var THREE_CHAR_OPS = ["===", "!=="];
-var Kind;
-(function(Kind2) {
-  Kind2[Kind2["STRING"] = 1] = "STRING";
-  Kind2[Kind2["IDENTIFIER"] = 2] = "IDENTIFIER";
-  Kind2[Kind2["DOT"] = 3] = "DOT";
-  Kind2[Kind2["COMMA"] = 4] = "COMMA";
-  Kind2[Kind2["COLON"] = 5] = "COLON";
-  Kind2[Kind2["INTEGER"] = 6] = "INTEGER";
-  Kind2[Kind2["DECIMAL"] = 7] = "DECIMAL";
-  Kind2[Kind2["OPERATOR"] = 8] = "OPERATOR";
-  Kind2[Kind2["GROUPER"] = 9] = "GROUPER";
-  Kind2[Kind2["KEYWORD"] = 10] = "KEYWORD";
-  Kind2[Kind2["ARROW"] = 11] = "ARROW";
-})(Kind || (Kind = {}));
-var token = (kind, value, precedence = 0) => ({
-  kind,
-  value,
-  precedence
-});
-var isWhitespace = (ch) => ch === 9 || ch === 10 || ch === 13 || ch === 32;
-var isIdentOrKeywordStart = (ch) => ch === 95 || ch === 36 || // ch &= ~32 puts ch into the range [65,90] [A-Z] only if ch was already in
-// the that range or in the range [97,122] [a-z]. We must mutate ch only after
-// checking other characters, thus the comma operator.
-(ch &= ~32, 65 <= ch && ch <= 90);
-var isIdentifier = (ch) => isIdentOrKeywordStart(ch) || isNumber(ch);
-var isKeyword = (str) => KEYWORDS.indexOf(str) !== -1;
-var isQuote = (ch) => ch === 34 || ch === 39;
-var isNumber = (ch) => 48 <= ch && ch <= 57;
-var isOperator = (ch) => ch === 43 || ch === 45 || ch === 42 || ch === 47 || ch === 33 || ch === 38 || ch === 37 || ch === 60 || ch === 61 || ch === 62 || ch === 63 || ch === 94 || ch === 124;
-var _isGrouper = (ch) => ch === 40 || ch === 41 || ch === 91 || ch === 93 || ch === 123 || ch === 125;
-var escapeString = (str) => str.replace(/\\(.)/g, (_match, group) => {
-  switch (group) {
-    case "n":
-      return "\n";
-    case "r":
-      return "\r";
-    case "t":
-      return "	";
-    case "b":
-      return "\b";
-    case "f":
-      return "\f";
-    default:
-      return group;
-  }
-});
-var Tokenizer = class {
-  #input;
-  #index = -1;
-  #tokenStart = 0;
-  #next;
-  constructor(input) {
-    this.#input = input;
-    this.#advance();
-  }
-  nextToken() {
-    while (isWhitespace(this.#next)) {
-      this.#advance(true);
-    }
-    if (isQuote(this.#next))
-      return this.#tokenizeString();
-    if (isIdentOrKeywordStart(this.#next)) {
-      return this.#tokenizeIdentOrKeyword();
-    }
-    if (isNumber(this.#next))
-      return this.#tokenizeNumber();
-    if (this.#next === 46)
-      return this.#tokenizeDot();
-    if (this.#next === 44)
-      return this.#tokenizeComma();
-    if (this.#next === 58)
-      return this.#tokenizeColon();
-    if (isOperator(this.#next))
-      return this.#tokenizeOperator();
-    if (_isGrouper(this.#next))
-      return this.#tokenizeGrouper();
-    this.#advance();
-    if (this.#next !== void 0) {
-      throw new Error(`Expected end of input, got ${this.#next}`);
-    }
-    return void 0;
-  }
-  #advance(resetTokenStart) {
-    this.#index++;
-    if (this.#index < this.#input.length) {
-      this.#next = this.#input.charCodeAt(this.#index);
-      if (resetTokenStart === true) {
-        this.#tokenStart = this.#index;
-      }
-    } else {
-      this.#next = void 0;
-    }
-  }
-  #getValue(lookahead = 0) {
-    const v = this.#input.substring(this.#tokenStart, this.#index + lookahead);
-    if (lookahead === 0) {
-      this.#clearValue();
-    }
-    return v;
-  }
-  #clearValue() {
-    this.#tokenStart = this.#index;
-  }
-  #tokenizeString() {
-    const _us = "unterminated string";
-    const quoteChar = this.#next;
-    this.#advance(true);
-    while (this.#next !== quoteChar) {
-      if (this.#next === void 0)
-        throw new Error(_us);
-      if (this.#next === 92) {
-        this.#advance();
-        if (this.#next === void 0)
-          throw new Error(_us);
-      }
-      this.#advance();
-    }
-    const t2 = token(Kind.STRING, escapeString(this.#getValue()));
-    this.#advance();
-    return t2;
-  }
-  #tokenizeIdentOrKeyword() {
-    do {
-      this.#advance();
-    } while (isIdentifier(this.#next));
-    const value = this.#getValue();
-    const kind = isKeyword(value) ? Kind.KEYWORD : Kind.IDENTIFIER;
-    return token(kind, value);
-  }
-  #tokenizeNumber() {
-    do {
-      this.#advance();
-    } while (isNumber(this.#next));
-    if (this.#next === 46)
-      return this.#tokenizeDot();
-    return token(Kind.INTEGER, this.#getValue());
-  }
-  #tokenizeDot() {
-    this.#advance();
-    if (isNumber(this.#next))
-      return this.#tokenizeFraction();
-    this.#clearValue();
-    return token(Kind.DOT, ".", POSTFIX_PRECEDENCE);
-  }
-  #tokenizeComma() {
-    this.#advance(true);
-    return token(Kind.COMMA, ",");
-  }
-  #tokenizeColon() {
-    this.#advance(true);
-    return token(Kind.COLON, ":");
-  }
-  #tokenizeFraction() {
-    do {
-      this.#advance();
-    } while (isNumber(this.#next));
-    return token(Kind.DECIMAL, this.#getValue());
-  }
-  #tokenizeOperator() {
-    this.#advance();
-    let op = this.#getValue(2);
-    if (THREE_CHAR_OPS.indexOf(op) !== -1) {
-      this.#advance();
-      this.#advance();
-    } else {
-      op = this.#getValue(1);
-      if (op === "=>") {
-        this.#advance();
-        return token(Kind.ARROW, op);
-      }
-      if (TWO_CHAR_OPS.indexOf(op) !== -1) {
-        this.#advance();
-      }
-    }
-    op = this.#getValue();
-    return token(Kind.OPERATOR, op, PRECEDENCE[op]);
-  }
-  #tokenizeGrouper() {
-    const value = String.fromCharCode(this.#next);
-    const t2 = token(Kind.GROUPER, value, PRECEDENCE[value]);
-    this.#advance(true);
-    return t2;
-  }
-};
-
-// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/parser.js
-var parse = (expr, astFactory2) => new Parser(expr, astFactory2).parse();
-var Parser = class {
-  #kind;
-  #tokenizer;
-  #ast;
-  #token;
-  #value;
-  constructor(input, astFactory2) {
-    this.#tokenizer = new Tokenizer(input);
-    this.#ast = astFactory2;
-  }
-  parse() {
-    this.#advance();
-    return this.#parseExpression();
-  }
-  #advance(kind, value) {
-    if (!this._matches(kind, value)) {
-      throw new Error(`Expected kind ${kind} (${value}), was ${this.#token?.kind} (${this.#token?.value})`);
-    }
-    const t2 = this.#tokenizer.nextToken();
-    this.#token = t2;
-    this.#kind = t2?.kind;
-    this.#value = t2?.value;
-  }
-  _matches(kind, value) {
-    return !(kind && this.#kind !== kind || value && this.#value !== value);
-  }
-  #parseExpression() {
-    if (!this.#token)
-      return this.#ast.empty();
-    const expr = this.#parseUnary();
-    return expr === void 0 ? void 0 : this.#parsePrecedence(expr, 0);
-  }
-  // #parsePrecedence and #parseBinary implement the precedence climbing
-  // algorithm as described in:
-  // http://en.wikipedia.org/wiki/Operator-precedence_parser#Precedence_climbing_method
-  #parsePrecedence(left, precedence) {
-    if (left === void 0) {
-      throw new Error("Expected left to be defined.");
-    }
-    while (this.#token) {
-      if (this._matches(Kind.GROUPER, "(")) {
-        const args = this.#parseArguments();
-        left = this.#ast.invoke(left, void 0, args);
-      } else if (this._matches(Kind.GROUPER, "[")) {
-        const indexExpr = this.#parseIndex();
-        left = this.#ast.index(left, indexExpr);
-      } else if (this._matches(Kind.DOT)) {
-        this.#advance();
-        const right = this.#parseUnary();
-        left = this.#makeInvokeOrGetter(left, right);
-      } else if (this._matches(Kind.KEYWORD)) {
-        break;
-      } else if (this._matches(Kind.OPERATOR) && this.#token.precedence >= precedence) {
-        left = this.#value === "?" ? this.#parseTernary(left) : this.#parseBinary(left, this.#token);
-      } else {
-        break;
-      }
-    }
-    return left;
-  }
-  #makeInvokeOrGetter(left, right) {
-    if (right === void 0) {
-      throw new Error("expected identifier");
-    }
-    if (right.type === "ID") {
-      return this.#ast.getter(left, right.value);
-    } else if (right.type === "Invoke" && right.receiver.type === "ID") {
-      const method = right.receiver;
-      return this.#ast.invoke(left, method.value, right.arguments);
-    } else {
-      throw new Error(`expected identifier: ${right}`);
-    }
-  }
-  #parseBinary(left, op) {
-    if (BINARY_OPERATORS.indexOf(op.value) === -1) {
-      throw new Error(`unknown operator: ${op.value}`);
-    }
-    this.#advance();
-    let right = this.#parseUnary();
-    while ((this.#kind === Kind.OPERATOR || this.#kind === Kind.DOT || this.#kind === Kind.GROUPER) && this.#token.precedence > op.precedence) {
-      right = this.#parsePrecedence(right, this.#token.precedence);
-    }
-    return this.#ast.binary(left, op.value, right);
-  }
-  #parseUnary() {
-    if (this._matches(Kind.OPERATOR)) {
-      const value = this.#value;
-      this.#advance();
-      if (value === "+" || value === "-") {
-        if (this._matches(Kind.INTEGER)) {
-          return this.#parseInteger(value);
-        } else if (this._matches(Kind.DECIMAL)) {
-          return this.#parseDecimal(value);
-        }
-      }
-      if (UNARY_OPERATORS.indexOf(value) === -1)
-        throw new Error(`unexpected token: ${value}`);
-      const expr = this.#parsePrecedence(this.#parsePrimary(), POSTFIX_PRECEDENCE);
-      return this.#ast.unary(value, expr);
-    }
-    return this.#parsePrimary();
-  }
-  #parseTernary(condition) {
-    this.#advance(Kind.OPERATOR, "?");
-    const trueExpr = this.#parseExpression();
-    this.#advance(Kind.COLON);
-    const falseExpr = this.#parseExpression();
-    return this.#ast.ternary(condition, trueExpr, falseExpr);
-  }
-  #parsePrimary() {
-    switch (this.#kind) {
-      case Kind.KEYWORD:
-        const keyword = this.#value;
-        if (keyword === "this") {
-          this.#advance();
-          return this.#ast.id(keyword);
-        } else if (KEYWORDS.indexOf(keyword) !== -1) {
-          throw new Error(`unexpected keyword: ${keyword}`);
-        }
-        throw new Error(`unrecognized keyword: ${keyword}`);
-      case Kind.IDENTIFIER:
-        return this.#parseInvokeOrIdentifier();
-      case Kind.STRING:
-        return this.#parseString();
-      case Kind.INTEGER:
-        return this.#parseInteger();
-      case Kind.DECIMAL:
-        return this.#parseDecimal();
-      case Kind.GROUPER:
-        if (this.#value === "(") {
-          return this.#parseParenOrFunction();
-        } else if (this.#value === "{") {
-          return this.#parseMap();
-        } else if (this.#value === "[") {
-          return this.#parseList();
-        }
-        return void 0;
-      case Kind.COLON:
-        throw new Error('unexpected token ":"');
-      default:
-        return void 0;
-    }
-  }
-  #parseList() {
-    const items = [];
-    do {
-      this.#advance();
-      if (this._matches(Kind.GROUPER, "]"))
-        break;
-      items.push(this.#parseExpression());
-    } while (this._matches(Kind.COMMA));
-    this.#advance(Kind.GROUPER, "]");
-    return this.#ast.list(items);
-  }
-  #parseMap() {
-    const entries = {};
-    do {
-      this.#advance();
-      if (this._matches(Kind.GROUPER, "}"))
-        break;
-      const key = this.#value;
-      if (this._matches(Kind.STRING) || this._matches(Kind.IDENTIFIER)) {
-        this.#advance();
-      }
-      this.#advance(Kind.COLON);
-      entries[key] = this.#parseExpression();
-    } while (this._matches(Kind.COMMA));
-    this.#advance(Kind.GROUPER, "}");
-    return this.#ast.map(entries);
-  }
-  #parseInvokeOrIdentifier() {
-    const value = this.#value;
-    if (value === "true") {
-      this.#advance();
-      return this.#ast.literal(true);
-    }
-    if (value === "false") {
-      this.#advance();
-      return this.#ast.literal(false);
-    }
-    if (value === "null") {
-      this.#advance();
-      return this.#ast.literal(null);
-    }
-    if (value === "undefined") {
-      this.#advance();
-      return this.#ast.literal(void 0);
-    }
-    const identifier = this.#parseIdentifier();
-    const args = this.#parseArguments();
-    return !args ? identifier : this.#ast.invoke(identifier, void 0, args);
-  }
-  #parseIdentifier() {
-    if (!this._matches(Kind.IDENTIFIER)) {
-      throw new Error(`expected identifier: ${this.#value}`);
-    }
-    const value = this.#value;
-    this.#advance();
-    return this.#ast.id(value);
-  }
-  #parseArguments() {
-    if (!this._matches(Kind.GROUPER, "(")) {
-      return void 0;
-    }
-    const args = [];
-    do {
-      this.#advance();
-      if (this._matches(Kind.GROUPER, ")")) {
-        break;
-      }
-      const expr = this.#parseExpression();
-      args.push(expr);
-    } while (this._matches(Kind.COMMA));
-    this.#advance(Kind.GROUPER, ")");
-    return args;
-  }
-  #parseIndex() {
-    this.#advance();
-    const expr = this.#parseExpression();
-    this.#advance(Kind.GROUPER, "]");
-    return expr;
-  }
-  #parseParenOrFunction() {
-    const expressions = this.#parseArguments();
-    if (this._matches(Kind.ARROW)) {
-      this.#advance();
-      const body = this.#parseExpression();
-      const params = expressions?.map((e2) => e2.value) ?? [];
-      return this.#ast.arrowFunction(params, body);
-    } else {
-      return this.#ast.paren(expressions[0]);
-    }
-  }
-  #parseString() {
-    const value = this.#ast.literal(this.#value);
-    this.#advance();
-    return value;
-  }
-  #parseInteger(prefix = "") {
-    const value = this.#ast.literal(parseInt(`${prefix}${this.#value}`, 10));
-    this.#advance();
-    return value;
-  }
-  #parseDecimal(prefix = "") {
-    const value = this.#ast.literal(parseFloat(`${prefix}${this.#value}`));
-    this.#advance();
-    return value;
-  }
-};
-
-// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/eval.js
-var { hasOwn, fromEntries } = Object;
-var _BINARY_OPERATORS = {
-  "+": (a, b) => a + b,
-  "-": (a, b) => a - b,
-  "*": (a, b) => a * b,
-  "/": (a, b) => a / b,
-  "%": (a, b) => a % b,
-  "==": (a, b) => a == b,
-  "!=": (a, b) => a != b,
-  "===": (a, b) => a === b,
-  "!==": (a, b) => a !== b,
-  ">": (a, b) => a > b,
-  ">=": (a, b) => a >= b,
-  "<": (a, b) => a < b,
-  "<=": (a, b) => a <= b,
-  "||": (a, b) => a || b,
-  "&&": (a, b) => a && b,
-  "??": (a, b) => a ?? b,
-  "|": (a, f) => f(a),
-  "|>": (a, f) => f(a)
-};
-var _UNARY_OPERATORS = {
-  "+": (a) => a,
-  "-": (a) => -a,
-  "!": (a) => !a
-};
-var EvalAstFactory = class {
-  empty() {
-    return {
-      type: "Empty",
-      evaluate(scope) {
-        return scope;
-      },
-      getIds(idents) {
-        return idents;
-      }
-    };
-  }
-  // TODO(justinfagnani): just use a JS literal?
-  literal(v) {
-    return {
-      type: "Literal",
-      value: v,
-      evaluate(_scope) {
-        return this.value;
-      },
-      getIds(idents) {
-        return idents;
-      }
-    };
-  }
-  id(v) {
-    return {
-      type: "ID",
-      value: v,
-      evaluate(scope) {
-        if (this.value === "this")
-          return scope;
-        return scope?.[this.value];
-      },
-      getIds(idents) {
-        idents.push(this.value);
-        return idents;
-      }
-    };
-  }
-  unary(op, expr) {
-    const f = _UNARY_OPERATORS[op];
-    return {
-      type: "Unary",
-      operator: op,
-      child: expr,
-      evaluate(scope) {
-        return f(this.child.evaluate(scope));
-      },
-      getIds(idents) {
-        return this.child.getIds(idents);
-      }
-    };
-  }
-  binary(l, op, r3) {
-    const f = _BINARY_OPERATORS[op];
-    return {
-      type: "Binary",
-      operator: op,
-      left: l,
-      right: r3,
-      evaluate(scope) {
-        if (this.operator === "=") {
-          if (this.left.type !== "ID" && this.left.type !== "Getter" && this.left.type !== "Index") {
-            throw new Error(`Invalid assignment target: ${this.left}`);
-          }
-          const value = this.right.evaluate(scope);
-          let receiver = void 0;
-          let property;
-          if (this.left.type === "Getter") {
-            receiver = this.left.receiver.evaluate(scope);
-            property = this.left.name;
-          } else if (this.left.type === "Index") {
-            receiver = this.left.receiver.evaluate(scope);
-            property = this.left.argument.evaluate(scope);
-          } else if (this.left.type === "ID") {
-            receiver = scope;
-            property = this.left.value;
-          }
-          return receiver === void 0 ? void 0 : receiver[property] = value;
-        }
-        return f(this.left.evaluate(scope), this.right.evaluate(scope));
-      },
-      getIds(idents) {
-        this.left.getIds(idents);
-        this.right.getIds(idents);
-        return idents;
-      }
-    };
-  }
-  getter(g, n2) {
-    return {
-      type: "Getter",
-      receiver: g,
-      name: n2,
-      evaluate(scope) {
-        return this.receiver.evaluate(scope)?.[this.name];
-      },
-      getIds(idents) {
-        this.receiver.getIds(idents);
-        return idents;
-      }
-    };
-  }
-  invoke(receiver, method, args) {
-    if (method != null && typeof method !== "string") {
-      throw new Error("method not a string");
-    }
-    return {
-      type: "Invoke",
-      receiver,
-      method,
-      arguments: args,
-      evaluate(scope) {
-        const receiver2 = this.receiver.evaluate(scope);
-        const _this = this.method ? receiver2 : scope?.["this"] ?? scope;
-        const f = this.method ? receiver2?.[method] : receiver2;
-        const args2 = this.arguments ?? [];
-        const argValues = args2.map((a) => a?.evaluate(scope));
-        return f?.apply?.(_this, argValues);
-      },
-      getIds(idents) {
-        this.receiver.getIds(idents);
-        this.arguments?.forEach((a) => a?.getIds(idents));
-        return idents;
-      }
-    };
-  }
-  paren(e2) {
-    return e2;
-  }
-  index(e2, a) {
-    return {
-      type: "Index",
-      receiver: e2,
-      argument: a,
-      evaluate(scope) {
-        return this.receiver.evaluate(scope)?.[this.argument.evaluate(scope)];
-      },
-      getIds(idents) {
-        this.receiver.getIds(idents);
-        return idents;
-      }
-    };
-  }
-  ternary(c2, t2, f) {
-    return {
-      type: "Ternary",
-      condition: c2,
-      trueExpr: t2,
-      falseExpr: f,
-      evaluate(scope) {
-        const c3 = this.condition.evaluate(scope);
-        if (c3) {
-          return this.trueExpr.evaluate(scope);
-        } else {
-          return this.falseExpr.evaluate(scope);
-        }
-      },
-      getIds(idents) {
-        this.condition.getIds(idents);
-        this.trueExpr.getIds(idents);
-        this.falseExpr.getIds(idents);
-        return idents;
-      }
-    };
-  }
-  map(entries) {
-    return {
-      type: "Map",
-      entries,
-      evaluate(scope) {
-        const map = {};
-        if (entries && this.entries) {
-          for (const key in entries) {
-            const val = this.entries[key];
-            if (val) {
-              map[key] = val.evaluate(scope);
-            }
-          }
-        }
-        return map;
-      },
-      getIds(idents) {
-        if (entries && this.entries) {
-          for (const key in entries) {
-            const val = this.entries[key];
-            if (val) {
-              val.getIds(idents);
-            }
-          }
-        }
-        return idents;
-      }
-    };
-  }
-  // TODO(justinfagnani): if the list is deeply literal
-  list(l) {
-    return {
-      type: "List",
-      items: l,
-      evaluate(scope) {
-        return this.items?.map((a) => a?.evaluate(scope));
-      },
-      getIds(idents) {
-        this.items?.forEach((i4) => i4?.getIds(idents));
-        return idents;
-      }
-    };
-  }
-  arrowFunction(params, body) {
-    return {
-      type: "ArrowFunction",
-      params,
-      body,
-      evaluate(scope) {
-        const params2 = this.params;
-        const body2 = this.body;
-        return function(...args) {
-          const paramsObj = fromEntries(params2.map((p, i4) => [p, args[i4]]));
-          const newScope = new Proxy(scope ?? {}, {
-            set(target, prop, value) {
-              if (hasOwn(paramsObj, prop)) {
-                paramsObj[prop] = value;
-              }
-              return target[prop] = value;
-            },
-            get(target, prop) {
-              if (hasOwn(paramsObj, prop)) {
-                return paramsObj[prop];
-              }
-              return target[prop];
-            }
-          });
-          return body2.evaluate(newScope);
-        };
-      },
-      getIds(idents) {
-        return this.body.getIds(idents).filter((id) => !this.params.includes(id));
-      }
-    };
-  }
-};
-
-// ../../node_modules/.pnpm/lit-html@3.3.1/node_modules/lit-html/node/private-ssr-support.js
-var r2 = null;
-var i3 = { boundAttributeSuffix: W.M, marker: W.P, markerMatch: W.A, HTML_RESULT: W.C, getTemplateHtml: W.L, overrideDirectiveResolve: (e2, t2) => class extends e2 {
-  _$AS(e3, r3) {
-    return t2(this, r3);
-  }
-}, patchDirectiveResolve: (e2, t2) => {
-  if (e2.prototype._$AS.name !== t2.name) {
-    r2 ??= e2.prototype._$AS.name;
-    for (let i4 = e2.prototype; i4 !== Object.prototype; i4 = Object.getPrototypeOf(i4)) if (i4.hasOwnProperty(r2)) return void (i4[r2] = t2);
-    throw Error("Internal error: It is possible that both dev mode and production mode Lit was mixed together during SSR. Please comment on the issue: https://github.com/lit/lit/issues/4527");
-  }
-}, setDirectiveClass(e2, t2) {
-  e2._$litDirective$ = t2;
-}, getAttributePartCommittedValue: (e2, r3, i4) => {
-  let o = w;
-  return e2.j = (e3) => o = e3, e2._$AI(r3, e2, i4), o;
-}, connectedDisconnectable: (e2) => ({ ...e2, _$AU: true }), resolveDirective: W.V, AttributePart: W.H, PropertyPart: W.B, BooleanAttributePart: W.N, EventPart: W.U, ElementPart: W.F, TemplateInstance: W.R, isIterable: W.D, ChildPart: W.I };
-
-// ../../node_modules/.pnpm/@heximal+templates@0.1.5/node_modules/@heximal/templates/index.js
-var { AttributePart, PropertyPart, BooleanAttributePart, EventPart } = i3;
-var astFactory = new EvalAstFactory();
-var expressionCache = /* @__PURE__ */ new Map();
-var toCamelCase = (s) => s.replace(/-(-|\w)/g, (_, p1) => p1.toUpperCase());
-var getSingleValue = (s, model) => {
-  let ast = expressionCache.get(s);
-  if (ast === void 0) {
-    if (expressionCache.has(s)) {
-      return void 0;
-    }
-    s = s.trim();
-    if (s.startsWith("{{") && s.endsWith("}}")) {
-      const expression = s.substring(2, s.length - 2).trim();
-      ast = new Parser(expression, astFactory).parse();
-      expressionCache.set(s, ast);
-    }
-  }
-  return ast?.evaluate(model);
-};
-var ifHandler = (template, model, handlers, renderers) => {
-  const ifAttribute = template.getAttribute("if");
-  if (ifAttribute !== null && getSingleValue(ifAttribute, model)) {
-    return evaluateTemplate(template, model, handlers, renderers);
-  }
-  return void 0;
-};
-var bindingRegex = /(?<!\\){{(.*?)(?:(?<!\\)}})/g;
-var hasEscapedBindingMarkers = (s) => /(?:\\{{)|(?:\\}})/g.test(s);
-var unescapeBindingMarkers = (s) => s.replaceAll(/\\{{/g, "{{").replace(/\\}}/g, "}}");
-var repeatHandler = (template, model, handlers, renderers) => {
-  const repeatAttribute = template.getAttribute("repeat");
-  if (repeatAttribute !== null) {
-    const items = getSingleValue(repeatAttribute, model);
-    if (!items[Symbol.iterator]) {
-      return E;
-    }
-    const litTemplate = getLitTemplate(template);
-    let index = -1;
-    const result = [];
-    for (const item of items) {
-      index++;
-      const itemModel = Object.create(model);
-      itemModel.item = item;
-      itemModel.index = index;
-      itemModel["this"] = model["this"] ?? model;
-      const values = [];
-      for (const part of litTemplate.parts) {
-        const value = part.update(itemModel, handlers, renderers);
-        if (part.type === 1) {
-          values.push(...value);
-        } else {
-          values.push(value);
-        }
-      }
-      const templateResult = {
-        _$litType$: litTemplate,
-        values
-      };
-      result.push(templateResult);
-    }
-    return result;
-  }
-  return void 0;
-};
-var defaultHandlers = {
-  if: ifHandler,
-  repeat: repeatHandler
-};
-var prepareTemplate = (template, handlers = defaultHandlers, renderers = {}, superTemplate) => {
-  const litTemplate = getLitTemplate(template);
-  const templateRenderers = litTemplate.renderers;
-  if (superTemplate) {
-    const superLitTemplate = getLitTemplate(superTemplate);
-    const superRenderers = superLitTemplate.renderers;
-    const superCallRenderer = templateRenderers["super"];
-    if (superCallRenderer !== void 0) {
-      renderers = {
-        // sub template's own renderes
-        ...templateRenderers,
-        // passed-in renderers
-        ...renderers,
-        // a super call renderer
-        super: (model, handlers2, renderers2) => {
-          renderers2 = {
-            // super template's own blocks
-            ...superRenderers,
-            // passed-in renderers
-            ...renderers2,
-            // sub template's overrides will be added by the inner super call
-            super: (model2, handlers3, renderers3) => {
-              return evaluateTemplate(superTemplate, model2, handlers3, renderers3);
-            }
-          };
-          return superCallRenderer(model, handlers2, renderers2);
-        }
-      };
-    } else {
-      renderers = {
-        // super template's own blocks
-        ...superRenderers,
-        // sub template's overrides
-        ...templateRenderers,
-        // passed-in renderers
-        ...renderers
-      };
-      template = superTemplate;
-    }
-  } else {
-    renderers = {
-      // template's named blocks
-      ...templateRenderers,
-      // passed-in renderers
-      ...renderers
-    };
-  }
-  return (model) => evaluateTemplate(template, model, handlers, renderers);
-};
-var evaluateTemplate = (template, model, handlers = defaultHandlers, renderers = {}) => {
-  const litTemplate = getLitTemplate(template);
-  const values = [];
-  for (const part of litTemplate.parts) {
-    const value = part.update(model, handlers, renderers);
-    if (part.type === 1) {
-      values.push(...value);
-    } else {
-      values.push(value);
-    }
-  }
-  const templateResult = {
-    _$litType$: litTemplate,
-    values
-  };
-  return templateResult;
-};
-var litTemplateCache = /* @__PURE__ */ new Map();
-var getLitTemplate = (template) => {
-  let litTemplate = litTemplateCache.get(template);
-  if (litTemplate === void 0) {
-    litTemplateCache.set(template, litTemplate = makeLitTemplate(template));
-  }
-  return litTemplate;
-};
-var makeLitTemplate = (template) => {
-  const litTemplate = {
-    h: void 0,
-    el: template.cloneNode(true),
-    parts: [],
-    renderers: {}
-  };
-  const walker = document.createTreeWalker(litTemplate.el.content, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_COMMENT);
-  let node = walker.currentNode;
-  let nodeIndex = -1;
-  const elementsToRemove = [];
-  while ((node = walker.nextNode()) !== null) {
-    if (node.nodeType === Node.COMMENT_NODE) {
-      nodeIndex++;
-    } else if (node.nodeType === Node.ELEMENT_NODE) {
-      nodeIndex++;
-      const element = node;
-      if (element.tagName === "TEMPLATE") {
-        const type = element.getAttribute("type");
-        const name = element.getAttribute("name");
-        const call = element.getAttribute("call");
-        if (call !== null || type !== null || name !== null) {
-          element.parentNode.insertBefore(document.createComment(""), element);
-          elementsToRemove.push(element);
-          let update;
-          if (call !== null) {
-            const templateName = call.trim();
-            const templateNameIsExpression = templateName.startsWith("{{") && templateName.endsWith("}}");
-            update = (model, handlers, renderers) => {
-              const dataAttr = element.getAttribute("data");
-              const data = dataAttr === null ? void 0 : getSingleValue(dataAttr, model);
-              const renderer = templateNameIsExpression ? getSingleValue(templateName, model) : renderers[call];
-              return renderer?.(data, handlers, renderers);
-            };
-          } else if (type !== null) {
-            update = (model, handlers, renderers) => {
-              const handler = handlers[type];
-              return handler?.(element, model, handlers, renderers);
-            };
-          } else {
-            if (name === "super") {
-              litTemplate.renderers["super"] = (model, handlers, renderers) => {
-                const superRenderer = renderers["super"];
-                const superCallTemplate = getLitTemplate(element);
-                renderers = {
-                  ...renderers,
-                  ...superCallTemplate.renderers
-                };
-                return superRenderer(model, handlers, renderers);
-              };
-            } else {
-              litTemplate.renderers[name] = (model, handlers, renderers) => {
-                return evaluateTemplate(element, model, handlers, renderers);
-              };
-            }
-            update = (model, handlers, renderers) => {
-              const renderer = renderers[name];
-              return renderer?.(model, handlers, renderers);
-            };
-          }
-          litTemplate.parts.push({
-            type: 2,
-            // text binding
-            index: nodeIndex,
-            update
-          });
-          continue;
-        }
-      }
-      const attributeNames = element.getAttributeNames();
-      for (const attributeName of attributeNames) {
-        const attributeValue = element.getAttribute(attributeName);
-        const splitValue = attributeValue.split(bindingRegex);
-        if (splitValue.length === 1) {
-          if (hasEscapedBindingMarkers(attributeValue)) {
-            element.setAttribute(attributeName, unescapeBindingMarkers(attributeValue));
-          }
-          continue;
-        }
-        element.removeAttribute(attributeName);
-        let name = attributeName;
-        let ctor = AttributePart;
-        const prefix = attributeName[0];
-        if (prefix === ".") {
-          name = toCamelCase(attributeName.substring(1));
-          ctor = PropertyPart;
-        } else if (prefix === "?") {
-          name = attributeName.substring(1);
-          ctor = BooleanAttributePart;
-        } else if (prefix === "@") {
-          name = toCamelCase(attributeName.substring(1));
-          ctor = EventPart;
-        }
-        const strings = [unescapeBindingMarkers(splitValue[0])];
-        const exprs = [];
-        for (let i4 = 1; i4 < splitValue.length; i4 += 2) {
-          const exprText = splitValue[i4];
-          exprs.push(parse(exprText, astFactory));
-          strings.push(unescapeBindingMarkers(splitValue[i4 + 1]));
-        }
-        litTemplate.parts.push({
-          type: 1,
-          // attribute binding
-          index: nodeIndex,
-          name,
-          strings,
-          ctor,
-          update: (model, _handlers, _renderers) => {
-            return exprs.map((expr) => expr.evaluate(model));
-          }
-        });
-      }
-    } else if (node.nodeType === Node.TEXT_NODE) {
-      let textNode = node;
-      const text = textNode.textContent;
-      const strings = text.split(bindingRegex);
-      if (strings.length > 1) {
-        textNode.textContent = unescapeBindingMarkers(strings[0]);
-      } else if (hasEscapedBindingMarkers(text)) {
-        textNode.textContent = unescapeBindingMarkers(text);
-      }
-      for (let i4 = 1; i4 < strings.length; i4 += 2) {
-        const exprText = strings[i4];
-        const expr = parse(exprText, astFactory);
-        litTemplate.parts.push({
-          type: 2,
-          index: ++nodeIndex,
-          update: (model, _handlers) => expr.evaluate(model)
-        });
-        const newTextNode = new Text(strings[i4 + 1].replace("\\{{", "{{"));
-        textNode.parentNode.insertBefore(newTextNode, textNode.nextSibling);
-        textNode.parentNode.insertBefore(document.createComment(""), textNode.nextSibling);
-        textNode = newTextNode;
-        walker.currentNode = newTextNode;
-      }
-    }
-  }
-  for (const e2 of elementsToRemove) {
-    e2.remove();
-  }
-  return litTemplate;
-};
-
-// ../qti-test/src/components/test-paging-buttons-stamp/test-paging-buttons-stamp.ts
-var TestPagingButtonsStamp = class extends i2 {
-  createRenderRoot() {
-    return this;
-  }
-  constructor() {
-    super();
-    this._internals = this.attachInternals();
-    this._internals.ariaLabel = "pagination";
-  }
-  connectedCallback() {
-    super.connectedCallback();
-    const templateElement = this.querySelector("template");
-    this.myTemplate = prepareTemplate(templateElement);
-  }
-  render() {
-    if (!this.computedContext) return x``;
-    const items = this.computedContext.testParts.flatMap(
-      (testPart) => testPart.sections.flatMap((section) => section.items)
-    );
-    return x` ${items.map((item) => this.myTemplate({ item, view: this.computedContext.view }))} `;
-  }
-};
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestPagingButtonsStamp.prototype, "computedContext", 2);
-TestPagingButtonsStamp = __decorateClass([
-  t("test-paging-buttons-stamp")
-], TestPagingButtonsStamp);
-
-// ../qti-test/src/components/test-container/test-container.ts
-var TestContainer = class extends i2 {
-  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 {
-      let api = await qtiTransformTest().load(this.testURL);
-      const qtiTest = this.closest("qti-test");
-      if (qtiTest?.postLoadTestTransformCallback) {
-        const tempDoc = api.htmlDoc();
-        const testElement = tempDoc.querySelector("qti-assessment-test");
-        if (testElement) {
-          api = await qtiTest.postLoadTestTransformCallback(api, testElement);
-        }
-      }
-      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 : x``;
-  }
-  applyStyles() {
-    const sheet = new CSSStyleSheet();
-    sheet.replaceSync(item_default);
-    this.shadowRoot.adoptedStyleSheets = [sheet];
-  }
-  render() {
-    return x`
-      ${this.templateContent}
-      <slot></slot>
-      ${m(this.testDoc, x`<span>Loading...</span>`)}
-    `;
-  }
-};
-__decorateClass([
-  n({ type: String, attribute: "test-url" })
-], TestContainer.prototype, "testURL", 2);
-__decorateClass([
-  r()
-], TestContainer.prototype, "testDoc", 2);
-__decorateClass([
-  r()
-], TestContainer.prototype, "testXML", 2);
-__decorateClass([
-  watch("testURL", { waitUntilFirstUpdate: true })
-], TestContainer.prototype, "handleTestURLChange", 1);
-__decorateClass([
-  watch("testXML", { waitUntilFirstUpdate: true })
-], TestContainer.prototype, "handleTestXMLChange", 1);
-TestContainer = __decorateClass([
-  t("test-container")
-], TestContainer);
-
-// ../qti-test/src/components/test-print-item-variables/test-print-item-variables.ts
-var TestPrintVariables = class extends i2 {
-  render() {
-    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
-    if (!activeItem || !activeItem.variables) return x``;
-    const responseVariables = activeItem.variables.filter((v) => v.type === "response");
-    const outcomeVariables = activeItem.variables.filter((v) => v.type === "outcome");
-    const renderTable = (variables, title) => x`
-      <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((m2) => `${m2.mapKey}=${m2.mappedValue}pt`).join(", ") || "";
-      const areaMapEntries = v.areaMapping?.areaMapEntries?.map((m2) => `${m2.shape}(${m2.coords})=${m2.mappedValue}pt`).join(", ") || "";
-      return x`
-              <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 x`
-      ${renderTable(responseVariables, "Response Variables")} ${renderTable(outcomeVariables, "Outcome Variables")}
-    `;
-  }
-};
-TestPrintVariables.styles = i`
-    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([
-  c({ context: computedContext, subscribe: true })
-], TestPrintVariables.prototype, "computedContext", 2);
-TestPrintVariables = __decorateClass([
-  t("test-print-item-variables")
-], TestPrintVariables);
-
-// ../qti-test/src/components/test-section-buttons-stamp/test-section-buttons-stamp.ts
-var TestSectionButtonsStamp = class extends i2 {
-  createRenderRoot() {
-    return this;
-  }
-  constructor() {
-    super();
-    this._internals = this.attachInternals();
-    this._internals.ariaLabel = "pagination";
-  }
-  connectedCallback() {
-    super.connectedCallback();
-    const templateElement = this.querySelector("template");
-    this.myTemplate = prepareTemplate(templateElement);
-  }
-  render() {
-    if (!this.computedContext) return x``;
-    const sections = this.computedContext.testParts.flatMap((testPart) => testPart.sections);
-    return x` ${sections.map((item) => this.myTemplate({ item }))} `;
-  }
-};
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestSectionButtonsStamp.prototype, "computedContext", 2);
-TestSectionButtonsStamp = __decorateClass([
-  t("test-section-buttons-stamp")
-], TestSectionButtonsStamp);
-
-// ../qti-test/src/components/test-section-link/test-section-link.ts
-var TestSectionLink = class extends i2 {
-  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 x` <slot></slot> `;
-  }
-};
-TestSectionLink.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-__decorateClass([
-  n({ type: String, attribute: "section-id" })
-], TestSectionLink.prototype, "sectionId", 2);
-TestSectionLink = __decorateClass([
-  t("test-section-link")
-], TestSectionLink);
-
-// ../qti-test/src/components/test-print-context/test-print-context.ts
-var TestPrintContext = class extends i2 {
-  render() {
-    return x` <small><pre>${JSON.stringify(this.computedContext, null, 2)}</pre></small> `;
-  }
-};
-__decorateClass([
-  r(),
-  c({ context: computedContext, subscribe: true })
-], TestPrintContext.prototype, "computedContext", 2);
-TestPrintContext = __decorateClass([
-  t("test-print-context")
-], TestPrintContext);
-
-// ../qti-test/src/components/test-stamp/test-stamp.ts
-var TestStamp = class extends i2 {
-  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 = prepareTemplate(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
-    };
-    this.dispatchEvent(
-      new CustomEvent("qti-stamp-context-updated", {
-        detail: this.stampContext,
-        bubbles: true
-      })
-    );
-  }
-  render() {
-    return x` ${this.debug ? x`<small><pre>${JSON.stringify(this.stampContext, null, 2)}</pre></small>` : E}
-    ${this.myTemplate ? this.myTemplate(this.stampContext) : E}`;
-  }
-};
-__decorateClass([
-  n({ type: Boolean, reflect: true })
-], TestStamp.prototype, "debug", 2);
-__decorateClass([
-  r(),
-  c({ context: computedContext, subscribe: true })
-], TestStamp.prototype, "computedContext", 2);
-__decorateClass([
-  r()
-], TestStamp.prototype, "stampContext", 2);
-TestStamp = __decorateClass([
-  t("test-stamp")
-], TestStamp);
-
-// ../qti-test/src/components/test-scoring-buttons/test-scoring-buttons.ts
-var TestScoringButtons = class extends i2 {
-  constructor() {
-    super();
-    this.view = "";
-    this.disabled = false;
-    this.myTemplate = null;
-    this.addEventListener("click", (e2) => {
-      const target = e2.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 = prepareTemplate(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 x``;
-    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 E;
-    const scores = [...Array(Number(maxScore) + 1).keys()];
-    return x`${this.myTemplate ? this.myTemplate({ scores, score, disabled }) : E}`;
-  }
-};
-__decorateClass([
-  n({ type: String, attribute: "view" })
-], TestScoringButtons.prototype, "view", 2);
-__decorateClass([
-  n({ type: Boolean })
-], TestScoringButtons.prototype, "disabled", 2);
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestScoringButtons.prototype, "computedContext", 2);
-TestScoringButtons = __decorateClass([
-  t("test-scoring-buttons")
-], TestScoringButtons);
-
-// ../qti-test/src/components/test-view-toggle/test-view-toggle.ts
-var TestViewToggle = class extends i2 {
-  createRenderRoot() {
-    return this;
-  }
-  connectedCallback() {
-    super.connectedCallback();
-    const templateElement = this.querySelector("template");
-    if (!templateElement) {
-      this.myTemplate = null;
-      return;
-    }
-    this.myTemplate = prepareTemplate(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 x`${this.myTemplate ? this.myTemplate({
-      view: this.sessionContext?.view
-    }) : E}`;
-  }
-};
-__decorateClass([
-  c({ context: sessionContext, subscribe: true })
-], TestViewToggle.prototype, "sessionContext", 2);
-TestViewToggle = __decorateClass([
-  t("test-view-toggle")
-], TestViewToggle);
-
-// ../qti-test/src/components/test-scoring-feedback/test-scoring-feedback.ts
-var TestScoringFeedback = class extends i2 {
-  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 x``;
-    if (activeItem["category"] === "dep-informational") return x`<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 x`<div>${feedbackText()}</div>`;
-  }
-};
-__decorateClass([
-  c({ context: computedContext, subscribe: true })
-], TestScoringFeedback.prototype, "computedContext", 2);
-__decorateClass([
-  n({ type: String, attribute: "view" })
-], TestScoringFeedback.prototype, "view", 2);
-TestScoringFeedback = __decorateClass([
-  t("test-scoring-feedback")
-], TestScoringFeedback);
-
-// ../qti-test/src/components/test-check-item/test-check-item.ts
-var TestCheckItem = class extends i2 {
-  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 x` <slot></slot> `;
-  }
-};
-TestCheckItem.styles = i`
-    :host {
-      ${btn};
-    }
-    :host([disabled]) {
-      ${dis};
-    }
-  `;
-TestCheckItem = __decorateClass([
-  t("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
-};
-/*! Bundled license information:
-
-@heximal/expressions/lib/constants.js:
-@heximal/expressions/lib/tokenizer.js:
-@heximal/expressions/lib/parser.js:
-@heximal/expressions/lib/ast_factory.js:
-@heximal/expressions/lib/eval.js:
-  (*
-   * @license
-   * Portions Copyright (c) 2013, the Dart project authors.
-   *)
-
-lit-html/node/private-ssr-support.js:
-  (**
-   * @license
-   * Copyright 2019 Google LLC
-   * SPDX-License-Identifier: BSD-3-Clause
-   *)
-*/
-//# sourceMappingURL=chunk-352OTVTY.js.map