@citolab/qti-components 8.0.1 → 8.1.0

package/dist/chunk-EKXZI26R.js

@@ -0,0 +1,917 @@
+// ../qti-base/dist/utils/custom-state-set.js
+var CustomStateSetShim = class extends Set {
+  #host;
+  constructor(host) {
+    super();
+    this.#host = host;
+  }
+  add(state3) {
+    super.add(state3);
+    this.#reflect();
+    return this;
+  }
+  delete(state3) {
+    const deleted = super.delete(state3);
+    this.#reflect();
+    return deleted;
+  }
+  clear() {
+    super.clear();
+    this.#reflect();
+  }
+  #reflect() {
+    if (this.#host.isConnected)
+      this.#write();
+    else
+      queueMicrotask(() => this.#write());
+  }
+  #write() {
+    if (this.size === 0)
+      this.#host.removeAttribute("data-state");
+    else
+      this.#host.setAttribute("data-state", Array.from(this).join(" "));
+  }
+};
+var PROBE_TAG = "custom-state-support-probe";
+function classifyCustomStateSupport(attachInternals) {
+  if (!("states" in ElementInternals.prototype))
+    return "missing";
+  if (typeof customElements === "undefined")
+    return "modern";
+  try {
+    if (!customElements.get(PROBE_TAG))
+      customElements.define(PROBE_TAG, class extends HTMLElement {
+      });
+    const states = attachInternals.call(document.createElement(PROBE_TAG)).states;
+    if (!states)
+      return "missing";
+    states.add("probe");
+    states.delete("probe");
+    return "modern";
+  } catch {
+    return "legacy";
+  }
+}
+var installed = false;
+function installCustomStateSetFallback() {
+  if (installed)
+    return "already-installed";
+  if (typeof HTMLElement === "undefined" || typeof ElementInternals === "undefined")
+    return "modern";
+  const native = HTMLElement.prototype.attachInternals;
+  if (!native)
+    return "modern";
+  const support = classifyCustomStateSupport(native);
+  if (support === "modern")
+    return support;
+  installed = true;
+  HTMLElement.prototype.attachInternals = function attachInternals() {
+    const internals = native.call(this);
+    Object.defineProperty(internals, "states", {
+      configurable: true,
+      enumerable: true,
+      value: new CustomStateSetShim(this)
+    });
+    return internals;
+  };
+  return support;
+}
+
+// ../qti-base/dist/context/computed-item.context.js
+import { createContext } from "@lit/context";
+var computedItemContext = createContext(/* @__PURE__ */ Symbol("computedItemContext"));
+
+// ../qti-base/dist/context/computed.context.js
+import { createContext as createContext2 } from "@lit/context";
+var computedContext = createContext2(/* @__PURE__ */ Symbol("computedContext"));
+
+// ../qti-base/dist/context/config.context.js
+import { createContext as createContext3 } from "@lit/context";
+var configContext = createContext3(/* @__PURE__ */ Symbol("configContext"));
+
+// ../qti-base/dist/context/interaction.context.js
+import { createContext as createContext4 } from "@lit/context";
+var interactionContext = createContext4(/* @__PURE__ */ Symbol("interactionContext"));
+
+// ../qti-base/dist/context/item.context.js
+import { createContext as createContext5 } from "@lit/context";
+var itemContext = createContext5(/* @__PURE__ */ Symbol("item"));
+
+// ../qti-base/dist/context/types/item.types.js
+var itemContextVariables = [
+  {
+    identifier: "completionStatus",
+    cardinality: "single",
+    baseType: "string",
+    value: "unknown",
+    type: "outcome"
+  },
+  {
+    identifier: "numAttempts",
+    cardinality: "single",
+    baseType: "integer",
+    value: "0",
+    type: "response"
+  }
+];
+
+// ../qti-base/dist/context/qti.context.js
+import { createContext as createContext6 } from "@lit/context";
+var SEED_PATTERN = /^[A-Za-z0-9-]+$/;
+var isSeed = (value) => typeof value === "string" && SEED_PATTERN.test(value);
+var asSeed = (value) => isSeed(value) ? value : void 0;
+var qtiContext = createContext6(/* @__PURE__ */ Symbol("qtiContext"));
+
+// ../qti-base/dist/context/session.context.js
+import { createContext as createContext7 } from "@lit/context";
+var INITIAL_SESSION_CONTEXT = { view: "candidate" };
+var sessionContext = createContext7(/* @__PURE__ */ Symbol("testContext"));
+
+// ../qti-base/dist/context/test.context.js
+import { createContext as createContext8 } from "@lit/context";
+var INITIAL_TEST_CONTEXT = { items: [], testOutcomeVariables: [] };
+var testContext = createContext8(/* @__PURE__ */ Symbol("testContext"));
+
+// ../qti-base/dist/styles/box-sizing.styles.js
+import { css } from "lit";
+var boxSizing = css`
+  :host {
+    box-sizing: border-box;
+  }
+
+  *,
+  *::before,
+  *::after {
+    box-sizing: inherit;
+  }
+`;
+
+// ../qti-base/dist/styles/drop-region.styles.js
+import { css as css2 } from "lit";
+var dropRegion = css2`
+  [part~='drop'] {
+    /*
+     * The one deliberate opt-out from the border-box reset.
+     *
+     * --qti-dropzone-min-* is the border-box of the largest chip, and what has to hold that chip is
+     * this region's *content* area. Under border-box a theme's dashed drop border is subtracted
+     * from the chip's own size, the content comes up short, and the drop grows the moment a chip
+     * lands in it. Order's drop did exactly that: 64px empty, 66px full, for a 1px border.
+     */
+    box-sizing: content-box;
+
+    /*
+     * No padding, and no token for one.
+     *
+     * A drop reserves --qti-dropzone-min-*, which is the chip's BORDER-box, as this region's CONTENT
+     * area — so the chip already fits exactly, with nothing to spare and nothing squeezed. An inset
+     * on top would only make the drop bigger than the thing it holds.
+     *
+     * There was a 1px one, to make the drop read as a frame a hair outside the chip. It never painted:
+     * an EMPTY slot has nothing inside the inset to separate from, and a FILLED one hides its edge
+     * (DROP-SIZING.md §4), so both states spent 2px on an invisible ring. The one drop that genuinely
+     * wants breathing room — match's category card — declares padding on its own rule, which a
+     * theme reaches with ::part(drop). A token in between bought nothing.
+     */
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-start;
+    justify-content: flex-start;
+    /* No gap either: 0 is the flex initial value, so the declaration only existed to host a token.
+       A drop that wants space between chips sets gap on its own rule. */
+    /* Containing block for anything a theme draws over the drop. Was 'position: relative' in the
+       theme's 'drop' mixin, which put a document stylesheet in charge of a shadow node's position. */
+    position: relative;
+  }
+
+  [part~='drop'] > * {
+    flex: 0 1 auto;
+    align-self: flex-start;
+  }
+`;
+
+// ../qti-base/dist/styles/validation-message.styles.js
+import { css as css3 } from "lit";
+var validationMessage = css3`
+  [part~='message'] {
+    display: none;
+  }
+`;
+
+// ../qti-base/dist/abstract/interaction.js
+import { consume, provide } from "@lit/context";
+import { LitElement } from "lit";
+import { property } from "lit/decorators.js";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Interaction = class extends LitElement {
+  #didLogDisableAfterIfMaxChoicesReachedDeprecation;
+  static {
+    this.formAssociated = true;
+  }
+  get internals() {
+    return this._internals;
+  }
+  /** Extension point used by wrappers that should not register as candidate inputs. */
+  get registersWithItem() {
+    return true;
+  }
+  get isInline() {
+    return false;
+  }
+  get responseVariable() {
+    if (!this._context?.variables) {
+      return void 0;
+    }
+    const responseVariables = this._context.variables.filter((v) => v.type === "response");
+    const responseIdentifier = this.getAttribute("response-identifier");
+    return responseVariables.find((v) => v.identifier === responseIdentifier);
+  }
+  get value() {
+    return JSON.stringify(this.response);
+  }
+  set value(val) {
+    this.response = val ? JSON.parse(val) : null;
+  }
+  reportValidity() {
+    const isValid = this._internals.validity.valid;
+    const mode = this.validationDisplayMode;
+    if (mode === "native" || mode === "both") {
+      this._internals.reportValidity();
+    }
+    if (mode === "inline" || mode === "both") {
+      this.updateInlineValidationMessage();
+    } else {
+      this.clearInlineValidationMessage();
+    }
+    if (mode === "none") {
+      this.clearInlineValidationMessage();
+    }
+    return isValid;
+  }
+  get validationDisplayMode() {
+    return this.configContext?.validationDisplayMode ?? "inline";
+  }
+  resolveAllowReorder(options) {
+    const defaultWhenUnset = options?.defaultWhenUnset ?? true;
+    const config = this.configContext;
+    if (!config) {
+      return defaultWhenUnset;
+    }
+    if (config.allowReorder !== void 0) {
+      return config.allowReorder;
+    }
+    return defaultWhenUnset;
+  }
+  resolveDisableAfterMaxReached(options) {
+    const defaultWhenUnset = options?.defaultWhenUnset ?? false;
+    const config = this.configContext;
+    if (!config) {
+      return defaultWhenUnset;
+    }
+    if (config.disableAfterMaxReached !== void 0) {
+      return config.disableAfterMaxReached;
+    }
+    if (config.disableAfterIfMaxChoicesReached !== void 0) {
+      if (!this.#didLogDisableAfterIfMaxChoicesReachedDeprecation) {
+        this.#didLogDisableAfterIfMaxChoicesReachedDeprecation = true;
+        console.log("[QTI Config] `disableAfterIfMaxChoicesReached` is deprecated. Use `disableAfterMaxReached` instead.");
+      }
+      return config.disableAfterIfMaxChoicesReached;
+    }
+    return defaultWhenUnset;
+  }
+  setInteractionValidity(isValid, validityMessage = "", anchor, options) {
+    const validityAnchor = anchor ?? this;
+    this._internals.setValidity(isValid ? {} : { customError: true }, validityMessage, validityAnchor);
+    if (options?.suppressInline !== true && (this.validationDisplayMode === "inline" || this.validationDisplayMode === "both")) {
+      this.updateInlineValidationMessage();
+    }
+  }
+  updateInlineValidationMessage() {
+    const validationMessageElement = this.getValidationMessageElement();
+    if (!validationMessageElement) {
+      return;
+    }
+    if (!this._internals.validity.valid) {
+      validationMessageElement.textContent = this._internals.validationMessage;
+      validationMessageElement.style.setProperty("display", "block", "important");
+      return;
+    }
+    validationMessageElement.textContent = "";
+    validationMessageElement.style.display = "none";
+  }
+  clearInlineValidationMessage() {
+    const validationMessageElement = this.getValidationMessageElement();
+    if (!validationMessageElement) {
+      return;
+    }
+    validationMessageElement.textContent = "";
+    validationMessageElement.style.display = "none";
+  }
+  getValidationMessageElement() {
+    return this.shadowRoot?.querySelector("#validation-message");
+  }
+  reset() {
+    this.response = null;
+  }
+  formResetCallback() {
+    this.reset();
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (!this.registersWithItem) {
+      return;
+    }
+    this.dispatchEvent(new CustomEvent("qti-register-interaction", {
+      bubbles: true,
+      composed: true,
+      cancelable: false,
+      detail: {
+        interactionElement: this,
+        responseIdentifier: this.responseIdentifier
+      }
+    }));
+  }
+  saveResponse(value, state3) {
+    this.dispatchEvent(new CustomEvent("qti-interaction-response", {
+      bubbles: true,
+      composed: true,
+      cancelable: false,
+      detail: {
+        responseIdentifier: this.responseIdentifier,
+        response: Array.isArray(value) ? [...value] : value,
+        ...state3 !== void 0 ? { state: state3 } : {}
+      }
+    }));
+  }
+  constructor() {
+    super();
+    this.#didLogDisableAfterIfMaxChoicesReachedDeprecation = false;
+    this._interactionContext = { choiceRole: null, draggablesSelector: null };
+    this.disabled = false;
+    this.readonly = false;
+    this._internals = this.attachInternals();
+  }
+  /**
+   * Optional lifecycle bridge for interaction subclasses that do not need changed-property data.
+   *
+   * The parameter is `PropertyValues`, matching LitElement, and NOT `PropertyValues<this>`.
+   * The polymorphic `this` narrowed the parameter per subclass, which made every interaction
+   * class structurally incompatible with `LitElement` — so `Constructor<LitElement>`, the
+   * standard constraint for a Lit mixin, rejected all of them and consumers could not wrap an
+   * interaction in a mixin without casting. `this` buys nothing in a parameter position and
+   * costs contravariant compatibility with the base class.
+   *
+   * Still optional, so subclasses that ignore the argument can override with `firstUpdated()`.
+   */
+  firstUpdated(_changedProperties) {
+  }
+};
+__decorate([
+  consume({ context: itemContext, subscribe: true })
+], Interaction.prototype, "_context", void 0);
+__decorate([
+  consume({ context: configContext, subscribe: true })
+], Interaction.prototype, "configContext", void 0);
+__decorate([
+  provide({ context: interactionContext })
+], Interaction.prototype, "_interactionContext", void 0);
+__decorate([
+  property({ type: String, attribute: "response-identifier" })
+], Interaction.prototype, "responseIdentifier", void 0);
+__decorate([
+  property({ reflect: true, type: Boolean })
+], Interaction.prototype, "disabled", void 0);
+__decorate([
+  property({ reflect: true, type: Boolean })
+], Interaction.prototype, "readonly", void 0);
+__decorate([
+  property({ type: String })
+], Interaction.prototype, "name", void 0);
+
+// ../qti-base/dist/abstract/qti-variable-declaration.js
+import { html, LitElement as LitElement2 } from "lit";
+var QtiVariableDeclaration = class extends LitElement2 {
+  render() {
+    return html`<slot></slot>`;
+  }
+  defaultValues(cardinality) {
+    const htmlValues = Array.from(this.querySelectorAll("qti-default-value > qti-value"));
+    if (htmlValues.length === 0) {
+      return null;
+    }
+    const defaultValues = htmlValues.map((n) => n.innerHTML.trim());
+    if (defaultValues.length > 1 || cardinality === "multiple" || cardinality === "ordered") {
+      return defaultValues;
+    }
+    return defaultValues[0];
+  }
+};
+
+// ../qti-base/dist/abstract/qti-expression.js
+import { consume as consume2 } from "@lit/context";
+import { css as css4, html as html2, LitElement as LitElement3 } from "lit";
+import { state } from "lit/decorators.js";
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var QtiExpression = class extends LitElement3 {
+  constructor() {
+    super(...arguments);
+    this.getVariables = () => (
+      // FIXME: if this itself is multiple, this will never enter the qti-multiple switch
+      // See this example here: https://github.com/1EdTech/qti-examples/blob/master/qtiv3-examples/packaging/items/Example05-feedbackBlock-adaptive.xml
+      Array.from(this.children).map((e) => {
+        console.debug("getVariables", e.tagName.toLowerCase());
+        switch (e.tagName.toLowerCase()) {
+          case "qti-base-value": {
+            return {
+              baseType: e.getAttribute("base-type"),
+              value: e.textContent.trim(),
+              cardinality: "single"
+            };
+          }
+          case "qti-variable": {
+            const identifier = e.getAttribute("identifier") || "";
+            if (identifier === "QTI_CONTEXT") {
+              if (!this.qtiContext?.QTI_CONTEXT) {
+                console.warn("QTI_CONTEXT not available");
+                return {
+                  identifier: "QTI_CONTEXT",
+                  baseType: "record",
+                  value: this.qtiContext.QTI_CONTEXT,
+                  cardinality: "record",
+                  type: "context"
+                };
+              }
+              return {
+                identifier: "QTI_CONTEXT",
+                baseType: "record",
+                value: this.qtiContext.QTI_CONTEXT,
+                cardinality: "record",
+                type: "context"
+              };
+            }
+            const variable = this.context.variables.find((v) => v.identifier === identifier) || null;
+            return variable;
+          }
+          case "qti-multiple": {
+            const multiple = e;
+            const values = multiple.getResult();
+            console.debug("values", values);
+            if (values?.length > 0) {
+              return {
+                identifier: "",
+                baseType: values[0].baseType,
+                value: values.map((v) => v.value),
+                cardinality: "multiple",
+                type: "response"
+              };
+            }
+            return null;
+          }
+          case "qti-ordered": {
+            const multiple = e;
+            const values = multiple.getResult();
+            if (values?.length > 0) {
+              return {
+                identifier: "",
+                baseType: values[0].baseType,
+                value: values.map((v) => v.value),
+                cardinality: "ordered",
+                type: "response"
+              };
+            }
+            return null;
+          }
+          case "qti-repeat": {
+            const repeat = e;
+            const values = repeat.getResult();
+            if (values?.length > 0) {
+              return values;
+            }
+            return null;
+          }
+          case "qti-correct": {
+            const identifier = e.getAttribute("identifier") || "";
+            const responseVariable = this.context?.variables?.find((v) => v.identifier === identifier) || null;
+            return {
+              baseType: responseVariable.baseType,
+              value: responseVariable.correctResponse,
+              cardinality: responseVariable.cardinality
+            };
+          }
+          default: {
+            try {
+              const expression = e;
+              const value = expression.getResult();
+              return {
+                baseType: "integer",
+                value: value?.toString() || null,
+                cardinality: "single"
+              };
+            } catch (error) {
+              console.warn("default not sufficient");
+            }
+            return null;
+          }
+        }
+      }).flatMap((v) => Array.isArray(v) ? v : [v]).filter((v) => v !== null)
+    );
+  }
+  static {
+    this.styles = css4`
+    slot {
+      display: none;
+    }
+  `;
+  }
+  render() {
+    return html2`<pre>${JSON.stringify(this.result, null, 2)}</pre>
+      <slot></slot>`;
+  }
+  calculate() {
+    this.result = this.getResult();
+    return this.result;
+  }
+  getResult() {
+    throw new Error("Not implemented");
+  }
+};
+__decorate2([
+  state()
+], QtiExpression.prototype, "result", void 0);
+__decorate2([
+  consume2({ context: itemContext, subscribe: true }),
+  state()
+], QtiExpression.prototype, "context", void 0);
+__decorate2([
+  consume2({ context: qtiContext, subscribe: true }),
+  state()
+], QtiExpression.prototype, "qtiContext", void 0);
+
+// ../qti-base/dist/abstract/qti-condition-expression.js
+var QtiConditionExpression = class extends QtiExpression {
+  calculate() {
+    this.result = this.getResult();
+    return this.result;
+  }
+  getResult() {
+    throw new Error("Not implemented");
+  }
+};
+
+// ../qti-base/dist/utils/utils.js
+var decimalSeparator = () => {
+  return new Intl.NumberFormat().format(0.1).replace(/\d/g, "");
+};
+var convertNumberToUniversalFormat = (number) => {
+  if (typeof number === "string") {
+    return number;
+  }
+  const dSep = decimalSeparator();
+  if (dSep === ".") {
+    return number.toLocaleString();
+  } else {
+    return number.toString().replace(".", "").replace(dSep, ".");
+  }
+};
+function IsNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function removeDoubleSlashes(str) {
+  const singleForwardSlashes = str.replace(/([^:]\/)\/+/g, "$1").replace(/\/\//g, "/").replace("http:/", "http://").replace("https:/", "https://");
+  return singleForwardSlashes;
+}
+
+// ../qti-base/dist/abstract/qti-feedback.js
+import { consume as consume3 } from "@lit/context";
+import { LitElement as LitElement4 } from "lit";
+import { property as property2, state as state2 } from "lit/decorators.js";
+var __decorate3 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var QtiFeedback = class extends LitElement4 {
+  constructor() {
+    super(...arguments);
+    this.showHide = "show";
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.dispatchEvent(new CustomEvent("qti-register-feedback", {
+      bubbles: true,
+      composed: true,
+      detail: this
+    }));
+  }
+  checkShowFeedback(outcomeIdentifier) {
+    const outcomeVariable = this._context.variables.find((v) => v.identifier === outcomeIdentifier) || null;
+    if (this.outcomeIdentifier !== outcomeIdentifier || !outcomeVariable)
+      return;
+    let isFound = false;
+    if (Array.isArray(outcomeVariable.value)) {
+      isFound = outcomeVariable.value.includes(this.identifier);
+    } else {
+      isFound = !IsNullOrUndefined(this.identifier) && !IsNullOrUndefined(outcomeVariable?.value) && this.identifier === outcomeVariable.value || false;
+    }
+    this.#showFeedback(isFound);
+  }
+  #showFeedback(value) {
+    this.showStatus = value && this.showHide === "show" || !value && this.showHide === "hide" ? "on" : "off";
+  }
+};
+__decorate3([
+  property2({ type: String, attribute: "show-hide" })
+], QtiFeedback.prototype, "showHide", void 0);
+__decorate3([
+  property2({ type: String, attribute: "outcome-identifier" })
+], QtiFeedback.prototype, "outcomeIdentifier", void 0);
+__decorate3([
+  property2({ type: String })
+], QtiFeedback.prototype, "identifier", void 0);
+__decorate3([
+  property2({ type: String, attribute: false })
+], QtiFeedback.prototype, "showStatus", void 0);
+__decorate3([
+  consume3({ context: itemContext, subscribe: true }),
+  state2()
+], QtiFeedback.prototype, "_context", void 0);
+
+// ../qti-base/dist/lib/response.js
+function parseResponseAttribute(raw) {
+  if (raw == null)
+    return null;
+  if (!raw.includes(",")) {
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  const tokens = raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+  if (tokens.length === 0)
+    return null;
+  if (tokens.length === 1)
+    return tokens[0];
+  return tokens;
+}
+function serializeResponseAttribute(value) {
+  if (value == null)
+    return null;
+  if (Array.isArray(value)) {
+    const tokens = value.map((token) => token.trim()).filter((token) => token.length > 0);
+    return tokens.length > 0 ? tokens.join(",") : null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function* iterResponseValues(raw) {
+  if (raw == null)
+    return;
+  if (Array.isArray(raw)) {
+    for (const v of raw) {
+      const t = v.trim();
+      if (t)
+        yield t;
+    }
+    return;
+  }
+  if (!raw.includes(",")) {
+    const t = raw.trim();
+    if (t)
+      yield t;
+    return;
+  }
+  for (const v of raw.split(",")) {
+    const t = v.trim();
+    if (t)
+      yield t;
+  }
+}
+function parsePair(value) {
+  const [source, target, ...rest] = value.trim().split(/\s+/);
+  if (!source || !target || rest.length > 0) {
+    throw new Error(`malformed directed-pair value: "${value}" (expected "source target")`);
+  }
+  return { source, target };
+}
+function serializePair(source, target) {
+  return `${source} ${target}`;
+}
+function parsePoint(value) {
+  const [xStr, yStr, ...rest] = value.trim().split(/\s+/);
+  const x = Number(xStr);
+  const y = Number(yStr);
+  if (!Number.isFinite(x) || !Number.isFinite(y) || rest.length > 0) {
+    throw new Error(`malformed point value: "${value}" (expected "x y" numeric coords)`);
+  }
+  return { x, y };
+}
+function serializePoint(x, y) {
+  return `${x} ${y}`;
+}
+function responseAttributeConverter(opts) {
+  const { emptyAs } = opts;
+  const isEmptySentinel = (value) => value === emptyAs || value == null || value === "" || Array.isArray(value) && value.length === 0;
+  return {
+    fromAttribute: (value) => {
+      const parsed = parseResponseAttribute(value);
+      return parsed === null ? emptyAs : parsed;
+    },
+    toAttribute: (value) => {
+      if (isEmptySentinel(value))
+        return null;
+      return serializeResponseAttribute(value);
+    }
+  };
+}
+
+// ../qti-base/dist/lib/qti-rule-base.js
+import { LitElement as LitElement5 } from "lit";
+var QtiRuleElement = class extends LitElement5 {
+};
+
+// ../qti-base/dist/utils/scoring-helper.js
+var ScoringHelper = class {
+  /**
+   * Checks if a given point is within a specified area.
+   * @param point The point to test, represented as a string "x y" (e.g., "102 113").
+   * @param areaKey The area definition, including shape and coordinates (e.g., "circle,102,113,16").
+   * @param baseType The base type of the response, must be "point" for this method to proceed.
+   * @returns True if the point is within the area; false otherwise.
+   */
+  static isPointInArea(point, areaKey, baseType) {
+    if (baseType !== "point") {
+      console.warn(`Base type ${baseType} is not supported for point area mapping.`);
+      return false;
+    }
+    const [px, py] = point.split(" ").map(Number);
+    const [shape, ...coords] = areaKey.split(",");
+    const coordinates = coords.map(Number);
+    switch (shape.toLowerCase()) {
+      case "circle":
+      case "default": {
+        const [cx, cy, radius] = coordinates;
+        if (coordinates.length !== 3) {
+          console.warn(`Invalid circle definition: ${areaKey}`);
+          return false;
+        }
+        const distance = Math.sqrt((px - cx) ** 2 + (py - cy) ** 2);
+        return distance <= radius;
+      }
+      case "rect": {
+        const [x1, y1, x2, y2] = coordinates;
+        if (coordinates.length !== 4) {
+          console.warn(`Invalid rectangle definition: ${areaKey}`);
+          return false;
+        }
+        return px >= x1 && px <= x2 && py >= y1 && py <= y2;
+      }
+      case "ellipse": {
+        const [cx, cy, rx, ry] = coordinates;
+        if (coordinates.length !== 4) {
+          console.warn(`Invalid ellipse definition: ${areaKey}`);
+          return false;
+        }
+        const normalizedX = (px - cx) ** 2 / rx ** 2;
+        const normalizedY = (py - cy) ** 2 / ry ** 2;
+        return normalizedX + normalizedY <= 1;
+      }
+      case "poly": {
+        if (coordinates.length < 6 || coordinates.length % 2 !== 0) {
+          console.warn(`Invalid polygon definition: ${areaKey}`);
+          return false;
+        }
+        const vertices = [];
+        for (let i = 0; i < coordinates.length; i += 2) {
+          vertices.push({ x: coordinates[i], y: coordinates[i + 1] });
+        }
+        return this.isPointInPolygon({ x: px, y: py }, vertices);
+      }
+      default:
+        console.warn(`Unsupported shape type: ${shape}`);
+        return false;
+    }
+  }
+  /**
+   * Checks if a point is inside a polygon using the ray-casting algorithm.
+   * @param point The point to test.
+   * @param vertices The vertices of the polygon in order (array of {x, y} objects).
+   * @returns True if the point is inside the polygon; false otherwise.
+   */
+  static isPointInPolygon(point, vertices) {
+    let inside = false;
+    for (let i = 0, j = vertices.length - 1; i < vertices.length; j = i++) {
+      const xi = vertices[i].x, yi = vertices[i].y;
+      const xj = vertices[j].x, yj = vertices[j].y;
+      const intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+      if (intersect)
+        inside = !inside;
+    }
+    return inside;
+  }
+  static compareSingleValues(value1, value2, baseType) {
+    switch (baseType) {
+      case "identifier":
+      case "string":
+        return value1 === value2;
+      case "integer": {
+        const int1 = parseInt(value1, 10);
+        const int2 = parseInt(value2, 10);
+        if (!isNaN(int1) && !isNaN(int2)) {
+          return int1 === int2;
+        } else {
+          console.error(`Cannot convert ${value1} and/or ${value2} to int.`);
+        }
+        break;
+      }
+      case "float": {
+        const float1 = parseFloat(value1);
+        const float2 = parseFloat(value2);
+        if (!isNaN(float1) && !isNaN(float2)) {
+          return float1 === float2;
+        } else {
+          console.error(`couldn't convert ${value1} and/or ${value2} to float.`);
+        }
+        break;
+      }
+      case "pair":
+      case "directedPair": {
+        const pair1 = value1.split(" ").sort();
+        const pair2 = value2.split(" ").sort();
+        if (pair1.length === 2 && pair2.length === 2) {
+          if (baseType === "pair") {
+            pair1.sort();
+            pair2.sort();
+          }
+          return pair1.join(" ") === pair2.join(" ");
+        } else {
+          console.error(`compared two pair but one of the values does not have 2 values: 1: ${value1} 2: ${value2}`);
+        }
+        break;
+      }
+    }
+    return false;
+  }
+};
+
+// ../qti-base/dist/elements.js
+var qtiBaseElements = [];
+
+// ../qti-base/dist/register.js
+installCustomStateSetFallback();
+for (const { tag, ctor } of qtiBaseElements) {
+  if (!customElements.get(tag)) {
+    customElements.define(tag, ctor);
+  }
+}
+
+export {
+  CustomStateSetShim,
+  classifyCustomStateSupport,
+  installCustomStateSetFallback,
+  computedItemContext,
+  computedContext,
+  configContext,
+  interactionContext,
+  itemContext,
+  itemContextVariables,
+  isSeed,
+  asSeed,
+  qtiContext,
+  INITIAL_SESSION_CONTEXT,
+  sessionContext,
+  INITIAL_TEST_CONTEXT,
+  testContext,
+  boxSizing,
+  dropRegion,
+  validationMessage,
+  Interaction,
+  QtiVariableDeclaration,
+  QtiExpression,
+  QtiConditionExpression,
+  decimalSeparator,
+  convertNumberToUniversalFormat,
+  IsNullOrUndefined,
+  removeDoubleSlashes,
+  QtiFeedback,
+  parseResponseAttribute,
+  serializeResponseAttribute,
+  iterResponseValues,
+  parsePair,
+  serializePair,
+  parsePoint,
+  serializePoint,
+  responseAttributeConverter,
+  QtiRuleElement,
+  ScoringHelper
+};
+//# sourceMappingURL=chunk-EKXZI26R.js.map