@citolab/qti-components 7.14.3 → 7.15.0

package/dist/chunk-O4XIWHTF.js

@@ -0,0 +1,1139 @@
+import {
+  o
+} from "./chunk-DWIRLYDS.js";
+import {
+  watch
+} from "./chunk-2ZEJ3RR5.js";
+import {
+  qtiTransformItem
+} from "./chunk-INKI27D5.js";
+import {
+  QtiFeedback,
+  QtiVariableDeclaration,
+  c,
+  e,
+  i,
+  i2,
+  itemContext,
+  itemContextVariables,
+  n,
+  r,
+  t,
+  x
+} from "./chunk-JEUY3MYB.js";
+import {
+  __decorateClass
+} from "./chunk-EUXUH3YW.js";
+
+// ../qti-elements/src/components/qti-assessment-item/qti-assessment-item.ts
+var QtiAssessmentItem = class extends i2 {
+  constructor() {
+    super(...arguments);
+    this._templateProcessing = null;
+    this.identifier = "";
+    this.adaptive = "false";
+    this.timeDependent = null;
+    this._handleDisabledChange = (_, disabled) => {
+      this._interactionElements.forEach((ch) => ch.disabled = disabled);
+    };
+    this._handleReadonlyChange = (_, readonly) => this._interactionElements.forEach((ch) => ch.readonly = readonly);
+    this._context = {
+      variables: itemContextVariables
+    };
+    this._initialContext = { ...this._context, variables: this._context.variables };
+    this._feedbackElements = [];
+    this._interactionElements = [];
+    this._handleRegisterVariable = (e2) => {
+      e2.stopImmediatePropagation();
+      this._context = { ...this._context, variables: [...this._context.variables, e2.detail.variable] };
+      this._initialContext = this._context;
+      e2.stopPropagation();
+    };
+    this._handleRegisterFeedback = (e2) => {
+      e2.stopImmediatePropagation();
+      const feedbackElement = e2.detail;
+      this._feedbackElements.push(feedbackElement);
+      const numAttempts = Number(this._context.variables.find((v) => v.identifier === "numAttempts")?.value) || 0;
+      if (numAttempts > 0) {
+        feedbackElement.checkShowFeedback(feedbackElement.outcomeIdentifier);
+      }
+    };
+    this._handleRegisterInteraction = (e2) => {
+      e2.stopImmediatePropagation();
+      this._interactionElements.push(e2.detail.interactionElement);
+    };
+    this._handleEndAttempt = (e2) => {
+      e2.stopImmediatePropagation();
+      const { responseIdentifier, countAttempt } = e2.detail;
+      this.validate();
+      this.updateResponseVariable(responseIdentifier, "true");
+      this.processResponse(countAttempt);
+    };
+    this._handleSetOutcomeValue = (e2) => {
+      e2.stopImmediatePropagation();
+      const { outcomeIdentifier, value } = e2.detail;
+      this.updateOutcomeVariable(outcomeIdentifier, value);
+      e2.stopPropagation();
+    };
+    this._handleUpdateResponseVariable = (e2) => {
+      e2.stopImmediatePropagation();
+      const { responseIdentifier, response } = e2.detail;
+      this.updateResponseVariable(responseIdentifier, response);
+      this.dispatchEvent(
+        new CustomEvent("qti-item-context-updated", {
+          bubbles: true,
+          composed: true,
+          detail: { itemContext: this._context }
+        })
+      );
+    };
+  }
+  get title() {
+    return this._itemTitle;
+  }
+  set title(value) {
+    this._itemTitle = value;
+    this.removeAttribute("title");
+    this.setAttribute("data-title", value);
+  }
+  /**
+   * Sets the identifier for the assessment item reference if this item is in a test.
+   *
+   * @param identifier - The identifier for the assessment item reference.
+   */
+  set assessmentItemRefId(identifier) {
+    this._context = { ...this._context, identifier };
+  }
+  get assessmentItemRefId() {
+    return this._context.identifier;
+  }
+  get variables() {
+    return this._context.variables.map((v) => ({
+      identifier: v.identifier,
+      value: v.value,
+      type: v.type,
+      // add externalscored, a fixed prop to the test, so the testcontext can read and decide how to score this item
+      ...v.type === "outcome" && v.identifier === "SCORE" ? { externalScored: v.externalScored } : {}
+    }));
+  }
+  set variables(value) {
+    if (!Array.isArray(value) || value.some((v) => !("identifier" in v))) {
+      console.warn("variables property should be an array of VariableDeclaration");
+      return;
+    }
+    this._context = {
+      ...this._context,
+      variables: this._context.variables.map((variable) => {
+        const matchingValue = value.find((v) => v.identifier === variable.identifier);
+        if (matchingValue) {
+          return {
+            ...variable,
+            ...matchingValue,
+            interpolationTable: variable.interpolationTable
+          };
+        }
+        return variable;
+      })
+    };
+    this._context.variables.forEach((variable) => {
+      if (variable.type === "response") {
+        const interactionElement = this._interactionElements.find(
+          (el) => el.responseIdentifier === variable.identifier
+        );
+        if (interactionElement) {
+          interactionElement.response = variable.value;
+        }
+      }
+    });
+    this.variables.forEach((variable) => {
+      if (variable.type === "outcome") {
+        this._feedbackElements.forEach((fe) => fe.checkShowFeedback(variable.identifier));
+      }
+    });
+  }
+  /** @deprecated use variables property instead */
+  set responses(myResponses) {
+    if (myResponses) {
+      for (const response of myResponses) {
+        const responseVariable = this.getResponse(response.responseIdentifier);
+        if (responseVariable) {
+          this.updateResponseVariable(response.responseIdentifier, response.response);
+        }
+        const interaction = this._interactionElements.find(
+          (i3) => i3.getAttribute("response-identifier") === response.responseIdentifier
+        );
+        if (interaction) {
+          interaction.response = response.response;
+        }
+      }
+    }
+  }
+  render() {
+    return x`<slot></slot>`;
+  }
+  connectedCallback() {
+    this._attachEventListeners();
+    super.connectedCallback();
+    this.updateComplete.then(() => {
+      this.dispatchEvent(
+        new CustomEvent("qti-assessment-item-connected", {
+          bubbles: true,
+          composed: true,
+          detail: this
+        })
+      );
+      this._processTemplates();
+    });
+  }
+  disconnectedCallback() {
+    this._removeEventListeners();
+    super.disconnectedCallback();
+  }
+  _attachEventListeners() {
+    this.addEventListener("qti-register-variable", this._handleRegisterVariable);
+    this.addEventListener("qti-register-feedback", this._handleRegisterFeedback);
+    this.addEventListener("qti-register-interaction", this._handleRegisterInteraction);
+    this.addEventListener("end-attempt", this._handleEndAttempt);
+    this.addEventListener("qti-set-outcome-value", this._handleSetOutcomeValue);
+    this.addEventListener("qti-interaction-response", this._handleUpdateResponseVariable);
+  }
+  _removeEventListeners() {
+    this.removeEventListener("qti-register-variable", this._handleRegisterVariable);
+    this.removeEventListener("qti-register-feedback", this._handleRegisterFeedback);
+    this.removeEventListener("qti-register-interaction", this._handleRegisterInteraction);
+    this.removeEventListener("end-attempt", this._handleEndAttempt);
+    this.removeEventListener("qti-set-outcome-value", this._handleSetOutcomeValue);
+    this.removeEventListener("qti-interaction-response", this._handleUpdateResponseVariable);
+  }
+  /**
+   * Toggles the display of correct responses for all interactions.
+   * @param show - A boolean indicating whether to show or hide correct responses.
+   */
+  showCorrectResponse(show) {
+    for (const interaction of this._interactionElements) {
+      interaction.toggleCorrectResponse(show);
+    }
+    document.querySelectorAll("item-show-correct-response").forEach((el) => {
+      el.shown = show;
+    });
+  }
+  /**
+   * Toggles the display of the candidate correction for all interactions.
+   * @param show - A boolean indicating whether to show or hide candidate correction.
+   */
+  showCandidateCorrection(show) {
+    for (const interaction of this._interactionElements) {
+      interaction.toggleCandidateCorrection(show);
+    }
+    document.querySelectorAll("item-show-candidate-correction").forEach((el) => {
+      el.shown = show;
+    });
+  }
+  _processTemplates() {
+    this._templateProcessing = this.querySelector("qti-template-processing");
+    if (this._templateProcessing) {
+      this._templateProcessing.process();
+    }
+  }
+  processResponse(countNumAttempts = true, reportValidityAfterScoring = true) {
+    this.validate(reportValidityAfterScoring);
+    if (countNumAttempts) {
+      this.updateOutcomeVariable(
+        "numAttempts",
+        (+this._context.variables.find((v) => v.identifier === "numAttempts")?.value + 1).toString()
+      );
+    }
+    const responseProcessor = this.querySelector("qti-response-processing");
+    if (!responseProcessor) {
+      return false;
+    }
+    if (!responseProcessor.process) {
+      return false;
+    }
+    responseProcessor.process();
+    if (this.adaptive === "false") {
+      this.updateOutcomeVariable("completionStatus", this._getCompletionStatus());
+    }
+    this.dispatchEvent(
+      new CustomEvent("qti-item-context-updated", {
+        bubbles: true,
+        composed: true,
+        detail: { itemContext: this._context }
+      })
+    );
+    return true;
+  }
+  resetResponses() {
+    this._context = this._initialContext;
+  }
+  getResponse(identifier) {
+    return this.getVariable(identifier);
+  }
+  getOutcome(identifier) {
+    return this.getVariable(identifier);
+  }
+  getVariable(identifier) {
+    return this._context.variables.find((v) => v.identifier === identifier) || null;
+  }
+  // saving privates here: ------------------------------------------------------------------------------
+  /**
+   * Updates the response variable with the specified identifier to the given value.
+   *
+   * @protected
+   *
+   * This method is intended for internal use within the class and subclasses.
+   * It should not be called externally by third parties.
+   *
+   * @param identifier - The identifier of the response variable to update.
+   * @param value - The new value for the response variable.
+   */
+  updateResponseVariable(identifier, value) {
+    this._context = {
+      ...this._context,
+      variables: this._context.variables.map((v) => v.identifier !== identifier ? v : { ...v, value })
+    };
+    this.showCandidateCorrection(false);
+    this.dispatchEvent(
+      new CustomEvent("qti-interaction-changed", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          item: this.identifier,
+          responseIdentifier: identifier,
+          response: Array.isArray(value) ? [...value] : value
+        }
+      })
+    );
+    if (this.adaptive === "false") {
+      this.updateOutcomeVariable("completionStatus", this._getCompletionStatus());
+    }
+  }
+  setOutcomeVariable(identifier, value) {
+    this.updateOutcomeVariable(identifier, value);
+    this.dispatchEvent(
+      new CustomEvent("qti-item-context-updated", {
+        bubbles: true,
+        composed: true,
+        detail: { itemContext: this._context }
+      })
+    );
+  }
+  /**
+   * Updates the outcome variable with the specified identifier to the given value.
+   *
+   * @protected
+   *
+   * This method is intended for internal use within the class and subclasses.
+   * It should not be called externally by third parties.
+   *
+   * @param identifier - The identifier of the response variable to update.
+   * @param value - The new value for the response variable.
+   */
+  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._context = {
+      ...this._context,
+      variables: this._context.variables.map((v) => {
+        if (v.identifier !== identifier) {
+          return v;
+        }
+        return {
+          ...v,
+          value: outcomeVariable.cardinality === "single" ? value : Array.isArray(value) ? value : [value]
+        };
+      })
+    };
+    this._feedbackElements.forEach((fe) => fe.checkShowFeedback(identifier));
+    this.dispatchEvent(
+      new CustomEvent("qti-outcome-changed", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          item: this.identifier,
+          outcomeIdentifier: identifier,
+          value: this._context.variables.find((v) => v.identifier === identifier)?.value
+        }
+      })
+    );
+  }
+  validate(reportValidity = true) {
+    const isValid = this._interactionElements.every((interactionElement) => interactionElement.validate());
+    if (reportValidity) {
+      this.reportValidity();
+    }
+    return isValid;
+  }
+  reportValidity() {
+    for (const interactionElement of this._interactionElements) {
+      interactionElement.reportValidity();
+    }
+  }
+  _getCompletionStatus() {
+    const valid = this.validate(false);
+    if (valid === true) return "completed";
+    if (valid === false) return "incomplete";
+    return "not_attempted";
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiAssessmentItem.prototype, "identifier", 2);
+__decorateClass([
+  n({ type: String })
+], QtiAssessmentItem.prototype, "adaptive", 2);
+__decorateClass([
+  n({ type: String })
+], QtiAssessmentItem.prototype, "timeDependent", 2);
+__decorateClass([
+  n({ type: String })
+], QtiAssessmentItem.prototype, "title", 1);
+__decorateClass([
+  n({ type: Boolean })
+], QtiAssessmentItem.prototype, "disabled", 2);
+__decorateClass([
+  watch("disabled", { waitUntilFirstUpdate: true })
+], QtiAssessmentItem.prototype, "_handleDisabledChange", 2);
+__decorateClass([
+  n({ type: Boolean })
+], QtiAssessmentItem.prototype, "readonly", 2);
+__decorateClass([
+  watch("readonly", { waitUntilFirstUpdate: true })
+], QtiAssessmentItem.prototype, "_handleReadonlyChange", 2);
+__decorateClass([
+  e({ context: itemContext })
+], QtiAssessmentItem.prototype, "_context", 2);
+QtiAssessmentItem = __decorateClass([
+  t("qti-assessment-item")
+], QtiAssessmentItem);
+
+// ../qti-elements/src/components/qti-assessment-stimulus-ref/qti-assessment-stimulus-ref.ts
+var QtiAssessmentStimulusRefConnectedEvent = class _QtiAssessmentStimulusRefConnectedEvent extends Event {
+  constructor(element, item) {
+    super(_QtiAssessmentStimulusRefConnectedEvent.eventName, { bubbles: true, composed: true, cancelable: true });
+    this.element = element;
+    this.item = item;
+  }
+  static {
+    this.eventName = "qti-assessment-stimulus-ref-connected";
+  }
+};
+var QtiAssessmentStimulusRef = class extends i2 {
+  constructor() {
+    super(...arguments);
+    this.identifier = "";
+    this.href = "";
+  }
+  /**
+   * Lifecycle method called when the element is connected to the DOM.
+   * First checks if there's a data-stimulus-idref element. If found, loads the stimulus directly.
+   * If not found, delegates to the delivery platform via an event.
+   */
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    const item = this.closest("qti-assessment-item");
+    const event = new QtiAssessmentStimulusRefConnectedEvent(this, item);
+    this.dispatchEvent(event);
+    const stimulusRef = item?.querySelector(`[data-stimulus-idref="${this.identifier}"]`);
+    if (!event.defaultPrevented && stimulusRef) {
+      await this.updateStimulusRef(stimulusRef);
+    }
+  }
+  /**
+   * Loads and appends the stimulus to the specified element.
+   * @param stimulusRef - The element to which the stimulus will be appended.
+   */
+  async updateStimulusRef(stimulusRef) {
+    const stimulus = await qtiTransformItem().load(this.href).then((api) => api.htmlDoc());
+    if (stimulus) {
+      const elements = stimulus.querySelectorAll("qti-stimulus-body, qti-stylesheet");
+      stimulusRef.innerHTML = "";
+      stimulusRef.append(...elements);
+    }
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiAssessmentStimulusRef.prototype, "identifier", 2);
+__decorateClass([
+  n({ type: String })
+], QtiAssessmentStimulusRef.prototype, "href", 2);
+QtiAssessmentStimulusRef = __decorateClass([
+  t("qti-assessment-stimulus-ref")
+], QtiAssessmentStimulusRef);
+
+// ../qti-elements/src/components/qti-companion-materials-info/qti-companion-materials-info.ts
+var QtiCompanionMaterialsInfo = class extends i2 {
+  // static override styles = css`
+  //   slot {
+  //     display: hidden;
+  //   }
+  // `;
+  // override render() {
+  //   return html` <slot></slot> `;
+  // }
+};
+QtiCompanionMaterialsInfo = __decorateClass([
+  t("qti-companion-materials-info")
+], QtiCompanionMaterialsInfo);
+
+// ../qti-elements/src/components/qti-custom-operator/qti-custom-operator.ts
+var QtiCustomOperator = class extends i2 {
+  render() {
+    return x`<slot @slotchange=${this.handleSlotChange}></slot>`;
+  }
+  handleSlotChange() {
+    const commentNode = Array.from(this.firstElementChild?.childNodes ?? []).find(
+      (node) => node.nodeType === Node.COMMENT_NODE
+    );
+    try {
+      this.operatorFunction = new Function("context", "fn", "item", commentNode?.textContent ?? "");
+    } catch (e2) {
+      console.error("custom-operator contains invalid javascript code", e2);
+    }
+  }
+  calculate() {
+    const fn = {
+      variable: (responseIdentifier) => this._context?.variables.find((v) => v.identifier === responseIdentifier)?.value ?? "",
+      correct: (responseIdentifier) => this._context?.variables.find((v) => v.identifier === responseIdentifier)?.correctResponse ?? ""
+    };
+    const item = {
+      getVariable: (variableIdentifier) => this._context?.variables.find((v) => v.identifier === variableIdentifier),
+      updateOutcomeVariable: (outcomeIdentifier, value) => {
+        this.dispatchEvent(
+          new CustomEvent("qti-set-outcome-value", {
+            bubbles: true,
+            composed: true,
+            detail: {
+              outcomeIdentifier,
+              value
+            }
+          })
+        );
+      },
+      updateResponseVariable: (responseIdentifier, response) => {
+        this.dispatchEvent(
+          new CustomEvent("qti-interaction-response", {
+            bubbles: true,
+            composed: true,
+            detail: {
+              responseIdentifier,
+              response
+            }
+          })
+        );
+      }
+    };
+    return this.operatorFunction(this._context, fn, item);
+  }
+};
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r()
+], QtiCustomOperator.prototype, "_context", 2);
+QtiCustomOperator = __decorateClass([
+  t("qti-custom-operator")
+], QtiCustomOperator);
+
+// ../qti-elements/src/components/qti-feedback-block/qti-feedback-block.ts
+var QtiFeedbackBlock = class extends QtiFeedback {
+  render() {
+    return x` <slot part="feedback" class="feedback ${this.showStatus}"></slot> `;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.checkShowFeedback(this.outcomeIdentifier);
+  }
+};
+QtiFeedbackBlock.styles = i`
+    :host {
+      display: block;
+    }
+    .on {
+      display: block;
+    }
+    .off {
+      display: none;
+    }
+  `;
+QtiFeedbackBlock = __decorateClass([
+  t("qti-feedback-block")
+], QtiFeedbackBlock);
+
+// ../qti-elements/src/components/qti-feedback-inline/qti-feedback-inline.ts
+var QtiFeedbackInline = class extends QtiFeedback {
+  constructor() {
+    super(...arguments);
+    this.render = () => x` <slot part="feedback" class="${o(this.showStatus)}"></slot> `;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.checkShowFeedback(this.outcomeIdentifier);
+  }
+};
+QtiFeedbackInline.styles = i`
+    .on {
+      display: inline-block;
+    }
+    .off {
+      display: none;
+    }
+  `;
+QtiFeedbackInline = __decorateClass([
+  t("qti-feedback-inline")
+], QtiFeedbackInline);
+
+// ../qti-elements/src/components/qti-modal-feedback/qti-modal-feedback.ts
+var QtiModalFeedback = class extends QtiFeedback {
+  render() {
+    return x`
+      <dialog class="qti-dialog" part="feedback" ?open="${this.showStatus === "on"}">
+        <slot></slot>
+        <div style="margin-top: var(--qti-gap-size); text-align: center;">
+          <button class="button close-button" @click="${this.closeFeedback}">Close</button>
+        </div>
+      </dialog>
+    `;
+  }
+  openFeedback() {
+    const dialog = this.shadowRoot?.querySelector("dialog");
+    if (dialog && !dialog.open) {
+      dialog.showModal();
+    }
+  }
+  closeFeedback() {
+    const dialog = this.shadowRoot?.querySelector("dialog");
+    if (dialog && dialog.open) {
+      dialog.close();
+      this.showStatus = "off";
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.showStatus === "on") {
+      this.openFeedback();
+    }
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("showStatus")) {
+      if (this.showStatus === "on") {
+        this.openFeedback();
+      } else {
+        this.closeFeedback();
+      }
+    }
+  }
+};
+QtiModalFeedback.styles = i`
+    .qti-dialog {
+      background: var(--qti-bg);
+      border: var(--qti-border-thickness) var(--qti-border-style) var(--qti-border-color);
+      border-radius: var(--qti-border-radius);
+      padding: var(--qti-padding-vertical) var(--qti-padding-horizontal);
+      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+      position: fixed;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+      z-index: 1000;
+      width: auto;
+      max-width: 90%;
+    }
+
+    .button {
+      border-radius: var(--qti-border-radius);
+      padding: var(--qti-padding-vertical) var(--qti-padding-horizontal);
+      background-color: var(--qti-bg-active);
+      border: var(--qti-border-active);
+      cursor: pointer;
+      position: relative;
+      display: inline-block;
+    }
+
+    .button:hover {
+      background-color: var(--qti-hover-bg);
+    }
+
+    .button:disabled {
+      background-color: var(--qti-disabled-bg);
+      color: var(--qti-disabled-color);
+      cursor: not-allowed;
+    }
+
+    .button:focus {
+      outline: var(--qti-focus-border-width) solid var(--qti-focus-color);
+    }
+  `;
+QtiModalFeedback = __decorateClass([
+  t("qti-modal-feedback")
+], QtiModalFeedback);
+
+// ../qti-elements/src/components/qti-item-body/qti-item-body.styles.ts
+var qti_item_body_styles_default = i`
+  :host {
+    display: block;
+  }
+`;
+
+// ../qti-elements/src/components/qti-item-body/qti-item-body.ts
+var QtiItemBody = class extends i2 {
+  render() {
+    return x`<slot part="qti-rubric-blocks" name="qti-rubric-block"></slot><slot></slot>`;
+  }
+};
+QtiItemBody.styles = qti_item_body_styles_default;
+QtiItemBody = __decorateClass([
+  t("qti-item-body")
+], QtiItemBody);
+
+// ../qti-elements/src/components/qti-prompt/qti-prompt.ts
+var QtiPrompt = class extends i2 {
+  render() {
+    return x`<slot></slot>`;
+  }
+  connectedCallback() {
+    const inInteraction = this.parentElement.tagName.endsWith("INTERACTION");
+    if (inInteraction) {
+      this.setAttribute("slot", "prompt");
+    }
+  }
+};
+QtiPrompt = __decorateClass([
+  t("qti-prompt")
+], QtiPrompt);
+
+// ../qti-elements/src/components/qti-content-body/qti-content-body.ts
+var QtiContentBody = class extends i2 {
+  render() {
+    return x`<slot></slot>`;
+  }
+};
+QtiContentBody = __decorateClass([
+  t("qti-content-body")
+], QtiContentBody);
+
+// ../qti-elements/src/components/qti-rubric-block/qti-rubric-block.ts
+var QtiRubricBlock = class extends i2 {
+  handleclassNamesChange() {
+    const classNames = this.classNames.split(" ");
+    classNames.forEach((className) => {
+      switch (className) {
+        case "qti-rubric-discretionary-placement":
+          {
+            const event = new CustomEvent("qti-rubric:discretionary-placement", {
+              detail: { className, element: this },
+              bubbles: true,
+              composed: true,
+              cancelable: true
+            });
+            const notCancelled = this.dispatchEvent(event);
+            if (!notCancelled) return;
+            this.setAttribute("slot", "qti-rubric-block");
+          }
+          break;
+        case "qti-rubric-inline":
+          this.setAttribute("slot", "");
+          break;
+        default:
+          break;
+      }
+    });
+  }
+  render() {
+    return x`<slot></slot>`;
+  }
+};
+QtiRubricBlock.styles = i`
+    :host {
+      display: block;
+    }
+  `;
+__decorateClass([
+  n({ type: String })
+], QtiRubricBlock.prototype, "id", 2);
+__decorateClass([
+  n({ type: String })
+], QtiRubricBlock.prototype, "use", 2);
+__decorateClass([
+  n({ type: String })
+], QtiRubricBlock.prototype, "view", 2);
+__decorateClass([
+  n({ type: String, attribute: "class" })
+], QtiRubricBlock.prototype, "classNames", 2);
+__decorateClass([
+  watch("classNames", { waitUntilFirstUpdate: true })
+], QtiRubricBlock.prototype, "handleclassNamesChange", 1);
+QtiRubricBlock = __decorateClass([
+  t("qti-rubric-block")
+], QtiRubricBlock);
+
+// ../qti-elements/src/components/qti-stylesheet/qti-stylesheet.ts
+var QtiStylesheet = class extends i2 {
+  constructor() {
+    super(...arguments);
+    this.styleElement = null;
+  }
+  firstUpdated(_changedProperties) {
+    super.firstUpdated(_changedProperties);
+    const link = this.getAttribute("href");
+    if (link !== null) {
+      fetch(link).then((response) => response.text()).then((cssContent) => {
+        const minifiedCss = this.minifyCss(cssContent);
+        this.styleElement = document.createElement("style");
+        this.styleElement.media = "screen";
+        this.styleElement.textContent = `@scope {${minifiedCss}}`;
+        if (this.parentElement) {
+          this.parentElement.appendChild(this.styleElement);
+        } else {
+          console.warn("No parent element to append the scoped stylesheet to.");
+        }
+      }).catch((error) => {
+        console.error("Failed to load stylesheet:", error);
+      });
+    }
+    if (this.textContent !== null && this.textContent.trim() !== "") {
+      const minifiedCss = this.minifyCss(this.textContent);
+      this.styleElement = document.createElement("style");
+      this.styleElement.media = "screen";
+      this.styleElement.textContent = `@scope {${minifiedCss}}`;
+      if (this.parentElement) {
+        this.parentElement.appendChild(this.styleElement);
+      } else {
+        console.warn("No parent element to append the scoped stylesheet to.");
+      }
+    }
+  }
+  minifyCss(cssContent) {
+    return cssContent.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}:;])\s*/g, "$1").trim();
+  }
+  disconnectedCallback() {
+    if (this.styleElement) {
+      try {
+        this.styleElement.remove();
+      } catch (error) {
+        console.error("Could not remove stylesheet:", error);
+      }
+    }
+    super.disconnectedCallback();
+  }
+};
+QtiStylesheet = __decorateClass([
+  t("qti-stylesheet")
+], QtiStylesheet);
+
+// ../qti-elements/src/components/qti-response-declaration/qti-response-declaration.ts
+var QtiResponseDeclaration = class extends QtiVariableDeclaration {
+  render() {
+    const value = this.itemContext?.variables.find((v) => v.identifier === this.identifier)?.value;
+    return x`${JSON.stringify(value, null, 2)}`;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const defaultValue = this.defaultValues(this.cardinality);
+    const responseVariable = {
+      baseType: this.baseType,
+      identifier: this.identifier,
+      correctResponse: this.correctResponse,
+      cardinality: this.cardinality || "single",
+      mapping: this.mapping,
+      defaultValue,
+      areaMapping: this.areaMapping,
+      value: null,
+      type: "response",
+      candidateResponse: null
+    };
+    responseVariable.value = defaultValue;
+    this.dispatchEvent(
+      new CustomEvent("qti-register-variable", {
+        bubbles: true,
+        composed: true,
+        detail: { variable: responseVariable }
+      })
+    );
+  }
+  get correctResponse() {
+    let result;
+    const correctResponse = this.querySelector("qti-correct-response");
+    if (correctResponse) {
+      const values = correctResponse.querySelectorAll("qti-value");
+      if (this.cardinality === "single" && values.length > 0) {
+        result = values[0].textContent.trim();
+        values[0].remove();
+      } else if (this.cardinality !== "single") {
+        result = [];
+        for (let i3 = 0; i3 < values.length; i3++) {
+          result.push(values[i3].textContent.trim());
+          values[i3].remove();
+        }
+      }
+    }
+    return result;
+  }
+  get mapping() {
+    const mappingElement = this.querySelector("qti-mapping");
+    const lowerBound = parseFloat(mappingElement?.getAttribute("lower-bound"));
+    const uppperBound = parseFloat(mappingElement?.getAttribute("upper-bound"));
+    const mappingValue = {
+      defaultValue: Number(mappingElement?.getAttribute("default-value")) || 0,
+      lowerBound: isNaN(lowerBound) ? null : lowerBound,
+      upperBound: isNaN(uppperBound) ? null : uppperBound,
+      mapEntries: Array.from(mappingElement?.querySelectorAll("qti-map-entry") || []).map((el) => ({
+        mapKey: el.getAttribute("map-key") || "",
+        mappedValue: Number(el.getAttribute("mapped-value")) || 0,
+        caseSensitive: el.hasAttribute("case-sensitive") ? el.getAttribute("case-sensitive") !== "false" : false
+      }))
+    };
+    return mappingValue;
+  }
+  get areaMapping() {
+    const areaMappingElement = this.querySelector("qti-area-mapping");
+    const defaultValue = Number(areaMappingElement?.getAttribute("default-value")) || 0;
+    const lowerBound = parseFloat(areaMappingElement?.getAttribute("lower-bound"));
+    const uppperBound = parseFloat(areaMappingElement?.getAttribute("upper-bound"));
+    const areaMapEntries = Array.from(areaMappingElement?.querySelectorAll("qti-area-map-entry") || []).map(
+      (el) => ({
+        shape: el.getAttribute("shape") || "default",
+        coords: el.getAttribute("coords") || "",
+        mappedValue: Number(el.getAttribute("mapped-value")) || 0,
+        defaultValue: Number(el.getAttribute("default-value")) || 0
+      })
+    );
+    return {
+      defaultValue,
+      lowerBound: isNaN(lowerBound) ? null : lowerBound,
+      upperBound: isNaN(uppperBound) ? null : uppperBound,
+      areaMapEntries
+    };
+  }
+};
+QtiResponseDeclaration.styles = [
+  i`
+      :host {
+        display: none;
+      }
+    `
+];
+__decorateClass([
+  n({ type: String, attribute: "base-type" })
+], QtiResponseDeclaration.prototype, "baseType", 2);
+__decorateClass([
+  n({ type: String })
+], QtiResponseDeclaration.prototype, "identifier", 2);
+__decorateClass([
+  n({ type: String })
+], QtiResponseDeclaration.prototype, "cardinality", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r()
+], QtiResponseDeclaration.prototype, "itemContext", 2);
+QtiResponseDeclaration = __decorateClass([
+  t("qti-response-declaration")
+], QtiResponseDeclaration);
+
+// ../qti-elements/src/components/qti-outcome-declaration/qti-outcome-declaration.ts
+var QtiOutcomeDeclaration = class extends QtiVariableDeclaration {
+  constructor() {
+    super(...arguments);
+    this.externalScored = null;
+  }
+  render() {
+    const value = this.itemContext?.variables.find((v) => v.identifier === this.identifier)?.value;
+    return x`${JSON.stringify(value, null, 2)}`;
+  }
+  get interpolationTable() {
+    const table = this.querySelector("qti-interpolation-table");
+    if (table) {
+      const entries = /* @__PURE__ */ new Map();
+      for (const entry of table.querySelectorAll("qti-interpolation-table-entry")) {
+        if (!entry.getAttribute("source-value") && entry.getAttribute("target-value")) {
+          console.error("source-value or target-value is missing in qti-interpolation-table-entry");
+        }
+        const sourceValue = parseFloat(entry.getAttribute("source-value"));
+        const targetValue = parseFloat(entry.getAttribute("target-value"));
+        if (isNaN(sourceValue) || isNaN(targetValue)) {
+          console.error("source-value or target-value is not a number in qti-interpolation-table-entry");
+        }
+        entries.set(sourceValue, targetValue);
+      }
+      return entries;
+    }
+    return null;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const defaultValue = this.defaultValues(this.cardinality);
+    const outcomeVariable = {
+      identifier: this.identifier,
+      cardinality: this.cardinality,
+      baseType: this.baseType,
+      defaultValue,
+      type: "outcome",
+      value: null,
+      interpolationTable: this.interpolationTable,
+      externalScored: this.externalScored
+    };
+    outcomeVariable.value = defaultValue;
+    if ((outcomeVariable.value === null || outcomeVariable.value == void 0) && (outcomeVariable.baseType === "integer" || outcomeVariable.baseType === "float")) {
+      outcomeVariable.value = "0";
+    }
+    this.dispatchEvent(
+      new CustomEvent("qti-register-variable", {
+        bubbles: true,
+        composed: true,
+        detail: { variable: outcomeVariable }
+      })
+    );
+  }
+};
+QtiOutcomeDeclaration.styles = [
+  i`
+      :host {
+        display: none;
+      }
+    `
+];
+__decorateClass([
+  n({ type: String, attribute: "base-type" })
+], QtiOutcomeDeclaration.prototype, "baseType", 2);
+__decorateClass([
+  n({ type: String, attribute: "external-scored" })
+], QtiOutcomeDeclaration.prototype, "externalScored", 2);
+__decorateClass([
+  n({ type: String })
+], QtiOutcomeDeclaration.prototype, "identifier", 2);
+__decorateClass([
+  n({ type: String })
+], QtiOutcomeDeclaration.prototype, "cardinality", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r()
+], QtiOutcomeDeclaration.prototype, "itemContext", 2);
+QtiOutcomeDeclaration = __decorateClass([
+  t("qti-outcome-declaration")
+], QtiOutcomeDeclaration);
+
+// ../qti-elements/src/internal/template-strings.ts
+var matchCorrect = `<qti-response-processing>
+  <qti-response-condition>
+    <qti-response-if>
+      <qti-match>
+        <qti-variable identifier="RESPONSE"></qti-variable>
+        <qti-correct identifier="RESPONSE"></qti-correct>
+      </qti-match>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-base-value base-type="float">1</qti-base-value>
+      </qti-set-outcome-value>
+    </qti-response-if>
+    <qti-response-else>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-base-value base-type="float">0</qti-base-value>
+      </qti-set-outcome-value>
+    </qti-response-else>
+  </qti-response-condition>
+</qti-response-processing>`;
+var mapResponse = `<qti-response-processing>
+  <qti-response-condition>
+    <qti-response-if>
+      <qti-is-null>
+        <qti-variable identifier="RESPONSE"></qti-variable>
+      </qti-is-null>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-base-value base-type="float">0.0</qti-base-value>
+      </qti-set-outcome-value>
+    </qti-response-if>
+    <qti-response-else>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-map-response identifier="RESPONSE"> </qti-map-response>
+      </qti-set-outcome-value>
+    </qti-response-else>
+  </qti-response-condition>
+</qti-response-processing>`;
+var mapResponsePoint = `<qti-response-processing>
+  <qti-response-condition>
+    <qti-response-if>
+      <qti-is-null>
+        <qti-variable identifier="RESPONSE"></qti-variable>
+      </qti-is-null>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-base-value base-type="float">0</qti-base-value>
+      </qti-set-outcome-value>
+    </qti-response-if>
+    <qti-response-else>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-map-response-point identifier="RESPONSE"></qti-map-response-point>
+      </qti-set-outcome-value>
+    </qti-response-else>
+  </qti-response-condition>
+</qti-response-processing>`;
+
+// ../qti-elements/src/components/qti-response-processing/qti-response-processing.ts
+var QtiResponseProcessing = class extends i2 {
+  render() {
+    return x`<slot></slot>`;
+  }
+  process() {
+    const assessmentItem = this.closest("qti-assessment-item");
+    if (!assessmentItem) return;
+    const rules = [...this.children];
+    for (const rule of rules) {
+      rule.process();
+    }
+  }
+  firstUpdated(_changedProperties) {
+    if (this.getAttribute("template")) {
+      const splittedTemplateName = this.getAttribute("template").split("/");
+      const templateName = splittedTemplateName[splittedTemplateName.length - 1].replace(".xml", "");
+      this.innerHTML = "";
+      switch (templateName) {
+        case "map_response": {
+          this.appendChild(this.fragmentFromString(mapResponse).firstElementChild.firstElementChild);
+          break;
+        }
+        case "map_response_point": {
+          this.appendChild(this.fragmentFromString(mapResponsePoint).firstElementChild.firstElementChild);
+          break;
+        }
+        case "match_correct":
+          this.appendChild(this.fragmentFromString(matchCorrect).firstElementChild.firstElementChild);
+          break;
+      }
+    }
+  }
+  fragmentFromString(strHTML) {
+    return document.createRange().createContextualFragment(strHTML);
+  }
+};
+QtiResponseProcessing.styles = [
+  i`
+      :host {
+        display: none;
+      }
+    `
+];
+QtiResponseProcessing = __decorateClass([
+  t("qti-response-processing")
+], QtiResponseProcessing);
+
+export {
+  QtiAssessmentItem,
+  QtiAssessmentStimulusRefConnectedEvent,
+  QtiAssessmentStimulusRef,
+  QtiCompanionMaterialsInfo,
+  QtiCustomOperator,
+  QtiFeedbackBlock,
+  QtiFeedbackInline,
+  QtiModalFeedback,
+  QtiItemBody,
+  QtiPrompt,
+  QtiContentBody,
+  QtiRubricBlock,
+  QtiStylesheet,
+  QtiResponseDeclaration,
+  QtiOutcomeDeclaration,
+  QtiResponseProcessing
+};
+//# sourceMappingURL=chunk-O4XIWHTF.js.map