@citolab/qti-components 7.28.1 → 8.0.1

package/dist/chunk-XU7HNT4F.js

@@ -0,0 +1,1608 @@
+import {
+  QtiTest,
+  TestCheckItem,
+  TestNavigation
+} from "./chunk-RXGDQDOV.js";
+import {
+  QtiAssessmentItem
+} from "./chunk-WVVMNF74.js";
+import {
+  QtiAssociateInteraction,
+  QtiChoiceInteraction,
+  QtiExtendedTextInteraction,
+  QtiGapMatchInteraction,
+  QtiGapText,
+  QtiGraphicAssociateInteraction,
+  QtiGraphicGapMatchInteraction,
+  QtiGraphicOrderInteraction,
+  QtiHotspotChoice,
+  QtiHotspotInteraction,
+  QtiHottext,
+  QtiHottextInteraction,
+  QtiInlineChoiceInteraction,
+  QtiMatchInteraction,
+  QtiOrderInteraction,
+  QtiPortableCustomInteraction,
+  QtiSelectPointInteraction,
+  QtiSimpleAssociableChoice,
+  QtiSimpleChoice,
+  QtiSliderInteraction,
+  QtiTextEntryInteraction,
+  c as c2,
+  o
+} from "./chunk-F4BNJWYN.js";
+import {
+  QtiItem
+} from "./chunk-QECOPVPO.js";
+import {
+  watch
+} from "./chunk-64XSIBGO.js";
+import {
+  A,
+  ScoringHelper,
+  T,
+  b,
+  c,
+  computedContext,
+  computedItemContext,
+  configContext,
+  i,
+  i2,
+  n2 as n,
+  r,
+  responseAttributeConverter
+} from "./chunk-H3J7LFRO.js";
+
+// ../qti-corrections/dist/mixins/correct-response.mixin.js
+var __decorate = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var Correctness;
+(function(Correctness2) {
+  Correctness2["Correct"] = "correct";
+  Correctness2["PartiallyCorrect"] = "partially-correct";
+  Correctness2["Incorrect"] = "incorrect";
+})(Correctness || (Correctness = {}));
+var CorrectResponseMixin = (superClass) => {
+  class CorrectResponseMixinClass extends superClass {
+    constructor() {
+      super(...arguments);
+      this.showCorrectResponse = false;
+      this._handleShowCorrectResponseChange = (_, show) => {
+        this.toggleInternalCorrectResponse(show);
+      };
+      this.showFullCorrectResponse = false;
+      this._handleShowFullCorrectResponseChange = (_, show) => {
+        this.toggleFullCorrectResponse(show);
+      };
+      this.showCandidateCorrection = false;
+      this._handleShowCandidateCorrectionChange = (_, show) => {
+        this.toggleCandidateCorrection(show);
+      };
+      this._correctResponse = null;
+    }
+    /**
+     * The correct response for this interaction. Can be set as a comma-separated
+     * string via attribute or as string/string[] via property.
+     *
+     * @example
+     * ```html
+     * <qti-choice-interaction correct-response="A,B">
+     * ```
+     */
+    set correctResponseAttr(val) {
+      this._correctResponse = val;
+    }
+    get correctResponseAttr() {
+      return this._correctResponse;
+    }
+    get isFullCorrectResponse() {
+      return this._isFullCorrectResponse;
+    }
+    get registersWithItem() {
+      return !this.isFullCorrectResponse && super.registersWithItem;
+    }
+    set isFullCorrectResponse(val) {
+      this._isFullCorrectResponse = val;
+      if (val) {
+        this.setAttribute("inert", "");
+        this.setAttribute("response-identifier", this.responseIdentifier + "_cr");
+        this.setAttribute("answer-key", "");
+      }
+    }
+    get correctResponse() {
+      const responseVariable = this.responseVariable;
+      if (responseVariable?.correctResponse) {
+        return responseVariable.correctResponse;
+      }
+      return this._correctResponse;
+    }
+    set correctResponse(val) {
+      const oldVal = this._correctResponse;
+      this._correctResponse = val;
+      if (val === null || val === void 0) {
+        this.removeAttribute("correct-response");
+      } else {
+        this.setAttribute("correct-response", Array.isArray(val) ? val.join(",") : val);
+      }
+      this.requestUpdate("_correctResponse", oldVal);
+    }
+    // ─── correctness getter ───────────────────────────────────────────────────
+    get correctness() {
+      const correctResponse = this.correctResponse;
+      if (!correctResponse)
+        return null;
+      const currentResponse = this.response;
+      if (currentResponse === null || currentResponse === void 0 || currentResponse === "" || Array.isArray(currentResponse) && currentResponse.length === 0) {
+        return null;
+      }
+      const correctArr = Array.isArray(correctResponse) ? correctResponse : [correctResponse];
+      const responseArr = Array.isArray(currentResponse) ? currentResponse : [currentResponse];
+      const filteredResponseArr = responseArr.filter((r2) => r2 !== "");
+      if (filteredResponseArr.length === 0)
+        return null;
+      const correctCount = filteredResponseArr.filter((r2) => correctArr.includes(r2)).length;
+      const incorrectCount = filteredResponseArr.filter((r2) => !correctArr.includes(r2)).length;
+      if (correctCount === correctArr.length && incorrectCount === 0 && filteredResponseArr.length === correctArr.length) {
+        return Correctness.Correct;
+      }
+      if (correctCount > 0 && (correctCount < correctArr.length || incorrectCount > 0)) {
+        return Correctness.PartiallyCorrect;
+      }
+      return Correctness.Incorrect;
+    }
+    // ─── correctionPart ───────────────────────────────────────────────────────
+    get correctionPart() {
+      return "correction";
+    }
+    // ─── toggle methods ───────────────────────────────────────────────────────
+    toggleCorrectResponse(show) {
+      const correctionConfig = this.configContext;
+      const correctResponseMode = correctionConfig?.correctResponseMode || "internal";
+      if (correctResponseMode === "full") {
+        this.toggleFullCorrectResponse(show);
+      } else {
+        this.toggleInternalCorrectResponse(show);
+      }
+    }
+    /**
+     * Whether the full correct response is withheld from a candidate who is already correct.
+     *
+     * Withheld by default, unless the item configures `fullCorrectResponseOnlyWhenIncorrect: false`
+     * — the behaviour `show-full-correct-response` has always had, on the reasoning that a correct
+     * answer already *is* the key.
+     *
+     * An interaction that routes its internal mode here overrides this to false: there, the caller
+     * asked to show the correct response, and silently showing nothing is worse than showing the
+     * candidate the answer they already gave.
+     */
+    get withholdsFullCorrectResponseWhenCorrect() {
+      return this.configContext?.fullCorrectResponseOnlyWhenIncorrect !== false;
+    }
+    async toggleFullCorrectResponse(show) {
+      const nextSibling = this.nextSibling;
+      const nextSiblingIsFullCorrectResponse = nextSibling instanceof HTMLDivElement && nextSibling?.classList.contains("full-correct-response");
+      const correctResponse = this.correctResponse;
+      if (!correctResponse) {
+        return;
+      }
+      const showFullCorrectResponse = show && (!this.withholdsFullCorrectResponseWhenCorrect || this.correctness !== Correctness.Correct);
+      if (!showFullCorrectResponse) {
+        if (!nextSiblingIsFullCorrectResponse) {
+          return;
+        }
+        this.parentElement?.removeChild(nextSibling);
+        return;
+      }
+      if (nextSiblingIsFullCorrectResponse) {
+        return;
+      }
+      const clone = this.cloneNode(true);
+      clone.removeAttribute("show-full-correct-response");
+      clone.removeAttribute("show-correct-response");
+      clone.removeAttribute("show-candidate-correction");
+      const containerDiv = document.createElement("div");
+      containerDiv.classList.add("full-correct-response");
+      if (this.isInline) {
+        containerDiv.classList.add("full-correct-response-inline");
+      } else {
+        containerDiv.classList.add("full-correct-response-block");
+      }
+      containerDiv.role = "full-correct-response";
+      containerDiv.appendChild(clone);
+      clone.isFullCorrectResponse = true;
+      this.parentElement?.insertBefore(containerDiv, this.nextSibling);
+      await clone.updateComplete;
+      clone.response = Array.isArray(correctResponse) ? [...correctResponse] : correctResponse;
+    }
+    toggleInternalCorrectResponse(show) {
+      this._internals.states.delete("show-correct-response");
+      if (show && this.correctResponse) {
+        this._internals.states.add("show-correct-response");
+      }
+    }
+    toggleCandidateCorrection(show) {
+      if (!show) {
+        return;
+      }
+    }
+    // ─── Lifecycle ────────────────────────────────────────────────────────────
+    firstUpdated() {
+      super.firstUpdated();
+      if (this.isFullCorrectResponse) {
+        return;
+      }
+      if (this.showCorrectResponse) {
+        this.toggleInternalCorrectResponse(true);
+      }
+      if (this.showFullCorrectResponse) {
+        this.toggleFullCorrectResponse(true);
+      }
+    }
+  }
+  __decorate([
+    n({
+      attribute: "correct-response",
+      reflect: true,
+      converter: responseAttributeConverter({ emptyAs: null })
+    })
+  ], CorrectResponseMixinClass.prototype, "correctResponseAttr", null);
+  __decorate([
+    n({ type: Boolean, attribute: "show-correct-response", reflect: true })
+  ], CorrectResponseMixinClass.prototype, "showCorrectResponse", void 0);
+  __decorate([
+    watch("showCorrectResponse", { waitUntilFirstUpdate: true })
+  ], CorrectResponseMixinClass.prototype, "_handleShowCorrectResponseChange", void 0);
+  __decorate([
+    n({ type: Boolean, attribute: "show-full-correct-response", reflect: true })
+  ], CorrectResponseMixinClass.prototype, "showFullCorrectResponse", void 0);
+  __decorate([
+    watch("showFullCorrectResponse", { waitUntilFirstUpdate: true })
+  ], CorrectResponseMixinClass.prototype, "_handleShowFullCorrectResponseChange", void 0);
+  __decorate([
+    n({ type: Boolean, attribute: "show-candidate-correction", reflect: true })
+  ], CorrectResponseMixinClass.prototype, "showCandidateCorrection", void 0);
+  __decorate([
+    watch("showCandidateCorrection", { waitUntilFirstUpdate: true })
+  ], CorrectResponseMixinClass.prototype, "_handleShowCandidateCorrectionChange", void 0);
+  __decorate([
+    r()
+  ], CorrectResponseMixinClass.prototype, "_isFullCorrectResponse", void 0);
+  __decorate([
+    r()
+  ], CorrectResponseMixinClass.prototype, "_correctResponse", void 0);
+  return CorrectResponseMixinClass;
+};
+
+// ../qti-corrections/dist/styles/correction.styles.js
+var correctionPart = i`
+  /* Nothing at all until the item judges this element. */
+  [part~='correction'] {
+    display: none;
+  }
+
+  [part~='correction-correct'],
+  [part~='correction-incorrect'],
+  [part~='correction-partially-correct'] {
+    display: inline-flex;
+    flex: 0 0 auto;
+
+    /*
+     * The badge aligns ITSELF, and that is the whole of the vertical story.
+     *
+     * It is a flex item with a definite height, so left alone its cross-axis position is decided by
+     * whatever its host says — and the hosts disagree: qti-simple-associable-choice defaults to
+     * align-items: normal, and qti-gap-text gates center behind :not([part~='drag']), so the
+     * same chip centred its badge in the bank and top-aligned it once placed. align-self settles it
+     * from the badge's side, in one line, without touching a single container.
+     *
+     * This replaces an align-items/justify-content: center pair that had never done anything: the
+     * badge is empty — a mask painted over a background — so centring its CONTENTS centres nothing.
+     */
+    align-self: center;
+
+    box-sizing: border-box;
+    width: var(--qti-correction-size, 1em);
+    height: var(--qti-correction-size, 1em);
+    margin-left: var(--qti-glyph-gap, 0.5em);
+
+    pointer-events: none;
+  }
+`;
+
+// ../qti-corrections/dist/mixins/candidate-correction.mixin.js
+var __decorate2 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var CandidateCorrectionMixin = (superClass) => {
+  class CandidateCorrectionMixinClass extends CorrectResponseMixin(superClass) {
+    constructor() {
+      super(...arguments);
+      this._candidateCorrection = null;
+    }
+    get correctionPart() {
+      return this._candidateCorrection ? `correction correction-${this._candidateCorrection}` : "correction";
+    }
+    toggleCandidateCorrection(show) {
+      if (this.showCandidateCorrection !== show) {
+        this.showCandidateCorrection = show;
+      }
+      super.toggleCandidateCorrection(show);
+      const internals = this._internals;
+      internals.states.delete("candidate-correct");
+      internals.states.delete("candidate-partially-correct");
+      internals.states.delete("candidate-incorrect");
+      let verdict = null;
+      if (show) {
+        if (this.correctness === Correctness.Correct) {
+          internals.states.add("candidate-correct");
+          verdict = "correct";
+        }
+        if (this.correctness === Correctness.PartiallyCorrect) {
+          internals.states.add("candidate-partially-correct");
+          verdict = "partially-correct";
+        }
+        if (this.correctness === Correctness.Incorrect) {
+          internals.states.add("candidate-incorrect");
+          verdict = "incorrect";
+        }
+      }
+      if (this._candidateCorrection !== verdict) {
+        this._candidateCorrection = verdict;
+      }
+    }
+    connectedCallback() {
+      super.connectedCallback?.();
+      queueMicrotask(() => {
+        if (!this.isConnected || this.isFullCorrectResponse) {
+          return;
+        }
+        if (this.showCandidateCorrection) {
+          this.toggleCandidateCorrection(true);
+        }
+      });
+    }
+  }
+  __decorate2([
+    r()
+  ], CandidateCorrectionMixinClass.prototype, "_candidateCorrection", void 0);
+  return CandidateCorrectionMixinClass;
+};
+
+// ../qti-corrections/dist/mixins/choice-correction.mixin.js
+var ChoiceCorrectionMixin = (superClass) => {
+  class ChoiceCorrectionMixinClass extends CandidateCorrectionMixin(superClass) {
+    toggleInternalCorrectResponse(show) {
+      super.toggleInternalCorrectResponse(show);
+      const correctResponse = this.correctResponse;
+      const correctResponses = correctResponse ? Array.isArray(correctResponse) ? correctResponse : [correctResponse] : [];
+      for (const choice of this._choiceElements) {
+        choice.internals.states.delete("correct-response");
+        choice.internals.states.delete("incorrect-response");
+        if (show && correctResponses.length > 0) {
+          choice.internals.states.add(correctResponses.includes(choice.identifier) ? "correct-response" : "incorrect-response");
+        }
+      }
+    }
+    toggleCandidateCorrection(show) {
+      super.toggleCandidateCorrection(show);
+      for (const choice of this._choiceElements) {
+        choice.candidateCorrection = null;
+      }
+      if (!show || !this.correctResponse) {
+        return;
+      }
+      const correctResponses = Array.isArray(this.correctResponse) ? this.correctResponse : [this.correctResponse];
+      const candidateResponses = Array.isArray(this.response) ? this.response : this.response ? [this.response] : [];
+      for (const choice of this._choiceElements) {
+        if (!candidateResponses.includes(choice.identifier)) {
+          continue;
+        }
+        choice.candidateCorrection = correctResponses.includes(choice.identifier) ? "correct" : "incorrect";
+      }
+    }
+  }
+  return ChoiceCorrectionMixinClass;
+};
+
+// ../qti-corrections/dist/mixins/active-element-correction.mixin.js
+var ActiveElementCorrectionMixin = (superClass) => {
+  class ActiveElementCorrectionMixinClass extends superClass {
+    #candidateCorrection = null;
+    get candidateCorrection() {
+      return this.#candidateCorrection;
+    }
+    set candidateCorrection(value) {
+      if (this.#candidateCorrection === value)
+        return;
+      const previous = this.#candidateCorrection;
+      this.#candidateCorrection = value;
+      const states = this.internals.states;
+      states.delete("candidate-correct");
+      states.delete("candidate-incorrect");
+      states.delete("candidate-partially-correct");
+      if (value)
+        states.add(`candidate-${value}`);
+      this.requestUpdate("candidateCorrection", previous);
+    }
+    get correctionPart() {
+      return this.#candidateCorrection ? `correction correction-${this.#candidateCorrection}` : "correction";
+    }
+  }
+  return ActiveElementCorrectionMixinClass;
+};
+
+// ../qti-corrections/dist/elements/qti-gap-text-correction.js
+var QtiGapTextCorrection = class extends ActiveElementCorrectionMixin(QtiGapText) {
+  static {
+    this.styles = [QtiGapText.styles, correctionPart];
+  }
+  render() {
+    return T`<div part="control"></div>
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+  }
+};
+
+// ../qti-corrections/dist/elements/qti-hotspot-choice-correction.js
+var __decorate3 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var QtiHotspotChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiHotspotChoice) {
+  constructor() {
+    super(...arguments);
+    this.orderCorrect = null;
+  }
+};
+__decorate3([
+  n({ attribute: "aria-ordercorrectvalue", type: Number, reflect: true })
+], QtiHotspotChoiceCorrection.prototype, "orderCorrect", void 0);
+
+// ../qti-corrections/dist/elements/qti-hottext-correction.js
+var QtiHottextCorrection = class extends ActiveElementCorrectionMixin(QtiHottext) {
+  static {
+    this.styles = [QtiHottext.styles, correctionPart];
+  }
+  render() {
+    return T`<div part="control"><div part="control-mark"></div></div>
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+  }
+};
+
+// ../qti-corrections/dist/elements/qti-simple-associable-choice-correction.js
+var QtiSimpleAssociableChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiSimpleAssociableChoice) {
+  static {
+    this.styles = [QtiSimpleAssociableChoice.styles, correctionPart];
+  }
+  render() {
+    return T`
+      <div part="control"></div>
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>
+      <div part="drop">
+        ${c2(this.drags, (node) => node.getAttribute("identifier"), (node) => node)}
+      </div>
+    `;
+  }
+};
+
+// ../qti-corrections/dist/elements/qti-simple-choice-correction.js
+var QtiSimpleChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiSimpleChoice) {
+  static {
+    this.styles = [QtiSimpleChoice.styles, correctionPart];
+  }
+  render() {
+    return T`<div part="control" tabindex="0"><div part="control-mark"></div></div>
+      ${this.marker ? T`<div id="label" part="marker">${this.marker}</div>` : A}
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+  }
+};
+
+// ../qti-corrections/dist/components/qti-assessment-item-correction.js
+var QtiAssessmentItemCorrection = class extends QtiAssessmentItem {
+  showCorrectResponse(show) {
+    for (const interaction of this.interactionElements) {
+      interaction.toggleCorrectResponse?.(show);
+    }
+    this.updateControlState("item-show-correct-response", show);
+  }
+  showCandidateCorrection(show) {
+    for (const interaction of this.interactionElements) {
+      interaction.toggleCandidateCorrection?.(show);
+    }
+    this.updateControlState("item-show-candidate-correction", show);
+  }
+  afterResponseVariableUpdated() {
+    this.showCandidateCorrection(false);
+  }
+  updateControlState(selector, shown) {
+    let root = this.getRootNode();
+    while (true) {
+      root.querySelectorAll(selector).forEach((control) => control.shown = shown);
+      if (!(root instanceof ShadowRoot))
+        return;
+      root = root.host.getRootNode();
+    }
+  }
+};
+
+// ../qti-corrections/dist/components/qti-item-correction.js
+var QtiItemCorrection = class extends QtiItem {
+  #onShowCorrectResponse = (event) => {
+    const show = event.detail;
+    this.assessmentItem?.showCorrectResponse?.(show);
+    this.updateControlState("item-show-correct-response", show);
+  };
+  #onShowCandidateCorrection = (event) => {
+    const show = event.detail;
+    this.assessmentItem?.showCandidateCorrection?.(show);
+    this.updateControlState("item-show-candidate-correction", show);
+  };
+  #onSwitchCorrectResponseMode = (event) => {
+    this.assessmentItem?.showCorrectResponse?.(false);
+    this.configContext = {
+      ...this.configContext,
+      correctResponseMode: event.detail
+    };
+  };
+  constructor() {
+    super();
+    this.addEventListener("item-show-correct-response", this.#onShowCorrectResponse);
+    this.addEventListener("item-show-candidate-correction", this.#onShowCandidateCorrection);
+    this.addEventListener("item-switch-correct-response-mode", this.#onSwitchCorrectResponseMode);
+  }
+  updateControlState(selector, shown) {
+    this.querySelectorAll(selector).forEach((control) => control.shown = shown);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("item-show-correct-response", this.#onShowCorrectResponse);
+    this.removeEventListener("item-show-candidate-correction", this.#onShowCandidateCorrection);
+    this.removeEventListener("item-switch-correct-response-mode", this.#onSwitchCorrectResponseMode);
+    super.disconnectedCallback();
+  }
+};
+
+// ../qti-corrections/dist/components/test-correction-elements.js
+var TestNavigationCorrection = class extends TestNavigation {
+  #onShowCorrectResponse = (event) => {
+    this.activeAssessmentItem?.showCorrectResponse?.(event.detail);
+  };
+  #onShowCandidateCorrection = (event) => {
+    this.activeAssessmentItem?.showCandidateCorrection?.(event.detail);
+  };
+  constructor() {
+    super();
+    this.addEventListener("test-show-correct-response", this.#onShowCorrectResponse);
+    this.addEventListener("test-show-candidate-correction", this.#onShowCandidateCorrection);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("test-show-correct-response", this.#onShowCorrectResponse);
+    this.removeEventListener("test-show-candidate-correction", this.#onShowCandidateCorrection);
+    super.disconnectedCallback();
+  }
+};
+var QtiTestCorrection = class extends QtiTest {
+  updateAssessmentItemView(assessmentItem, view) {
+    assessmentItem.showCorrectResponse?.(view === "scorer");
+  }
+};
+var TestCheckItemCorrection = class extends TestCheckItem {
+  constructor() {
+    super();
+    this.addEventListener("click", () => {
+      this.dispatchEvent(new CustomEvent("test-show-correct-response", { detail: true, bubbles: true }));
+    });
+  }
+};
+
+// ../qti-corrections/dist/components/item-correct-response-mode/item-correct-response-mode.js
+var __decorate4 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var ItemCorrectResponseMode = class extends i2 {
+  constructor() {
+    super(...arguments);
+    this.label = "Correct response mode";
+    this._options = {
+      internal: "Internal",
+      full: "Full (copy)"
+    };
+  }
+  #switchMode(view) {
+    this.dispatchEvent(new CustomEvent("item-switch-correct-response-mode", {
+      detail: view,
+      bubbles: true
+    }));
+  }
+  render() {
+    return T`
+      <label part="label" for="modeSelect">${this.label}</label>
+      <select
+        part="select"
+        id="modeSelect"
+        @change=${(e) => {
+      const el = e.target;
+      this.#switchMode(el.value);
+    }}
+      >
+        ${Object.keys(this._options).map((value) => T`<option value="${value}" ?selected=${value === this.itemContext?.correctResponseMode}>
+              ${this._options[value]}
+            </option>`)}
+      </select>
+    `;
+  }
+};
+__decorate4([
+  c({ context: configContext, subscribe: true })
+], ItemCorrectResponseMode.prototype, "itemContext", void 0);
+__decorate4([
+  n({ type: String })
+], ItemCorrectResponseMode.prototype, "label", void 0);
+__decorate4([
+  r()
+], ItemCorrectResponseMode.prototype, "_options", void 0);
+
+// ../qti-corrections/dist/components/styles.js
+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-corrections/dist/components/item-show-candidate-correction/item-show-candidate-correction.js
+var __decorate5 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var ItemShowCandidateCorrection = class extends i2 {
+  static {
+    this.styles = i`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+  }
+  #hasCorrectResponse;
+  // correct response is removed on certain point
+  #previousActiveItem;
+  // Store previous active item reference
+  constructor() {
+    super();
+    this.shown = false;
+    this.disabled = false;
+    this.showCandidateCorrectionText = "Show candidate correction";
+    this.hideCandidateCorrectionText = "Hide candidate correction";
+    this.noCorrectResponseText = "No correct response specified";
+    this.#hasCorrectResponse = false;
+    this.#previousActiveItem = "";
+  }
+  updated() {
+    if (!this.#hasCorrectResponse || this.#previousActiveItem !== this.computedContext?.identifier) {
+      this.#previousActiveItem = this.computedContext?.identifier;
+      const containsCorrectResponse = !!this.computedContext?.variables.some((v) => v["correctResponse"]);
+      const containsMapping = !!this.computedContext?.variables.some((v) => {
+        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+      });
+      this.#hasCorrectResponse = containsCorrectResponse || containsMapping;
+    }
+    this.disabled = !this.#hasCorrectResponse;
+  }
+  #toggleState() {
+    if (this.disabled)
+      return;
+    this.dispatchEvent(new CustomEvent("item-show-candidate-correction", {
+      detail: !this.shown,
+      bubbles: true
+    }));
+  }
+  #getDisplayedText() {
+    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCandidateCorrectionText : this.showCandidateCorrectionText;
+  }
+  render() {
+    return T` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
+  }
+};
+__decorate5([
+  c({ context: computedItemContext, subscribe: true })
+], ItemShowCandidateCorrection.prototype, "computedContext", void 0);
+__decorate5([
+  n({ type: Boolean, reflect: true })
+], ItemShowCandidateCorrection.prototype, "shown", void 0);
+__decorate5([
+  n({ type: Boolean, reflect: true })
+], ItemShowCandidateCorrection.prototype, "disabled", void 0);
+__decorate5([
+  n({ type: String })
+], ItemShowCandidateCorrection.prototype, "showCandidateCorrectionText", void 0);
+__decorate5([
+  n({ type: String })
+], ItemShowCandidateCorrection.prototype, "hideCandidateCorrectionText", void 0);
+__decorate5([
+  n({ type: String })
+], ItemShowCandidateCorrection.prototype, "noCorrectResponseText", void 0);
+
+// ../qti-corrections/dist/components/item-show-correct-response/item-show-correct-response.js
+var __decorate6 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var ItemShowCorrectResponse = 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";
+    this.#hasCorrectResponse = false;
+    this.#previousActiveItem = "";
+  }
+  static {
+    this.styles = i`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+  }
+  #hasCorrectResponse;
+  // correct response is removed on certain point
+  #previousActiveItem;
+  // Store previous active item reference
+  updated() {
+    if (!this.#hasCorrectResponse || this.#previousActiveItem !== this.computedContext?.identifier) {
+      this.#previousActiveItem = this.computedContext?.identifier;
+      const containsCorrectResponse = !!this.computedContext?.variables.some((v) => v["correctResponse"]);
+      const containsMapping = !!this.computedContext?.variables.some((v) => {
+        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+      });
+      this.#hasCorrectResponse = containsCorrectResponse || containsMapping;
+    }
+    this.disabled = !this.#hasCorrectResponse;
+  }
+  #toggleState() {
+    if (this.disabled)
+      return;
+    this.dispatchEvent(new CustomEvent("item-show-correct-response", {
+      detail: !this.shown,
+      bubbles: true
+    }));
+  }
+  #getDisplayedText() {
+    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
+  }
+  render() {
+    return T` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
+  }
+};
+__decorate6([
+  c({ context: computedItemContext, subscribe: true })
+], ItemShowCorrectResponse.prototype, "computedContext", void 0);
+__decorate6([
+  n({ type: Boolean, reflect: true })
+], ItemShowCorrectResponse.prototype, "shown", void 0);
+__decorate6([
+  n({ type: Boolean, reflect: true })
+], ItemShowCorrectResponse.prototype, "disabled", void 0);
+__decorate6([
+  n({ type: String })
+], ItemShowCorrectResponse.prototype, "showCorrectText", void 0);
+__decorate6([
+  n({ type: String })
+], ItemShowCorrectResponse.prototype, "hideCorrectText", void 0);
+__decorate6([
+  n({ type: String })
+], ItemShowCorrectResponse.prototype, "noCorrectResponseText", void 0);
+
+// ../qti-corrections/dist/components/test-show-correct-response/test-show-correct-response.js
+var __decorate7 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+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";
+  }
+  static {
+    this.styles = i`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
+  }
+  #previousActiveItem;
+  // 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 T` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
+  }
+};
+__decorate7([
+  c({ context: computedContext, subscribe: true })
+], TestShowCorrectResponse.prototype, "computedContext", void 0);
+__decorate7([
+  n({ type: Boolean, reflect: true })
+], TestShowCorrectResponse.prototype, "shown", void 0);
+__decorate7([
+  n({ type: Boolean, reflect: true })
+], TestShowCorrectResponse.prototype, "disabled", void 0);
+__decorate7([
+  n({ type: String })
+], TestShowCorrectResponse.prototype, "showCorrectText", void 0);
+__decorate7([
+  n({ type: String })
+], TestShowCorrectResponse.prototype, "hideCorrectText", void 0);
+__decorate7([
+  n({ type: String })
+], TestShowCorrectResponse.prototype, "noCorrectResponseText", void 0);
+
+// ../qti-corrections/dist/mixins/drag-drop-correction.mixin.js
+var DragDropCorrectionMixin = (superClass) => {
+  class DragDropCorrectionMixinClass extends CandidateCorrectionMixin(superClass) {
+    toggleInternalCorrectResponse(show) {
+      if (!this.showFullCorrectResponse) {
+        this.toggleFullCorrectResponse(show);
+      }
+    }
+    afterCache() {
+      super.afterCache();
+      if (this.showCorrectResponse)
+        this.toggleInternalCorrectResponse(true);
+      if (this.showCandidateCorrection)
+        this.toggleCandidateCorrection(true);
+      if (this.showFullCorrectResponse)
+        this.toggleFullCorrectResponse(true);
+    }
+  }
+  return DragDropCorrectionMixinClass;
+};
+
+// ../qti-corrections/dist/interactions/qti-associate-interaction-correction.js
+var QtiAssociateInteractionCorrection = class extends DragDropCorrectionMixin(QtiAssociateInteraction) {
+};
+
+// ../qti-corrections/dist/interactions/qti-choice-interaction-correction.js
+var QtiChoiceInteractionCorrection = class extends ChoiceCorrectionMixin(QtiChoiceInteraction) {
+};
+
+// ../qti-corrections/dist/interactions/qti-extended-text-interaction-correction.js
+var __decorate8 = function(decorators, target, key, desc) {
+  var c3 = arguments.length, r2 = c3 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i3 = decorators.length - 1; i3 >= 0; i3--) if (d = decorators[i3]) r2 = (c3 < 3 ? d(r2) : c3 > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c3 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+};
+var QtiExtendedTextInteractionCorrection = class extends ActiveElementCorrectionMixin(QtiExtendedTextInteraction) {
+  static {
+    this.styles = [
+      QtiExtendedTextInteraction.styles,
+      correctionPart,
+      i`
+      /*
+       * Placement only — the glyph itself is the theme's, keyed on ::part(correction-*). That split
+       * is the contract in correction.styles.ts, which deliberately leaves the shared badge in flow
+       * and invites a component to lift it out if it wants a corner badge.
+       *
+       * A textarea is a box the candidate writes in, so the badge goes over its top-left corner
+       * rather than trailing the text the way a chip's does, and the theme reserves the gutter for it
+       * (padding-left on ::part(textarea)).
+       *
+       * Anchored to the TEXTAREA, not to the host. The badge's containing block is :host, and the
+       * host also contains the prompt slot — so a plain top: 0.85rem measured from the host lands on
+       * the prompt and the badge floats above the field, which is exactly what it did. Only the
+       * vertical offset needs anchoring: the textarea spans the host's full width, so the left
+       * offset is the same measured from either.
+       */
+      [part~='textarea'] {
+        anchor-name: --qti-extended-text-field;
+      }
+
+      [part~='correction'] {
+        position: absolute;
+        position-anchor: --qti-extended-text-field;
+        margin: 0;
+        width: var(--qti-correction-size);
+
+        /*
+         * One FIELD line tall, not square — this is what puts the glyph on the text rather than near
+         * it. The mask is drawn center / contain, so in a box exactly one line high it centres itself
+         * on that line while the width still governs the glyph's size.
+         *
+         * Not 1lh: that unit resolves against the BADGE's own inherited line-height (measured 18.4px),
+         * not the textarea's (24px), so it landed a third of a line low. --qti-field-line-height is
+         * the same number @mixin field-typography gives the field, so the two cannot drift.
+         */
+        height: calc(var(--qti-correction-size) * var(--qti-field-line-height));
+
+        /* Inset exactly as the text is: the same trailing token the two field-shaped interactions
+           use, read here as a LEADING inset because this badge lives in a left gutter. */
+        left: var(--qti-correction-inset);
+
+        /* Anchored to the field's first line: its top edge plus the field's own padding-top. */
+        top: calc(anchor(top) + var(--qti-spacing));
+      }
+
+      /*
+       * Fallback for engines without anchor positioning, where the top above does not parse and the
+       * badge would fall to its static position below the field. The bottom of the gutter needs no
+       * knowledge of where the field starts, and the gutter runs the full height, so the badge still
+       * clears the text.
+       *
+       * Scoped by @supports rather than declared alongside. Both were set at first, on the assumption
+       * that top + height over-constrains the box and bottom is ignored — it is not: measured, the
+       * bottom won and put the badge on the third line.
+       */
+      @supports not (anchor-name: --probe) {
+        [part~='correction'] {
+          top: auto;
+          bottom: var(--qti-correction-inset);
+        }
+      }
+    `
+    ];
+  }
+  /** The badge goes between the field and the validation message; everything else is the base's. */
+  render() {
+    return T`${this.renderPrompt()}${this.renderTextarea()}
+      <span part=${this.correctionPart} aria-hidden="true"></span>
+      ${this.renderValidationMessage()}`;
+  }
+};
+__decorate8([
+  n({ attribute: "candidate-correction", reflect: true, noAccessor: true })
+], QtiExtendedTextInteractionCorrection.prototype, "candidateCorrection", void 0);
+
+// ../qti-corrections/dist/interactions/shared.js
+var parsePairs = (response) => {
+  if (!response)
+    return [];
+  const entries = Array.isArray(response) ? response : [response];
+  return entries.map((entry) => {
+    const [source, target] = entry.split(" ");
+    return { source, target };
+  });
+};
+
+// ../qti-corrections/dist/interactions/qti-gap-match-interaction-correction.js
+var QtiGapMatchInteractionCorrection = class extends DragDropCorrectionMixin(QtiGapMatchInteraction) {
+  toggleCandidateCorrection(show) {
+    super.toggleCandidateCorrection(show);
+    const matches = parsePairs(this.correctResponse);
+    for (const target of this.querySelectorAll("qti-gap")) {
+      const targetId = target.getAttribute("identifier");
+      const selectedChoices = target.drags;
+      for (const choice of selectedChoices) {
+        choice.candidateCorrection = null;
+        if (show && matches.some((match) => match.source === choice.identifier && match.target === targetId)) {
+          choice.candidateCorrection = "correct";
+        } else if (show) {
+          choice.candidateCorrection = "incorrect";
+        }
+      }
+    }
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-graphic-associate-interaction-correction.js
+var QtiGraphicAssociateInteractionCorrection = class extends CandidateCorrectionMixin(QtiGraphicAssociateInteraction) {
+  #correctLines = [];
+  toggleInternalCorrectResponse(show) {
+    super.toggleInternalCorrectResponse(show);
+    const response = this.correctResponse;
+    const previous = this.#correctLines;
+    this.#correctLines = show && response ? Array.isArray(response) ? [...response] : [response] : [];
+    this.requestUpdate("correctLines", previous);
+  }
+  renderSupplementalLines() {
+    return c2(this.#correctLines, (line) => line, (line) => b`
+        <line
+          part="correct-line"
+          x1=${parseInt(this.querySelector(`[identifier=${line.split(" ")[0]}]`).style.left)}
+          y1=${parseInt(this.querySelector(`[identifier=${line.split(" ")[0]}]`).style.top)}
+          x2=${parseInt(this.querySelector(`[identifier=${line.split(" ")[1]}]`).style.left)}
+          y2=${parseInt(this.querySelector(`[identifier=${line.split(" ")[1]}]`).style.top)}
+          stroke="var(--qti-correct)"
+          stroke-width="3"
+          stroke-dasharray="5,5"
+        />
+      `);
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-graphic-gap-match-interaction-correction.js
+var QtiGraphicGapMatchInteractionCorrection = class extends DragDropCorrectionMixin(QtiGraphicGapMatchInteraction) {
+};
+
+// ../qti-corrections/dist/interactions/qti-graphic-order-interaction-correction.js
+var QtiGraphicOrderInteractionCorrection = class extends CandidateCorrectionMixin(QtiGraphicOrderInteraction) {
+  resolvePinColor(choice) {
+    const correctableChoice = choice;
+    if (correctableChoice.matches(":state(candidate-incorrect)"))
+      return "var(--qti-incorrect)";
+    if (correctableChoice.matches(":state(candidate-correct)"))
+      return "var(--qti-correct)";
+    if (correctableChoice.matches(":state(correct-response)"))
+      return "var(--qti-answer-border)";
+    return super.resolvePinColor(choice);
+  }
+  toggleInternalCorrectResponse(show) {
+    super.toggleInternalCorrectResponse(show);
+    const response = this.correctResponse;
+    const correctOrder = response ? Array.isArray(response) ? response : [response] : [];
+    for (const hotspot of this._choiceElements) {
+      const index = correctOrder.indexOf(hotspot.identifier);
+      hotspot.orderCorrect = show && index >= 0 ? index + 1 : null;
+    }
+    this.refreshLocatorPins();
+  }
+  toggleCandidateCorrection(show) {
+    super.toggleCandidateCorrection(show);
+    const response = this.correctResponse;
+    const correctOrder = response ? Array.isArray(response) ? response : [response] : [];
+    for (const hotspot of this._choiceElements) {
+      hotspot.candidateCorrection = null;
+      if (show && hotspot.order != null) {
+        hotspot.candidateCorrection = correctOrder[hotspot.order - 1] === hotspot.identifier ? "correct" : "incorrect";
+      }
+    }
+    this.refreshLocatorPins();
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-hotspot-interaction-correction.js
+var QtiHotspotInteractionCorrection = class extends ChoiceCorrectionMixin(QtiHotspotInteraction) {
+};
+
+// ../qti-corrections/dist/interactions/qti-hottext-interaction-correction.js
+var QtiHottextInteractionCorrection = class extends ChoiceCorrectionMixin(QtiHottextInteraction) {
+};
+
+// ../qti-corrections/dist/interactions/qti-inline-choice-interaction-correction.js
+var QtiInlineChoiceInteractionCorrection = class extends CandidateCorrectionMixin(QtiInlineChoiceInteraction) {
+  static get styles() {
+    return [
+      QtiInlineChoiceInteraction.styles,
+      correctionPart,
+      i`
+        /*
+         * Only the TRAILING inset — the leading gap is the shared --qti-glyph-gap, like every other
+         * badge. This used to set both margins to --qti-gap (1rem), twice everyone else's 0.5em, on
+         * the one token qti-variables.css calls "the page's rhythm … an order of magnitude too wide
+         * for a glyph sitting inside a line".
+         *
+         * The trailing inset is needed here, and in text-entry, because these two put the field's box
+         * on the HOST while its padding sits on an inner element (::part(trigger), ::part(input)) —
+         * so a badge that is a child of the host falls outside that padding and lands on the border.
+         * Chips, choices and hottext carry their padding on the host, so their badge is already inset
+         * by it and needs nothing.
+         */
+        [part~='correction'] {
+          margin-inline-end: var(--qti-correction-inset);
+        }
+      `
+    ];
+  }
+  /**
+   * Internal mode defers to the full correct response, exactly as text-entry does.
+   *
+   * There is no room beside a dropdown for an answer key: the interaction sits inside a line of
+   * running text, so a marker next to the field competes with the sentence around it, and when the
+   * candidate happened to pick the correct option it printed the same word twice. The full variant
+   * puts the key in a `div.full-correct-response-inline` after the field instead — one already-themed
+   * presentation for both inline interactions rather than a second one only these two use.
+   *
+   * `super` is deliberately not called: its `show-correct-response` host state paints the dashed
+   * outline in qti-states.css, and this element is no longer the thing presenting the key — the
+   * wrapper beside it is. Leaving the state off keeps internal mode looking identical to an item
+   * authored with `show-full-correct-response`.
+   *
+   * The guard stops the two entry points rendering two wrappers: `showFullCorrectResponse` has its
+   * own watcher, so with both flags set this would otherwise run a second time.
+   */
+  toggleInternalCorrectResponse(show) {
+    if (!this.showFullCorrectResponse)
+      this.toggleFullCorrectResponse(show);
+  }
+  /**
+   * The key is shown whether or not the candidate was right.
+   *
+   * The base withholds it from a correct candidate, on the reasoning that their answer already is
+   * the key. That reasoning does not survive contact with this element: asking for the correct
+   * response and being shown nothing is indistinguishable from the feature being broken, and it is
+   * the only inline interaction where the answer and the key are the same short phrase, so there is
+   * no visual clue either. Show it, and let the correctness badge say who was right.
+   */
+  get withholdsFullCorrectResponseWhenCorrect() {
+    return false;
+  }
+  /** The badge trails the validation message; everything else is the base's. */
+  render() {
+    return T`
+      ${this.renderTrigger()} ${this.renderMenu()} ${this.renderValidationMessage()}
+      <span part=${this.correctionPart} aria-hidden="true"></span>
+    `;
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-match-interaction-correction.js
+var QtiMatchInteractionCorrection = class extends DragDropCorrectionMixin(QtiMatchInteraction) {
+  #correctPairs = /* @__PURE__ */ new Set();
+  toggleCandidateCorrection(show) {
+    super.toggleCandidateCorrection(show);
+    const matches = parsePairs(this.correctResponse);
+    this.#correctPairs = show ? new Set(matches.map((match) => `${match.source} ${match.target}`)) : /* @__PURE__ */ new Set();
+    for (const target of this.targetChoices) {
+      const targetId = target.getAttribute("identifier");
+      const selectedChoices = target.drags;
+      for (const choice of selectedChoices) {
+        choice.candidateCorrection = null;
+        if (show) {
+          choice.candidateCorrection = this.#correctPairs.has(`${choice.identifier} ${targetId}`) ? "correct" : "incorrect";
+        }
+      }
+    }
+    this.requestUpdate();
+  }
+  getCellStateVariant(value, checked) {
+    if (!this.showCandidateCorrection || !checked)
+      return "";
+    return this.#correctPairs.has(value) ? "correct" : "incorrect";
+  }
+};
+
+// ../qti-corrections/dist/utils/longest-increasing-subsequence.js
+function findLongestIncreasingSubsequenceIndices(sequence) {
+  if (sequence.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const lengthEndingAt = new Array(sequence.length).fill(1);
+  const predecessorIndex = new Array(sequence.length).fill(-1);
+  for (let currentIndex = 0; currentIndex < sequence.length; currentIndex++) {
+    for (let previousIndex = 0; previousIndex < currentIndex; previousIndex++) {
+      if (sequence[previousIndex] < sequence[currentIndex] && lengthEndingAt[previousIndex] + 1 > lengthEndingAt[currentIndex]) {
+        lengthEndingAt[currentIndex] = lengthEndingAt[previousIndex] + 1;
+        predecessorIndex[currentIndex] = previousIndex;
+      }
+    }
+  }
+  let bestEndIndex = 0;
+  for (let index = 1; index < sequence.length; index++) {
+    if (lengthEndingAt[index] > lengthEndingAt[bestEndIndex]) {
+      bestEndIndex = index;
+    }
+  }
+  const resultIndices = /* @__PURE__ */ new Set();
+  for (let index = bestEndIndex; index !== -1; index = predecessorIndex[index]) {
+    resultIndices.add(index);
+  }
+  return resultIndices;
+}
+function findCorrectlyPlacedIdentifiers(candidateOrder, correctOrder) {
+  const rankByIdentifier = new Map(correctOrder.map((identifier, position) => [identifier, position]));
+  const knownIdentifiers = candidateOrder.filter((identifier) => rankByIdentifier.has(identifier));
+  const rankSequence = knownIdentifiers.map((identifier) => rankByIdentifier.get(identifier));
+  const winningIndices = findLongestIncreasingSubsequenceIndices(rankSequence);
+  const result = /* @__PURE__ */ new Set();
+  winningIndices.forEach((index) => result.add(knownIdentifiers[index]));
+  return result;
+}
+
+// ../qti-corrections/dist/interactions/qti-order-interaction-correction.js
+var QtiOrderInteractionCorrection = class extends DragDropCorrectionMixin(QtiOrderInteraction) {
+  toggleCandidateCorrection(show) {
+    super.toggleCandidateCorrection(show);
+    const dropTargets = Array.from(this.shadowRoot.querySelectorAll(`[part~='drop']`));
+    const placedChoices = dropTargets.flatMap((drop) => this.chipsIn(drop));
+    for (const choice of placedChoices)
+      choice.candidateCorrection = null;
+    if (!show)
+      return;
+    const response = this.correctResponse;
+    const entries = response ? Array.isArray(response) ? response : [response] : [];
+    const correctOrder = entries.map((entry, index) => {
+      const [identifier, dropId] = entry.split(" ");
+      const parsed = dropId?.startsWith("droplist") ? parseInt(dropId.slice("droplist".length), 10) : index;
+      return { identifier, dropIndex: Number.isNaN(parsed) ? index : parsed };
+    }).filter((entry) => entry.identifier).sort((a, b2) => a.dropIndex - b2.dropIndex).map((entry) => entry.identifier);
+    if (correctOrder.length === 0)
+      return;
+    const placedEntries = placedChoices.map((choice) => ({ choice, identifier: choice.getAttribute("identifier") })).filter((entry) => Boolean(entry.identifier));
+    const correctlyPlaced = findCorrectlyPlacedIdentifiers(placedEntries.map((entry) => entry.identifier), correctOrder);
+    for (const { choice, identifier } of placedEntries) {
+      choice.candidateCorrection = correctlyPlaced.has(identifier) ? "correct" : "incorrect";
+    }
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-portable-custom-interaction-correction.js
+var QtiPortableCustomInteractionCorrection = class extends CandidateCorrectionMixin(QtiPortableCustomInteraction) {
+  toggleInternalCorrectResponse(show) {
+    super.toggleInternalCorrectResponse(show);
+    const responseVariable = this.responseVariable;
+    const sourceResponse = responseVariable?.correctResponse ?? this.correctResponse;
+    this.correctResponse = show ? sourceResponse : responseVariable?.cardinality === "single" ? "" : [];
+    const containerId = `correct-response-container-${this.responseIdentifier}`;
+    this.parentElement?.querySelectorAll(`#${containerId}`).forEach((element) => element.remove());
+    if (!show) {
+      this.enable();
+      return;
+    }
+    this.disable();
+    if (!this.correctResponse)
+      return;
+    const container = document.createElement("div");
+    container.id = containerId;
+    container.className = "pci-correct-response-container";
+    Object.assign(container.style, {
+      position: "relative",
+      marginTop: "20px",
+      border: "2px solid green",
+      padding: "16px",
+      borderRadius: "4px",
+      backgroundColor: "rgba(0, 128, 0, 0.05)"
+    });
+    const label = document.createElement("div");
+    label.textContent = "Correct Response:";
+    Object.assign(label.style, { fontWeight: "bold", marginBottom: "10px", color: "green" });
+    container.append(label);
+    const viewer = this.cloneNode(false);
+    viewer.removeAttribute("id");
+    viewer.removeAttribute("show-correct-response");
+    viewer.removeAttribute("show-full-correct-response");
+    viewer.removeAttribute("show-candidate-correction");
+    viewer.isFullCorrectResponse = true;
+    const originalResponseId = this.responseIdentifier;
+    viewer.responseIdentifier = `${originalResponseId}-correct`;
+    for (const child of Array.from(this.children)) {
+      if (child.tagName.startsWith("QTI-"))
+        viewer.append(child.cloneNode(true));
+    }
+    const correctResponse = this.correctResponse;
+    const cardinality = responseVariable?.cardinality ?? (Array.isArray(correctResponse) ? "multiple" : "single");
+    const baseType = responseVariable?.baseType ?? "string";
+    viewer.status = "solution";
+    viewer.responseDeclaration = {
+      baseType,
+      cardinality,
+      correctResponse: { value: correctResponse }
+    };
+    viewer.addEventListener("qti-portable-custom-interaction-loaded", () => {
+      const value = viewer.responseVariablesToQtiVariableJSON(correctResponse, cardinality, baseType);
+      viewer.sendMessageToIframe("setBoundTo", { [originalResponseId]: value });
+      viewer.sendMessageToIframe("setState", { state: "review" });
+    }, { once: true });
+    viewer.style.pointerEvents = "none";
+    container.append(viewer);
+    this.after(container);
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-select-point-interaction-correction.js
+var QtiSelectPointInteractionCorrection = class extends CandidateCorrectionMixin(QtiSelectPointInteraction) {
+  #correctAreas = [];
+  #responseCorrection = [];
+  static {
+    this.styles = [
+      QtiSelectPointInteraction.styles,
+      i`
+      [part~='correct'] {
+        --qti-select-point-marker-color: var(--qti-correct);
+      }
+      [part~='incorrect'] {
+        --qti-select-point-marker-color: var(--qti-incorrect);
+      }
+    `
+    ];
+  }
+  toggleCandidateCorrection(show) {
+    super.toggleCandidateCorrection(show);
+    const previous = this.#responseCorrection;
+    this.#responseCorrection = [];
+    if (!show) {
+      this.requestUpdate("responseCorrection", previous);
+      return;
+    }
+    const areaEntries = this._effectiveAreaEntries;
+    const baseType = this.responseVariable?.baseType;
+    const response = this.correctResponse;
+    for (const point of this.responsePoints) {
+      let correct = areaEntries.some((area) => ScoringHelper.isPointInArea(`${point.x} ${point.y}`, `${area.shape},${area.coords}`, baseType));
+      if (!areaEntries.length && response) {
+        const expected = Array.isArray(response) ? response : [response];
+        correct = expected.some((entry) => {
+          const [x, y] = entry.split(" ").map(Number);
+          return Number.isFinite(x) && Number.isFinite(y) && Math.hypot(point.x - x, point.y - y) <= 10;
+        });
+      }
+      this.#responseCorrection.push(correct);
+    }
+    this.requestUpdate("responseCorrection", previous);
+  }
+  toggleInternalCorrectResponse(show) {
+    super.toggleInternalCorrectResponse(show);
+    if (!show) {
+      const previous2 = this.#correctAreas;
+      this.#correctAreas = [];
+      this.requestUpdate("correctAreas", previous2);
+      return;
+    }
+    let entries = this._effectiveAreaEntries;
+    if (!entries.length) {
+      const response = this.correctResponse;
+      const values = response ? Array.isArray(response) ? response : [response] : [];
+      if (values.some((value) => value.split(" ").length < 2)) {
+        console.error("No valid correct responses found.");
+        return;
+      }
+      entries = values.map((value) => ({
+        shape: "circle",
+        coords: `${value.split(" ").join(",")},10`,
+        defaultValue: 1,
+        mappedValue: 1
+      }));
+    }
+    const previous = this.#correctAreas;
+    this.#correctAreas = entries.map((entry) => ({ shape: entry.shape, coords: entry.coords }));
+    this.requestUpdate("correctAreas", previous);
+  }
+  pointPart(_point, index) {
+    const verdict = this.#responseCorrection[index];
+    return verdict === void 0 ? "point" : `point ${verdict ? "correct" : "incorrect"}`;
+  }
+  renderSupplementalLayer() {
+    return c2(this.#correctAreas, (area) => `${area.shape}:${area.coords}`, (area, index) => T`<div
+          style=${o({
+      position: "absolute",
+      pointerEvents: "none",
+      backgroundColor: "var(--qti-correct)",
+      opacity: "0.5"
+    })}
+          data-correction-area
+          data-coord=${area.coords}
+          data-shape=${area.shape}
+          alt=${`correct-response-${index + 1}`}
+        ></div>`);
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    if (changedProperties.has("correctAreas")) {
+      this.positionOverlayElements(this.shadowRoot.querySelectorAll("[data-correction-area]"));
+    }
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-slider-interaction-correction.js
+var QtiSliderInteractionCorrection = class extends CandidateCorrectionMixin(QtiSliderInteraction) {
+  #correctResponseNumber = null;
+  static {
+    this.styles = [
+      QtiSliderInteraction.styles,
+      i`
+      [part='knob-correct'] {
+        background-color: var(--qti-correct-light);
+        border: 2px solid var(--qti-correct);
+        position: relative;
+        height: 1rem;
+        width: 1rem;
+        transform-origin: center;
+        transform: translateX(-50%);
+        cursor: pointer;
+        border-radius: 9999px;
+        left: var(--value-percentage-correct);
+      }
+    `
+    ];
+  }
+  toggleInternalCorrectResponse(show) {
+    super.toggleInternalCorrectResponse(show);
+    const response = this.correctResponse;
+    const raw = Array.isArray(response) ? response[0] : response;
+    const value = show && raw ? parseFloat(raw) : NaN;
+    const previous = this.#correctResponseNumber;
+    this.#correctResponseNumber = Number.isFinite(value) ? value : null;
+    if (this.#correctResponseNumber !== null) {
+      const percentage = (this.#correctResponseNumber - this.min) / (this.max - this.min) * 100;
+      this.style.setProperty("--value-percentage-correct", `${percentage}%`);
+    } else {
+      this.style.removeProperty("--value-percentage-correct");
+    }
+    this.requestUpdate("correctResponseNumber", previous);
+  }
+  renderRailSupplement() {
+    return this.#correctResponseNumber === null ? A : T`<div id="knob-correct" part="knob-correct">
+          <div id="value" part="value">${this.#correctResponseNumber}</div>
+        </div>`;
+  }
+};
+
+// ../qti-corrections/dist/interactions/qti-text-entry-interaction-correction.js
+var QtiTextEntryInteractionCorrection = class extends CandidateCorrectionMixin(QtiTextEntryInteraction) {
+  static {
+    this.styles = [
+      QtiTextEntryInteraction.styles,
+      correctionPart,
+      i`
+      /*
+       * The trailing inset only — size and leading gap come from the shared sheet.
+       *
+       * This block used to also set position: static; translate: none (dead: nothing positions this
+       * badge) and size it with --qti-control-size, the radio/checkbox token — 1rem, absolute, where
+       * every other badge is 1em and scales with the text it annotates. The two agreed only while the
+       * item's font-size happened to equal the root's.
+       *
+       * The inset is needed because the field's box is the HOST while its padding is on ::part(input),
+       * so the badge — a child of the host — falls outside that padding and lands flush on the border.
+       * Measured at 0px from the border, against 16px for a choice and 12.8px for a chip.
+       */
+      [part~='correction'] {
+        margin-inline-end: var(--qti-correction-inset);
+      }
+      :host {
+        position: relative;
+        anchor-name: --text-entry-host, --qti-correction-anchor;
+      }
+      [part='correct'] {
+        position: absolute;
+        position-anchor: --text-entry-host;
+        position-area: top span-right;
+        margin-bottom: 0.25rem;
+        padding: var(--qti-padding-box);
+        background-color: var(--qti-bg);
+        white-space: nowrap;
+      }
+    `
+    ];
+  }
+  get correctness() {
+    const variable = this.responseVariable;
+    if (!variable)
+      return super.correctness;
+    if (variable.value === null)
+      return Correctness.Incorrect;
+    if (variable.mapping) {
+      const maxScore = variable.mapping.mapEntries.reduce((maximum, entry) => Math.max(entry.mappedValue, maximum), 0);
+      for (const entry of variable.mapping.mapEntries) {
+        let expected = entry.mapKey;
+        let actual = variable.value;
+        if (!entry.caseSensitive) {
+          expected = expected.toLowerCase();
+          actual = actual.toLowerCase();
+        }
+        if (expected !== actual)
+          continue;
+        if (entry.mappedValue === maxScore)
+          return Correctness.Correct;
+        if (entry.mappedValue <= (variable.mapping.defaultValue || 0))
+          return Correctness.Incorrect;
+        return Correctness.PartiallyCorrect;
+      }
+    }
+    return variable.correctResponse === variable.value ? Correctness.Correct : Correctness.Incorrect;
+  }
+  toggleInternalCorrectResponse(show) {
+    if (!this.showFullCorrectResponse)
+      this.toggleFullCorrectResponse(show);
+  }
+  /** The badge goes between the field and the validation message; everything else is the base's. */
+  render() {
+    return T`
+      ${this.renderAnswer()} ${this.renderInput()}
+      <span part=${this.correctionPart} aria-hidden="true"></span>
+      ${this.renderValidationMessage()}
+    `;
+  }
+};
+
+export {
+  Correctness,
+  CorrectResponseMixin,
+  correctionPart,
+  CandidateCorrectionMixin,
+  ChoiceCorrectionMixin,
+  QtiGapTextCorrection,
+  QtiHotspotChoiceCorrection,
+  QtiHottextCorrection,
+  QtiSimpleAssociableChoiceCorrection,
+  QtiSimpleChoiceCorrection,
+  QtiAssessmentItemCorrection,
+  QtiItemCorrection,
+  TestNavigationCorrection,
+  QtiTestCorrection,
+  TestCheckItemCorrection,
+  ItemCorrectResponseMode,
+  ItemShowCandidateCorrection,
+  ItemShowCorrectResponse,
+  TestShowCorrectResponse,
+  QtiAssociateInteractionCorrection,
+  QtiChoiceInteractionCorrection,
+  QtiExtendedTextInteractionCorrection,
+  QtiGapMatchInteractionCorrection,
+  QtiGraphicAssociateInteractionCorrection,
+  QtiGraphicGapMatchInteractionCorrection,
+  QtiGraphicOrderInteractionCorrection,
+  QtiHotspotInteractionCorrection,
+  QtiHottextInteractionCorrection,
+  QtiInlineChoiceInteractionCorrection,
+  QtiMatchInteractionCorrection,
+  QtiOrderInteractionCorrection,
+  QtiPortableCustomInteractionCorrection,
+  QtiSelectPointInteractionCorrection,
+  QtiSliderInteractionCorrection,
+  QtiTextEntryInteractionCorrection
+};
+//# sourceMappingURL=chunk-XU7HNT4F.js.map