@citolab/qti-components 7.14.2 → 7.15.0

package/dist/chunk-RI47B4ZT.js

@@ -0,0 +1,1753 @@
+import {
+  E,
+  QtiConditionExpression,
+  QtiExpression,
+  ScoringHelper,
+  c,
+  convertNumberToUniversalFormat,
+  i2 as i,
+  itemContext,
+  n,
+  r,
+  t,
+  testContext,
+  x
+} from "./chunk-JEUY3MYB.js";
+import {
+  __decorateClass
+} from "./chunk-EUXUH3YW.js";
+
+// ../qti-processing/src/components/qti-rule/qti-rule.ts
+var QtiRule = class extends i {
+  render() {
+    return x`<slot></slot>`;
+  }
+  process() {
+    throw new Error("Not implemented");
+  }
+};
+QtiRule = __decorateClass([
+  t("qti-rule")
+], QtiRule);
+
+// ../qti-processing/src/components/qti-lookup-outcome-value/qti-lookup-outcome-value.ts
+var QtiLookupOutcomeValue = class extends QtiRule {
+  get childExpression() {
+    return this.firstElementChild;
+  }
+  process() {
+    const identifier = this.getAttribute("identifier");
+    const outcomeVariable = this.context.variables.find((v) => v.identifier === identifier) || null;
+    let value;
+    if (outcomeVariable.interpolationTable) {
+      value = outcomeVariable.interpolationTable.get(parseFloat(this.childExpression.calculate()));
+    }
+    if (value === null || value === void 0) {
+      console.warn("lookupOutcomeValue: value is null or undefined");
+      return 0;
+    }
+    this.dispatchEvent(
+      new CustomEvent("qti-set-outcome-value", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          outcomeIdentifier: this.identifier,
+          value: convertNumberToUniversalFormat(value)
+        }
+      })
+    );
+    return value;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiLookupOutcomeValue.prototype, "identifier", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r()
+], QtiLookupOutcomeValue.prototype, "context", 2);
+customElements.define("qti-lookup-outcome-value", QtiLookupOutcomeValue);
+
+// ../qti-processing/src/components/qti-response-condition/qti-response-condition.ts
+var QtiResponseCondition = class extends QtiRule {
+  render() {
+    return x`<slot></slot>`;
+  }
+  process() {
+    const branches = [...this.children];
+    for (let i2 = 0; i2 < branches.length; i2++) {
+      const branch = branches[i2];
+      if (branch.calculate()) {
+        branch.process();
+        return;
+      }
+    }
+  }
+};
+customElements.define("qti-response-condition", QtiResponseCondition);
+
+// ../qti-processing/src/components/qti-set-outcome-value/qti-set-outcome-value.ts
+var QtiSetOutcomeValue = class extends QtiRule {
+  /**
+   * Processes the QTI rule and dispatches a custom event with the computed outcome value.
+   */
+  process() {
+    const outcomeIdentifier = this.getAttribute("identifier");
+    if (!outcomeIdentifier) {
+      console.warn('QtiSetOutcomeValue: Missing "identifier" attribute.');
+      return;
+    }
+    const expression = this.firstElementChild;
+    if (!expression) {
+      console.warn("QtiSetOutcomeValue: No expression found.");
+      return;
+    }
+    const rule = new QtiSetOutcomeValueRule(expression);
+    const value = rule.process();
+    this.dispatchEvent(
+      new CustomEvent("qti-set-outcome-value", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          outcomeIdentifier,
+          value: this.formatValue(value)
+        }
+      })
+    );
+  }
+  /**
+   * Formats the computed value before dispatching.
+   * Ensures numbers are converted to a universal format.
+   */
+  formatValue(value) {
+    if (Array.isArray(value)) {
+      return value.map(convertNumberToUniversalFormat);
+    }
+    return value !== null ? convertNumberToUniversalFormat(value) : null;
+  }
+};
+var QtiSetOutcomeValueRule = class {
+  constructor(expression) {
+    this.expression = expression;
+  }
+  /**
+   * Evaluates the expression and returns its value.
+   */
+  process() {
+    const value = this.expression.calculate() ?? null;
+    if (value === null) {
+      console.warn("QtiSetOutcomeValueRule: Evaluated value is null.");
+    }
+    return Array.isArray(value) ? value.map((v) => v.value ? v.value : v) : value;
+  }
+};
+customElements.define("qti-set-outcome-value", QtiSetOutcomeValue);
+
+// ../qti-processing/src/components/qti-response-else/qti-response-else.ts
+var QtiResponseElse = class extends i {
+  render() {
+    return x`<slot></slot>`;
+  }
+  calculate() {
+    return true;
+  }
+  getSubRules() {
+    return [...this.children];
+  }
+  process() {
+    const subRules = this.getSubRules();
+    for (let i2 = 0; i2 < subRules.length; i2++) {
+      const subRule = subRules[i2];
+      subRule.process();
+    }
+  }
+};
+customElements.define("qti-response-else", QtiResponseElse);
+
+// ../qti-processing/src/components/qti-response-if/qti-response-if.ts
+var QtiResponseIf = class extends QtiResponseElse {
+  calculate() {
+    const expression = this.firstElementChild;
+    const result = expression.calculate();
+    return result;
+  }
+  getSubRules() {
+    const result = [];
+    for (let i2 = 1; i2 < this.children.length; i2++) {
+      result.push(this.children[i2]);
+    }
+    return result;
+  }
+};
+customElements.define("qti-response-if", QtiResponseIf);
+
+// ../qti-processing/src/components/qti-response-else-if/qti-response-else-if.ts
+var QtiResponseElseIf = class extends QtiResponseIf {
+  render() {
+    return x`${super.render()}`;
+  }
+};
+customElements.define("qti-response-else-if", QtiResponseElseIf);
+
+// ../qti-processing/src/components/qti-and/qti-and.ts
+var QtiAnd = class extends qtiAndMixin(QtiConditionExpression) {
+  calculate() {
+    return this.calculateChildren(Array.from(this.children));
+  }
+};
+QtiAnd = __decorateClass([
+  t("qti-and")
+], QtiAnd);
+function qtiAndMixin(Base) {
+  return class MockQtiAnd extends Base {
+    calculateChildren(children) {
+      const values = children.map((c2) => {
+        const condition = c2;
+        if (!condition.calculate) {
+          console.error("Element doesn't implement QtiConditionExpression");
+          return null;
+        }
+        const value = condition.calculate();
+        let val = false;
+        if (typeof value === "string") {
+          if (value === "true") {
+            val = true;
+          } else if (value === "false") {
+            val = false;
+          } else {
+            console.error("unexpected val in qti-or, expected boolean");
+            return null;
+          }
+        } else {
+          if (typeof value === "boolean") {
+            val = value;
+          }
+        }
+        return val;
+      });
+      return values.every((e) => {
+        return typeof e === "boolean" && e;
+      });
+    }
+  };
+}
+
+// ../qti-processing/src/components/qti-basevalue/qti-basevalue.ts
+var QtiBaseValue = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.baseType = "string";
+  }
+  getResult() {
+    const value = this.textContent.trim();
+    return value;
+  }
+};
+__decorateClass([
+  n({ type: String, attribute: "base-type" })
+], QtiBaseValue.prototype, "baseType", 2);
+customElements.define("qti-base-value", QtiBaseValue);
+
+// ../qti-processing/src/components/qti-container-size/qti-container-size.ts
+var QtiContainerSize = class extends QtiExpression {
+  getResult() {
+    if (this.children?.length !== 1) {
+      console.error("qti-container-size must have exactly one child expression");
+      return 0;
+    }
+    const variables = this.getVariables();
+    if (!variables || variables?.length === 0) {
+      return 0;
+    }
+    const variable = variables[0];
+    if (variable.value === null || variable.value === void 0) {
+      return 0;
+    }
+    if (variable.cardinality !== "multiple" && variable.cardinality !== "ordered") {
+      console.error("qti-container-size requires multiple or ordered cardinality");
+      return 0;
+    }
+    if (!Array.isArray(variable.value)) {
+      console.error("qti-container-size: expected array value for multiple/ordered cardinality");
+      return 0;
+    }
+    return variable.value.length;
+  }
+};
+customElements.define("qti-container-size", QtiContainerSize);
+
+// ../qti-processing/src/components/qti-contains/qti-contains.ts
+var QtiContains = class extends QtiConditionExpression {
+  getResult() {
+    const values = this.getVariables();
+    if (this.children.length === 2) {
+      const value1 = values[0];
+      const value2 = values[1];
+      if (value1.baseType === "directedPair" && value2.baseType === "directedPair" && value1.cardinality === "multiple") {
+        const projection1 = value1.value;
+        const projection2 = value2.value;
+        const enumerable = projection1.filter((x2) => projection2.includes(x2));
+        const result = enumerable.length > 0;
+        return result;
+      } else if (value1.baseType === "directedPair" && value2.baseType === "directedPair" && value1.cardinality === "single") {
+        const projection1 = value1.value;
+        const projection2 = value2.value;
+        return projection2.includes(projection1);
+      } else {
+        console.error(
+          "unsupported baseType or cardinality in qti contains, only baseType: directedPair and cardinality: multiple is supported"
+        );
+      }
+    } else {
+      console.error("unexpected number of children in qti contains");
+    }
+    return false;
+  }
+};
+customElements.define("qti-contains", QtiContains);
+
+// ../qti-processing/src/components/qti-correct/qti-correct.ts
+var QtiCorrect = class extends QtiExpression {
+  get interpretation() {
+    return this.getAttribute("interpretation") || "";
+  }
+  getResult() {
+    const identifier = this.getAttribute("identifier") || "";
+    const responseVariable = this.context.variables.find((v) => v.identifier === identifier) || null;
+    if (responseVariable.cardinality !== "single") {
+      return responseVariable.correctResponse.length > 0 ? responseVariable.correctResponse[0] : "";
+    } else {
+      return responseVariable.correctResponse;
+    }
+  }
+};
+customElements.define("qti-correct", QtiCorrect);
+
+// ../qti-processing/src/components/qti-default/qti-default.ts
+var QtiDefault = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.identifier = "";
+  }
+  getResult() {
+    if (!this.identifier) {
+      console.error("qti-default requires an identifier attribute");
+      return null;
+    }
+    const parts = this.identifier.split(".");
+    let itemId = null;
+    let variableId;
+    if (parts.length === 2) {
+      itemId = parts[0];
+      variableId = parts[1];
+    } else if (parts.length === 1) {
+      variableId = parts[0];
+    } else {
+      console.error("qti-default: invalid identifier format");
+      return null;
+    }
+    if (itemId) {
+      const itemContext2 = this._testContext.items.find((item) => item.identifier === itemId);
+      console.debug(`itemContext: ${JSON.stringify(itemContext2)}`);
+      if (!this._testContext || !itemContext2) {
+        console.warn(`qti-default: item "${itemId}" not found in test context`);
+        return null;
+      }
+      const variable2 = this._testContext.items.find((item) => item.identifier === itemId)?.variables.find((v) => v.identifier === variableId);
+      if (!variable2) {
+        console.warn(`qti-default: variable "${variableId}" not found in item "${itemId}"`);
+        return null;
+      }
+      return variable2.defaultValue || null;
+    }
+    if (!this.context?.variables) {
+      console.warn("qti-default: no variables found in item context");
+      return null;
+    }
+    const variable = this.context.variables.find((v) => v.identifier === variableId);
+    if (!variable) {
+      console.warn(`qti-default: variable "${variableId}" not found in item context`);
+      return null;
+    }
+    return variable.defaultValue || null;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiDefault.prototype, "identifier", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r()
+], QtiDefault.prototype, "context", 2);
+__decorateClass([
+  r(),
+  c({ context: testContext, subscribe: true })
+], QtiDefault.prototype, "_testContext", 2);
+customElements.define("qti-default", QtiDefault);
+
+// ../qti-processing/src/components/qti-equal-rounded/qti-equal-rounded.ts
+var QtiEqualRounded = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.roundingMode = "significantFigures";
+  }
+  get figures() {
+    const attr = this.getAttribute("figures");
+    if (!attr) {
+      console.error("figures attribute is missing");
+      return null;
+    }
+    const figures = parseInt(this.getAttribute("figures") || "0");
+    if (isNaN(figures)) {
+      console.error("figures attribute is not a number");
+      return null;
+    }
+    if (figures < 0) {
+      console.error("figures attribute is negative");
+      return null;
+    }
+    if (figures < 1 && this.roundingMode === "significantFigures") {
+      console.error("figures cannot be smaller than 1 for RoundingMode significantFigures");
+      return null;
+    }
+    return figures;
+  }
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if (this.roundingMode === null) {
+        return null;
+      }
+      if (value1.cardinality !== "single" || value2.cardinality !== "single" || Array.isArray(value1.value) || Array.isArray(value2.value)) {
+        console.error("unexpected cardinality in qti equal");
+        return false;
+      }
+      switch (values[0].baseType) {
+        case "integer":
+        case "float": {
+          const float1 = parseFloat(value1.value);
+          const float2 = parseFloat(value2.value);
+          if (!isNaN(float1) && !isNaN(float2)) {
+            if (this.roundingMode === "significantFigures") {
+              return float1.toPrecision(this.figures) === float2.toPrecision(this.figures);
+            } else {
+              return Math.round(float1 * Math.pow(10, this.figures)) / Math.pow(10, this.figures) === Math.round(float2 * Math.pow(10, this.figures)) / Math.pow(10, this.figures);
+            }
+          } else {
+            console.error(`value cannot be casted to numeric value in equalRounded operator: ${float1}, ${float2}`);
+          }
+          break;
+        }
+        default: {
+          console.error(`values other than float and int cannot be used in equalRounded operator.`);
+          break;
+        }
+      }
+      return false;
+    }
+    console.error("unexpected number of children in qti-equal-rounded");
+    return null;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiEqualRounded.prototype, "roundingMode", 2);
+customElements.define("qti-equal-rounded", QtiEqualRounded);
+
+// ../qti-processing/src/components/qti-round/qti-round.ts
+var QtiRound = class extends QtiExpression {
+  getResult() {
+    if (this.children.length !== 1) {
+      console.error("qti-round must have exactly one child expression");
+      return null;
+    }
+    const variables = this.getVariables();
+    if (!variables || variables.length === 0) {
+      return null;
+    }
+    const variable = variables[0];
+    if (variable.cardinality !== "single") {
+      console.error("qti-round requires single cardinality");
+      return null;
+    }
+    if (Array.isArray(variable.value)) {
+      console.error("qti-round unexpected array value for single cardinality");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    if (variable.baseType !== "integer" && variable.baseType !== "float") {
+      console.error("qti-round requires numerical base-type (integer or float)");
+      return null;
+    }
+    const numericValue = parseFloat(variable.value);
+    if (isNaN(numericValue)) {
+      console.warn("qti-round: NaN input results in NULL");
+      return null;
+    }
+    if (!isFinite(numericValue)) {
+      if (numericValue === Infinity) {
+        return Infinity;
+      }
+      if (numericValue === -Infinity) {
+        return -Infinity;
+      }
+      return null;
+    }
+    return Math.floor(numericValue + 0.5);
+  }
+};
+customElements.define("qti-round", QtiRound);
+
+// ../qti-processing/src/components/qti-round-to/qti-round-to.ts
+var QtiRoundTo = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.roundingMode = "significantFigures";
+    this.figures = 3;
+  }
+  getResult() {
+    if (this.children.length !== 1) {
+      console.error("qti-round-to must have exactly one child expression");
+      return null;
+    }
+    const variables = this.getVariables();
+    if (!variables || variables.length === 0) {
+      return null;
+    }
+    const variable = variables[0];
+    if (variable.cardinality !== "single") {
+      console.error("qti-round-to requires single cardinality");
+      return null;
+    }
+    if (Array.isArray(variable.value)) {
+      console.error("qti-round-to unexpected array value for single cardinality");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    if (variable.baseType !== "integer" && variable.baseType !== "float") {
+      console.error("qti-round-to requires numerical base-type");
+      return null;
+    }
+    const numericValue = parseFloat(variable.value);
+    if (isNaN(numericValue)) {
+      return null;
+    }
+    if (!isFinite(numericValue)) {
+      if (numericValue === Infinity) {
+        return Infinity;
+      }
+      if (numericValue === -Infinity) {
+        return -Infinity;
+      }
+      return null;
+    }
+    if (this.figures < 0) {
+      console.error("qti-round-to: figures must be non-negative");
+      return null;
+    }
+    if (this.roundingMode === "significantFigures" && this.figures < 1) {
+      console.error("qti-round-to: figures must be at least 1 for significantFigures mode");
+      return null;
+    }
+    if (this.roundingMode === "decimalPlaces") {
+      return this._roundToDecimalPlaces(numericValue, this.figures);
+    } else {
+      return this._roundToSignificantFigures(numericValue, this.figures);
+    }
+  }
+  /**
+   * Round to specified number of decimal places
+   */
+  _roundToDecimalPlaces(value, decimalPlaces) {
+    if (value === 0) {
+      return 0;
+    }
+    const multiplier = Math.pow(10, decimalPlaces);
+    return Math.round(value * multiplier) / multiplier;
+  }
+  /**
+   * Round to specified number of significant figures
+   */
+  _roundToSignificantFigures(value, significantFigures) {
+    if (value === 0) {
+      return 0;
+    }
+    const magnitude = Math.floor(Math.log10(Math.abs(value)));
+    const multiplier = Math.pow(10, significantFigures - magnitude - 1);
+    return Math.round(value * multiplier) / multiplier;
+  }
+};
+__decorateClass([
+  n({ type: String, attribute: "rounding-mode" })
+], QtiRoundTo.prototype, "roundingMode", 2);
+__decorateClass([
+  n({ type: Number })
+], QtiRoundTo.prototype, "figures", 2);
+customElements.define("qti-round-to", QtiRoundTo);
+
+// ../qti-processing/src/components/qti-equal/qti-equal.ts
+var QtiEqual = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.toleranceMode = "exact";
+  }
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if (this.toleranceMode !== "exact") {
+        console.error("toleranceMode is not supported yet");
+        return false;
+      }
+      if (value1.cardinality !== "single" || value2.cardinality !== "single" || Array.isArray(value1.value) || Array.isArray(value2.value)) {
+        console.error("unexpected cardinality in qti equal");
+        return false;
+      }
+      return ScoringHelper.compareSingleValues(value1.value, value2.value, value1.baseType);
+    }
+    console.error("unexpected number of children in qti-equal");
+    return null;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiEqual.prototype, "toleranceMode", 2);
+customElements.define("qti-equal", QtiEqual);
+
+// ../qti-processing/src/components/qti-gcd/qti.gcd.ts
+var QtiGcd = class extends QtiExpression {
+  getResult() {
+    if (this.children.length === 0) {
+      console.error("qti-gcd must have at least one child expression");
+      return null;
+    }
+    const variables = this.getVariables();
+    if (!variables || variables.length === 0) {
+      return null;
+    }
+    const allValues = [];
+    for (const variable of variables) {
+      if (variable.baseType !== "integer") {
+        console.error("qti-gcd requires integer base-type");
+        return null;
+      }
+      if (variable.value === null || variable.value === void 0) {
+        return null;
+      }
+      if (variable.cardinality === "single") {
+        if (Array.isArray(variable.value)) {
+          console.error("qti-gcd unexpected array value for single cardinality");
+          return null;
+        }
+        const numValue = parseInt(variable.value, 10);
+        if (isNaN(numValue)) {
+          console.error("qti-gcd non-numerical value");
+          return null;
+        }
+        allValues.push(numValue);
+      } else if (variable.cardinality === "multiple" || variable.cardinality === "ordered") {
+        if (!Array.isArray(variable.value)) {
+          console.error("qti-gcd expected array value for multiple/ordered cardinality");
+          return null;
+        }
+        for (const value of variable.value) {
+          if (value === null || value === void 0) {
+            return null;
+          }
+          const numValue = parseInt(value, 10);
+          if (isNaN(numValue)) {
+            console.error("qti-gcd non-numerical value");
+            return null;
+          }
+          allValues.push(numValue);
+        }
+      } else {
+        console.error("qti-gcd unsupported cardinality");
+        return null;
+      }
+    }
+    if (allValues.length === 0) {
+      return null;
+    }
+    return this._calculateGcd(allValues);
+  }
+  /**
+   * Calculate the greatest common divisor of an array of integers
+   */
+  _calculateGcd(values) {
+    if (values.length === 0) {
+      return 0;
+    }
+    if (values.length === 1) {
+      return Math.abs(values[0]);
+    }
+    let result = Math.abs(values[0]);
+    for (let i2 = 1; i2 < values.length; i2++) {
+      result = this._gcdTwoNumbers(result, Math.abs(values[i2]));
+      if (result === 1) {
+        break;
+      }
+    }
+    return result;
+  }
+  /**
+   * Calculate GCD of two numbers using Euclidean algorithm
+   */
+  _gcdTwoNumbers(a, b) {
+    if (a === 0 && b === 0) {
+      return 0;
+    }
+    if (a === 0) {
+      return b;
+    }
+    if (b === 0) {
+      return a;
+    }
+    while (b !== 0) {
+      const temp = b;
+      b = a % b;
+      a = temp;
+    }
+    return a;
+  }
+};
+customElements.define("qti-gcd", QtiGcd);
+
+// ../qti-processing/src/components/qti-gt/qti-gt.ts
+var QtiGt = class extends QtiExpression {
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if ((value1.baseType === "integer" || value1.baseType === "float") && (value2.baseType === "integer" || value2.baseType === "float")) {
+        return +value1.value > +value2.value;
+      } else {
+        console.error("unexpected baseType or cardinality in qti gt");
+      }
+    }
+    console.error("unexpected number of children in qt");
+    return null;
+  }
+};
+customElements.define("qti-gt", QtiGt);
+
+// ../qti-processing/src/components/qti-gte/qti-gte.ts
+var QtiGte = class extends QtiConditionExpression {
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if ((value1.baseType === "integer" || value1.baseType === "float") && (value2.baseType === "integer" || value2.baseType === "float")) {
+        return +value1.value >= +value2.value;
+      } else {
+        console.error("unexpected baseType or cardinality in qti gte");
+        return null;
+      }
+    }
+    console.log("unexpected number of children in qte");
+    return null;
+  }
+};
+customElements.define("qti-gte", QtiGte);
+
+// ../qti-processing/src/components/qti-null/qti-null.ts
+var QtiNull = class extends QtiExpression {
+  getResult() {
+    return null;
+  }
+};
+customElements.define("qti-null", QtiNull);
+
+// ../qti-processing/src/components/qti-is-null/qti-is-null.ts
+var QtiIsNull = class extends QtiExpression {
+  getResult() {
+    if (this.children.length === 1) {
+      const variables = this.getVariables();
+      if (!variables) {
+        return true;
+      }
+      const value = variables[0].value;
+      return value == null || value == void 0 || value === "";
+    }
+    console.error("unexpected number of children in qti Null");
+    return null;
+  }
+};
+customElements.define("qti-is-null", QtiIsNull);
+
+// ../qti-processing/src/components/qti-field-value/qti-field-value.ts
+var QtiFieldValue = class extends QtiExpression {
+  getResult() {
+    const fieldIdentifier = this.getAttribute("field-identifier");
+    if (!fieldIdentifier) {
+      throw new Error("field-identifier attribute is required");
+    }
+    const childElements = Array.from(this.children);
+    if (childElements.length !== 1) {
+      throw new Error("qti-field-value must have exactly one child expression");
+    }
+    const variable = this.getVariables()[0];
+    if (variable.baseType !== "record" || variable.value === null) {
+      throw new Error("qti-field-value child expression must return a record");
+    }
+    const fieldValue = variable.value[fieldIdentifier];
+    if (fieldValue === void 0) {
+      throw new Error(`Field "${fieldIdentifier}" not found in record`);
+    }
+    return fieldValue;
+  }
+};
+customElements.define("qti-field-value", QtiFieldValue);
+
+// ../qti-processing/src/components/qti-lt/qti-lt.ts
+var QtiLt = class extends QtiExpression {
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if ((value1.baseType === "integer" || value1.baseType === "float") && (value2.baseType === "integer" || value2.baseType === "float")) {
+        return +value1.value < +value2.value;
+      } else {
+        console.error("unexpected baseType or cardinality in qti lt");
+      }
+    }
+    console.error("unexpected number of children in lt");
+    return null;
+  }
+};
+customElements.define("qti-lt", QtiLt);
+
+// ../qti-processing/src/components/qti-lte/qti-lte.ts
+var QtiLte = class extends QtiConditionExpression {
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if ((value1.baseType === "integer" || value1.baseType === "float") && (value2.baseType === "integer" || value2.baseType === "float")) {
+        return +value1.value <= +value2.value;
+      } else {
+        console.error("unexpected baseType or cardinality in qti lte");
+        return null;
+      }
+    }
+    console.log("unexpected number of children in lte");
+    return null;
+  }
+};
+customElements.define("qti-lte", QtiLte);
+
+// ../qti-processing/src/components/qti-map-response/qti-map-response.ts
+var QtiMapResponse = class extends QtiExpression {
+  getResult() {
+    const response = this.context.variables.find((r2) => r2.identifier === this.identifier);
+    if (!response || !response.mapping) {
+      console.error(`Response ${this.identifier} can not be found`);
+      return null;
+    }
+    const mapping = response.mapping;
+    const candidateResponses = !Array.isArray(response.value) ? [response.value] : response.value;
+    let result = 0;
+    for (const candidateResponse of candidateResponses) {
+      const mappedValues = mapping.mapEntries.filter((entry) => {
+        if (response.baseType === "string" && !entry.caseSensitive) {
+          return ScoringHelper.compareSingleValues(
+            entry.mapKey.toLowerCase(),
+            candidateResponse.toLowerCase(),
+            response.baseType
+          );
+        } else {
+          return ScoringHelper.compareSingleValues(entry.mapKey, candidateResponse, response.baseType);
+        }
+      });
+      const mappedValue = mappedValues.reduce(
+        (prev, current) => prev.mappedValue > current.mappedValue ? prev : current,
+        mappedValues.length > 0 ? mappedValues[0] : { mapKey: null, mappedValue: null }
+        // Use the first element instead of a manual initial value
+      );
+      if (!(mappedValue === null || mappedValue.mappedValue == void 0)) {
+        result += mappedValue.mappedValue;
+      } else {
+        result += mapping.defaultValue;
+      }
+    }
+    if (mapping?.lowerBound !== null && mapping?.lowerBound !== void 0) {
+      result = Math.max(mapping.lowerBound, result);
+    }
+    if (mapping?.upperBound !== null && mapping?.upperBound !== void 0) {
+      result = Math.min(mapping.upperBound, result);
+    }
+    return result;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiMapResponse.prototype, "identifier", 2);
+customElements.define("qti-map-response", QtiMapResponse);
+
+// ../qti-processing/src/components/qti-map-response-point/qti-map-response-point.ts
+var QtiMapResponsePoint = class extends QtiExpression {
+  getResult() {
+    const response = this.context.variables.find((r2) => r2.identifier === this.identifier);
+    if (!response) {
+      console.warn(`Response ${this.identifier} cannot be found`);
+      return null;
+    }
+    const areaMapping = response.areaMapping;
+    if (!areaMapping) {
+      console.warn(`Area mapping not found for response ${this.identifier}`);
+      return null;
+    }
+    const candidateResponses = !Array.isArray(response.value) ? [response.value] : response.value;
+    if (!candidateResponses || candidateResponses.length === 0) {
+      console.warn(`No candidate responses for response ${this.identifier}`);
+      return null;
+    }
+    let result = 0;
+    const mappedAreas = /* @__PURE__ */ new Set();
+    for (const candidateResponse of candidateResponses) {
+      for (const entry of areaMapping.areaMapEntries) {
+        if (mappedAreas.has(entry.coords)) {
+          continue;
+        }
+        const isPointInArea = ScoringHelper.isPointInArea(
+          candidateResponse,
+          `${entry.shape},${entry.coords}`,
+          response.baseType
+        );
+        if (isPointInArea) {
+          result += entry.mappedValue ?? 0;
+          mappedAreas.add(entry.coords);
+        }
+      }
+    }
+    if (mappedAreas.size < candidateResponses.length) {
+      result += areaMapping.defaultValue;
+    }
+    if (areaMapping.lowerBound != null) {
+      result = Math.max(areaMapping.lowerBound, result);
+    }
+    if (areaMapping.upperBound != null) {
+      result = Math.min(areaMapping.upperBound, result);
+    }
+    return result;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiMapResponsePoint.prototype, "identifier", 2);
+customElements.define("qti-map-response-point", QtiMapResponsePoint);
+
+// ../qti-processing/src/components/qti-math-operator/qti-math-operator.ts
+var QtiMathOperator = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.name = "";
+  }
+  getResult() {
+    if (!this.name) {
+      console.error("qti-math-operator requires a name attribute");
+      return null;
+    }
+    const variables = this.getVariables();
+    if (!variables || variables.length === 0) {
+      return null;
+    }
+    const values = [];
+    for (const variable of variables) {
+      if (variable.cardinality !== "single") {
+        console.error("qti-math-operator requires single cardinality");
+        return null;
+      }
+      if (Array.isArray(variable.value)) {
+        console.error("qti-math-operator unexpected array value for single cardinality");
+        return null;
+      }
+      if (variable.value === null || variable.value === void 0) {
+        return null;
+      }
+      if (variable.baseType !== "integer" && variable.baseType !== "float") {
+        console.error("qti-math-operator requires numerical base-type");
+        return null;
+      }
+      const numValue = parseFloat(variable.value);
+      if (isNaN(numValue)) {
+        console.error("qti-math-operator non-numerical value");
+        return null;
+      }
+      values.push(numValue);
+    }
+    return this._performOperation(this.name, values);
+  }
+  _performOperation(operation, values) {
+    try {
+      switch (operation.toLowerCase()) {
+        // Single argument functions
+        case "sin":
+          if (values.length !== 1) return null;
+          return Math.sin(values[0]);
+        case "cos":
+          if (values.length !== 1) return null;
+          return Math.cos(values[0]);
+        case "tan":
+          if (values.length !== 1) return null;
+          return Math.tan(values[0]);
+        case "asin":
+          if (values.length !== 1) return null;
+          if (values[0] < -1 || values[0] > 1) return null;
+          return Math.asin(values[0]);
+        case "acos":
+          if (values.length !== 1) return null;
+          if (values[0] < -1 || values[0] > 1) return null;
+          return Math.acos(values[0]);
+        case "atan":
+          if (values.length !== 1) return null;
+          return Math.atan(values[0]);
+        case "sinh":
+          if (values.length !== 1) return null;
+          return Math.sinh(values[0]);
+        case "cosh":
+          if (values.length !== 1) return null;
+          return Math.cosh(values[0]);
+        case "tanh":
+          if (values.length !== 1) return null;
+          return Math.tanh(values[0]);
+        case "log":
+          if (values.length !== 1) return null;
+          if (values[0] <= 0) return null;
+          return Math.log(values[0]);
+        case "ln":
+          if (values.length !== 1) return null;
+          if (values[0] <= 0) return null;
+          return Math.log(values[0]);
+        case "log10":
+          if (values.length !== 1) return null;
+          if (values[0] <= 0) return null;
+          return Math.log10(values[0]);
+        case "exp":
+          if (values.length !== 1) return null;
+          return Math.exp(values[0]);
+        case "abs":
+          if (values.length !== 1) return null;
+          return Math.abs(values[0]);
+        case "sqrt":
+          if (values.length !== 1) return null;
+          if (values[0] < 0) return null;
+          return Math.sqrt(values[0]);
+        case "signum":
+          if (values.length !== 1) return null;
+          return Math.sign(values[0]);
+        // Returns -1, 0, or 1 (integer)
+        case "floor":
+          if (values.length !== 1) return null;
+          return Math.floor(values[0]);
+        // Returns integer
+        case "ceil":
+          if (values.length !== 1) return null;
+          return Math.ceil(values[0]);
+        // Returns integer
+        case "round":
+          if (values.length !== 1) return null;
+          return Math.round(values[0]);
+        // Two argument functions
+        case "atan2":
+          if (values.length !== 2) return null;
+          return Math.atan2(values[0], values[1]);
+        case "pow": {
+          if (values.length !== 2) {
+            return null;
+          }
+          const base = values[0];
+          const exponent = values[1];
+          if (base === 0 && exponent <= 0) return null;
+          if (base < 0 && !Number.isInteger(exponent)) return null;
+          return Math.pow(base, exponent);
+        }
+        case "log_base": {
+          if (values.length !== 2) {
+            return null;
+          }
+          const value = values[0];
+          const base = values[1];
+          if (value <= 0 || base <= 0 || base === 1) return null;
+          return Math.log(value) / Math.log(base);
+        }
+        case "mod":
+          if (values.length !== 2) return null;
+          if (values[1] === 0) return null;
+          return values[0] % values[1];
+        case "max":
+          if (values.length < 1) return null;
+          return Math.max(...values);
+        case "min":
+          if (values.length < 1) return null;
+          return Math.min(...values);
+        default:
+          console.error(`qti-math-operator: unknown operation "${operation}"`);
+          return null;
+      }
+    } catch (error) {
+      console.error(`qti-math-operator: error performing operation "${operation}":`, error);
+      return null;
+    }
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiMathOperator.prototype, "name", 2);
+customElements.define("qti-math-operator", QtiMathOperator);
+
+// ../qti-processing/src/components/qti-match/qti-match.ts
+var QtiMatch = class _QtiMatch extends QtiExpression {
+  //PK : FIXME.
+  // This was a little experiment if we could call the match function as a static function,
+  // This can be used for all kind of things, but now especially for use in
+  // qti-response-condition-script
+  // in which we pass the expressions as pure functions, and hope for the best.
+  // SADLY, the getVariables throws roet in de eten.. weet nog niet precies hoe deze werkt.
+  // Maar ik ga erin duiken.
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const valueToMap = values[0];
+      const correctValueInfo = values[1];
+      return _QtiMatch.match(valueToMap, correctValueInfo);
+    }
+    console.error("unexpected number of children in match");
+    return null;
+  }
+  static match(valueToMap, correctValueInfo) {
+    if (valueToMap.value === null) return false;
+    switch (correctValueInfo.cardinality) {
+      case "single": {
+        if (Array.isArray(valueToMap.value) || Array.isArray(correctValueInfo.value)) {
+          console.error("unexpected cardinality in qti match");
+          return false;
+        }
+        return ScoringHelper.compareSingleValues(
+          valueToMap.value?.toString(),
+          correctValueInfo.value.toString(),
+          correctValueInfo.baseType
+        );
+      }
+      case "ordered": {
+        if (!Array.isArray(valueToMap.value) || !Array.isArray(correctValueInfo.value)) {
+          console.error("unexpected cardinality in qti match");
+          return false;
+        }
+        if (valueToMap.value.length !== correctValueInfo.value.length) {
+          return false;
+        }
+        for (let i2 = 0; i2 < valueToMap.value.length; i2++) {
+          const result = ScoringHelper.compareSingleValues(
+            correctValueInfo.value[i2],
+            valueToMap.value[i2],
+            correctValueInfo.baseType
+          );
+          if (!result) {
+            return false;
+          }
+        }
+        return true;
+      }
+      case "multiple": {
+        if (!Array.isArray(valueToMap.value) || !Array.isArray(correctValueInfo.value)) {
+          console.error("unexpected cardinality in qti match");
+          return false;
+        }
+        if (valueToMap.value.length !== correctValueInfo.value.length) {
+          return false;
+        }
+        let answerIndex = 0;
+        for (const correctAnswer of correctValueInfo.value) {
+          let matchingValue = null;
+          const arr = [...valueToMap.value];
+          for (const mv of arr) {
+            const result = ScoringHelper.compareSingleValues(correctAnswer, mv, correctValueInfo.baseType);
+            if (result) {
+              matchingValue = mv;
+              break;
+            }
+          }
+          if (matchingValue !== null) {
+            arr.splice(arr.indexOf(matchingValue), 1);
+          } else {
+            return false;
+          }
+          answerIndex++;
+        }
+        return true;
+      }
+      default:
+        console.error("unexpected cardinality in qti match");
+        return false;
+    }
+  }
+};
+customElements.define("qti-match", QtiMatch);
+
+// ../qti-processing/src/components/qti-member/qti-member.ts
+var QtiMember = class extends QtiExpression {
+  getResult() {
+    const values = this.getVariables();
+    if (!(this.children.length === 2)) {
+      console.warn("The member operator takes two sub-expressions");
+    }
+    const [value1, value2] = values;
+    if (!(value1.baseType === value2.baseType || value1.baseType === "integer" && value2.baseType === "float" || value1.baseType === "float" && value2.baseType === "integer")) {
+      console.warn("Which must both have the same base-type");
+    }
+    if (!(value2.cardinality === "multiple" || value2.cardinality === "ordered")) {
+      console.warn("and the second must be a multiple or ordered container");
+    }
+    if (value1.baseType === "float" || value2.baseType === "float") {
+      console.warn("The member operator should not be used on sub-expressions with a base-type of float");
+    }
+    if (value1.baseType === "duration" || value2.baseType === "duration") {
+      console.warn("It must not be used on sub-expressions with a base-type of duration");
+    }
+    if (value1.value === null || value2.value === null) {
+      return null;
+    }
+    const projection1 = value1.value;
+    const projection2 = value2.value;
+    return projection2.includes(projection1);
+  }
+};
+customElements.define("qti-member", QtiMember);
+
+// ../qti-processing/src/components/qti-multiple/qti-multiple.ts
+var QtiMultiple = class extends QtiExpression {
+  getResult() {
+    console.debug("qti-multiple getResult called", this.innerHTML);
+    const variables = this.getVariables();
+    if (variables.length === 0) {
+      console.error("unexpected number of children in qti multiple");
+      return null;
+    }
+    for (const variable of variables) {
+      if (variable.cardinality !== "multiple" && variable.cardinality !== "single") {
+        console.error("unexpected cardinality in qti multiple");
+        return [];
+      }
+    }
+    return variables;
+  }
+};
+customElements.define("qti-multiple", QtiMultiple);
+
+// ../qti-processing/src/components/qti-not/qti-not.ts
+var QtiNot = class extends QtiExpression {
+  render() {
+    return x`${super.render()}`;
+  }
+  getResult() {
+    const expression = this.firstElementChild;
+    const result = expression.calculate();
+    return !result;
+  }
+};
+customElements.define("qti-not", QtiNot);
+
+// ../qti-processing/src/components/qti-or/qti-or.ts
+var QtiOr = class extends QtiConditionExpression {
+  getResult() {
+    const values = Array.from(this.children).map((c2) => {
+      const condition = c2;
+      if (!condition.calculate) {
+        console.error("Element doesn't implement QtiConditionExpression");
+        return null;
+      }
+      const value = condition.calculate();
+      let val = false;
+      if (typeof value === "string") {
+        if (value === "true") {
+          val = true;
+        } else if (value === "false") {
+          val = false;
+        } else {
+          console.error("unexpected val in qti-or, expected boolean");
+          return null;
+        }
+      } else {
+        if (typeof value === "boolean") {
+          val = value;
+        }
+      }
+      return val;
+    });
+    return values.some((e) => {
+      return typeof e === "boolean" && e;
+    });
+  }
+};
+customElements.define("qti-or", QtiOr);
+
+// ../qti-processing/src/components/qti-ordered/qti-ordered.ts
+var QtiOrdered = class extends QtiExpression {
+  getResult() {
+    const variables = this.getVariables();
+    if (variables.length === 0) {
+      console.error("unexpected number of children in qti multiple");
+      return null;
+    }
+    for (const variable of variables) {
+      if (variable.cardinality !== "ordered" && variable.cardinality !== "single") {
+        console.error("unexpected cardinality in qti ordered");
+        return [];
+      }
+    }
+    return variables;
+  }
+};
+customElements.define("qti-ordered", QtiOrdered);
+
+// ../qti-processing/src/components/qti-power/qti-power.ts
+var QtiPower = class extends QtiExpression {
+  getResult() {
+    if (this.children.length !== 2) {
+      console.error("qti-power must have exactly two child expressions");
+      return null;
+    }
+    const variables = this.getVariables();
+    if (!variables || variables.length !== 2) {
+      return null;
+    }
+    const [base, exponent] = variables;
+    if (base.cardinality !== "single" || exponent.cardinality !== "single") {
+      console.error("qti-power requires single cardinality for both expressions");
+      return null;
+    }
+    if (Array.isArray(base.value) || Array.isArray(exponent.value)) {
+      console.error("qti-power unexpected array value for single cardinality");
+      return null;
+    }
+    if (base.value === null || base.value === void 0 || exponent.value === null || exponent.value === void 0) {
+      return null;
+    }
+    if (base.baseType !== "integer" && base.baseType !== "float" || exponent.baseType !== "integer" && exponent.baseType !== "float") {
+      console.error("qti-power requires numerical base-types");
+      return null;
+    }
+    const baseValue = parseFloat(base.value);
+    const exponentValue = parseFloat(exponent.value);
+    if (isNaN(baseValue) || isNaN(exponentValue)) {
+      console.error("qti-power: non-numerical values encountered");
+      return null;
+    }
+    if (baseValue === 0 && exponentValue <= 0) {
+      return null;
+    }
+    if (baseValue < 0 && !Number.isInteger(exponentValue)) {
+      return null;
+    }
+    let result;
+    try {
+      result = Math.pow(baseValue, exponentValue);
+    } catch (error) {
+      console.error("qti-power: error calculating power:", error);
+      return null;
+    }
+    if (isNaN(result)) {
+      return null;
+    }
+    if (result === Infinity || result === -Infinity) {
+      return result;
+    }
+    if (!isFinite(result)) {
+      return null;
+    }
+    if (Math.abs(result) > Number.MAX_VALUE) {
+      return null;
+    }
+    if (result !== 0 && Math.abs(result) < Number.MIN_VALUE) {
+      return null;
+    }
+    if (isFinite(result) && result !== 0) {
+      const magnitude = Math.floor(Math.log10(Math.abs(result)));
+      const precision = Math.max(0, 14 - magnitude);
+      const factor = Math.pow(10, precision);
+      result = Math.round(result * factor) / factor;
+    }
+    return result;
+  }
+};
+customElements.define("qti-power", QtiPower);
+
+// ../qti-processing/src/components/qti-printed-variable/qti-printed-variable.ts
+var QtiPrintedVariable = class extends i {
+  render() {
+    const value = this.context?.variables.find((v) => v.identifier === this.identifier)?.value;
+    return value === null ? E : x`${JSON.stringify(value, null, 2)}`;
+  }
+  calculate() {
+    const result = this.context.variables.find((v) => v.identifier === this.identifier) || null;
+    return result;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiPrintedVariable.prototype, "identifier", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r()
+], QtiPrintedVariable.prototype, "context", 2);
+customElements.define("qti-printed-variable", QtiPrintedVariable);
+
+// ../qti-processing/src/components/qti-product/qti-product.ts
+var QtiProduct = class extends QtiExpression {
+  getResult() {
+    const values = this.getVariables();
+    const product = values.reduce((accumulator, currentValue) => {
+      if (currentValue.baseType == "float" || currentValue.baseType == "integer") {
+        try {
+          return accumulator * parseFloat(currentValue.value.toString());
+        } catch (error) {
+          console.warn(`can not convert to number`);
+        }
+      } else {
+        console.warn(`has another baseType ${currentValue.baseType}`);
+      }
+      return accumulator;
+    }, 1);
+    return product;
+  }
+};
+customElements.define("qti-product", QtiProduct);
+
+// ../qti-processing/src/components/qti-subtract/qti-subtract.ts
+var QtiSubtract = class extends qtiSubtractMixin(QtiExpression) {
+  getResult() {
+    const value = this.calculateChildren(Array.from(this.children));
+    return value;
+  }
+};
+function qtiSubtractMixin(Base) {
+  return class MockQtiSubtract extends Base {
+    calculateChildren(children) {
+      const values = children.map((expression) => {
+        if (!expression.calculate) {
+          console.error("Element doesn't implement QtiConditionExpression");
+          return null;
+        }
+        const value = expression.calculate();
+        if (Number.isNaN(value)) {
+          console.error("Unexpected value in qti-subtract, expected number");
+          return null;
+        }
+        return Number(value);
+      });
+      if (values.some((value) => value === null)) {
+        console.error("One or more child expressions returned invalid values");
+        return 0;
+      }
+      return values[0] - values[1];
+    }
+  };
+}
+
+// ../qti-processing/src/components/qti-string-match/qti-string-match.ts
+var QtiStringMatch = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.caseSensitive = "true";
+  }
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if (value1.cardinality !== "single" || value2.cardinality !== "single" || Array.isArray(value1.value) || Array.isArray(value2.value)) {
+        console.error("unexpected cardinality in qti string-match");
+        return false;
+      }
+      const v1 = this.caseSensitive === "true" ? value1.value : value1.value.toLowerCase();
+      const v2 = this.caseSensitive === "true" ? value2.value : value2.value.toLowerCase();
+      return ScoringHelper.compareSingleValues(v1, v2, value1.baseType);
+    }
+    console.error("unexpected number of children in qti-string-match");
+    return null;
+  }
+};
+__decorateClass([
+  n({ type: String, attribute: "case-sensitive" })
+], QtiStringMatch.prototype, "caseSensitive", 2);
+customElements.define("qti-string-match", QtiStringMatch);
+
+// ../qti-processing/src/components/qti-sum/qti-sum.ts
+var QtiSum = class extends QtiExpression {
+  constructor() {
+    super();
+    this._expression = new QtiSumExpression(Array.from(this.children));
+  }
+  getResult() {
+    const value = this._expression.calculate();
+    return value;
+  }
+};
+var QtiSumExpression = class {
+  constructor(expressions) {
+    this.expressions = expressions;
+  }
+  calculate() {
+    const expressions = this.expressions.filter((c2) => c2.calculate !== void 0);
+    if (expressions.some((c2) => c2.calculate() === null)) {
+      return null;
+    }
+    const values = this.expressions.map((c2) => {
+      const value = c2.calculate();
+      if (Number.isNaN(value)) {
+        console.error("unexpected value in qti-sum, expected number");
+        return null;
+      }
+      return Number(value);
+    });
+    return values.reduce((a, b) => a + b, 0);
+  }
+};
+customElements.define("qti-sum", QtiSum);
+
+// ../qti-processing/src/components/qti-variable/qti-variable.ts
+var QtiVariable = class extends QtiExpression {
+  getResult() {
+    const identifier = this.getAttribute("identifier");
+    const result = this.context.variables.find((v) => v.identifier === identifier).value;
+    return result;
+  }
+};
+customElements.define("qti-variable", QtiVariable);
+
+// ../qti-processing/src/components/qti-random-integer/qti-random-integer.ts
+var QtiRandomInteger = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.min = 0;
+    this.max = 10;
+    this.step = 1;
+  }
+  getResult() {
+    if (this.min > this.max) {
+      console.error("qti-random-integer: min cannot be greater than max");
+      return this.min;
+    }
+    if (this.step <= 0) {
+      console.error("qti-random-integer: step must be positive");
+      return this.min;
+    }
+    const possibleValues = [];
+    let n2 = 0;
+    while (true) {
+      const value = this.min + this.step * n2;
+      if (value > this.max) {
+        break;
+      }
+      if (Number.isInteger(value)) {
+        possibleValues.push(value);
+      }
+      n2++;
+    }
+    if (possibleValues.length === 0) {
+      console.warn("qti-random-integer: no valid integer values in range");
+      return Number.isInteger(this.min) ? this.min : Math.floor(this.min);
+    }
+    const randomIndex = Math.floor(Math.random() * possibleValues.length);
+    return possibleValues[randomIndex];
+  }
+  /**
+   * Get all possible values for testing purposes
+   */
+  getPossibleValues() {
+    const possibleValues = [];
+    if (this.min > this.max || this.step <= 0) {
+      return [Number.isInteger(this.min) ? this.min : Math.floor(this.min)];
+    }
+    let n2 = 0;
+    while (true) {
+      const value = this.min + this.step * n2;
+      if (value > this.max) {
+        break;
+      }
+      if (Number.isInteger(value)) {
+        possibleValues.push(value);
+      }
+      n2++;
+    }
+    return possibleValues.length > 0 ? possibleValues : [Number.isInteger(this.min) ? this.min : Math.floor(this.min)];
+  }
+};
+__decorateClass([
+  n({ type: Number })
+], QtiRandomInteger.prototype, "min", 2);
+__decorateClass([
+  n({ type: Number })
+], QtiRandomInteger.prototype, "max", 2);
+__decorateClass([
+  n({ type: Number })
+], QtiRandomInteger.prototype, "step", 2);
+customElements.define("qti-random-integer", QtiRandomInteger);
+
+// ../qti-processing/src/components/qti-random/qti-random.ts
+var QtiRandom = class extends QtiExpression {
+  getResult() {
+    const values = this.getVariables();
+    if (values.length === 1) {
+      const value = values[0].value;
+      if (Array.isArray(value)) {
+        const randomIndex = Math.floor(Math.random() * value.length);
+        return value[randomIndex];
+      }
+      return value;
+    }
+    console.error("unexpected number of children in match");
+    return null;
+  }
+};
+customElements.define("qti-random", QtiRandom);
+
+// ../qti-processing/src/components/qti-delete/qti-delete.ts
+var QtiDelete = class extends QtiExpression {
+  getResult() {
+    if (this.children.length === 2) {
+      const values = this.getVariables();
+      const value1 = values[0];
+      const value2 = values[1];
+      if (value1.cardinality !== "single" || !Array.isArray(value2.value)) {
+        console.error("unexpected cardinality in qti equal");
+        return null;
+      }
+      if (values[0].baseType !== values[1].baseType) {
+        console.error("The baseType of the two variables is different");
+        return null;
+      }
+      const filtered = value2.value.filter((v) => !value1.value.includes(v));
+      return filtered;
+    }
+    return null;
+  }
+};
+customElements.define("qti-delete", QtiDelete);
+
+// ../qti-processing/src/components/qti-index/qti-index.ts
+var QtiIndex = class extends QtiExpression {
+  // Required attribute, can be a number or an identifier
+  getResult() {
+    if (!this.n) {
+      console.error('qti-index: missing required attribute "n"');
+      return null;
+    }
+    if (this.children.length !== 1) {
+      console.error("qti-index: must have exactly one child container element");
+      return null;
+    }
+    const containerVariable = this.getVariables()[0];
+    if (!containerVariable) {
+      console.error("qti-index: missing container");
+      return null;
+    }
+    let index;
+    if (!isNaN(Number(this.n))) {
+      index = Number(this.n);
+    } else {
+      const variableValue = this.lookupVariableValue(this.n);
+      if (variableValue === null) {
+        console.error(`qti-index: variable "${this.n}" is not a valid number`);
+        return null;
+      }
+      index = Number(variableValue);
+    }
+    if (index <= 0 || !Number.isInteger(index)) {
+      console.error("qti-index: index must be a positive integer");
+      return null;
+    }
+    if (containerVariable.cardinality === "ordered") {
+      const containerValues = Array.isArray(containerVariable.value) ? containerVariable.value : [containerVariable.value];
+      if (containerVariable.value === null || index > containerValues.length) {
+        return null;
+      }
+      return containerValues[index - 1];
+    } else {
+      console.error("qti-index: child must have ordered cardinality");
+      return null;
+    }
+  }
+  // Helper method to look up a variable value by identifier
+  // This would need to be implemented based on your actual QTI runtime environment
+  lookupVariableValue(identifier) {
+    const value = this.context.variables.find((v) => v.identifier === identifier)?.value;
+    if (value === null || isNaN(Number(value))) {
+      return null;
+    }
+    return Number(value);
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiIndex.prototype, "n", 2);
+QtiIndex = __decorateClass([
+  t("qti-index")
+], QtiIndex);
+
+// ../qti-processing/src/components/qti-subtract/index.ts
+customElements.define("qti-subtract", QtiSubtract);
+
+export {
+  QtiLookupOutcomeValue,
+  QtiResponseCondition,
+  QtiSetOutcomeValue,
+  QtiSetOutcomeValueRule,
+  QtiResponseElse,
+  QtiResponseIf,
+  QtiResponseElseIf,
+  QtiAnd,
+  qtiAndMixin,
+  QtiBaseValue,
+  QtiContainerSize,
+  QtiContains,
+  QtiCorrect,
+  QtiDefault,
+  QtiEqualRounded,
+  QtiRound,
+  QtiRoundTo,
+  QtiEqual,
+  QtiGcd,
+  QtiGt,
+  QtiGte,
+  QtiNull,
+  QtiIsNull,
+  QtiFieldValue,
+  QtiLt,
+  QtiLte,
+  QtiMapResponse,
+  QtiMapResponsePoint,
+  QtiMathOperator,
+  QtiMatch,
+  QtiMember,
+  QtiMultiple,
+  QtiNot,
+  QtiOr,
+  QtiOrdered,
+  QtiPower,
+  QtiPrintedVariable,
+  QtiProduct,
+  QtiSubtract,
+  qtiSubtractMixin,
+  QtiStringMatch,
+  QtiSum,
+  QtiSumExpression,
+  QtiVariable,
+  QtiRandomInteger,
+  QtiRandom,
+  QtiDelete,
+  QtiIndex
+};
+//# sourceMappingURL=chunk-RI47B4ZT.js.map