@citolab/qti-components 7.27.2 → 7.27.4

package/dist/{chunk-GG36UR7F.js → chunk-YLIYPNMK.js}

@@ -1,8 +1,9 @@
 import {
-  E,
+  A,
   QtiConditionExpression,
   QtiExpression,
   ScoringHelper,
+  T,
   c,
   convertNumberToUniversalFormat,
   i2 as i,
@@ -10,9 +11,8 @@ import {
   n,
   r,
   t,
-  testContext,
-  x
-} from "./chunk-TORB5UN2.js";
+  testContext
+} from "./chunk-Z2SUBRH5.js";
 import {
   __decorateClass,
   __privateAdd,
@@ -22,7 +22,7 @@ import {
 // ../qti-processing/src/components/qti-rule/qti-rule.ts
 var QtiRule = class extends i {
   render() {
-    return x`<slot></slot>`;
+    return T`<slot></slot>`;
   }
   process() {
     throw new Error("Not implemented");
@@ -73,7 +73,7 @@ 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>`;
+    return T`<slot></slot>`;
   }
   process() {
     const branches = [...this.children];
@@ -148,7 +148,7 @@ 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>`;
+    return T`<slot></slot>`;
   }
   calculate() {
     return true;
@@ -186,7 +186,7 @@ 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()}`;
+    return T`${super.render()}`;
   }
 };
 customElements.define("qti-response-else-if", QtiResponseElseIf);
@@ -234,6 +234,51 @@ function qtiAndMixin(Base) {
   };
 }
 
+// ../qti-processing/src/components/qti-any-n/qti-any-n.ts
+var QtiAnyN = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.min = 0;
+    this.max = Infinity;
+  }
+  getResult() {
+    const variables = this.getVariables();
+    if (!variables || variables.length === 0) {
+      console.error("qti-any-n requires at least one child expression");
+      return null;
+    }
+    if (this.min < 0 || this.max < this.min) {
+      console.error("qti-any-n requires 0 <= min <= max");
+      return null;
+    }
+    let trueCount = 0;
+    for (const variable of variables) {
+      if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+        console.error("qti-any-n requires single cardinality boolean expressions");
+        return null;
+      }
+      if (variable.baseType !== "boolean") {
+        console.error("qti-any-n requires boolean base-type");
+        return null;
+      }
+      if (variable.value === null || variable.value === void 0) {
+        return null;
+      }
+      if (variable.value === "true") {
+        trueCount++;
+      }
+    }
+    return trueCount >= this.min && trueCount <= this.max;
+  }
+};
+__decorateClass([
+  n({ type: Number })
+], QtiAnyN.prototype, "min", 2);
+__decorateClass([
+  n({ type: Number })
+], QtiAnyN.prototype, "max", 2);
+customElements.define("qti-any-n", QtiAnyN);
+
 // ../qti-processing/src/components/qti-basevalue/qti-basevalue.ts
 var QtiBaseValue = class extends QtiExpression {
   constructor() {
@@ -288,7 +333,7 @@ var QtiContains = class extends QtiConditionExpression {
       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 enumerable = projection1.filter((x) => projection2.includes(x));
         const result = enumerable.length > 0;
         return result;
       } else if (value1.baseType === "directedPair" && value2.baseType === "directedPair" && value1.cardinality === "single") {
@@ -604,6 +649,9 @@ var QtiEqual = class extends QtiExpression {
       const values = this.getVariables();
       const value1 = values[0];
       const value2 = values[1];
+      if (!value1 || !value2) {
+        return null;
+      }
       if (this.toleranceMode !== "exact") {
         console.error("toleranceMode is not supported yet");
         return false;
@@ -612,6 +660,9 @@ var QtiEqual = class extends QtiExpression {
         console.error("unexpected cardinality in qti equal");
         return false;
       }
+      if (value1.value === null || value2.value === null || value1.value === void 0 || value2.value === void 0) {
+        return null;
+      }
       return ScoringHelper.compareSingleValues(value1.value, value2.value, value1.baseType);
     }
     console.error("unexpected number of children in qti-equal");
@@ -623,6 +674,136 @@ __decorateClass([
 ], QtiEqual.prototype, "toleranceMode", 2);
 customElements.define("qti-equal", QtiEqual);
 
+// ../qti-processing/src/components/qti-divide/qti-divide.ts
+var QtiDivide = class extends QtiExpression {
+  getResult() {
+    const values = this.#collectNumericValues(this.getVariables());
+    if (values.length !== 2) {
+      console.warn("qti-divide: expected exactly 2 numeric values");
+      return null;
+    }
+    if (values[1] === 0) {
+      console.warn("qti-divide: division by zero");
+      return null;
+    }
+    return values[0] / values[1];
+  }
+  #collectNumericValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (!variable) {
+        continue;
+      }
+      const pushValue = (raw) => {
+        if (raw === null || raw === void 0) {
+          return;
+        }
+        const numValue = parseFloat(raw.toString());
+        if (Number.isNaN(numValue)) {
+          console.warn("qti-divide: non-numeric value encountered");
+          return;
+        }
+        values.push(numValue);
+      };
+      if (Array.isArray(variable.value)) {
+        variable.value.forEach((item) => pushValue(item));
+        continue;
+      }
+      pushValue(variable.value);
+    }
+    return values;
+  }
+};
+customElements.define("qti-divide", QtiDivide);
+
+// ../qti-processing/src/components/qti-duration-gte/qti-duration-gte.ts
+var QtiDurationGte = class extends QtiExpression {
+  getResult() {
+    const values = this.#getDurationValues();
+    if (!values) {
+      return null;
+    }
+    return values[0] >= values[1];
+  }
+  #getDurationValues() {
+    const variables = this.getVariables();
+    if (variables.length !== 2) {
+      console.error("qti-duration-gte requires exactly 2 duration expressions");
+      return null;
+    }
+    const values = variables.map((variable) => this.#parseDuration(variable));
+    if (values.some((value) => value === null)) {
+      return null;
+    }
+    return values;
+  }
+  #parseDuration(variable) {
+    if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+      console.error("qti-duration-gte requires single cardinality");
+      return null;
+    }
+    if (variable.baseType !== "duration") {
+      console.error("qti-duration-gte requires duration base-type");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    const value = Number.parseFloat(variable.value.toString());
+    if (Number.isNaN(value)) {
+      console.error(
+        `qti-duration-gte requires duration values expressed in seconds, got "${variable.value.toString()}"`
+      );
+      return null;
+    }
+    return value;
+  }
+};
+customElements.define("qti-duration-gte", QtiDurationGte);
+
+// ../qti-processing/src/components/qti-duration-lt/qti-duration-lt.ts
+var QtiDurationLt = class extends QtiExpression {
+  getResult() {
+    const values = this.#getDurationValues();
+    if (!values) {
+      return null;
+    }
+    return values[0] < values[1];
+  }
+  #getDurationValues() {
+    const variables = this.getVariables();
+    if (variables.length !== 2) {
+      console.error("qti-duration-lt requires exactly 2 duration expressions");
+      return null;
+    }
+    const values = variables.map((variable) => this.#parseDuration(variable));
+    if (values.some((value) => value === null)) {
+      return null;
+    }
+    return values;
+  }
+  #parseDuration(variable) {
+    if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+      console.error("qti-duration-lt requires single cardinality");
+      return null;
+    }
+    if (variable.baseType !== "duration") {
+      console.error("qti-duration-lt requires duration base-type");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    const value = Number.parseFloat(variable.value.toString());
+    if (Number.isNaN(value)) {
+      console.error(`qti-duration-lt requires duration values expressed in seconds, got "${variable.value.toString()}"`);
+      return null;
+    }
+    return value;
+  }
+};
+customElements.define("qti-duration-lt", QtiDurationLt);
+
 // ../qti-processing/src/components/qti-gcd/qti.gcd.ts
 var QtiGcd = class extends QtiExpression {
   getResult() {
@@ -761,6 +942,313 @@ var QtiGte = class extends QtiConditionExpression {
 };
 customElements.define("qti-gte", QtiGte);
 
+// ../qti-processing/src/components/qti-inside/qti-inside.ts
+var QtiInside = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.shape = "";
+    this.coords = "";
+  }
+  getResult() {
+    const variables = this.getVariables();
+    if (variables.length !== 1) {
+      console.error("qti-inside requires exactly one point expression");
+      return null;
+    }
+    const variable = variables[0];
+    if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+      console.error("qti-inside requires single cardinality");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    if (!this.shape || !this.coords) {
+      console.error("qti-inside requires shape and coords attributes");
+      return null;
+    }
+    const point = this.#parsePoint(variable.value.toString());
+    const coords = this.#parseCoords(this.coords);
+    if (!point || coords.length === 0) {
+      return null;
+    }
+    switch (this.shape.toLowerCase()) {
+      case "circle":
+        return this.#isInsideCircle(point, coords);
+      case "rect":
+        return this.#isInsideRect(point, coords);
+      case "ellipse":
+        return this.#isInsideEllipse(point, coords);
+      case "poly":
+      case "polygon":
+        return this.#isInsidePolygon(point, coords);
+      default:
+        console.error(`qti-inside does not support shape "${this.shape}"`);
+        return null;
+    }
+  }
+  #parsePoint(value) {
+    const tokens = value.split(/[,\s]+/).map((token) => token.trim()).filter(Boolean);
+    if (tokens.length !== 2) {
+      console.error('qti-inside requires a point value formatted as "x y" or "x,y"');
+      return null;
+    }
+    const x = Number.parseFloat(tokens[0]);
+    const y = Number.parseFloat(tokens[1]);
+    if (Number.isNaN(x) || Number.isNaN(y)) {
+      console.error("qti-inside requires numeric point coordinates");
+      return null;
+    }
+    return { x, y };
+  }
+  #parseCoords(value) {
+    const coords = value.split(",").map((token) => token.trim()).filter(Boolean).map((token) => Number.parseFloat(token));
+    if (coords.some((coord) => Number.isNaN(coord))) {
+      console.error("qti-inside requires numeric coords");
+      return [];
+    }
+    return coords;
+  }
+  #isInsideCircle(point, coords) {
+    if (coords.length !== 3) {
+      console.error("qti-inside circle requires x,y,r");
+      return null;
+    }
+    const [centerX, centerY, radius] = coords;
+    return (point.x - centerX) ** 2 + (point.y - centerY) ** 2 <= radius ** 2;
+  }
+  #isInsideRect(point, coords) {
+    if (coords.length !== 4) {
+      console.error("qti-inside rect requires left,top,right,bottom");
+      return null;
+    }
+    const [x1, y1, x2, y2] = coords;
+    const left = Math.min(x1, x2);
+    const right = Math.max(x1, x2);
+    const top = Math.min(y1, y2);
+    const bottom = Math.max(y1, y2);
+    return point.x >= left && point.x <= right && point.y >= top && point.y <= bottom;
+  }
+  #isInsideEllipse(point, coords) {
+    if (coords.length !== 4) {
+      console.error("qti-inside ellipse requires centerX,centerY,radiusX,radiusY");
+      return null;
+    }
+    const [centerX, centerY, radiusX, radiusY] = coords;
+    if (radiusX === 0 || radiusY === 0) {
+      return false;
+    }
+    return (point.x - centerX) ** 2 / radiusX ** 2 + (point.y - centerY) ** 2 / radiusY ** 2 <= 1;
+  }
+  #isInsidePolygon(point, coords) {
+    if (coords.length < 6 || coords.length % 2 !== 0) {
+      console.error("qti-inside polygon requires at least 3 coordinate pairs");
+      return null;
+    }
+    let inside = false;
+    for (let current = 0, previous = coords.length - 2; current < coords.length; current += 2) {
+      const xi = coords[current];
+      const yi = coords[current + 1];
+      const xj = coords[previous];
+      const yj = coords[previous + 1];
+      const intersects = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi || Number.EPSILON) + xi;
+      if (intersects) {
+        inside = !inside;
+      }
+      previous = current;
+    }
+    return inside;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiInside.prototype, "shape", 2);
+__decorateClass([
+  n({ type: String })
+], QtiInside.prototype, "coords", 2);
+customElements.define("qti-inside", QtiInside);
+
+// ../qti-processing/src/components/qti-integer-divide/qti-integer-divide.ts
+var QtiIntegerDivide = class extends QtiExpression {
+  getResult() {
+    const values = this.#collectIntegerValues(this.getVariables());
+    if (values.length !== 2) {
+      console.error("qti-integer-divide requires exactly 2 integer values");
+      return null;
+    }
+    if (values[1] === 0) {
+      console.error("qti-integer-divide: division by zero");
+      return null;
+    }
+    return Math.floor(values[0] / values[1]);
+  }
+  #collectIntegerValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (variable.baseType !== "integer") {
+        console.error("qti-integer-divide requires integer base-type");
+        return [];
+      }
+      if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+        console.error("qti-integer-divide requires single cardinality");
+        return [];
+      }
+      if (variable.value === null || variable.value === void 0) {
+        return [];
+      }
+      const value = Number.parseInt(variable.value, 10);
+      if (Number.isNaN(value)) {
+        console.error("qti-integer-divide requires integer values");
+        return [];
+      }
+      values.push(value);
+    }
+    return values;
+  }
+};
+customElements.define("qti-integer-divide", QtiIntegerDivide);
+
+// ../qti-processing/src/components/qti-integer-modulus/qti-integer-modulus.ts
+var QtiIntegerModulus = class extends QtiExpression {
+  getResult() {
+    const values = this.#collectIntegerValues(this.getVariables());
+    if (values.length !== 2) {
+      console.error("qti-integer-modulus requires exactly 2 integer values");
+      return null;
+    }
+    if (values[1] === 0) {
+      console.error("qti-integer-modulus: division by zero");
+      return null;
+    }
+    return values[0] % values[1];
+  }
+  #collectIntegerValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (variable.baseType !== "integer") {
+        console.error("qti-integer-modulus requires integer base-type");
+        return [];
+      }
+      if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+        console.error("qti-integer-modulus requires single cardinality");
+        return [];
+      }
+      if (variable.value === null || variable.value === void 0) {
+        return [];
+      }
+      const value = Number.parseInt(variable.value, 10);
+      if (Number.isNaN(value)) {
+        console.error("qti-integer-modulus requires integer values");
+        return [];
+      }
+      values.push(value);
+    }
+    return values;
+  }
+};
+customElements.define("qti-integer-modulus", QtiIntegerModulus);
+
+// ../qti-processing/src/components/qti-integer-to-float/qti-integer-to-float.ts
+var QtiIntegerToFloat = class extends QtiExpression {
+  getResult() {
+    const variables = this.getVariables();
+    if (variables.length !== 1) {
+      console.error("qti-integer-to-float requires exactly one child expression");
+      return null;
+    }
+    const variable = variables[0];
+    if (variable.baseType !== "integer") {
+      console.error("qti-integer-to-float requires integer base-type");
+      return null;
+    }
+    if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+      console.error("qti-integer-to-float requires single cardinality");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    const value = Number.parseInt(variable.value, 10);
+    if (Number.isNaN(value)) {
+      console.error("qti-integer-to-float requires an integer value");
+      return null;
+    }
+    return value;
+  }
+};
+customElements.define("qti-integer-to-float", QtiIntegerToFloat);
+
+// ../qti-processing/src/components/qti-lcm/qti-lcm.ts
+var QtiLcm = class extends QtiExpression {
+  getResult() {
+    const values = this.#collectIntegerValues(this.getVariables());
+    if (values.length === 0) {
+      console.error("qti-lcm requires at least one integer value");
+      return null;
+    }
+    return values.reduce((accumulator, value) => this.#lcm(accumulator, value));
+  }
+  #collectIntegerValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (variable.baseType !== "integer") {
+        console.error("qti-lcm requires integer base-type");
+        return [];
+      }
+      if (variable.value === null || variable.value === void 0) {
+        return [];
+      }
+      if (variable.cardinality === "single") {
+        if (Array.isArray(variable.value)) {
+          console.error("qti-lcm unexpected array value for single cardinality");
+          return [];
+        }
+        const value = Number.parseInt(variable.value, 10);
+        if (Number.isNaN(value)) {
+          console.error("qti-lcm requires integer values");
+          return [];
+        }
+        values.push(value);
+        continue;
+      }
+      if (variable.cardinality !== "multiple" && variable.cardinality !== "ordered") {
+        console.error("qti-lcm unsupported cardinality");
+        return [];
+      }
+      if (!Array.isArray(variable.value)) {
+        console.error("qti-lcm expected array value for container cardinality");
+        return [];
+      }
+      for (const entry of variable.value) {
+        const value = Number.parseInt(entry, 10);
+        if (Number.isNaN(value)) {
+          console.error("qti-lcm requires integer values");
+          return [];
+        }
+        values.push(value);
+      }
+    }
+    return values;
+  }
+  #gcd(a, b) {
+    let left = Math.abs(a);
+    let right = Math.abs(b);
+    while (right !== 0) {
+      const remainder = left % right;
+      left = right;
+      right = remainder;
+    }
+    return left;
+  }
+  #lcm(a, b) {
+    if (a === 0 || b === 0) {
+      return 0;
+    }
+    return Math.abs(a * b / this.#gcd(a, b));
+  }
+};
+customElements.define("qti-lcm", QtiLcm);
+
 // ../qti-processing/src/components/qti-null/qti-null.ts
 var QtiNull = class extends QtiExpression {
   getResult() {
@@ -1198,6 +1686,44 @@ var QtiMatch = class _QtiMatch extends QtiExpression {
 };
 customElements.define("qti-match", QtiMatch);
 
+// ../qti-processing/src/components/qti-max/qti-max.ts
+var QtiMax = class extends QtiExpression {
+  getResult() {
+    const values = this.#collectNumericValues(this.getVariables());
+    if (values.length === 0) {
+      console.warn("qti-max: no numeric values provided");
+      return null;
+    }
+    return Math.max(...values);
+  }
+  #collectNumericValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (!variable) {
+        continue;
+      }
+      const pushValue = (raw) => {
+        if (raw === null || raw === void 0) {
+          return;
+        }
+        const numValue = parseFloat(raw.toString());
+        if (Number.isNaN(numValue)) {
+          console.warn("qti-max: non-numeric value encountered");
+          return;
+        }
+        values.push(numValue);
+      };
+      if (Array.isArray(variable.value)) {
+        variable.value.forEach((item) => pushValue(item));
+        continue;
+      }
+      pushValue(variable.value);
+    }
+    return values;
+  }
+};
+customElements.define("qti-max", QtiMax);
+
 // ../qti-processing/src/components/qti-member/qti-member.ts
 var QtiMember = class extends QtiExpression {
   getResult() {
@@ -1228,6 +1754,44 @@ var QtiMember = class extends QtiExpression {
 };
 customElements.define("qti-member", QtiMember);
 
+// ../qti-processing/src/components/qti-min/qti-min.ts
+var QtiMin = class extends QtiExpression {
+  getResult() {
+    const values = this.#collectNumericValues(this.getVariables());
+    if (values.length === 0) {
+      console.warn("qti-min: no numeric values provided");
+      return null;
+    }
+    return Math.min(...values);
+  }
+  #collectNumericValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (!variable) {
+        continue;
+      }
+      const pushValue = (raw) => {
+        if (raw === null || raw === void 0) {
+          return;
+        }
+        const numValue = parseFloat(raw.toString());
+        if (Number.isNaN(numValue)) {
+          console.warn("qti-min: non-numeric value encountered");
+          return;
+        }
+        values.push(numValue);
+      };
+      if (Array.isArray(variable.value)) {
+        variable.value.forEach((item) => pushValue(item));
+        continue;
+      }
+      pushValue(variable.value);
+    }
+    return values;
+  }
+};
+customElements.define("qti-min", QtiMin);
+
 // ../qti-processing/src/components/qti-multiple/qti-multiple.ts
 var QtiMultiple = class extends QtiExpression {
   getResult() {
@@ -1251,7 +1815,7 @@ customElements.define("qti-multiple", QtiMultiple);
 // ../qti-processing/src/components/qti-not/qti-not.ts
 var QtiNot = class extends QtiExpression {
   render() {
-    return x`${super.render()}`;
+    return T`${super.render()}`;
   }
   getResult() {
     const expression = this.firstElementChild;
@@ -1386,11 +1950,48 @@ var QtiPower = class extends QtiExpression {
 };
 customElements.define("qti-power", QtiPower);
 
+// ../qti-processing/src/components/qti-pattern-match/qti-pattern-match.ts
+var QtiPatternMatch = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.pattern = "";
+  }
+  getResult() {
+    const variables = this.getVariables();
+    if (variables.length !== 1) {
+      console.error("qti-pattern-match requires exactly one child expression");
+      return null;
+    }
+    if (!this.pattern) {
+      console.error("qti-pattern-match requires a pattern attribute");
+      return null;
+    }
+    const variable = variables[0];
+    if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+      console.error("qti-pattern-match requires single cardinality");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    try {
+      return new RegExp(this.pattern).test(variable.value.toString());
+    } catch (error) {
+      console.error("qti-pattern-match requires a valid regular expression", error);
+      return null;
+    }
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiPatternMatch.prototype, "pattern", 2);
+customElements.define("qti-pattern-match", QtiPatternMatch);
+
 // ../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)}`;
+    return value === null ? A : T`${JSON.stringify(value, null, 2)}`;
   }
   calculate() {
     const result = this.context.variables.find((v) => v.identifier === this.identifier) || null;
@@ -1427,6 +2028,314 @@ var QtiProduct = class extends QtiExpression {
 };
 customElements.define("qti-product", QtiProduct);
 
+// ../qti-processing/src/components/qti-repeat/qti-repeat.ts
+var QtiRepeat = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.numberRepeats = "";
+  }
+  getResult() {
+    const count = this.#resolveRepeatCount();
+    if (count <= 0) {
+      return [];
+    }
+    const expression = this.firstElementChild;
+    if (!expression) {
+      console.warn("qti-repeat: missing child expression");
+      return [];
+    }
+    const results = [];
+    for (let i2 = 0; i2 < count; i2++) {
+      const value = expression.calculate();
+      const variable = this.#toResponseVariable(value);
+      if (variable) {
+        results.push(variable);
+      }
+    }
+    return results;
+  }
+  #resolveRepeatCount() {
+    if (!this.numberRepeats) {
+      console.warn("qti-repeat: missing number-repeats attribute");
+      return 0;
+    }
+    const numericCount = parseInt(this.numberRepeats, 10);
+    if (!Number.isNaN(numericCount)) {
+      return numericCount;
+    }
+    const identifier = this.numberRepeats;
+    const variable = this.context?.variables?.find((v) => v.identifier === identifier);
+    if (!variable) {
+      console.warn(`qti-repeat: unknown identifier "${identifier}"`);
+      return 0;
+    }
+    const rawValue = Array.isArray(variable.value) ? variable.value[0] : variable.value;
+    const resolvedCount = parseInt(rawValue?.toString() ?? "", 10);
+    if (Number.isNaN(resolvedCount)) {
+      console.warn(`qti-repeat: invalid repeat count from "${identifier}"`);
+      return 0;
+    }
+    return resolvedCount;
+  }
+  #toResponseVariable(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "number") {
+      return {
+        identifier: "",
+        cardinality: "single",
+        baseType: Number.isInteger(value) ? "integer" : "float",
+        value: value.toString(),
+        type: "response"
+      };
+    }
+    if (typeof value === "string") {
+      const numericValue = parseFloat(value);
+      if (!Number.isNaN(numericValue)) {
+        return {
+          identifier: "",
+          cardinality: "single",
+          baseType: Number.isInteger(numericValue) ? "integer" : "float",
+          value: value.toString(),
+          type: "response"
+        };
+      }
+    }
+    if (value && typeof value === "object" && "value" in value) {
+      const responseValue = value.value;
+      return {
+        identifier: "",
+        cardinality: "single",
+        baseType: value.baseType ?? "string",
+        value: responseValue !== null && responseValue !== void 0 ? responseValue.toString() : null,
+        type: "response"
+      };
+    }
+    return {
+      identifier: "",
+      cardinality: "single",
+      baseType: "string",
+      value: value.toString(),
+      type: "response"
+    };
+  }
+};
+__decorateClass([
+  n({ type: String, attribute: "number-repeats" })
+], QtiRepeat.prototype, "numberRepeats", 2);
+customElements.define("qti-repeat", QtiRepeat);
+
+// ../qti-processing/src/components/qti-set-correct-response/qti-set-correct-response.ts
+var QtiSetCorrectResponse = class extends QtiRule {
+  /**
+   * Processes the QTI rule and dispatches a custom event with the computed correct response value.
+   */
+  process() {
+    const responseIdentifier = this.getAttribute("identifier");
+    if (!responseIdentifier) {
+      console.warn('QtiSetCorrectResponse: Missing "identifier" attribute.');
+      return;
+    }
+    const expression = this.firstElementChild;
+    if (!expression) {
+      console.warn("QtiSetCorrectResponse: No expression found.");
+      return;
+    }
+    const rule = new QtiSetCorrectResponseRule(expression);
+    const value = rule.process();
+    this.dispatchEvent(
+      new CustomEvent("qti-set-correct-response", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          responseIdentifier,
+          value: this.#formatValue(value)
+        }
+      })
+    );
+  }
+  #formatValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => convertNumberToUniversalFormat(this.#unwrapValue(item)));
+    }
+    return convertNumberToUniversalFormat(this.#unwrapValue(value));
+  }
+  #unwrapValue(value) {
+    if (value && typeof value === "object" && "value" in value) {
+      const responseValue = value.value;
+      return responseValue !== null && responseValue !== void 0 ? responseValue.toString() : "";
+    }
+    return value?.toString() ?? "";
+  }
+};
+var QtiSetCorrectResponseRule = 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("QtiSetCorrectResponseRule: Evaluated value is null.");
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.#unwrapResult(item));
+    }
+    return this.#unwrapResult(value);
+  }
+  #unwrapResult(value) {
+    if (value && typeof value === "object" && "value" in value) {
+      return value.value;
+    }
+    return value;
+  }
+};
+customElements.define("qti-set-correct-response", QtiSetCorrectResponse);
+
+// ../qti-processing/src/components/qti-set-template-value/qti-set-template-value.ts
+var QtiSetTemplateValue = class extends QtiRule {
+  /**
+   * Processes the QTI rule and dispatches a custom event with the computed template value.
+   */
+  process() {
+    const templateIdentifier = this.getAttribute("identifier");
+    if (!templateIdentifier) {
+      console.warn('QtiSetTemplateValue: Missing "identifier" attribute.');
+      return;
+    }
+    const expression = this.firstElementChild;
+    if (!expression) {
+      console.warn("QtiSetTemplateValue: No expression found.");
+      return;
+    }
+    const rule = new QtiSetTemplateValueRule(expression);
+    const value = rule.process();
+    this.dispatchEvent(
+      new CustomEvent("qti-set-template-value", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          templateIdentifier,
+          value: this.#formatValue(value)
+        }
+      })
+    );
+  }
+  /**
+   * Formats the computed value before dispatching.
+   * Ensures numbers are converted to a universal format.
+   */
+  #formatValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => convertNumberToUniversalFormat(this.#unwrapValue(item)));
+    }
+    return convertNumberToUniversalFormat(this.#unwrapValue(value));
+  }
+  #unwrapValue(value) {
+    if (value && typeof value === "object" && "value" in value) {
+      const responseValue = value.value;
+      return responseValue !== null && responseValue !== void 0 ? responseValue.toString() : "";
+    }
+    return value?.toString() ?? "";
+  }
+};
+var QtiSetTemplateValueRule = 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("QtiSetTemplateValueRule: Evaluated value is null.");
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.#unwrapResult(item));
+    }
+    return this.#unwrapResult(value);
+  }
+  #unwrapResult(value) {
+    if (value && typeof value === "object" && "value" in value) {
+      return value.value;
+    }
+    return value;
+  }
+};
+customElements.define("qti-set-template-value", QtiSetTemplateValue);
+
+// ../qti-processing/src/components/qti-stats-operator/qti-stats-operator.ts
+var QtiStatsOperator = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.name = "";
+  }
+  getResult() {
+    if (!this.name) {
+      console.warn("qti-stats-operator: missing name attribute");
+      return null;
+    }
+    const values = this.#collectNumericValues(this.getVariables());
+    if (values.length === 0) {
+      console.warn("qti-stats-operator: no numeric values provided");
+      return null;
+    }
+    switch (this.name.toLowerCase()) {
+      case "mean":
+        return values.reduce((sum, value) => sum + value, 0) / values.length;
+      case "popsd":
+        return this.#populationStandardDeviation(values);
+      default:
+        console.warn(`qti-stats-operator: unsupported operator "${this.name}"`);
+        return null;
+    }
+  }
+  #populationStandardDeviation(values) {
+    const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+    const variance = values.reduce((sum, value) => sum + Math.pow(value - mean, 2), 0) / values.length;
+    return Math.sqrt(variance);
+  }
+  #collectNumericValues(variables) {
+    const values = [];
+    for (const variable of variables) {
+      if (!variable) {
+        continue;
+      }
+      const pushValue = (raw) => {
+        if (raw === null || raw === void 0) {
+          return;
+        }
+        const numValue = parseFloat(raw.toString());
+        if (Number.isNaN(numValue)) {
+          console.warn("qti-stats-operator: non-numeric value encountered");
+          return;
+        }
+        values.push(numValue);
+      };
+      if (Array.isArray(variable.value)) {
+        variable.value.forEach((item) => pushValue(item));
+        continue;
+      }
+      pushValue(variable.value);
+    }
+    return values;
+  }
+};
+__decorateClass([
+  n({ type: String })
+], QtiStatsOperator.prototype, "name", 2);
+customElements.define("qti-stats-operator", QtiStatsOperator);
+
 // ../qti-processing/src/components/qti-subtract/qti-subtract.ts
 var QtiSubtract = class extends qtiSubtractMixin(QtiExpression) {
   getResult() {
@@ -1458,6 +2367,39 @@ function qtiSubtractMixin(Base) {
   };
 }
 
+// ../qti-processing/src/components/qti-substring/qti-substring.ts
+var QtiSubstring = class extends QtiExpression {
+  constructor() {
+    super(...arguments);
+    this.caseSensitive = "true";
+  }
+  getResult() {
+    const variables = this.getVariables();
+    if (variables.length !== 2) {
+      console.error("qti-substring requires exactly 2 child expressions");
+      return null;
+    }
+    const [needle, haystack] = variables;
+    if (needle.cardinality !== "single" || haystack.cardinality !== "single" || Array.isArray(needle.value) || Array.isArray(haystack.value)) {
+      console.error("qti-substring requires single cardinality");
+      return null;
+    }
+    if (needle.value === null || haystack.value === null || needle.value === void 0 || haystack.value === void 0) {
+      return null;
+    }
+    const left = needle.value.toString();
+    const right = haystack.value.toString();
+    if (this.caseSensitive !== "true") {
+      return right.toLowerCase().includes(left.toLowerCase());
+    }
+    return right.includes(left);
+  }
+};
+__decorateClass([
+  n({ type: String, attribute: "case-sensitive" })
+], QtiSubstring.prototype, "caseSensitive", 2);
+customElements.define("qti-substring", QtiSubstring);
+
 // ../qti-processing/src/components/qti-string-match/qti-string-match.ts
 var QtiStringMatch = class extends QtiExpression {
   constructor() {
@@ -1516,6 +2458,36 @@ var QtiSumExpression = class {
 };
 customElements.define("qti-sum", QtiSum);
 
+// ../qti-processing/src/components/qti-truncate/qti-truncate.ts
+var QtiTruncate = class extends QtiExpression {
+  getResult() {
+    const variables = this.getVariables();
+    if (variables.length !== 1) {
+      console.error("qti-truncate requires exactly one child expression");
+      return null;
+    }
+    const variable = variables[0];
+    if (variable.cardinality !== "single" || Array.isArray(variable.value)) {
+      console.error("qti-truncate requires single cardinality");
+      return null;
+    }
+    if (variable.baseType !== "integer" && variable.baseType !== "float") {
+      console.error("qti-truncate requires numerical base-type");
+      return null;
+    }
+    if (variable.value === null || variable.value === void 0) {
+      return null;
+    }
+    const value = Number.parseFloat(variable.value);
+    if (Number.isNaN(value)) {
+      console.error("qti-truncate requires a numerical value");
+      return null;
+    }
+    return Math.trunc(value);
+  }
+};
+customElements.define("qti-truncate", QtiTruncate);
+
 // ../qti-processing/src/components/qti-variable/qti-variable.ts
 var QtiVariable = class extends QtiExpression {
   getResult() {
@@ -1715,6 +2687,7 @@ export {
   QtiResponseElseIf,
   QtiAnd,
   qtiAndMixin,
+  QtiAnyN,
   QtiBaseValue,
   QtiContainerSize,
   QtiContains,
@@ -1724,9 +2697,17 @@ export {
   QtiRound,
   QtiRoundTo,
   QtiEqual,
+  QtiDivide,
+  QtiDurationGte,
+  QtiDurationLt,
   QtiGcd,
   QtiGt,
   QtiGte,
+  QtiInside,
+  QtiIntegerDivide,
+  QtiIntegerModulus,
+  QtiIntegerToFloat,
+  QtiLcm,
   QtiNull,
   QtiIsNull,
   QtiFieldValue,
@@ -1736,23 +2717,34 @@ export {
   QtiMapResponsePoint,
   QtiMathOperator,
   QtiMatch,
+  QtiMax,
   QtiMember,
+  QtiMin,
   QtiMultiple,
   QtiNot,
   QtiOr,
   QtiOrdered,
   QtiPower,
+  QtiPatternMatch,
   QtiPrintedVariable,
   QtiProduct,
+  QtiRepeat,
+  QtiSetCorrectResponse,
+  QtiSetCorrectResponseRule,
+  QtiSetTemplateValue,
+  QtiSetTemplateValueRule,
+  QtiStatsOperator,
   QtiSubtract,
   qtiSubtractMixin,
+  QtiSubstring,
   QtiStringMatch,
   QtiSum,
   QtiSumExpression,
+  QtiTruncate,
   QtiVariable,
   QtiRandomInteger,
   QtiRandom,
   QtiDelete,
   QtiIndex
 };
-//# sourceMappingURL=chunk-GG36UR7F.js.map
+//# sourceMappingURL=chunk-YLIYPNMK.js.map