@citolab/qti-components 7.14.3 → 7.15.1

package/dist/chunk-JEUY3MYB.js

@@ -0,0 +1,2010 @@
+import {
+  __decorateClass
+} from "./chunk-EUXUH3YW.js";
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/context-request-event.js
+var s = class extends Event {
+  constructor(s7, t5, e7, o7) {
+    super("context-request", { bubbles: true, composed: true }), this.context = s7, this.contextTarget = t5, this.callback = e7, this.subscribe = o7 ?? false;
+  }
+};
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/create-context.js
+function n(n6) {
+  return n6;
+}
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/controllers/context-consumer.js
+var s2 = class {
+  constructor(t5, s7, i5, h3) {
+    if (this.subscribe = false, this.provided = false, this.value = void 0, this.t = (t6, s8) => {
+      this.unsubscribe && (this.unsubscribe !== s8 && (this.provided = false, this.unsubscribe()), this.subscribe || this.unsubscribe()), this.value = t6, this.host.requestUpdate(), this.provided && !this.subscribe || (this.provided = true, this.callback && this.callback(t6, s8)), this.unsubscribe = s8;
+    }, this.host = t5, void 0 !== s7.context) {
+      const t6 = s7;
+      this.context = t6.context, this.callback = t6.callback, this.subscribe = t6.subscribe ?? false;
+    } else this.context = s7, this.callback = i5, this.subscribe = h3 ?? false;
+    this.host.addController(this);
+  }
+  hostConnected() {
+    this.dispatchRequest();
+  }
+  hostDisconnected() {
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0);
+  }
+  dispatchRequest() {
+    this.host.dispatchEvent(new s(this.context, this.host, this.t, this.subscribe));
+  }
+};
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/value-notifier.js
+var s3 = class {
+  get value() {
+    return this.o;
+  }
+  set value(s7) {
+    this.setValue(s7);
+  }
+  setValue(s7, t5 = false) {
+    const i5 = t5 || !Object.is(s7, this.o);
+    this.o = s7, i5 && this.updateObservers();
+  }
+  constructor(s7) {
+    this.subscriptions = /* @__PURE__ */ new Map(), this.updateObservers = () => {
+      for (const [s8, { disposer: t5 }] of this.subscriptions) s8(this.o, t5);
+    }, void 0 !== s7 && (this.value = s7);
+  }
+  addCallback(s7, t5, i5) {
+    if (!i5) return void s7(this.value);
+    this.subscriptions.has(s7) || this.subscriptions.set(s7, { disposer: () => {
+      this.subscriptions.delete(s7);
+    }, consumerHost: t5 });
+    const { disposer: h3 } = this.subscriptions.get(s7);
+    s7(this.value, h3);
+  }
+  clearCallbacks() {
+    this.subscriptions.clear();
+  }
+};
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/controllers/context-provider.js
+var e = class extends Event {
+  constructor(t5, s7) {
+    super("context-provider", { bubbles: true, composed: true }), this.context = t5, this.contextTarget = s7;
+  }
+};
+var i = class extends s3 {
+  constructor(s7, e7, i5) {
+    super(void 0 !== e7.context ? e7.initialValue : i5), this.onContextRequest = (t5) => {
+      if (t5.context !== this.context) return;
+      const s8 = t5.contextTarget ?? t5.composedPath()[0];
+      s8 !== this.host && (t5.stopPropagation(), this.addCallback(t5.callback, s8, t5.subscribe));
+    }, this.onProviderRequest = (s8) => {
+      if (s8.context !== this.context) return;
+      if ((s8.contextTarget ?? s8.composedPath()[0]) === this.host) return;
+      const e8 = /* @__PURE__ */ new Set();
+      for (const [s9, { consumerHost: i6 }] of this.subscriptions) e8.has(s9) || (e8.add(s9), i6.dispatchEvent(new s(this.context, i6, s9, true)));
+      s8.stopPropagation();
+    }, this.host = s7, void 0 !== e7.context ? this.context = e7.context : this.context = e7, this.attachListeners(), this.host.addController?.(this);
+  }
+  attachListeners() {
+    this.host.addEventListener("context-request", this.onContextRequest), this.host.addEventListener("context-provider", this.onProviderRequest);
+  }
+  hostConnected() {
+    this.host.dispatchEvent(new e(this.context, this.host));
+  }
+};
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/decorators/provide.js
+function e2({ context: e7 }) {
+  return (n6, i5) => {
+    const r6 = /* @__PURE__ */ new WeakMap();
+    if ("object" == typeof i5) return { get() {
+      return n6.get.call(this);
+    }, set(t5) {
+      return r6.get(this).setValue(t5), n6.set.call(this, t5);
+    }, init(n7) {
+      return r6.set(this, new i(this, { context: e7, initialValue: n7 })), n7;
+    } };
+    {
+      n6.constructor.addInitializer(((n7) => {
+        r6.set(n7, new i(n7, { context: e7 }));
+      }));
+      const o7 = Object.getOwnPropertyDescriptor(n6, i5);
+      let s7;
+      if (void 0 === o7) {
+        const t5 = /* @__PURE__ */ new WeakMap();
+        s7 = { get() {
+          return t5.get(this);
+        }, set(e8) {
+          r6.get(this).setValue(e8), t5.set(this, e8);
+        }, configurable: true, enumerable: true };
+      } else {
+        const t5 = o7.set;
+        s7 = { ...o7, set(e8) {
+          r6.get(this).setValue(e8), t5?.call(this, e8);
+        } };
+      }
+      return void Object.defineProperty(n6, i5, s7);
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/decorators/consume.js
+function c({ context: c5, subscribe: e7 }) {
+  return (o7, n6) => {
+    "object" == typeof n6 ? n6.addInitializer((function() {
+      new s2(this, { context: c5, callback: (t5) => {
+        o7.set.call(this, t5);
+      }, subscribe: e7 });
+    })) : o7.constructor.addInitializer(((o8) => {
+      new s2(o8, { context: c5, callback: (t5) => {
+        o8[n6] = t5;
+      }, subscribe: e7 });
+    }));
+  };
+}
+
+// ../qti-base/src/context/computed-item.context.ts
+var computedItemContext = n(Symbol("computedItemContext"));
+
+// ../qti-base/src/context/computed.context.ts
+var computedContext = n(Symbol("computedContext"));
+
+// ../qti-base/src/context/config.context.ts
+var configContext = n(Symbol("configContext"));
+
+// ../qti-base/src/context/item.context.ts
+var itemContextVariables = [
+  {
+    identifier: "completionStatus",
+    cardinality: "single",
+    baseType: "string",
+    value: "unknown",
+    type: "outcome"
+  },
+  {
+    identifier: "numAttempts",
+    cardinality: "single",
+    baseType: "integer",
+    value: "0",
+    type: "response"
+  }
+];
+
+// ../qti-base/src/context/qti-assessment-item.context.ts
+var itemContext = n(Symbol("item"));
+
+// ../qti-base/src/context/qti.context.ts
+var qtiContext = n(Symbol("qtiContext"));
+
+// ../qti-base/src/context/session.context.ts
+var INITIAL_SESSION_CONTEXT = { view: "candidate" };
+var sessionContext = n(Symbol("testContext"));
+
+// ../qti-base/src/context/test.context.ts
+var INITIAL_TEST_CONTEXT = { items: [], testOutcomeVariables: [] };
+var testContext = n(Symbol("testContext"));
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/decorators/custom-element.js
+var t2 = (t5) => (e7, o7) => {
+  void 0 !== o7 ? o7.addInitializer((() => {
+    customElements.define(t5, e7);
+  })) : customElements.define(t5, e7);
+};
+
+// ../../node_modules/.pnpm/@lit-labs+ssr-dom-shim@1.4.0/node_modules/@lit-labs/ssr-dom-shim/lib/element-internals.js
+var ElementInternalsShim = class ElementInternals {
+  get shadowRoot() {
+    return this.__host.__shadowRoot;
+  }
+  constructor(_host) {
+    this.ariaAtomic = "";
+    this.ariaAutoComplete = "";
+    this.ariaBrailleLabel = "";
+    this.ariaBrailleRoleDescription = "";
+    this.ariaBusy = "";
+    this.ariaChecked = "";
+    this.ariaColCount = "";
+    this.ariaColIndex = "";
+    this.ariaColSpan = "";
+    this.ariaCurrent = "";
+    this.ariaDescription = "";
+    this.ariaDisabled = "";
+    this.ariaExpanded = "";
+    this.ariaHasPopup = "";
+    this.ariaHidden = "";
+    this.ariaInvalid = "";
+    this.ariaKeyShortcuts = "";
+    this.ariaLabel = "";
+    this.ariaLevel = "";
+    this.ariaLive = "";
+    this.ariaModal = "";
+    this.ariaMultiLine = "";
+    this.ariaMultiSelectable = "";
+    this.ariaOrientation = "";
+    this.ariaPlaceholder = "";
+    this.ariaPosInSet = "";
+    this.ariaPressed = "";
+    this.ariaReadOnly = "";
+    this.ariaRequired = "";
+    this.ariaRoleDescription = "";
+    this.ariaRowCount = "";
+    this.ariaRowIndex = "";
+    this.ariaRowSpan = "";
+    this.ariaSelected = "";
+    this.ariaSetSize = "";
+    this.ariaSort = "";
+    this.ariaValueMax = "";
+    this.ariaValueMin = "";
+    this.ariaValueNow = "";
+    this.ariaValueText = "";
+    this.role = "";
+    this.form = null;
+    this.labels = [];
+    this.states = /* @__PURE__ */ new Set();
+    this.validationMessage = "";
+    this.validity = {};
+    this.willValidate = true;
+    this.__host = _host;
+  }
+  checkValidity() {
+    console.warn("`ElementInternals.checkValidity()` was called on the server.This method always returns true.");
+    return true;
+  }
+  reportValidity() {
+    return true;
+  }
+  setFormValue() {
+  }
+  setValidity() {
+  }
+};
+
+// ../../node_modules/.pnpm/@lit-labs+ssr-dom-shim@1.4.0/node_modules/@lit-labs/ssr-dom-shim/lib/events.js
+var __classPrivateFieldSet = function(receiver, state, value, kind, f3) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f3) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f3 : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f3.call(receiver, value) : f3 ? f3.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f3) {
+  if (kind === "a" && !f3) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f3 : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f3 : kind === "a" ? f3.call(receiver) : f3 ? f3.value : state.get(receiver);
+};
+var _Event_cancelable;
+var _Event_bubbles;
+var _Event_composed;
+var _Event_defaultPrevented;
+var _Event_timestamp;
+var _Event_propagationStopped;
+var _Event_type;
+var _Event_target;
+var _Event_isBeingDispatched;
+var _a;
+var _CustomEvent_detail;
+var _b;
+var isCaptureEventListener = (options) => typeof options === "boolean" ? options : options?.capture ?? false;
+var NONE = 0;
+var CAPTURING_PHASE = 1;
+var AT_TARGET = 2;
+var BUBBLING_PHASE = 3;
+var EventTarget = class {
+  constructor() {
+    this.__eventListeners = /* @__PURE__ */ new Map();
+    this.__captureEventListeners = /* @__PURE__ */ new Map();
+  }
+  addEventListener(type, callback, options) {
+    if (callback === void 0 || callback === null) {
+      return;
+    }
+    const eventListenersMap = isCaptureEventListener(options) ? this.__captureEventListeners : this.__eventListeners;
+    let eventListeners = eventListenersMap.get(type);
+    if (eventListeners === void 0) {
+      eventListeners = /* @__PURE__ */ new Map();
+      eventListenersMap.set(type, eventListeners);
+    } else if (eventListeners.has(callback)) {
+      return;
+    }
+    const normalizedOptions = typeof options === "object" && options ? options : {};
+    normalizedOptions.signal?.addEventListener("abort", () => this.removeEventListener(type, callback, options));
+    eventListeners.set(callback, normalizedOptions ?? {});
+  }
+  removeEventListener(type, callback, options) {
+    if (callback === void 0 || callback === null) {
+      return;
+    }
+    const eventListenersMap = isCaptureEventListener(options) ? this.__captureEventListeners : this.__eventListeners;
+    const eventListeners = eventListenersMap.get(type);
+    if (eventListeners !== void 0) {
+      eventListeners.delete(callback);
+      if (!eventListeners.size) {
+        eventListenersMap.delete(type);
+      }
+    }
+  }
+  dispatchEvent(event) {
+    const composedPath = [this];
+    let parent = this.__eventTargetParent;
+    if (event.composed) {
+      while (parent) {
+        composedPath.push(parent);
+        parent = parent.__eventTargetParent;
+      }
+    } else {
+      while (parent && parent !== this.__host) {
+        composedPath.push(parent);
+        parent = parent.__eventTargetParent;
+      }
+    }
+    let stopPropagation = false;
+    let stopImmediatePropagation = false;
+    let eventPhase = NONE;
+    let target = null;
+    let tmpTarget = null;
+    let currentTarget = null;
+    const originalStopPropagation = event.stopPropagation;
+    const originalStopImmediatePropagation = event.stopImmediatePropagation;
+    Object.defineProperties(event, {
+      target: {
+        get() {
+          return target ?? tmpTarget;
+        },
+        ...enumerableProperty
+      },
+      srcElement: {
+        get() {
+          return event.target;
+        },
+        ...enumerableProperty
+      },
+      currentTarget: {
+        get() {
+          return currentTarget;
+        },
+        ...enumerableProperty
+      },
+      eventPhase: {
+        get() {
+          return eventPhase;
+        },
+        ...enumerableProperty
+      },
+      composedPath: {
+        value: () => composedPath,
+        ...enumerableProperty
+      },
+      stopPropagation: {
+        value: () => {
+          stopPropagation = true;
+          originalStopPropagation.call(event);
+        },
+        ...enumerableProperty
+      },
+      stopImmediatePropagation: {
+        value: () => {
+          stopImmediatePropagation = true;
+          originalStopImmediatePropagation.call(event);
+        },
+        ...enumerableProperty
+      }
+    });
+    const invokeEventListener = (listener, options, eventListenerMap) => {
+      if (typeof listener === "function") {
+        listener(event);
+      } else if (typeof listener?.handleEvent === "function") {
+        listener.handleEvent(event);
+      }
+      if (options.once) {
+        eventListenerMap.delete(listener);
+      }
+    };
+    const finishDispatch = () => {
+      currentTarget = null;
+      eventPhase = NONE;
+      return !event.defaultPrevented;
+    };
+    const captureEventPath = composedPath.slice().reverse();
+    target = !this.__host || !event.composed ? this : null;
+    const retarget = (eventTargets) => {
+      tmpTarget = this;
+      while (tmpTarget.__host && eventTargets.includes(tmpTarget.__host)) {
+        tmpTarget = tmpTarget.__host;
+      }
+    };
+    for (const eventTarget of captureEventPath) {
+      if (!target && (!tmpTarget || tmpTarget === eventTarget.__host)) {
+        retarget(captureEventPath.slice(captureEventPath.indexOf(eventTarget)));
+      }
+      currentTarget = eventTarget;
+      eventPhase = eventTarget === event.target ? AT_TARGET : CAPTURING_PHASE;
+      const captureEventListeners = eventTarget.__captureEventListeners.get(event.type);
+      if (captureEventListeners) {
+        for (const [listener, options] of captureEventListeners) {
+          invokeEventListener(listener, options, captureEventListeners);
+          if (stopImmediatePropagation) {
+            return finishDispatch();
+          }
+        }
+      }
+      if (stopPropagation) {
+        return finishDispatch();
+      }
+    }
+    const bubbleEventPath = event.bubbles ? composedPath : [this];
+    tmpTarget = null;
+    for (const eventTarget of bubbleEventPath) {
+      if (!target && (!tmpTarget || eventTarget === tmpTarget.__host)) {
+        retarget(bubbleEventPath.slice(0, bubbleEventPath.indexOf(eventTarget) + 1));
+      }
+      currentTarget = eventTarget;
+      eventPhase = eventTarget === event.target ? AT_TARGET : BUBBLING_PHASE;
+      const captureEventListeners = eventTarget.__eventListeners.get(event.type);
+      if (captureEventListeners) {
+        for (const [listener, options] of captureEventListeners) {
+          invokeEventListener(listener, options, captureEventListeners);
+          if (stopImmediatePropagation) {
+            return finishDispatch();
+          }
+        }
+      }
+      if (stopPropagation) {
+        return finishDispatch();
+      }
+    }
+    return finishDispatch();
+  }
+};
+var EventTargetShimWithRealType = EventTarget;
+var enumerableProperty = { __proto__: null };
+enumerableProperty.enumerable = true;
+Object.freeze(enumerableProperty);
+var EventShim = (_a = class Event2 {
+  constructor(type, options = {}) {
+    _Event_cancelable.set(this, false);
+    _Event_bubbles.set(this, false);
+    _Event_composed.set(this, false);
+    _Event_defaultPrevented.set(this, false);
+    _Event_timestamp.set(this, Date.now());
+    _Event_propagationStopped.set(this, false);
+    _Event_type.set(this, void 0);
+    _Event_target.set(this, void 0);
+    _Event_isBeingDispatched.set(this, void 0);
+    this.NONE = NONE;
+    this.CAPTURING_PHASE = CAPTURING_PHASE;
+    this.AT_TARGET = AT_TARGET;
+    this.BUBBLING_PHASE = BUBBLING_PHASE;
+    if (arguments.length === 0)
+      throw new Error(`The type argument must be specified`);
+    if (typeof options !== "object" || !options) {
+      throw new Error(`The "options" argument must be an object`);
+    }
+    const { bubbles, cancelable, composed } = options;
+    __classPrivateFieldSet(this, _Event_cancelable, !!cancelable, "f");
+    __classPrivateFieldSet(this, _Event_bubbles, !!bubbles, "f");
+    __classPrivateFieldSet(this, _Event_composed, !!composed, "f");
+    __classPrivateFieldSet(this, _Event_type, `${type}`, "f");
+    __classPrivateFieldSet(this, _Event_target, null, "f");
+    __classPrivateFieldSet(this, _Event_isBeingDispatched, false, "f");
+  }
+  initEvent(_type, _bubbles, _cancelable) {
+    throw new Error("Method not implemented.");
+  }
+  stopImmediatePropagation() {
+    this.stopPropagation();
+  }
+  preventDefault() {
+    __classPrivateFieldSet(this, _Event_defaultPrevented, true, "f");
+  }
+  get target() {
+    return __classPrivateFieldGet(this, _Event_target, "f");
+  }
+  get currentTarget() {
+    return __classPrivateFieldGet(this, _Event_target, "f");
+  }
+  get srcElement() {
+    return __classPrivateFieldGet(this, _Event_target, "f");
+  }
+  get type() {
+    return __classPrivateFieldGet(this, _Event_type, "f");
+  }
+  get cancelable() {
+    return __classPrivateFieldGet(this, _Event_cancelable, "f");
+  }
+  get defaultPrevented() {
+    return __classPrivateFieldGet(this, _Event_cancelable, "f") && __classPrivateFieldGet(this, _Event_defaultPrevented, "f");
+  }
+  get timeStamp() {
+    return __classPrivateFieldGet(this, _Event_timestamp, "f");
+  }
+  composedPath() {
+    return __classPrivateFieldGet(this, _Event_isBeingDispatched, "f") ? [__classPrivateFieldGet(this, _Event_target, "f")] : [];
+  }
+  get returnValue() {
+    return !__classPrivateFieldGet(this, _Event_cancelable, "f") || !__classPrivateFieldGet(this, _Event_defaultPrevented, "f");
+  }
+  get bubbles() {
+    return __classPrivateFieldGet(this, _Event_bubbles, "f");
+  }
+  get composed() {
+    return __classPrivateFieldGet(this, _Event_composed, "f");
+  }
+  get eventPhase() {
+    return __classPrivateFieldGet(this, _Event_isBeingDispatched, "f") ? _a.AT_TARGET : _a.NONE;
+  }
+  get cancelBubble() {
+    return __classPrivateFieldGet(this, _Event_propagationStopped, "f");
+  }
+  set cancelBubble(value) {
+    if (value) {
+      __classPrivateFieldSet(this, _Event_propagationStopped, true, "f");
+    }
+  }
+  stopPropagation() {
+    __classPrivateFieldSet(this, _Event_propagationStopped, true, "f");
+  }
+  get isTrusted() {
+    return false;
+  }
+}, _Event_cancelable = /* @__PURE__ */ new WeakMap(), _Event_bubbles = /* @__PURE__ */ new WeakMap(), _Event_composed = /* @__PURE__ */ new WeakMap(), _Event_defaultPrevented = /* @__PURE__ */ new WeakMap(), _Event_timestamp = /* @__PURE__ */ new WeakMap(), _Event_propagationStopped = /* @__PURE__ */ new WeakMap(), _Event_type = /* @__PURE__ */ new WeakMap(), _Event_target = /* @__PURE__ */ new WeakMap(), _Event_isBeingDispatched = /* @__PURE__ */ new WeakMap(), _a.NONE = NONE, _a.CAPTURING_PHASE = CAPTURING_PHASE, _a.AT_TARGET = AT_TARGET, _a.BUBBLING_PHASE = BUBBLING_PHASE, _a);
+Object.defineProperties(EventShim.prototype, {
+  initEvent: enumerableProperty,
+  stopImmediatePropagation: enumerableProperty,
+  preventDefault: enumerableProperty,
+  target: enumerableProperty,
+  currentTarget: enumerableProperty,
+  srcElement: enumerableProperty,
+  type: enumerableProperty,
+  cancelable: enumerableProperty,
+  defaultPrevented: enumerableProperty,
+  timeStamp: enumerableProperty,
+  composedPath: enumerableProperty,
+  returnValue: enumerableProperty,
+  bubbles: enumerableProperty,
+  composed: enumerableProperty,
+  eventPhase: enumerableProperty,
+  cancelBubble: enumerableProperty,
+  stopPropagation: enumerableProperty,
+  isTrusted: enumerableProperty
+});
+var CustomEventShim = (_b = class CustomEvent2 extends EventShim {
+  constructor(type, options = {}) {
+    super(type, options);
+    _CustomEvent_detail.set(this, void 0);
+    __classPrivateFieldSet(this, _CustomEvent_detail, options?.detail ?? null, "f");
+  }
+  initCustomEvent(_type, _bubbles, _cancelable, _detail) {
+    throw new Error("Method not implemented.");
+  }
+  get detail() {
+    return __classPrivateFieldGet(this, _CustomEvent_detail, "f");
+  }
+}, _CustomEvent_detail = /* @__PURE__ */ new WeakMap(), _b);
+Object.defineProperties(CustomEventShim.prototype, {
+  detail: enumerableProperty
+});
+var EventShimWithRealType = EventShim;
+var CustomEventShimWithRealType = CustomEventShim;
+
+// ../../node_modules/.pnpm/@lit-labs+ssr-dom-shim@1.4.0/node_modules/@lit-labs/ssr-dom-shim/index.js
+globalThis.Event ??= EventShimWithRealType;
+globalThis.CustomEvent ??= CustomEventShimWithRealType;
+var attributes = /* @__PURE__ */ new WeakMap();
+var attributesForElement = (element) => {
+  let attrs = attributes.get(element);
+  if (attrs === void 0) {
+    attributes.set(element, attrs = /* @__PURE__ */ new Map());
+  }
+  return attrs;
+};
+var ElementShim = class Element extends EventTargetShimWithRealType {
+  constructor() {
+    super(...arguments);
+    this.__shadowRootMode = null;
+    this.__shadowRoot = null;
+    this.__internals = null;
+  }
+  get attributes() {
+    return Array.from(attributesForElement(this)).map(([name, value]) => ({
+      name,
+      value
+    }));
+  }
+  get shadowRoot() {
+    if (this.__shadowRootMode === "closed") {
+      return null;
+    }
+    return this.__shadowRoot;
+  }
+  get localName() {
+    return this.constructor.__localName;
+  }
+  get tagName() {
+    return this.localName?.toUpperCase();
+  }
+  setAttribute(name, value) {
+    attributesForElement(this).set(name, String(value));
+  }
+  removeAttribute(name) {
+    attributesForElement(this).delete(name);
+  }
+  toggleAttribute(name, force) {
+    if (this.hasAttribute(name)) {
+      if (force === void 0 || !force) {
+        this.removeAttribute(name);
+        return false;
+      }
+    } else {
+      if (force === void 0 || force) {
+        this.setAttribute(name, "");
+        return true;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  hasAttribute(name) {
+    return attributesForElement(this).has(name);
+  }
+  attachShadow(init) {
+    const shadowRoot = { host: this };
+    this.__shadowRootMode = init.mode;
+    if (init && init.mode === "open") {
+      this.__shadowRoot = shadowRoot;
+    }
+    return shadowRoot;
+  }
+  attachInternals() {
+    if (this.__internals !== null) {
+      throw new Error(`Failed to execute 'attachInternals' on 'HTMLElement': ElementInternals for the specified element was already attached.`);
+    }
+    const internals = new ElementInternalsShim(this);
+    this.__internals = internals;
+    return internals;
+  }
+  getAttribute(name) {
+    const value = attributesForElement(this).get(name);
+    return value ?? null;
+  }
+};
+var HTMLElementShim = class HTMLElement extends ElementShim {
+};
+var HTMLElementShimWithRealType = HTMLElementShim;
+globalThis.litServerRoot ??= Object.defineProperty(new HTMLElementShimWithRealType(), "localName", {
+  // Patch localName (and tagName) to return a unique name.
+  get() {
+    return "lit-server-root";
+  }
+});
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var CustomElementRegistry = class {
+  constructor() {
+    this.__definitions = /* @__PURE__ */ new Map();
+    this.__reverseDefinitions = /* @__PURE__ */ new Map();
+    this.__pendingWhenDefineds = /* @__PURE__ */ new Map();
+  }
+  define(name, ctor) {
+    if (this.__definitions.has(name)) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn(`'CustomElementRegistry' already has "${name}" defined. This may have been caused by live reload or hot module replacement in which case it can be safely ignored.
+Make sure to test your application with a production build as repeat registrations will throw in production.`);
+      } else {
+        throw new Error(`Failed to execute 'define' on 'CustomElementRegistry': the name "${name}" has already been used with this registry`);
+      }
+    }
+    if (this.__reverseDefinitions.has(ctor)) {
+      throw new Error(`Failed to execute 'define' on 'CustomElementRegistry': the constructor has already been used with this registry for the tag name ${this.__reverseDefinitions.get(ctor)}`);
+    }
+    ctor.__localName = name;
+    this.__definitions.set(name, {
+      ctor,
+      // Note it's important we read `observedAttributes` in case it is a getter
+      // with side-effects, as is the case in Lit, where it triggers class
+      // finalization.
+      //
+      // TODO(aomarks) To be spec compliant, we should also capture the
+      // registration-time lifecycle methods like `connectedCallback`. For them
+      // to be actually accessible to e.g. the Lit SSR element renderer, though,
+      // we'd need to introduce a new API for accessing them (since `get` only
+      // returns the constructor).
+      observedAttributes: ctor.observedAttributes ?? []
+    });
+    this.__reverseDefinitions.set(ctor, name);
+    this.__pendingWhenDefineds.get(name)?.resolve(ctor);
+    this.__pendingWhenDefineds.delete(name);
+  }
+  get(name) {
+    const definition = this.__definitions.get(name);
+    return definition?.ctor;
+  }
+  getName(ctor) {
+    return this.__reverseDefinitions.get(ctor) ?? null;
+  }
+  upgrade(_element) {
+    throw new Error(`customElements.upgrade is not currently supported in SSR. Please file a bug if you need it.`);
+  }
+  async whenDefined(name) {
+    const definition = this.__definitions.get(name);
+    if (definition) {
+      return definition.ctor;
+    }
+    let withResolvers = this.__pendingWhenDefineds.get(name);
+    if (!withResolvers) {
+      withResolvers = promiseWithResolvers();
+      this.__pendingWhenDefineds.set(name, withResolvers);
+    }
+    return withResolvers.promise;
+  }
+};
+var CustomElementRegistryShimWithRealType = CustomElementRegistry;
+var customElements2 = new CustomElementRegistryShimWithRealType();
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/css-tag.js
+var t3 = globalThis;
+var e3 = t3.ShadowRoot && (void 0 === t3.ShadyCSS || t3.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype;
+var s4 = Symbol();
+var o = /* @__PURE__ */ new WeakMap();
+var n2 = class {
+  constructor(t5, e7, o7) {
+    if (this._$cssResult$ = true, o7 !== s4) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = t5, this.t = e7;
+  }
+  get styleSheet() {
+    let t5 = this.o;
+    const s7 = this.t;
+    if (e3 && void 0 === t5) {
+      const e7 = void 0 !== s7 && 1 === s7.length;
+      e7 && (t5 = o.get(s7)), void 0 === t5 && ((this.o = t5 = new CSSStyleSheet()).replaceSync(this.cssText), e7 && o.set(s7, t5));
+    }
+    return t5;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+var r = (t5) => new n2("string" == typeof t5 ? t5 : t5 + "", void 0, s4);
+var i2 = (t5, ...e7) => {
+  const o7 = 1 === t5.length ? t5[0] : e7.reduce(((e8, s7, o8) => e8 + ((t6) => {
+    if (true === t6._$cssResult$) return t6.cssText;
+    if ("number" == typeof t6) return t6;
+    throw Error("Value passed to 'css' function must be a 'css' function result: " + t6 + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
+  })(s7) + t5[o8 + 1]), t5[0]);
+  return new n2(o7, t5, s4);
+};
+var S = (s7, o7) => {
+  if (e3) s7.adoptedStyleSheets = o7.map(((t5) => t5 instanceof CSSStyleSheet ? t5 : t5.styleSheet));
+  else for (const e7 of o7) {
+    const o8 = document.createElement("style"), n6 = t3.litNonce;
+    void 0 !== n6 && o8.setAttribute("nonce", n6), o8.textContent = e7.cssText, s7.appendChild(o8);
+  }
+};
+var c2 = e3 || void 0 === t3.CSSStyleSheet ? (t5) => t5 : (t5) => t5 instanceof CSSStyleSheet ? ((t6) => {
+  let e7 = "";
+  for (const s7 of t6.cssRules) e7 += s7.cssText;
+  return r(e7);
+})(t5) : t5;
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/reactive-element.js
+var { is: h, defineProperty: r2, getOwnPropertyDescriptor: o2, getOwnPropertyNames: n3, getOwnPropertySymbols: a, getPrototypeOf: c3 } = Object;
+var l = globalThis;
+l.customElements ??= customElements2;
+var p = l.trustedTypes;
+var d = p ? p.emptyScript : "";
+var u = l.reactiveElementPolyfillSupport;
+var f = (t5, s7) => t5;
+var b = { toAttribute(t5, s7) {
+  switch (s7) {
+    case Boolean:
+      t5 = t5 ? d : null;
+      break;
+    case Object:
+    case Array:
+      t5 = null == t5 ? t5 : JSON.stringify(t5);
+  }
+  return t5;
+}, fromAttribute(t5, s7) {
+  let i5 = t5;
+  switch (s7) {
+    case Boolean:
+      i5 = null !== t5;
+      break;
+    case Number:
+      i5 = null === t5 ? null : Number(t5);
+      break;
+    case Object:
+    case Array:
+      try {
+        i5 = JSON.parse(t5);
+      } catch (t6) {
+        i5 = null;
+      }
+  }
+  return i5;
+} };
+var m = (t5, s7) => !h(t5, s7);
+var y = { attribute: true, type: String, converter: b, reflect: false, useDefault: false, hasChanged: m };
+Symbol.metadata ??= Symbol("metadata"), l.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
+var g = class extends (globalThis.HTMLElement ?? HTMLElementShimWithRealType) {
+  static addInitializer(t5) {
+    this._$Ei(), (this.l ??= []).push(t5);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(t5, s7 = y) {
+    if (s7.state && (s7.attribute = false), this._$Ei(), this.prototype.hasOwnProperty(t5) && ((s7 = Object.create(s7)).wrapped = true), this.elementProperties.set(t5, s7), !s7.noAccessor) {
+      const i5 = Symbol(), e7 = this.getPropertyDescriptor(t5, i5, s7);
+      void 0 !== e7 && r2(this.prototype, t5, e7);
+    }
+  }
+  static getPropertyDescriptor(t5, s7, i5) {
+    const { get: e7, set: h3 } = o2(this.prototype, t5) ?? { get() {
+      return this[s7];
+    }, set(t6) {
+      this[s7] = t6;
+    } };
+    return { get: e7, set(s8) {
+      const r6 = e7?.call(this);
+      h3?.call(this, s8), this.requestUpdate(t5, r6, i5);
+    }, configurable: true, enumerable: true };
+  }
+  static getPropertyOptions(t5) {
+    return this.elementProperties.get(t5) ?? y;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(f("elementProperties"))) return;
+    const t5 = c3(this);
+    t5.finalize(), void 0 !== t5.l && (this.l = [...t5.l]), this.elementProperties = new Map(t5.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(f("finalized"))) return;
+    if (this.finalized = true, this._$Ei(), this.hasOwnProperty(f("properties"))) {
+      const t6 = this.properties, s7 = [...n3(t6), ...a(t6)];
+      for (const i5 of s7) this.createProperty(i5, t6[i5]);
+    }
+    const t5 = this[Symbol.metadata];
+    if (null !== t5) {
+      const s7 = litPropertyMetadata.get(t5);
+      if (void 0 !== s7) for (const [t6, i5] of s7) this.elementProperties.set(t6, i5);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [t6, s7] of this.elementProperties) {
+      const i5 = this._$Eu(t6, s7);
+      void 0 !== i5 && this._$Eh.set(i5, t6);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(t5) {
+    const s7 = [];
+    if (Array.isArray(t5)) {
+      const e7 = new Set(t5.flat(1 / 0).reverse());
+      for (const t6 of e7) s7.unshift(c2(t6));
+    } else void 0 !== t5 && s7.push(c2(t5));
+    return s7;
+  }
+  static _$Eu(t5, s7) {
+    const i5 = s7.attribute;
+    return false === i5 ? void 0 : "string" == typeof i5 ? i5 : "string" == typeof t5 ? t5.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    this._$ES = new Promise(((t5) => this.enableUpdating = t5)), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach(((t5) => t5(this)));
+  }
+  addController(t5) {
+    (this._$EO ??= /* @__PURE__ */ new Set()).add(t5), void 0 !== this.renderRoot && this.isConnected && t5.hostConnected?.();
+  }
+  removeController(t5) {
+    this._$EO?.delete(t5);
+  }
+  _$E_() {
+    const t5 = /* @__PURE__ */ new Map(), s7 = this.constructor.elementProperties;
+    for (const i5 of s7.keys()) this.hasOwnProperty(i5) && (t5.set(i5, this[i5]), delete this[i5]);
+    t5.size > 0 && (this._$Ep = t5);
+  }
+  createRenderRoot() {
+    const t5 = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return S(t5, this.constructor.elementStyles), t5;
+  }
+  connectedCallback() {
+    this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(true), this._$EO?.forEach(((t5) => t5.hostConnected?.()));
+  }
+  enableUpdating(t5) {
+  }
+  disconnectedCallback() {
+    this._$EO?.forEach(((t5) => t5.hostDisconnected?.()));
+  }
+  attributeChangedCallback(t5, s7, i5) {
+    this._$AK(t5, i5);
+  }
+  _$ET(t5, s7) {
+    const i5 = this.constructor.elementProperties.get(t5), e7 = this.constructor._$Eu(t5, i5);
+    if (void 0 !== e7 && true === i5.reflect) {
+      const h3 = (void 0 !== i5.converter?.toAttribute ? i5.converter : b).toAttribute(s7, i5.type);
+      this._$Em = t5, null == h3 ? this.removeAttribute(e7) : this.setAttribute(e7, h3), this._$Em = null;
+    }
+  }
+  _$AK(t5, s7) {
+    const i5 = this.constructor, e7 = i5._$Eh.get(t5);
+    if (void 0 !== e7 && this._$Em !== e7) {
+      const t6 = i5.getPropertyOptions(e7), h3 = "function" == typeof t6.converter ? { fromAttribute: t6.converter } : void 0 !== t6.converter?.fromAttribute ? t6.converter : b;
+      this._$Em = e7;
+      const r6 = h3.fromAttribute(s7, t6.type);
+      this[e7] = r6 ?? this._$Ej?.get(e7) ?? r6, this._$Em = null;
+    }
+  }
+  requestUpdate(t5, s7, i5) {
+    if (void 0 !== t5) {
+      const e7 = this.constructor, h3 = this[t5];
+      if (i5 ??= e7.getPropertyOptions(t5), !((i5.hasChanged ?? m)(h3, s7) || i5.useDefault && i5.reflect && h3 === this._$Ej?.get(t5) && !this.hasAttribute(e7._$Eu(t5, i5)))) return;
+      this.C(t5, s7, i5);
+    }
+    false === this.isUpdatePending && (this._$ES = this._$EP());
+  }
+  C(t5, s7, { useDefault: i5, reflect: e7, wrapped: h3 }, r6) {
+    i5 && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(t5) && (this._$Ej.set(t5, r6 ?? s7 ?? this[t5]), true !== h3 || void 0 !== r6) || (this._$AL.has(t5) || (this.hasUpdated || i5 || (s7 = void 0), this._$AL.set(t5, s7)), true === e7 && this._$Em !== t5 && (this._$Eq ??= /* @__PURE__ */ new Set()).add(t5));
+  }
+  async _$EP() {
+    this.isUpdatePending = true;
+    try {
+      await this._$ES;
+    } catch (t6) {
+      Promise.reject(t6);
+    }
+    const t5 = this.scheduleUpdate();
+    return null != t5 && await t5, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
+        for (const [t7, s8] of this._$Ep) this[t7] = s8;
+        this._$Ep = void 0;
+      }
+      const t6 = this.constructor.elementProperties;
+      if (t6.size > 0) for (const [s8, i5] of t6) {
+        const { wrapped: t7 } = i5, e7 = this[s8];
+        true !== t7 || this._$AL.has(s8) || void 0 === e7 || this.C(s8, void 0, i5, e7);
+      }
+    }
+    let t5 = false;
+    const s7 = this._$AL;
+    try {
+      t5 = this.shouldUpdate(s7), t5 ? (this.willUpdate(s7), this._$EO?.forEach(((t6) => t6.hostUpdate?.())), this.update(s7)) : this._$EM();
+    } catch (s8) {
+      throw t5 = false, this._$EM(), s8;
+    }
+    t5 && this._$AE(s7);
+  }
+  willUpdate(t5) {
+  }
+  _$AE(t5) {
+    this._$EO?.forEach(((t6) => t6.hostUpdated?.())), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t5)), this.updated(t5);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = false;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(t5) {
+    return true;
+  }
+  update(t5) {
+    this._$Eq &&= this._$Eq.forEach(((t6) => this._$ET(t6, this[t6]))), this._$EM();
+  }
+  updated(t5) {
+  }
+  firstUpdated(t5) {
+  }
+};
+g.elementStyles = [], g.shadowRootOptions = { mode: "open" }, g[f("elementProperties")] = /* @__PURE__ */ new Map(), g[f("finalized")] = /* @__PURE__ */ new Map(), u?.({ ReactiveElement: g }), (l.reactiveElementVersions ??= []).push("2.1.1");
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/decorators/property.js
+var o3 = { attribute: true, type: String, converter: b, reflect: false, hasChanged: m };
+var r3 = (t5 = o3, e7, r6) => {
+  const { kind: n6, metadata: i5 } = r6;
+  let s7 = globalThis.litPropertyMetadata.get(i5);
+  if (void 0 === s7 && globalThis.litPropertyMetadata.set(i5, s7 = /* @__PURE__ */ new Map()), "setter" === n6 && ((t5 = Object.create(t5)).wrapped = true), s7.set(r6.name, t5), "accessor" === n6) {
+    const { name: o7 } = r6;
+    return { set(r7) {
+      const n7 = e7.get.call(this);
+      e7.set.call(this, r7), this.requestUpdate(o7, n7, t5);
+    }, init(e8) {
+      return void 0 !== e8 && this.C(o7, void 0, t5, e8), e8;
+    } };
+  }
+  if ("setter" === n6) {
+    const { name: o7 } = r6;
+    return function(r7) {
+      const n7 = this[o7];
+      e7.call(this, r7), this.requestUpdate(o7, n7, t5);
+    };
+  }
+  throw Error("Unsupported decorator location: " + n6);
+};
+function n4(t5) {
+  return (e7, o7) => "object" == typeof o7 ? r3(t5, e7, o7) : ((t6, e8, o8) => {
+    const r6 = e8.hasOwnProperty(o8);
+    return e8.constructor.createProperty(o8, t6), r6 ? Object.getOwnPropertyDescriptor(e8, o8) : void 0;
+  })(t5, e7, o7);
+}
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/decorators/state.js
+function r4(r6) {
+  return n4({ ...r6, state: true, attribute: false });
+}
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/decorators/base.js
+var e4 = (e7, t5, c5) => (c5.configurable = true, c5.enumerable = true, Reflect.decorate && "object" != typeof t5 && Object.defineProperty(e7, t5, c5), c5);
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/decorators/query.js
+function e5(e7, r6) {
+  return (n6, s7, i5) => {
+    const o7 = (t5) => t5.renderRoot?.querySelector(e7) ?? null;
+    if (r6) {
+      const { get: e8, set: r7 } = "object" == typeof s7 ? n6 : i5 ?? (() => {
+        const t5 = Symbol();
+        return { get() {
+          return this[t5];
+        }, set(e9) {
+          this[t5] = e9;
+        } };
+      })();
+      return e4(n6, s7, { get() {
+        let t5 = e8.call(this);
+        return void 0 === t5 && (t5 = o7(this), (null !== t5 || this.hasUpdated) && r7.call(this, t5)), t5;
+      } });
+    }
+    return e4(n6, s7, { get() {
+      return o7(this);
+    } });
+  };
+}
+
+// ../../node_modules/.pnpm/@lit+reactive-element@2.1.1/node_modules/@lit/reactive-element/node/decorators/query-assigned-elements.js
+function o4(o7) {
+  return (e7, n6) => {
+    const { slot: r6, selector: s7 } = o7 ?? {}, c5 = "slot" + (r6 ? `[name=${r6}]` : ":not([name])");
+    return e4(e7, n6, { get() {
+      const t5 = this.renderRoot?.querySelector(c5), e8 = t5?.assignedElements(o7) ?? [];
+      return void 0 === s7 ? e8 : e8.filter(((t6) => t6.matches(s7)));
+    } });
+  };
+}
+
+// ../../node_modules/.pnpm/lit-html@3.3.1/node_modules/lit-html/node/lit-html.js
+var t4 = globalThis;
+var i3 = t4.trustedTypes;
+var s5 = i3 ? i3.createPolicy("lit-html", { createHTML: (t5) => t5 }) : void 0;
+var e6 = "$lit$";
+var h2 = `lit$${Math.random().toFixed(9).slice(2)}$`;
+var o5 = "?" + h2;
+var n5 = `<${o5}>`;
+var r5 = void 0 === t4.document ? { createTreeWalker: () => ({}) } : document;
+var l2 = () => r5.createComment("");
+var c4 = (t5) => null === t5 || "object" != typeof t5 && "function" != typeof t5;
+var a2 = Array.isArray;
+var u2 = (t5) => a2(t5) || "function" == typeof t5?.[Symbol.iterator];
+var d2 = "[ 	\n\f\r]";
+var f2 = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g;
+var v = /-->/g;
+var _ = />/g;
+var m2 = RegExp(`>|${d2}(?:([^\\s"'>=/]+)(${d2}*=${d2}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g");
+var p2 = /'/g;
+var g2 = /"/g;
+var $ = /^(?:script|style|textarea|title)$/i;
+var y2 = (t5) => (i5, ...s7) => ({ _$litType$: t5, strings: i5, values: s7 });
+var x = y2(1);
+var T = y2(2);
+var b2 = y2(3);
+var w = Symbol.for("lit-noChange");
+var E = Symbol.for("lit-nothing");
+var A = /* @__PURE__ */ new WeakMap();
+var C = r5.createTreeWalker(r5, 129);
+function P(t5, i5) {
+  if (!a2(t5) || !t5.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return void 0 !== s5 ? s5.createHTML(i5) : i5;
+}
+var V = (t5, i5) => {
+  const s7 = t5.length - 1, o7 = [];
+  let r6, l3 = 2 === i5 ? "<svg>" : 3 === i5 ? "<math>" : "", c5 = f2;
+  for (let i6 = 0; i6 < s7; i6++) {
+    const s8 = t5[i6];
+    let a3, u3, d3 = -1, y3 = 0;
+    for (; y3 < s8.length && (c5.lastIndex = y3, u3 = c5.exec(s8), null !== u3); ) y3 = c5.lastIndex, c5 === f2 ? "!--" === u3[1] ? c5 = v : void 0 !== u3[1] ? c5 = _ : void 0 !== u3[2] ? ($.test(u3[2]) && (r6 = RegExp("</" + u3[2], "g")), c5 = m2) : void 0 !== u3[3] && (c5 = m2) : c5 === m2 ? ">" === u3[0] ? (c5 = r6 ?? f2, d3 = -1) : void 0 === u3[1] ? d3 = -2 : (d3 = c5.lastIndex - u3[2].length, a3 = u3[1], c5 = void 0 === u3[3] ? m2 : '"' === u3[3] ? g2 : p2) : c5 === g2 || c5 === p2 ? c5 = m2 : c5 === v || c5 === _ ? c5 = f2 : (c5 = m2, r6 = void 0);
+    const x2 = c5 === m2 && t5[i6 + 1].startsWith("/>") ? " " : "";
+    l3 += c5 === f2 ? s8 + n5 : d3 >= 0 ? (o7.push(a3), s8.slice(0, d3) + e6 + s8.slice(d3) + h2 + x2) : s8 + h2 + (-2 === d3 ? i6 : x2);
+  }
+  return [P(t5, l3 + (t5[s7] || "<?>") + (2 === i5 ? "</svg>" : 3 === i5 ? "</math>" : "")), o7];
+};
+var N = class _N {
+  constructor({ strings: t5, _$litType$: s7 }, n6) {
+    let r6;
+    this.parts = [];
+    let c5 = 0, a3 = 0;
+    const u3 = t5.length - 1, d3 = this.parts, [f3, v2] = V(t5, s7);
+    if (this.el = _N.createElement(f3, n6), C.currentNode = this.el.content, 2 === s7 || 3 === s7) {
+      const t6 = this.el.content.firstChild;
+      t6.replaceWith(...t6.childNodes);
+    }
+    for (; null !== (r6 = C.nextNode()) && d3.length < u3; ) {
+      if (1 === r6.nodeType) {
+        if (r6.hasAttributes()) for (const t6 of r6.getAttributeNames()) if (t6.endsWith(e6)) {
+          const i5 = v2[a3++], s8 = r6.getAttribute(t6).split(h2), e7 = /([.?@])?(.*)/.exec(i5);
+          d3.push({ type: 1, index: c5, name: e7[2], strings: s8, ctor: "." === e7[1] ? H : "?" === e7[1] ? I : "@" === e7[1] ? L : R }), r6.removeAttribute(t6);
+        } else t6.startsWith(h2) && (d3.push({ type: 6, index: c5 }), r6.removeAttribute(t6));
+        if ($.test(r6.tagName)) {
+          const t6 = r6.textContent.split(h2), s8 = t6.length - 1;
+          if (s8 > 0) {
+            r6.textContent = i3 ? i3.emptyScript : "";
+            for (let i5 = 0; i5 < s8; i5++) r6.append(t6[i5], l2()), C.nextNode(), d3.push({ type: 2, index: ++c5 });
+            r6.append(t6[s8], l2());
+          }
+        }
+      } else if (8 === r6.nodeType) if (r6.data === o5) d3.push({ type: 2, index: c5 });
+      else {
+        let t6 = -1;
+        for (; -1 !== (t6 = r6.data.indexOf(h2, t6 + 1)); ) d3.push({ type: 7, index: c5 }), t6 += h2.length - 1;
+      }
+      c5++;
+    }
+  }
+  static createElement(t5, i5) {
+    const s7 = r5.createElement("template");
+    return s7.innerHTML = t5, s7;
+  }
+};
+function S2(t5, i5, s7 = t5, e7) {
+  if (i5 === w) return i5;
+  let h3 = void 0 !== e7 ? s7._$Co?.[e7] : s7._$Cl;
+  const o7 = c4(i5) ? void 0 : i5._$litDirective$;
+  return h3?.constructor !== o7 && (h3?._$AO?.(false), void 0 === o7 ? h3 = void 0 : (h3 = new o7(t5), h3._$AT(t5, s7, e7)), void 0 !== e7 ? (s7._$Co ??= [])[e7] = h3 : s7._$Cl = h3), void 0 !== h3 && (i5 = S2(t5, h3._$AS(t5, i5.values), h3, e7)), i5;
+}
+var M = class {
+  constructor(t5, i5) {
+    this._$AV = [], this._$AN = void 0, this._$AD = t5, this._$AM = i5;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(t5) {
+    const { el: { content: i5 }, parts: s7 } = this._$AD, e7 = (t5?.creationScope ?? r5).importNode(i5, true);
+    C.currentNode = e7;
+    let h3 = C.nextNode(), o7 = 0, n6 = 0, l3 = s7[0];
+    for (; void 0 !== l3; ) {
+      if (o7 === l3.index) {
+        let i6;
+        2 === l3.type ? i6 = new k(h3, h3.nextSibling, this, t5) : 1 === l3.type ? i6 = new l3.ctor(h3, l3.name, l3.strings, this, t5) : 6 === l3.type && (i6 = new z(h3, this, t5)), this._$AV.push(i6), l3 = s7[++n6];
+      }
+      o7 !== l3?.index && (h3 = C.nextNode(), o7++);
+    }
+    return C.currentNode = r5, e7;
+  }
+  p(t5) {
+    let i5 = 0;
+    for (const s7 of this._$AV) void 0 !== s7 && (void 0 !== s7.strings ? (s7._$AI(t5, s7, i5), i5 += s7.strings.length - 2) : s7._$AI(t5[i5])), i5++;
+  }
+};
+var k = class _k {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(t5, i5, s7, e7) {
+    this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t5, this._$AB = i5, this._$AM = s7, this.options = e7, this._$Cv = e7?.isConnected ?? true;
+  }
+  get parentNode() {
+    let t5 = this._$AA.parentNode;
+    const i5 = this._$AM;
+    return void 0 !== i5 && 11 === t5?.nodeType && (t5 = i5.parentNode), t5;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(t5, i5 = this) {
+    t5 = S2(this, t5, i5), c4(t5) ? t5 === E || null == t5 || "" === t5 ? (this._$AH !== E && this._$AR(), this._$AH = E) : t5 !== this._$AH && t5 !== w && this._(t5) : void 0 !== t5._$litType$ ? this.$(t5) : void 0 !== t5.nodeType ? this.T(t5) : u2(t5) ? this.k(t5) : this._(t5);
+  }
+  O(t5) {
+    return this._$AA.parentNode.insertBefore(t5, this._$AB);
+  }
+  T(t5) {
+    this._$AH !== t5 && (this._$AR(), this._$AH = this.O(t5));
+  }
+  _(t5) {
+    this._$AH !== E && c4(this._$AH) ? this._$AA.nextSibling.data = t5 : this.T(r5.createTextNode(t5)), this._$AH = t5;
+  }
+  $(t5) {
+    const { values: i5, _$litType$: s7 } = t5, e7 = "number" == typeof s7 ? this._$AC(t5) : (void 0 === s7.el && (s7.el = N.createElement(P(s7.h, s7.h[0]), this.options)), s7);
+    if (this._$AH?._$AD === e7) this._$AH.p(i5);
+    else {
+      const t6 = new M(e7, this), s8 = t6.u(this.options);
+      t6.p(i5), this.T(s8), this._$AH = t6;
+    }
+  }
+  _$AC(t5) {
+    let i5 = A.get(t5.strings);
+    return void 0 === i5 && A.set(t5.strings, i5 = new N(t5)), i5;
+  }
+  k(t5) {
+    a2(this._$AH) || (this._$AH = [], this._$AR());
+    const i5 = this._$AH;
+    let s7, e7 = 0;
+    for (const h3 of t5) e7 === i5.length ? i5.push(s7 = new _k(this.O(l2()), this.O(l2()), this, this.options)) : s7 = i5[e7], s7._$AI(h3), e7++;
+    e7 < i5.length && (this._$AR(s7 && s7._$AB.nextSibling, e7), i5.length = e7);
+  }
+  _$AR(t5 = this._$AA.nextSibling, i5) {
+    for (this._$AP?.(false, true, i5); t5 !== this._$AB; ) {
+      const i6 = t5.nextSibling;
+      t5.remove(), t5 = i6;
+    }
+  }
+  setConnected(t5) {
+    void 0 === this._$AM && (this._$Cv = t5, this._$AP?.(t5));
+  }
+};
+var R = class {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(t5, i5, s7, e7, h3) {
+    this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t5, this.name = i5, this._$AM = e7, this.options = h3, s7.length > 2 || "" !== s7[0] || "" !== s7[1] ? (this._$AH = Array(s7.length - 1).fill(new String()), this.strings = s7) : this._$AH = E;
+  }
+  _$AI(t5, i5 = this, s7, e7) {
+    const h3 = this.strings;
+    let o7 = false;
+    if (void 0 === h3) t5 = S2(this, t5, i5, 0), o7 = !c4(t5) || t5 !== this._$AH && t5 !== w, o7 && (this._$AH = t5);
+    else {
+      const e8 = t5;
+      let n6, r6;
+      for (t5 = h3[0], n6 = 0; n6 < h3.length - 1; n6++) r6 = S2(this, e8[s7 + n6], i5, n6), r6 === w && (r6 = this._$AH[n6]), o7 ||= !c4(r6) || r6 !== this._$AH[n6], r6 === E ? t5 = E : t5 !== E && (t5 += (r6 ?? "") + h3[n6 + 1]), this._$AH[n6] = r6;
+    }
+    o7 && !e7 && this.j(t5);
+  }
+  j(t5) {
+    t5 === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t5 ?? "");
+  }
+};
+var H = class extends R {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(t5) {
+    this.element[this.name] = t5 === E ? void 0 : t5;
+  }
+};
+var I = class extends R {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(t5) {
+    this.element.toggleAttribute(this.name, !!t5 && t5 !== E);
+  }
+};
+var L = class extends R {
+  constructor(t5, i5, s7, e7, h3) {
+    super(t5, i5, s7, e7, h3), this.type = 5;
+  }
+  _$AI(t5, i5 = this) {
+    if ((t5 = S2(this, t5, i5, 0) ?? E) === w) return;
+    const s7 = this._$AH, e7 = t5 === E && s7 !== E || t5.capture !== s7.capture || t5.once !== s7.once || t5.passive !== s7.passive, h3 = t5 !== E && (s7 === E || e7);
+    e7 && this.element.removeEventListener(this.name, this, s7), h3 && this.element.addEventListener(this.name, this, t5), this._$AH = t5;
+  }
+  handleEvent(t5) {
+    "function" == typeof this._$AH ? this._$AH.call(this.options?.host ?? this.element, t5) : this._$AH.handleEvent(t5);
+  }
+};
+var z = class {
+  constructor(t5, i5, s7) {
+    this.element = t5, this.type = 6, this._$AN = void 0, this._$AM = i5, this.options = s7;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(t5) {
+    S2(this, t5);
+  }
+};
+var W = { M: e6, P: h2, A: o5, C: 1, L: V, R: M, D: u2, V: S2, I: k, H: R, N: I, U: L, B: H, F: z };
+var Z = t4.litHtmlPolyfillSupport;
+Z?.(N, k), (t4.litHtmlVersions ??= []).push("3.3.1");
+var j = (t5, i5, s7) => {
+  const e7 = s7?.renderBefore ?? i5;
+  let h3 = e7._$litPart$;
+  if (void 0 === h3) {
+    const t6 = s7?.renderBefore ?? null;
+    e7._$litPart$ = h3 = new k(i5.insertBefore(l2(), t6), t6, void 0, s7 ?? {});
+  }
+  return h3._$AI(t5), h3;
+};
+
+// ../../node_modules/.pnpm/lit-element@4.2.1/node_modules/lit-element/lit-element.js
+var s6 = globalThis;
+var i4 = class extends g {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+  }
+  createRenderRoot() {
+    const t5 = super.createRenderRoot();
+    return this.renderOptions.renderBefore ??= t5.firstChild, t5;
+  }
+  update(t5) {
+    const r6 = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t5), this._$Do = j(r6, this.renderRoot, this.renderOptions);
+  }
+  connectedCallback() {
+    super.connectedCallback(), this._$Do?.setConnected(true);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this._$Do?.setConnected(false);
+  }
+  render() {
+    return w;
+  }
+};
+i4._$litElement$ = true, i4["finalized"] = true, s6.litElementHydrateSupport?.({ LitElement: i4 });
+var o6 = s6.litElementPolyfillSupport;
+o6?.({ LitElement: i4 });
+(s6.litElementVersions ??= []).push("4.2.1");
+
+// ../qti-base/src/abstract/interaction.ts
+var Correctness = /* @__PURE__ */ ((Correctness2) => {
+  Correctness2["Correct"] = "correct";
+  Correctness2["PartiallyCorrect"] = "partially-correct";
+  Correctness2["Incorrect"] = "incorrect";
+  return Correctness2;
+})(Correctness || {});
+var Interaction = class extends i4 {
+  constructor() {
+    super();
+    this.disabled = false;
+    this.readonly = false;
+    this._internals = this.attachInternals();
+  }
+  static {
+    this.formAssociated = true;
+  }
+  get internals() {
+    return this._internals;
+  }
+  get isFullCorrectResponse() {
+    return this._isFullCorrectResponse;
+  }
+  set isFullCorrectResponse(val) {
+    this._isFullCorrectResponse = val;
+    if (val) {
+      this.disabled = true;
+      this.setAttribute("response-identifier", this.responseIdentifier + "_cr");
+    }
+  }
+  get correctResponse() {
+    return this._correctResponse;
+  }
+  set correctResponse(val) {
+    this._correctResponse = val;
+  }
+  get correctness() {
+    const responseVariable = this.responseVariable;
+    if (!responseVariable || responseVariable.correctResponse === null) return null;
+    return responseVariable.correctResponse === responseVariable.value ? "correct" /* Correct */ : "incorrect" /* Incorrect */;
+  }
+  get isInline() {
+    return false;
+  }
+  get responseVariable() {
+    const responseVariables = this._context.variables.filter((v2) => v2.type === "response");
+    const responseIdentifier = this.getAttribute("response-identifier");
+    return responseVariables.find((v2) => v2.identifier === responseIdentifier);
+  }
+  toggleCorrectResponse(show) {
+    const correctResponseMode = this?.configContext?.correctResponseMode || "internal";
+    if (correctResponseMode === "full") {
+      this.toggleFullCorrectResponse(show);
+    } else {
+      this.toggleInternalCorrectResponse(show);
+    }
+  }
+  async toggleFullCorrectResponse(show) {
+    const nextSibling = this.nextSibling;
+    const nextSiblingIsFullCorrectResponse = nextSibling instanceof HTMLDivElement && nextSibling?.classList.contains("full-correct-response");
+    const responseVariable = this.responseVariable;
+    if (!responseVariable) {
+      return;
+    }
+    const showFullCorrectResponse = show && (this?.configContext?.fullCorrectResponseOnlyWhenIncorrect === false || this.correctness !== "correct" /* Correct */);
+    if (!showFullCorrectResponse) {
+      if (!nextSiblingIsFullCorrectResponse) {
+        return;
+      }
+      this.parentElement?.removeChild(nextSibling);
+    }
+    if (nextSiblingIsFullCorrectResponse) {
+      return;
+    }
+    const clone = this.cloneNode(true);
+    const containerDiv = document.createElement("div");
+    containerDiv.classList.add("full-correct-response");
+    if (this.isInline) {
+      containerDiv.classList.add("full-correct-response-inline");
+    } else {
+      containerDiv.classList.add("full-correct-response-block");
+    }
+    containerDiv.role = "full-correct-response";
+    containerDiv.appendChild(clone);
+    clone.isFullCorrectResponse = true;
+    this.parentElement?.insertBefore(containerDiv, this.nextSibling);
+    await clone.updateComplete;
+    clone.response = Array.isArray(responseVariable.correctResponse) ? [...responseVariable.correctResponse] : responseVariable.correctResponse;
+  }
+  toggleInternalCorrectResponse(show) {
+    const responseVariable = this.responseVariable;
+    this.correctResponse = show ? responseVariable?.correctResponse : responseVariable?.cardinality === "single" ? "" : [];
+  }
+  toggleCandidateCorrection(show) {
+    const responseVariable = this.responseVariable;
+    if (!responseVariable) return;
+    this._internals.states.delete("candidate-correct");
+    this._internals.states.delete("candidate-partially-correct");
+    this._internals.states.delete("candidate-incorrect");
+    if (!show) {
+      return;
+    }
+    if (this.correctness === "correct" /* Correct */) {
+      this._internals.states.add("candidate-correct");
+    }
+    if (this.correctness === "partially-correct" /* PartiallyCorrect */) {
+      this._internals.states.add("candidate-partially-correct");
+    }
+    if (this.correctness === "incorrect" /* Incorrect */) {
+      this._internals.states.add("candidate-incorrect");
+    }
+  }
+  get value() {
+    return JSON.stringify(this.response);
+  }
+  set value(val) {
+    this.response = val ? JSON.parse(val) : null;
+  }
+  reportValidity() {
+    return this._internals.reportValidity();
+  }
+  reset() {
+    this.response = null;
+  }
+  // attributeChangedCallback(name: string, _old: string | null, value: string | null): void {
+  //   super.attributeChangedCallback(name, _old, value);
+  //   // changing attributes in lit is not a thing, they are defined in the QTI XML and will never change
+  //   // except in storybook where we can change the value of the attribute
+  //   // this can make the internal state out of sync with the attribute
+  //   // so we reset the value to null to force the internal state to be reset
+  //   const attributeNamesToExclude = ['style', 'class'];
+  //   if (!attributeNamesToExclude.includes(name)) {
+  //     this.reset();
+  //   }
+  // }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.isFullCorrectResponse) {
+      return;
+    }
+    this.dispatchEvent(
+      new CustomEvent("qti-register-interaction", {
+        bubbles: true,
+        composed: true,
+        cancelable: false,
+        detail: {
+          interactionElement: this,
+          responseIdentifier: this.responseIdentifier
+        }
+      })
+    );
+  }
+  saveResponse(value) {
+    this.dispatchEvent(
+      new CustomEvent("qti-interaction-response", {
+        bubbles: true,
+        composed: true,
+        cancelable: false,
+        detail: {
+          responseIdentifier: this.responseIdentifier,
+          response: Array.isArray(value) ? [...value] : value
+        }
+      })
+    );
+  }
+};
+__decorateClass([
+  c({ context: itemContext, subscribe: true })
+], Interaction.prototype, "_context", 2);
+__decorateClass([
+  c({ context: configContext, subscribe: true })
+], Interaction.prototype, "configContext", 2);
+__decorateClass([
+  n4({ type: String, attribute: "response-identifier" })
+], Interaction.prototype, "responseIdentifier", 2);
+__decorateClass([
+  n4({ reflect: true, type: Boolean })
+], Interaction.prototype, "disabled", 2);
+__decorateClass([
+  n4({ reflect: true, type: Boolean })
+], Interaction.prototype, "readonly", 2);
+__decorateClass([
+  r4()
+], Interaction.prototype, "_isFullCorrectResponse", 2);
+__decorateClass([
+  r4()
+], Interaction.prototype, "_correctResponse", 2);
+
+// ../qti-base/src/abstract/qti-variable-declaration.ts
+var QtiVariableDeclaration = class extends i4 {
+  render() {
+    return x`<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((n6) => n6.innerHTML.trim());
+    if (defaultValues.length > 1 || cardinality === "multiple" || cardinality === "ordered") {
+      return defaultValues;
+    }
+    return defaultValues[0];
+  }
+};
+
+// ../qti-base/src/abstract/qti-expression.ts
+var QtiExpression = class extends i4 {
+  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((e7) => {
+        console.debug("getVariables", e7.tagName.toLowerCase());
+        switch (e7.tagName.toLowerCase()) {
+          case "qti-base-value": {
+            return {
+              baseType: e7.getAttribute("base-type"),
+              value: e7.textContent.trim(),
+              cardinality: "single"
+            };
+          }
+          case "qti-variable": {
+            const identifier = e7.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((v2) => v2.identifier === identifier) || null;
+            return variable;
+          }
+          case "qti-multiple": {
+            const multiple = e7;
+            const values = multiple.getResult();
+            console.debug("values", values);
+            if (values?.length > 0) {
+              return {
+                identifier: "",
+                baseType: values[0].baseType,
+                value: values.map((v2) => v2.value),
+                cardinality: "multiple",
+                type: "response"
+              };
+            }
+            return null;
+          }
+          case "qti-ordered": {
+            const multiple = e7;
+            const values = multiple.getResult();
+            if (values?.length > 0) {
+              return {
+                identifier: "",
+                baseType: values[0].baseType,
+                value: values.map((v2) => v2.value),
+                cardinality: "ordered",
+                type: "response"
+              };
+            }
+            return null;
+          }
+          case "qti-correct": {
+            const identifier = e7.getAttribute("identifier") || "";
+            const responseVariable = this.context?.variables?.find((v2) => v2.identifier === identifier) || null;
+            return {
+              baseType: responseVariable.baseType,
+              value: responseVariable.correctResponse,
+              cardinality: responseVariable.cardinality
+            };
+          }
+          default: {
+            try {
+              const expression = e7;
+              const value = expression.getResult();
+              return {
+                baseType: "integer",
+                value: value?.toString() || null,
+                cardinality: "single"
+              };
+            } catch (error) {
+              console.warn("default not sufficient");
+            }
+            return null;
+          }
+        }
+      }).filter((v2) => v2 !== null)
+    );
+  }
+  static {
+    // hide the slot with css
+    this.styles = i2`
+    slot {
+      display: none;
+    }
+  `;
+  }
+  render() {
+    return x`<pre>${JSON.stringify(this.result, null, 2)}</pre>
+      <slot></slot>`;
+  }
+  calculate() {
+    this.result = this.getResult();
+    return this.result;
+  }
+  getResult() {
+    throw new Error("Not implemented");
+  }
+};
+__decorateClass([
+  r4()
+], QtiExpression.prototype, "result", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r4()
+], QtiExpression.prototype, "context", 2);
+__decorateClass([
+  c({ context: qtiContext, subscribe: true }),
+  r4()
+], QtiExpression.prototype, "qtiContext", 2);
+
+// ../qti-base/src/abstract/qti-condition-expression.ts
+var QtiConditionExpression = class extends QtiExpression {
+  calculate() {
+    this.result = this.getResult();
+    return this.result;
+  }
+  getResult() {
+    throw new Error("Not implemented");
+  }
+};
+
+// ../qti-base/src/utils/utils.ts
+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/src/abstract/qti-feedback.ts
+var QtiFeedback = class extends i4 {
+  connectedCallback() {
+    super.connectedCallback();
+    this.dispatchEvent(
+      new CustomEvent("qti-register-feedback", {
+        bubbles: true,
+        composed: true,
+        detail: this
+      })
+    );
+  }
+  checkShowFeedback(outcomeIdentifier) {
+    const outcomeVariable = this._context.variables.find((v2) => v2.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";
+  }
+};
+__decorateClass([
+  n4({ type: String, attribute: "show-hide" })
+], QtiFeedback.prototype, "showHide", 2);
+__decorateClass([
+  n4({ type: String, attribute: "outcome-identifier" })
+], QtiFeedback.prototype, "outcomeIdentifier", 2);
+__decorateClass([
+  n4({ type: String })
+], QtiFeedback.prototype, "identifier", 2);
+__decorateClass([
+  n4({ type: String, attribute: false })
+], QtiFeedback.prototype, "showStatus", 2);
+__decorateClass([
+  c({ context: itemContext, subscribe: true }),
+  r4()
+], QtiFeedback.prototype, "_context", 2);
+
+// ../qti-base/src/lib/qti-rule-base.ts
+var QtiRuleElement = class extends i4 {
+};
+
+// ../qti-base/src/utils/scoring-helper.ts
+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, y22] = coordinates;
+        if (coordinates.length !== 4) {
+          console.warn(`Invalid rectangle definition: ${areaKey}`);
+          return false;
+        }
+        return px >= x1 && px <= x2 && py >= y1 && py <= y22;
+      }
+      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 i5 = 0; i5 < coordinates.length; i5 += 2) {
+          vertices.push({ x: coordinates[i5], y: coordinates[i5 + 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 i5 = 0, j2 = vertices.length - 1; i5 < vertices.length; j2 = i5++) {
+      const xi = vertices[i5].x, yi = vertices[i5].y;
+      const xj = vertices[j2].x, yj = vertices[j2].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;
+  }
+};
+
+export {
+  e2 as e,
+  c,
+  computedItemContext,
+  computedContext,
+  configContext,
+  itemContextVariables,
+  itemContext,
+  qtiContext,
+  INITIAL_SESSION_CONTEXT,
+  sessionContext,
+  INITIAL_TEST_CONTEXT,
+  testContext,
+  t2 as t,
+  i2 as i,
+  n4 as n,
+  r4 as r,
+  e5 as e2,
+  o4 as o,
+  x,
+  T,
+  w,
+  E,
+  W,
+  i4 as i2,
+  Correctness,
+  Interaction,
+  QtiVariableDeclaration,
+  QtiExpression,
+  QtiConditionExpression,
+  decimalSeparator,
+  convertNumberToUniversalFormat,
+  IsNullOrUndefined,
+  removeDoubleSlashes,
+  QtiFeedback,
+  QtiRuleElement,
+  ScoringHelper
+};
+/*! Bundled license information:
+
+@lit/context/lib/context-request-event.js:
+@lit/context/lib/create-context.js:
+@lit/context/lib/controllers/context-consumer.js:
+@lit/context/lib/value-notifier.js:
+@lit/context/lib/controllers/context-provider.js:
+@lit/context/lib/context-root.js:
+@lit/reactive-element/node/decorators/query-assigned-elements.js:
+  (**
+   * @license
+   * Copyright 2021 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/context/lib/decorators/provide.js:
+@lit/reactive-element/node/decorators/custom-element.js:
+@lit/reactive-element/node/decorators/property.js:
+@lit/reactive-element/node/decorators/state.js:
+@lit/reactive-element/node/decorators/event-options.js:
+@lit/reactive-element/node/decorators/base.js:
+@lit/reactive-element/node/decorators/query.js:
+@lit/reactive-element/node/decorators/query-all.js:
+@lit/reactive-element/node/decorators/query-async.js:
+@lit/reactive-element/node/decorators/query-assigned-nodes.js:
+lit-html/node/lit-html.js:
+lit-element/lit-element.js:
+  (**
+   * @license
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/context/lib/decorators/consume.js:
+lit-html/node/is-server.js:
+  (**
+   * @license
+   * Copyright 2022 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit-labs/ssr-dom-shim/lib/element-internals.js:
+@lit-labs/ssr-dom-shim/lib/events.js:
+  (**
+   * @license
+   * Copyright 2023 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit-labs/ssr-dom-shim/index.js:
+@lit/reactive-element/node/css-tag.js:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/
+//# sourceMappingURL=chunk-JEUY3MYB.js.map