@citolab/qti-components 7.14.2 → 7.15.0

package/dist/{chunks/chunk-Z2FFXTKX.js → chunk-352OTVTY.js}

@@ -1,43 +1,42 @@
-import {
-  INITIAL_SESSION_CONTEXT,
-  sessionContext
-} from "./chunk-C5RLRG3L.js";
-import {
-  item_default
-} from "./chunk-PT5ASWGQ.js";
 import {
   QtiModalFeedback
-} from "./chunk-YD7FVKDP.js";
-import {
-  INITIAL_TEST_CONTEXT,
-  testContext
-} from "./chunk-CJADUWEC.js";
+} from "./chunk-O4XIWHTF.js";
 import {
-  qtiContext
-} from "./chunk-H6KHXSIO.js";
+  item_default,
+  m
+} from "./chunk-W4SQRNWO.js";
 import {
   watch
-} from "./chunk-ELDMXTUQ.js";
+} from "./chunk-2ZEJ3RR5.js";
 import {
   qtiTransformItem,
   qtiTransformTest
-} from "./chunk-XBPO6E25.js";
-import {
-  computedContext
-} from "./chunk-DVQQ7I6Y.js";
+} from "./chunk-INKI27D5.js";
 import {
-  configContext
-} from "./chunk-BHJSX3Q6.js";
+  E,
+  INITIAL_SESSION_CONTEXT,
+  INITIAL_TEST_CONTEXT,
+  W,
+  c,
+  computedContext,
+  configContext,
+  e,
+  i,
+  i2,
+  n,
+  qtiContext,
+  r,
+  sessionContext,
+  t,
+  testContext,
+  w,
+  x
+} from "./chunk-JEUY3MYB.js";
 import {
   __decorateClass
-} from "./chunk-H2JE6IVU.js";
+} from "./chunk-EUXUH3YW.js";
 
-// src/lib/qti-test/core/qti-test.ts
-import { html } from "lit";
-import { customElement } from "lit/decorators.js";
-
-// src/lib/qti-test/core/mixins/test-navigation.mixin.ts
-import { property } from "lit/decorators.js";
+// ../qti-test/src/mixins/test-navigation.mixin.ts
 var TestNavigationMixin = (superClass) => {
   class TestNavigationClass extends superClass {
     constructor(...args) {
@@ -92,15 +91,15 @@ var TestNavigationMixin = (superClass) => {
       this.addEventListener("qti-assessment-item-connected", this._handleItemConnected.bind(this));
       this.addEventListener("qti-assessment-stimulus-ref-connected", this._handleStimulusRefConnected.bind(this));
     }
-    _handleTestConnected(e) {
-      this._testElement = e.detail;
+    _handleTestConnected(e2) {
+      this._testElement = e2.detail;
       this._initializeNavigation();
     }
     /**
      * Handle item connection events - track connected items and discover stimulus references
      */
-    _handleItemConnected(e) {
-      const itemRef = e.detail;
+    _handleItemConnected(e2) {
+      const itemRef = e2.detail;
       this._loadingState.connectedItems++;
       const stimulusRefs = itemRef.querySelectorAll("qti-assessment-stimulus-ref");
       this._loadingState.expectedStimulus += stimulusRefs.length;
@@ -109,9 +108,9 @@ var TestNavigationMixin = (superClass) => {
     /**
      * Handle stimulus reference connection events with duplicate prevention
      */
-    async _handleStimulusRefConnected(e) {
-      e.preventDefault();
-      const { element, item } = e;
+    async _handleStimulusRefConnected(e2) {
+      e2.preventDefault();
+      const { element, item } = e2;
       console.info("Stimulus ref connected:", {
         identifier: element.identifier,
         href: element.href,
@@ -248,7 +247,6 @@ var TestNavigationMixin = (superClass) => {
       const allStimulusLoaded = this._loadingState.loadedStimulus >= this._loadingState.expectedStimulus;
       if (allItemsConnected && allStimulusLoaded && !this._loadingState.isComplete) {
         this._loadingState.isComplete = true;
-        console.info("Loading complete:", this._loadingState);
       }
     }
     /**
@@ -465,39 +463,39 @@ var TestNavigationMixin = (superClass) => {
     }
   }
   __decorateClass([
-    property({ type: String })
+    n({ type: String })
   ], TestNavigationClass.prototype, "navigate", 2);
   __decorateClass([
-    property({ type: Boolean, attribute: "cache-transform" })
+    n({ type: Boolean, attribute: "cache-transform" })
   ], TestNavigationClass.prototype, "cacheTransform", 2);
   __decorateClass([
-    property({ type: Number })
+    n({ type: Number })
   ], TestNavigationClass.prototype, "requestTimeout", 2);
   __decorateClass([
-    property({ attribute: false })
+    n({ attribute: false })
   ], TestNavigationClass.prototype, "postLoadTransformCallback", 2);
   __decorateClass([
-    property({ attribute: false })
+    n({ attribute: false })
   ], TestNavigationClass.prototype, "postLoadTestTransformCallback", 2);
   return TestNavigationClass;
 };
 
-// src/lib/qti-test/core/mixins/test-view.mixin.ts
+// ../qti-test/src/mixins/test-view.mixin.ts
 var TestViewMixin = (superClass) => {
   class TestViewClass extends superClass {
     constructor(...args) {
       super(...args);
       this.sessionContext = { ...this.sessionContext, view: "candidate" };
-      this.addEventListener("on-test-switch-view", (e) => {
-        this.sessionContext = { ...this.sessionContext, view: e.detail };
+      this.addEventListener("on-test-switch-view", (e2) => {
+        this.sessionContext = { ...this.sessionContext, view: e2.detail };
         this._updateElementView();
       });
       this.addEventListener("qti-assessment-test-connected", () => {
         this._updateElementView();
       });
-      this.addEventListener("qti-assessment-item-connected", (e) => {
+      this.addEventListener("qti-assessment-item-connected", (e2) => {
         this._updateElementView();
-        this._setCorrectResponseVisibility(e.detail);
+        this._setCorrectResponseVisibility(e2.detail);
       });
     }
     willUpdate(changedProperties) {
@@ -530,146 +528,151 @@ var TestViewMixin = (superClass) => {
   return TestViewClass;
 };
 
-// src/lib/qti-test/core/test-base.ts
-import { provide } from "@lit/context";
-import { LitElement } from "lit";
-import { property as property2 } from "lit/decorators.js";
-var TestBase = class extends LitElement {
-  constructor() {
-    super();
-    this.testContext = INITIAL_TEST_CONTEXT;
-    this.sessionContext = INITIAL_SESSION_CONTEXT;
-    /**
-     * Updates the variables of an assessment item in the test context.
-     * - Matches the assessment item with the corresponding test context item.
-     * - If the item is not found, logs a warning.
-     * - Updates variables in the test context if exactly one variable exists.
-     * - Otherwise, syncs the assessment item's variables with the test context.
-     *
-     * @param assessmentItem - The assessment item to update.
-     */
-    this._updateItemInTestContext = (assessmentItem) => {
-      const context = assessmentItem._context;
-      const identifier = context.identifier;
-      const fullVariables = context.variables;
-      const itemContext = this.testContext.items.find((i) => i?.identifier === identifier);
-      if (!itemContext) {
-        console.warn(`Item IDs between assessment.xml and item.xml should match: ${identifier} is not found!`);
-        return;
-      }
-      if (itemContext.variables?.length === 1) {
-        this._updateItemVariablesInTestContext(identifier, fullVariables);
-      } else {
-        const newVariables = [...assessmentItem.variables];
-        for (const variable of itemContext.variables) {
-          const currentVariable = newVariables.find((v) => v.identifier === variable.identifier);
-          if (currentVariable) {
-            currentVariable.value = variable.value;
-          } else {
-            newVariables.push(variable);
-          }
-        }
-        assessmentItem.variables = newVariables;
-      }
-    };
-    this.addEventListener("qti-assessment-test-connected", (e) => {
+// ../qti-test/src/mixins/test-base.ts
+var TestBaseMixin = (superClass) => {
+  class TestBaseClass extends superClass {
+    constructor(...args) {
+      super(...args);
       this.testContext = INITIAL_TEST_CONTEXT;
       this.sessionContext = INITIAL_SESSION_CONTEXT;
-      if (this.testContext && this.testContext.items.length > 0) return;
-      this._testElement = e.detail;
-      const items = Array.from(this._testElement.querySelectorAll("qti-assessment-item-ref")).map((itemRef) => {
-        return {
-          href: itemRef.href,
-          identifier: itemRef.identifier,
-          category: itemRef.category,
-          variables: [
-            {
-              identifier: "completionStatus",
-              value: "not_attempted",
-              type: "outcome"
+      /**
+       * Updates the variables of an assessment item in the test context.
+       * - Matches the assessment item with the corresponding test context item.
+       * - If the item is not found, logs a warning.
+       * - Updates variables in the test context if exactly one variable exists.
+       * - Otherwise, syncs the assessment item's variables with the test context.
+       *
+       * @param assessmentItem - The assessment item to update.
+       */
+      this._updateItemInTestContext = (assessmentItem) => {
+        const context = assessmentItem._context;
+        const identifier = context.identifier;
+        const fullVariables = context.variables;
+        const itemContext = this.testContext.items.find((i4) => i4?.identifier === identifier);
+        if (!itemContext) {
+          console.warn(`Item IDs between assessment.xml and item.xml should match: ${identifier} is not found!`);
+          return;
+        }
+        if (itemContext.variables?.length === 1) {
+          this._updateItemVariablesInTestContext(identifier, fullVariables);
+        } else {
+          const newVariables = [...assessmentItem.variables];
+          for (const variable of itemContext.variables) {
+            const currentVariable = newVariables.find((v) => v.identifier === variable.identifier);
+            if (currentVariable) {
+              currentVariable.value = variable.value;
+            } else {
+              newVariables.push(variable);
             }
-          ]
-        };
-      });
-      this.testContext = { ...this.testContext, items };
-    });
-    this.addEventListener("qti-assessment-item-connected", (e) => {
-      const assessmentItem = e.detail;
-      const assessmentRefId = assessmentItem.closest("qti-assessment-item-ref")?.identifier;
-      if (assessmentRefId) {
-        assessmentItem.assessmentItemRefId = assessmentRefId;
+          }
+          assessmentItem.variables = newVariables;
+        }
+      };
+      this._initializeEventListeners();
+    }
+    updateItemVariables(itemRefID, variables) {
+      const itemContext = this.testContext.items.find((item) => item.identifier === itemRefID);
+      if (itemContext) {
+        itemContext.variables = itemContext.variables.map((variable) => {
+          const updatedVariable = variables.find((v) => v.identifier === variable.identifier);
+          return updatedVariable ? { ...variable, ...updatedVariable } : variable;
+        });
       }
-      this._updateItemInTestContext(e.detail);
-    });
-    this.addEventListener("qti-item-context-updated", (e) => {
-      this._updateItemVariablesInTestContext(e.detail.itemContext.identifier, e.detail.itemContext.variables);
-    });
-  }
-  updateItemVariables(itemRefID, variables) {
-    const itemContext = this.testContext.items.find((item) => item.identifier === itemRefID);
-    if (itemContext) {
-      itemContext.variables = itemContext.variables.map((variable) => {
-        const updatedVariable = variables.find((v) => v.identifier === variable.identifier);
-        return updatedVariable ? { ...variable, ...updatedVariable } : variable;
+      const itemRef = this._testElement.querySelector(
+        `qti-assessment-item-ref[identifier="${itemRefID}"]`
+      );
+      if (itemRef && itemRef.assessmentItem) {
+        itemRef.assessmentItem.variables = variables;
+      }
+    }
+    _initializeEventListeners() {
+      this.addEventListener("qti-assessment-test-connected", (e2) => {
+        this.testContext = INITIAL_TEST_CONTEXT;
+        this.sessionContext = INITIAL_SESSION_CONTEXT;
+        if (this.testContext && this.testContext.items.length > 0) return;
+        this._testElement = e2.detail;
+        const items = Array.from(this._testElement.querySelectorAll("qti-assessment-item-ref")).map((itemRef) => {
+          return {
+            href: itemRef.href,
+            identifier: itemRef.identifier,
+            category: itemRef.category,
+            variables: [
+              {
+                identifier: "completionStatus",
+                value: "not_attempted",
+                type: "outcome"
+              }
+            ]
+          };
+        });
+        this.testContext = { ...this.testContext, items };
+      });
+      this.addEventListener("qti-assessment-item-connected", (e2) => {
+        const assessmentItem = e2.detail;
+        const assessmentRefId = assessmentItem.closest("qti-assessment-item-ref")?.identifier;
+        if (assessmentRefId) {
+          assessmentItem.assessmentItemRefId = assessmentRefId;
+        }
+        this._updateItemInTestContext(e2.detail);
+      });
+      this.addEventListener("qti-item-context-updated", (e2) => {
+        this._updateItemVariablesInTestContext(e2.detail.itemContext.identifier, e2.detail.itemContext.variables);
       });
     }
-    const itemRef = this._testElement.querySelector(
-      `qti-assessment-item-ref[identifier="${itemRefID}"]`
-    );
-    if (itemRef && itemRef.assessmentItem) {
-      itemRef.assessmentItem.variables = variables;
+    _updateItemVariablesInTestContext(identifier, variables) {
+      this.testContext = {
+        ...this.testContext,
+        // Spread existing test context properties
+        items: this.testContext.items.map((itemContext) => {
+          if (itemContext.identifier !== identifier) {
+            return itemContext;
+          }
+          return {
+            ...itemContext,
+            // Keep other properties of the item context
+            variables: variables.map((variable) => {
+              const matchingVariable = itemContext.variables.find((v) => v.identifier === variable.identifier);
+              return matchingVariable ? { ...matchingVariable, ...variable } : variable;
+            })
+          };
+        })
+      };
+      this.dispatchEvent(
+        new CustomEvent("qti-test-context-updated", { detail: this.testContext, bubbles: false, composed: false })
+      );
     }
   }
-  _updateItemVariablesInTestContext(identifier, variables) {
-    this.testContext = {
-      ...this.testContext,
-      // Spread existing test context properties
-      items: this.testContext.items.map((itemContext) => {
-        if (itemContext.identifier !== identifier) {
-          return itemContext;
-        }
-        return {
-          ...itemContext,
-          // Keep other properties of the item context
-          variables: variables.map((variable) => {
-            const matchingVariable = itemContext.variables.find((v) => v.identifier === variable.identifier);
-            return matchingVariable ? { ...matchingVariable, ...variable } : variable;
-          })
-        };
-      })
-    };
-    this.dispatchEvent(
-      new CustomEvent("qti-test-context-updated", { detail: this.testContext, bubbles: false, composed: false })
-    );
-  }
+  __decorateClass([
+    n({ attribute: false, type: Object }),
+    e({ context: testContext })
+  ], TestBaseClass.prototype, "testContext", 2);
+  __decorateClass([
+    n({ attribute: false, type: Object }),
+    e({ context: sessionContext })
+  ], TestBaseClass.prototype, "sessionContext", 2);
+  return TestBaseClass;
+};
+var TestBase = class extends TestBaseMixin(i2) {
 };
-__decorateClass([
-  property2({ attribute: false, type: Object }),
-  provide({ context: testContext })
-], TestBase.prototype, "testContext", 2);
-__decorateClass([
-  property2({ attribute: false, type: Object }),
-  provide({ context: sessionContext })
-], TestBase.prototype, "sessionContext", 2);
 
-// src/lib/qti-test/core/mixins/test-processing.mixin.ts
+// ../qti-test/src/mixins/test-processing.mixin.ts
 var TestProcessingMixin = (superClass) => {
   class TestProcessingElement extends superClass {
     constructor(...args) {
       super(...args);
-      this.addEventListener("qti-register-variable", (e) => {
+      this.addEventListener("qti-register-variable", (e2) => {
         this.testContext = {
           ...this.testContext,
-          testOutcomeVariables: [...this.testContext.testOutcomeVariables || [], e.detail.variable]
+          testOutcomeVariables: [...this.testContext.testOutcomeVariables || [], e2.detail.variable]
         };
-        e.stopPropagation();
+        e2.stopPropagation();
       });
       this.addEventListener(
         "qti-set-outcome-value",
-        (e) => {
-          const { outcomeIdentifier, value } = e.detail;
+        (e2) => {
+          const { outcomeIdentifier, value } = e2.detail;
           this.updateOutcomeVariable(outcomeIdentifier, value);
-          e.stopPropagation();
+          e2.stopPropagation();
         }
       );
     }
@@ -710,8 +713,9 @@ var TestProcessingMixin = (superClass) => {
   return TestProcessingElement;
 };
 
-// src/lib/qti-test/core/qti-test.ts
-var QtiTest = class extends TestNavigationMixin(TestViewMixin(TestProcessingMixin(TestBase))) {
+// ../qti-test/src/components/qti-test/qti-test.ts
+var QtiTest = class extends TestNavigationMixin(TestViewMixin(TestProcessingMixin(TestBaseMixin(i2)))) {
+  // TODO: Properly implement IQtiTest interface
   // export class QtiTest extends TestLoaderMixin(TestNavigationMixin(TestViewMixin(TestBase))) {
   /**
    * Renders the component's template.
@@ -723,16 +727,14 @@ var QtiTest = class extends TestNavigationMixin(TestViewMixin(TestProcessingMixi
     this.dispatchEvent(new CustomEvent("qti-test-connected", { detail: this }));
   }
   render() {
-    return html`<slot></slot>`;
+    return x`<slot></slot>`;
   }
 };
 QtiTest = __decorateClass([
-  customElement("qti-test")
+  t("qti-test")
 ], QtiTest);
 
-// src/lib/qti-test/core/qti-assessment-test/qti-assessment-item-ref.ts
-import { LitElement as LitElement2 } from "lit";
-import { property as property3 } from "lit/decorators.js";
+// ../qti-test/src/components/qti-assessment-item-ref/qti-assessment-item-ref.ts
 var stringToBooleanConverter = {
   fromAttribute(value) {
     return value === "true";
@@ -741,7 +743,7 @@ var stringToBooleanConverter = {
     return value ? "true" : "false";
   }
 };
-var QtiAssessmentItemRef = class extends LitElement2 {
+var QtiAssessmentItemRef = class extends i2 {
   constructor() {
     super(...arguments);
     // @consume({ context: computedContext, subscribe: true })
@@ -771,31 +773,28 @@ var QtiAssessmentItemRef = class extends LitElement2 {
   }
 };
 __decorateClass([
-  property3({ type: String })
+  n({ type: String })
 ], QtiAssessmentItemRef.prototype, "category", 2);
 __decorateClass([
-  property3({ type: String })
+  n({ type: String })
 ], QtiAssessmentItemRef.prototype, "identifier", 2);
 __decorateClass([
-  property3({ type: Boolean, converter: stringToBooleanConverter })
+  n({ type: Boolean, converter: stringToBooleanConverter })
 ], QtiAssessmentItemRef.prototype, "required", 2);
 __decorateClass([
-  property3({ type: Boolean, converter: stringToBooleanConverter })
+  n({ type: Boolean, converter: stringToBooleanConverter })
 ], QtiAssessmentItemRef.prototype, "fixed", 2);
 __decorateClass([
-  property3({ type: String })
+  n({ type: String })
 ], QtiAssessmentItemRef.prototype, "href", 2);
 __decorateClass([
-  property3({ type: Object, attribute: false })
+  n({ type: Object, attribute: false })
 ], QtiAssessmentItemRef.prototype, "xmlDoc", 2);
 if (!customElements.get("qti-assessment-item-ref")) {
   customElements.define("qti-assessment-item-ref", QtiAssessmentItemRef);
 }
 
-// src/lib/qti-test/core/qti-assessment-test/qti-assessment-section.ts
-import { consume } from "@lit/context";
-import { html as html2, LitElement as LitElement3 } from "lit";
-import { property as property4 } from "lit/decorators.js";
+// ../qti-test/src/components/qti-assessment-section/qti-assessment-section.ts
 var stringToBooleanConverter2 = {
   fromAttribute(value) {
     return value === "true";
@@ -804,7 +803,7 @@ var stringToBooleanConverter2 = {
     return value ? "true" : "false";
   }
 };
-var QtiAssessmentSection = class extends LitElement3 {
+var QtiAssessmentSection = class extends i2 {
   constructor() {
     super(...arguments);
     this._title = "";
@@ -829,36 +828,33 @@ var QtiAssessmentSection = class extends LitElement3 {
     );
   }
   render() {
-    return html2`<slot name="qti-rubric-block"></slot><slot></slot>`;
+    return x`<slot name="qti-rubric-block"></slot><slot></slot>`;
   }
 };
 __decorateClass([
-  property4({ type: String })
+  n({ type: String })
 ], QtiAssessmentSection.prototype, "identifier", 2);
 __decorateClass([
-  property4({ type: String })
+  n({ type: String })
 ], QtiAssessmentSection.prototype, "required", 2);
 __decorateClass([
-  property4({ type: Boolean, converter: stringToBooleanConverter2 })
+  n({ type: Boolean, converter: stringToBooleanConverter2 })
 ], QtiAssessmentSection.prototype, "fixed", 2);
 __decorateClass([
-  property4({ type: Boolean, converter: stringToBooleanConverter2 })
+  n({ type: Boolean, converter: stringToBooleanConverter2 })
 ], QtiAssessmentSection.prototype, "visible", 2);
 __decorateClass([
-  property4({ type: Boolean, converter: stringToBooleanConverter2, attribute: "keep-together" })
+  n({ type: Boolean, converter: stringToBooleanConverter2, attribute: "keep-together" })
 ], QtiAssessmentSection.prototype, "keepTogether", 2);
 __decorateClass([
-  consume({ context: testContext, subscribe: true })
+  c({ context: testContext, subscribe: true })
 ], QtiAssessmentSection.prototype, "_testContext", 2);
 if (!customElements.get("qti-assessment-section")) {
   customElements.define("qti-assessment-section", QtiAssessmentSection);
 }
 
-// src/lib/qti-test/core/qti-assessment-test/qti-assessment-test.ts
-import { consume as consume2 } from "@lit/context";
-import { html as html3, LitElement as LitElement4 } from "lit";
-import { customElement as customElement2, property as property5 } from "lit/decorators.js";
-var QtiAssessmentTest = class extends LitElement4 {
+// ../qti-test/src/components/qti-assessment-test/qti-assessment-test.ts
+var QtiAssessmentTest = class extends i2 {
   constructor() {
     super(...arguments);
     this._title = "";
@@ -883,26 +879,24 @@ var QtiAssessmentTest = class extends LitElement4 {
     );
   }
   render() {
-    return html3` <slot></slot>`;
+    return x` <slot></slot>`;
   }
 };
 __decorateClass([
-  property5({ type: String })
+  n({ type: String })
 ], QtiAssessmentTest.prototype, "identifier", 2);
 __decorateClass([
-  property5({ type: String })
+  n({ type: String })
 ], QtiAssessmentTest.prototype, "title", 1);
 __decorateClass([
-  consume2({ context: testContext, subscribe: true })
+  c({ context: testContext, subscribe: true })
 ], QtiAssessmentTest.prototype, "_testContext", 2);
 QtiAssessmentTest = __decorateClass([
-  customElement2("qti-assessment-test")
+  t("qti-assessment-test")
 ], QtiAssessmentTest);
 
-// src/lib/qti-test/core/qti-assessment-test/qti-test-part.ts
-import { html as html4, LitElement as LitElement5 } from "lit";
-import { customElement as customElement3, property as property6 } from "lit/decorators.js";
-var QtiTestPart = class extends LitElement5 {
+// ../qti-test/src/components/qti-test-part/qti-test-part.ts
+var QtiTestPart = class extends i2 {
   constructor() {
     super(...arguments);
     this.identifier = "";
@@ -930,50 +924,45 @@ var QtiTestPart = class extends LitElement5 {
     );
   }
   render() {
-    return html4` <slot></slot>`;
+    return x` <slot></slot>`;
   }
 };
 __decorateClass([
-  property6({ type: String })
+  n({ type: String })
 ], QtiTestPart.prototype, "identifier", 2);
 __decorateClass([
-  property6({ type: String })
+  n({ type: String })
 ], QtiTestPart.prototype, "class", 2);
 __decorateClass([
-  property6({ type: String, attribute: "navigation-mode" })
+  n({ type: String, attribute: "navigation-mode" })
 ], QtiTestPart.prototype, "navigationMode", 2);
 __decorateClass([
-  property6({ type: String, attribute: "submission-mode" })
+  n({ type: String, attribute: "submission-mode" })
 ], QtiTestPart.prototype, "submissionMode", 2);
 QtiTestPart = __decorateClass([
-  customElement3("qti-test-part")
+  t("qti-test-part")
 ], QtiTestPart);
 if (!customElements.get("qti-test-part")) {
   customElements.define("qti-test-part", QtiTestPart);
 }
 
-// src/lib/qti-test/core/qti-assessment-test/qti-test-feedback.ts
-import { customElement as customElement4 } from "lit/decorators.js";
-import { css, html as html5 } from "lit";
+// ../qti-test/src/components/qti-test-feedback/qti-test-feedback.ts
 var QtiTestFeedback = class extends QtiModalFeedback {
   render() {
-    return html5``;
+    return x``;
   }
 };
-QtiTestFeedback.styles = css`
+QtiTestFeedback.styles = i`
     :host {
       color: gray;
     }
   `;
 QtiTestFeedback = __decorateClass([
-  customElement4("qti-test-feedback")
+  t("qti-test-feedback")
 ], QtiTestFeedback);
 
-// src/lib/qti-test/components/test-navigation.ts
-import { consume as consume3, provide as provide2 } from "@lit/context";
-import { html as html6, LitElement as LitElement6 } from "lit";
-import { customElement as customElement5, property as property7, state } from "lit/decorators.js";
-var TestNavigation = class extends LitElement6 {
+// ../qti-test/src/components/test-navigation/test-navigation.ts
+var TestNavigation = class extends i2 {
   constructor() {
     super();
     this.identifier = void 0;
@@ -1058,7 +1047,9 @@ var TestNavigation = class extends LitElement6 {
   }
   _handleInteractionChanged(_event) {
     if (this.autoScoreItems) {
-      const assessmentItem = _event.composedPath()[0].closest("qti-assessment-item");
+      const assessmentItem = _event.composedPath()[0].closest(
+        "qti-assessment-item"
+      );
       const scoreOutcomeIdentifier = assessmentItem.variables.find((v) => v.identifier === "SCORE");
       if (scoreOutcomeIdentifier && scoreOutcomeIdentifier.externalScored === null && assessmentItem.adaptive === "false") {
         const reportValidityAfterScoring = this.configContext?.reportValidityAfterScoring === true ? true : false;
@@ -1067,7 +1058,7 @@ var TestNavigation = class extends LitElement6 {
     }
   }
   render() {
-    return html6`<slot></slot>`;
+    return x`<slot></slot>`;
   }
   /* PK: on test connected we can build the computed context */
   _handleTestConnected(event) {
@@ -1119,7 +1110,7 @@ var TestNavigation = class extends LitElement6 {
               identifier: section.identifier,
               title: section.title,
               items: itemElements.map((item) => ({
-                ...this.initContext?.find((i) => i.identifier === item.identifier),
+                ...this.initContext?.find((i4) => i4.identifier === item.identifier),
                 active: false,
                 identifier: item.identifier,
                 categories: item.category ? item.category?.split(" ") : [],
@@ -1190,11 +1181,11 @@ var TestNavigation = class extends LitElement6 {
                 const externalScored = scoreOutcome?.getAttribute("externalScored");
                 const responseDeclarations = itemElement.querySelectorAll("qti-response-declaration");
                 const containsCorrectResponse = Array.from(responseDeclarations).some(
-                  (r) => r.querySelector("qti-correct-response")
+                  (r3) => r3.querySelector("qti-correct-response")
                 );
-                const containsMapping = Array.from(responseDeclarations).some((r) => {
-                  const mapping = r.querySelector("qti-mapping");
-                  const areaMapping = r.querySelector("qti-area-mapping");
+                const containsMapping = Array.from(responseDeclarations).some((r3) => {
+                  const mapping = r3.querySelector("qti-mapping");
+                  const areaMapping = r3.querySelector("qti-area-mapping");
                   return mapping?.querySelector("qti-map-entry") || areaMapping?.querySelector("qti-area-map-entry");
                 });
                 const hasCorrectResponse = containsCorrectResponse || containsMapping;
@@ -1234,14 +1225,14 @@ var TestNavigation = class extends LitElement6 {
               ...section,
               active: this._sessionContext?.navSectionId === section.identifier || false,
               completed: section.items.every(
-                (item) => this._testContext.items.find((i) => i.identifier === item.identifier)?.variables.find((v) => v.identifier === "completionStatus").value === "completed"
+                (item) => this._testContext.items.find((i4) => i4.identifier === item.identifier)?.variables.find((v) => v.identifier === "completionStatus").value === "completed"
               ),
               items: section.items.map((item) => {
-                const itemContext = this._testContext?.items.find((i) => i.identifier === item.identifier);
+                const itemContext = this._testContext?.items.find((i4) => i4.identifier === item.identifier);
                 const computedItem = {
                   ...item,
                   ...itemContext,
-                  ...this.initContext?.find((i) => i.identifier === item.identifier)
+                  ...this.initContext?.find((i4) => i4.identifier === item.identifier)
                 };
                 const rawscore = computedItem.variables?.find((vr) => vr.identifier == "SCORE")?.value;
                 const score = rawscore === void 0 || rawscore === null ? null : parseFloat(rawscore?.toString());
@@ -1281,46 +1272,40 @@ var TestNavigation = class extends LitElement6 {
   }
 };
 __decorateClass([
-  property7({ type: String })
+  n({ type: String })
 ], TestNavigation.prototype, "identifier", 2);
 __decorateClass([
-  state()
+  r()
 ], TestNavigation.prototype, "initContext", 2);
 __decorateClass([
-  state(),
-  provide2({ context: qtiContext })
+  r(),
+  e({ context: qtiContext })
 ], TestNavigation.prototype, "qtiContext", 2);
 __decorateClass([
-  state(),
-  provide2({ context: configContext })
+  r(),
+  e({ context: configContext })
 ], TestNavigation.prototype, "configContext", 2);
 __decorateClass([
-  state(),
-  consume3({ context: testContext, subscribe: true })
+  r(),
+  c({ context: testContext, subscribe: true })
 ], TestNavigation.prototype, "_testContext", 2);
 __decorateClass([
-  state(),
-  consume3({ context: sessionContext, subscribe: true })
+  r(),
+  c({ context: sessionContext, subscribe: true })
 ], TestNavigation.prototype, "_sessionContext", 2);
 __decorateClass([
-  state(),
-  provide2({ context: computedContext })
+  r(),
+  e({ context: computedContext })
 ], TestNavigation.prototype, "computedContext", 2);
 __decorateClass([
-  property7({ type: Boolean, attribute: "auto-score-items" })
+  n({ type: Boolean, attribute: "auto-score-items" })
 ], TestNavigation.prototype, "autoScoreItems", 2);
 TestNavigation = __decorateClass([
-  customElement5("test-navigation")
+  t("test-navigation")
 ], TestNavigation);
 
-// src/lib/qti-test/components/test-next.ts
-import { css as css3, html as html7, LitElement as LitElement7 } from "lit";
-import { customElement as customElement6, property as property8 } from "lit/decorators.js";
-import { consume as consume4 } from "@lit/context";
-
-// src/lib/qti-test/components/styles.ts
-import { css as css2 } from "lit";
-var form = css2`
+// ../qti-test/src/components/styles.ts
+var form = i`
   display: inline-flex;
   align-items: center;
   cursor: pointer;
@@ -1328,29 +1313,29 @@ var form = css2`
   border-radius: 0.25rem;
   user-select: none;
 `;
-var btn = css2`
+var btn = i`
   background-color: lightgray;
   ${form};
 `;
-var dis = css2`
+var dis = i`
   cursor: not-allowed;
   opacity: 0.8;
 `;
-var ind = css2`
+var ind = i`
   ${form};
   border: 1px solid gray;
 `;
 
-// src/lib/qti-test/components/test-next.ts
-var TestNext = class extends LitElement7 {
+// ../qti-test/src/components/test-next/test-next.ts
+var TestNext = class extends i2 {
   constructor() {
     super();
     this._internalDisabled = true;
     this._internals = this.attachInternals();
     this._internals.role = "button";
     this._internals.ariaLabel = "Next item";
-    this.addEventListener("click", (e) => {
-      e.preventDefault();
+    this.addEventListener("click", (e2) => {
+      e2.preventDefault();
       if (!this._internalDisabled) this._requestItem(this.sectionItems[this.itemIndex + 1].identifier);
     });
   }
@@ -1387,10 +1372,10 @@ var TestNext = class extends LitElement7 {
     );
   }
   render() {
-    return html7`<slot></slot>`;
+    return x`<slot></slot>`;
   }
 };
-TestNext.styles = css3`
+TestNext.styles = i`
     :host {
       ${btn};
     }
@@ -1399,28 +1384,25 @@ TestNext.styles = css3`
     }
   `;
 __decorateClass([
-  property8({ type: Boolean, reflect: true, attribute: "disabled" })
+  n({ type: Boolean, reflect: true, attribute: "disabled" })
 ], TestNext.prototype, "_internalDisabled", 2);
 __decorateClass([
-  consume4({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestNext.prototype, "computedContext", 2);
 __decorateClass([
   watch("computedContext")
 ], TestNext.prototype, "_handleTestElementChange", 1);
 TestNext = __decorateClass([
-  customElement6("test-next")
+  t("test-next")
 ], TestNext);
 
-// src/lib/qti-test/components/test-prev.ts
-import { css as css4, html as html8, LitElement as LitElement8 } from "lit";
-import { customElement as customElement7, property as property9 } from "lit/decorators.js";
-import { consume as consume5 } from "@lit/context";
-var TestPrev = class extends LitElement8 {
+// ../qti-test/src/components/test-prev/test-prev.ts
+var TestPrev = class extends i2 {
   constructor() {
     super();
     this._internalDisabled = true;
-    this.addEventListener("click", (e) => {
-      e.preventDefault();
+    this.addEventListener("click", (e2) => {
+      e2.preventDefault();
       if (!this._internalDisabled) this._requestItem(this.sectionItems[this.itemIndex - 1].identifier);
     });
   }
@@ -1453,10 +1435,10 @@ var TestPrev = class extends LitElement8 {
     );
   }
   render() {
-    return html8`<slot></slot>`;
+    return x`<slot></slot>`;
   }
 };
-TestPrev.styles = css4`
+TestPrev.styles = i`
     :host {
       ${btn};
     }
@@ -1465,23 +1447,20 @@ TestPrev.styles = css4`
     }
   `;
 __decorateClass([
-  property9({ type: Boolean, reflect: true, attribute: "disabled" })
+  n({ type: Boolean, reflect: true, attribute: "disabled" })
 ], TestPrev.prototype, "_internalDisabled", 2);
 __decorateClass([
-  consume5({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestPrev.prototype, "computedContext", 2);
 __decorateClass([
   watch("computedContext")
 ], TestPrev.prototype, "_handleTestElementChange", 1);
 TestPrev = __decorateClass([
-  customElement7("test-prev")
+  t("test-prev")
 ], TestPrev);
 
-// src/lib/qti-test/components/test-view.ts
-import { html as html9, LitElement as LitElement9 } from "lit";
-import { customElement as customElement8, property as property10, state as state2 } from "lit/decorators.js";
-import { consume as consume6 } from "@lit/context";
-var TestView = class extends LitElement9 {
+// ../qti-test/src/components/test-view-toggle/test-view.ts
+var TestView = class extends i2 {
   constructor() {
     super(...arguments);
     this.label = "view";
@@ -1512,18 +1491,18 @@ var TestView = class extends LitElement9 {
     );
   }
   render() {
-    return html9`
+    return x`
       <label part="label" for="viewSelect">${this.label}</label>
       <select
         part="select"
         id="viewSelect"
-        @change=${(e) => {
-      const el = e.target;
+        @change=${(e2) => {
+      const el = e2.target;
       this._switchView(el.value);
     }}
       >
         ${this._viewOptions.map(
-      (v) => html9`<option value="${v}" ?selected=${v === this.sessionContext.view}>${v}</option>`
+      (v) => x`<option value="${v}" ?selected=${v === this.sessionContext.view}>${v}</option>`
     )}
       </select>
     `;
@@ -1531,28 +1510,26 @@ var TestView = class extends LitElement9 {
 };
 TestView.DEFAULT_VIEW_OPTIONS = ["author", "candidate", "proctor", "scorer", "testConstructor", "tutor"];
 __decorateClass([
-  consume6({ context: sessionContext, subscribe: true })
+  c({ context: sessionContext, subscribe: true })
 ], TestView.prototype, "sessionContext", 2);
 __decorateClass([
-  property10({ type: String })
+  n({ type: String })
 ], TestView.prototype, "label", 2);
 __decorateClass([
-  property10({ type: String, attribute: "view-options" })
+  n({ type: String, attribute: "view-options" })
 ], TestView.prototype, "viewOptions", 2);
 __decorateClass([
   watch("viewOptions", { waitUntilFirstUpdate: true })
 ], TestView.prototype, "_handleViewOptionsChange", 2);
 __decorateClass([
-  state2()
+  r()
 ], TestView.prototype, "_viewOptions", 2);
 TestView = __decorateClass([
-  customElement8("test-view")
+  t("test-view")
 ], TestView);
 
-// src/lib/qti-test/components/test-item-link.ts
-import { css as css5, html as html10, LitElement as LitElement10 } from "lit";
-import { customElement as customElement9, property as property11 } from "lit/decorators.js";
-var TestItemLink = class extends LitElement10 {
+// ../qti-test/src/components/test-item-link/test-item-link.ts
+var TestItemLink = class extends i2 {
   constructor() {
     super();
     this.itemId = null;
@@ -1571,10 +1548,10 @@ var TestItemLink = class extends LitElement10 {
     );
   }
   render() {
-    return html10` <slot></slot> `;
+    return x` <slot></slot> `;
   }
 };
-TestItemLink.styles = css5`
+TestItemLink.styles = i`
     :host {
       ${btn};
     }
@@ -1583,25 +1560,23 @@ TestItemLink.styles = css5`
     }
   `;
 __decorateClass([
-  property11({ type: String, attribute: "item-id" })
+  n({ type: String, attribute: "item-id" })
 ], TestItemLink.prototype, "itemId", 2);
 TestItemLink = __decorateClass([
-  customElement9("test-item-link")
+  t("test-item-link")
 ], TestItemLink);
 
-// src/lib/qti-test/components/test-end-attempt.ts
-import { css as css6, html as html11, LitElement as LitElement11 } from "lit";
-import { customElement as customElement10 } from "lit/decorators.js";
-var TestEndAttempt = class extends LitElement11 {
+// ../qti-test/src/components/test-end-attempt/test-end-attempt.ts
+var TestEndAttempt = class extends i2 {
   constructor() {
     super();
     this.addEventListener("click", () => this.dispatchEvent(new CustomEvent("test-end-attempt", { bubbles: true })));
   }
   render() {
-    return html11` <slot></slot> `;
+    return x` <slot></slot> `;
   }
 };
-TestEndAttempt.styles = css6`
+TestEndAttempt.styles = i`
     :host {
       ${btn};
     }
@@ -1610,14 +1585,11 @@ TestEndAttempt.styles = css6`
     }
   `;
 TestEndAttempt = __decorateClass([
-  customElement10("test-end-attempt")
+  t("test-end-attempt")
 ], TestEndAttempt);
 
-// src/lib/qti-test/components/test-show-correct-response.ts
-import { css as css7, html as html12, LitElement as LitElement12 } from "lit";
-import { customElement as customElement11, property as property12 } from "lit/decorators.js";
-import { consume as consume7 } from "@lit/context";
-var TestShowCorrectResponse = class extends LitElement12 {
+// ../qti-test/src/components/test-show-correct-response/test-show-correct-response.ts
+var TestShowCorrectResponse = class extends i2 {
   constructor() {
     super(...arguments);
     this.shown = false;
@@ -1657,10 +1629,10 @@ var TestShowCorrectResponse = class extends LitElement12 {
     return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
   }
   render() {
-    return html12` <div @click="${this._toggleState}">${this._getDisplayedText()}</div> `;
+    return x` <div @click="${this._toggleState}">${this._getDisplayedText()}</div> `;
   }
 };
-TestShowCorrectResponse.styles = css7`
+TestShowCorrectResponse.styles = i`
     :host {
       ${btn};
     }
@@ -1669,33 +1641,1112 @@ TestShowCorrectResponse.styles = css7`
     }
   `;
 __decorateClass([
-  consume7({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestShowCorrectResponse.prototype, "computedContext", 2);
 __decorateClass([
-  property12({ type: Boolean, reflect: true })
+  n({ type: Boolean, reflect: true })
 ], TestShowCorrectResponse.prototype, "shown", 2);
 __decorateClass([
-  property12({ type: Boolean, reflect: true })
+  n({ type: Boolean, reflect: true })
 ], TestShowCorrectResponse.prototype, "disabled", 2);
 __decorateClass([
-  property12({ type: String })
+  n({ type: String })
 ], TestShowCorrectResponse.prototype, "showCorrectText", 2);
 __decorateClass([
-  property12({ type: String })
+  n({ type: String })
 ], TestShowCorrectResponse.prototype, "hideCorrectText", 2);
 __decorateClass([
-  property12({ type: String })
+  n({ type: String })
 ], TestShowCorrectResponse.prototype, "noCorrectResponseText", 2);
 TestShowCorrectResponse = __decorateClass([
-  customElement11("test-show-correct-response")
+  t("test-show-correct-response")
 ], TestShowCorrectResponse);
 
-// src/lib/qti-test/components/test-paging-buttons-stamp.ts
-import { html as html13, LitElement as LitElement13 } from "lit";
-import { customElement as customElement12 } from "lit/decorators.js";
-import { prepareTemplate } from "@heximal/templates";
-import { consume as consume8 } from "@lit/context";
-var TestPagingButtonsStamp = class extends LitElement13 {
+// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/constants.js
+var KEYWORDS = ["this"];
+var UNARY_OPERATORS = ["+", "-", "!"];
+var BINARY_OPERATORS = [
+  "=",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "^",
+  "==",
+  "!=",
+  ">",
+  "<",
+  ">=",
+  "<=",
+  "||",
+  "&&",
+  "??",
+  "&",
+  "===",
+  "!==",
+  "|",
+  "|>"
+];
+var PRECEDENCE = {
+  "!": 0,
+  ":": 0,
+  ",": 0,
+  ")": 0,
+  "]": 0,
+  "}": 0,
+  "|>": 1,
+  "?": 2,
+  "??": 3,
+  "||": 4,
+  "&&": 5,
+  "|": 6,
+  "^": 7,
+  "&": 8,
+  // equality
+  "!=": 9,
+  "==": 9,
+  "!==": 9,
+  "===": 9,
+  // relational
+  ">=": 10,
+  ">": 10,
+  "<=": 10,
+  "<": 10,
+  // additive
+  "+": 11,
+  "-": 11,
+  // multiplicative
+  "%": 12,
+  "/": 12,
+  "*": 12,
+  // postfix
+  "(": 13,
+  "[": 13,
+  ".": 13,
+  "{": 13
+  // not sure this is correct
+};
+var POSTFIX_PRECEDENCE = 13;
+
+// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/tokenizer.js
+var TWO_CHAR_OPS = ["==", "!=", "<=", ">=", "||", "&&", "??", "|>"];
+var THREE_CHAR_OPS = ["===", "!=="];
+var Kind;
+(function(Kind2) {
+  Kind2[Kind2["STRING"] = 1] = "STRING";
+  Kind2[Kind2["IDENTIFIER"] = 2] = "IDENTIFIER";
+  Kind2[Kind2["DOT"] = 3] = "DOT";
+  Kind2[Kind2["COMMA"] = 4] = "COMMA";
+  Kind2[Kind2["COLON"] = 5] = "COLON";
+  Kind2[Kind2["INTEGER"] = 6] = "INTEGER";
+  Kind2[Kind2["DECIMAL"] = 7] = "DECIMAL";
+  Kind2[Kind2["OPERATOR"] = 8] = "OPERATOR";
+  Kind2[Kind2["GROUPER"] = 9] = "GROUPER";
+  Kind2[Kind2["KEYWORD"] = 10] = "KEYWORD";
+  Kind2[Kind2["ARROW"] = 11] = "ARROW";
+})(Kind || (Kind = {}));
+var token = (kind, value, precedence = 0) => ({
+  kind,
+  value,
+  precedence
+});
+var isWhitespace = (ch) => ch === 9 || ch === 10 || ch === 13 || ch === 32;
+var isIdentOrKeywordStart = (ch) => ch === 95 || ch === 36 || // ch &= ~32 puts ch into the range [65,90] [A-Z] only if ch was already in
+// the that range or in the range [97,122] [a-z]. We must mutate ch only after
+// checking other characters, thus the comma operator.
+(ch &= ~32, 65 <= ch && ch <= 90);
+var isIdentifier = (ch) => isIdentOrKeywordStart(ch) || isNumber(ch);
+var isKeyword = (str) => KEYWORDS.indexOf(str) !== -1;
+var isQuote = (ch) => ch === 34 || ch === 39;
+var isNumber = (ch) => 48 <= ch && ch <= 57;
+var isOperator = (ch) => ch === 43 || ch === 45 || ch === 42 || ch === 47 || ch === 33 || ch === 38 || ch === 37 || ch === 60 || ch === 61 || ch === 62 || ch === 63 || ch === 94 || ch === 124;
+var _isGrouper = (ch) => ch === 40 || ch === 41 || ch === 91 || ch === 93 || ch === 123 || ch === 125;
+var escapeString = (str) => str.replace(/\\(.)/g, (_match, group) => {
+  switch (group) {
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "t":
+      return "	";
+    case "b":
+      return "\b";
+    case "f":
+      return "\f";
+    default:
+      return group;
+  }
+});
+var Tokenizer = class {
+  #input;
+  #index = -1;
+  #tokenStart = 0;
+  #next;
+  constructor(input) {
+    this.#input = input;
+    this.#advance();
+  }
+  nextToken() {
+    while (isWhitespace(this.#next)) {
+      this.#advance(true);
+    }
+    if (isQuote(this.#next))
+      return this.#tokenizeString();
+    if (isIdentOrKeywordStart(this.#next)) {
+      return this.#tokenizeIdentOrKeyword();
+    }
+    if (isNumber(this.#next))
+      return this.#tokenizeNumber();
+    if (this.#next === 46)
+      return this.#tokenizeDot();
+    if (this.#next === 44)
+      return this.#tokenizeComma();
+    if (this.#next === 58)
+      return this.#tokenizeColon();
+    if (isOperator(this.#next))
+      return this.#tokenizeOperator();
+    if (_isGrouper(this.#next))
+      return this.#tokenizeGrouper();
+    this.#advance();
+    if (this.#next !== void 0) {
+      throw new Error(`Expected end of input, got ${this.#next}`);
+    }
+    return void 0;
+  }
+  #advance(resetTokenStart) {
+    this.#index++;
+    if (this.#index < this.#input.length) {
+      this.#next = this.#input.charCodeAt(this.#index);
+      if (resetTokenStart === true) {
+        this.#tokenStart = this.#index;
+      }
+    } else {
+      this.#next = void 0;
+    }
+  }
+  #getValue(lookahead = 0) {
+    const v = this.#input.substring(this.#tokenStart, this.#index + lookahead);
+    if (lookahead === 0) {
+      this.#clearValue();
+    }
+    return v;
+  }
+  #clearValue() {
+    this.#tokenStart = this.#index;
+  }
+  #tokenizeString() {
+    const _us = "unterminated string";
+    const quoteChar = this.#next;
+    this.#advance(true);
+    while (this.#next !== quoteChar) {
+      if (this.#next === void 0)
+        throw new Error(_us);
+      if (this.#next === 92) {
+        this.#advance();
+        if (this.#next === void 0)
+          throw new Error(_us);
+      }
+      this.#advance();
+    }
+    const t2 = token(Kind.STRING, escapeString(this.#getValue()));
+    this.#advance();
+    return t2;
+  }
+  #tokenizeIdentOrKeyword() {
+    do {
+      this.#advance();
+    } while (isIdentifier(this.#next));
+    const value = this.#getValue();
+    const kind = isKeyword(value) ? Kind.KEYWORD : Kind.IDENTIFIER;
+    return token(kind, value);
+  }
+  #tokenizeNumber() {
+    do {
+      this.#advance();
+    } while (isNumber(this.#next));
+    if (this.#next === 46)
+      return this.#tokenizeDot();
+    return token(Kind.INTEGER, this.#getValue());
+  }
+  #tokenizeDot() {
+    this.#advance();
+    if (isNumber(this.#next))
+      return this.#tokenizeFraction();
+    this.#clearValue();
+    return token(Kind.DOT, ".", POSTFIX_PRECEDENCE);
+  }
+  #tokenizeComma() {
+    this.#advance(true);
+    return token(Kind.COMMA, ",");
+  }
+  #tokenizeColon() {
+    this.#advance(true);
+    return token(Kind.COLON, ":");
+  }
+  #tokenizeFraction() {
+    do {
+      this.#advance();
+    } while (isNumber(this.#next));
+    return token(Kind.DECIMAL, this.#getValue());
+  }
+  #tokenizeOperator() {
+    this.#advance();
+    let op = this.#getValue(2);
+    if (THREE_CHAR_OPS.indexOf(op) !== -1) {
+      this.#advance();
+      this.#advance();
+    } else {
+      op = this.#getValue(1);
+      if (op === "=>") {
+        this.#advance();
+        return token(Kind.ARROW, op);
+      }
+      if (TWO_CHAR_OPS.indexOf(op) !== -1) {
+        this.#advance();
+      }
+    }
+    op = this.#getValue();
+    return token(Kind.OPERATOR, op, PRECEDENCE[op]);
+  }
+  #tokenizeGrouper() {
+    const value = String.fromCharCode(this.#next);
+    const t2 = token(Kind.GROUPER, value, PRECEDENCE[value]);
+    this.#advance(true);
+    return t2;
+  }
+};
+
+// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/parser.js
+var parse = (expr, astFactory2) => new Parser(expr, astFactory2).parse();
+var Parser = class {
+  #kind;
+  #tokenizer;
+  #ast;
+  #token;
+  #value;
+  constructor(input, astFactory2) {
+    this.#tokenizer = new Tokenizer(input);
+    this.#ast = astFactory2;
+  }
+  parse() {
+    this.#advance();
+    return this.#parseExpression();
+  }
+  #advance(kind, value) {
+    if (!this._matches(kind, value)) {
+      throw new Error(`Expected kind ${kind} (${value}), was ${this.#token?.kind} (${this.#token?.value})`);
+    }
+    const t2 = this.#tokenizer.nextToken();
+    this.#token = t2;
+    this.#kind = t2?.kind;
+    this.#value = t2?.value;
+  }
+  _matches(kind, value) {
+    return !(kind && this.#kind !== kind || value && this.#value !== value);
+  }
+  #parseExpression() {
+    if (!this.#token)
+      return this.#ast.empty();
+    const expr = this.#parseUnary();
+    return expr === void 0 ? void 0 : this.#parsePrecedence(expr, 0);
+  }
+  // #parsePrecedence and #parseBinary implement the precedence climbing
+  // algorithm as described in:
+  // http://en.wikipedia.org/wiki/Operator-precedence_parser#Precedence_climbing_method
+  #parsePrecedence(left, precedence) {
+    if (left === void 0) {
+      throw new Error("Expected left to be defined.");
+    }
+    while (this.#token) {
+      if (this._matches(Kind.GROUPER, "(")) {
+        const args = this.#parseArguments();
+        left = this.#ast.invoke(left, void 0, args);
+      } else if (this._matches(Kind.GROUPER, "[")) {
+        const indexExpr = this.#parseIndex();
+        left = this.#ast.index(left, indexExpr);
+      } else if (this._matches(Kind.DOT)) {
+        this.#advance();
+        const right = this.#parseUnary();
+        left = this.#makeInvokeOrGetter(left, right);
+      } else if (this._matches(Kind.KEYWORD)) {
+        break;
+      } else if (this._matches(Kind.OPERATOR) && this.#token.precedence >= precedence) {
+        left = this.#value === "?" ? this.#parseTernary(left) : this.#parseBinary(left, this.#token);
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  #makeInvokeOrGetter(left, right) {
+    if (right === void 0) {
+      throw new Error("expected identifier");
+    }
+    if (right.type === "ID") {
+      return this.#ast.getter(left, right.value);
+    } else if (right.type === "Invoke" && right.receiver.type === "ID") {
+      const method = right.receiver;
+      return this.#ast.invoke(left, method.value, right.arguments);
+    } else {
+      throw new Error(`expected identifier: ${right}`);
+    }
+  }
+  #parseBinary(left, op) {
+    if (BINARY_OPERATORS.indexOf(op.value) === -1) {
+      throw new Error(`unknown operator: ${op.value}`);
+    }
+    this.#advance();
+    let right = this.#parseUnary();
+    while ((this.#kind === Kind.OPERATOR || this.#kind === Kind.DOT || this.#kind === Kind.GROUPER) && this.#token.precedence > op.precedence) {
+      right = this.#parsePrecedence(right, this.#token.precedence);
+    }
+    return this.#ast.binary(left, op.value, right);
+  }
+  #parseUnary() {
+    if (this._matches(Kind.OPERATOR)) {
+      const value = this.#value;
+      this.#advance();
+      if (value === "+" || value === "-") {
+        if (this._matches(Kind.INTEGER)) {
+          return this.#parseInteger(value);
+        } else if (this._matches(Kind.DECIMAL)) {
+          return this.#parseDecimal(value);
+        }
+      }
+      if (UNARY_OPERATORS.indexOf(value) === -1)
+        throw new Error(`unexpected token: ${value}`);
+      const expr = this.#parsePrecedence(this.#parsePrimary(), POSTFIX_PRECEDENCE);
+      return this.#ast.unary(value, expr);
+    }
+    return this.#parsePrimary();
+  }
+  #parseTernary(condition) {
+    this.#advance(Kind.OPERATOR, "?");
+    const trueExpr = this.#parseExpression();
+    this.#advance(Kind.COLON);
+    const falseExpr = this.#parseExpression();
+    return this.#ast.ternary(condition, trueExpr, falseExpr);
+  }
+  #parsePrimary() {
+    switch (this.#kind) {
+      case Kind.KEYWORD:
+        const keyword = this.#value;
+        if (keyword === "this") {
+          this.#advance();
+          return this.#ast.id(keyword);
+        } else if (KEYWORDS.indexOf(keyword) !== -1) {
+          throw new Error(`unexpected keyword: ${keyword}`);
+        }
+        throw new Error(`unrecognized keyword: ${keyword}`);
+      case Kind.IDENTIFIER:
+        return this.#parseInvokeOrIdentifier();
+      case Kind.STRING:
+        return this.#parseString();
+      case Kind.INTEGER:
+        return this.#parseInteger();
+      case Kind.DECIMAL:
+        return this.#parseDecimal();
+      case Kind.GROUPER:
+        if (this.#value === "(") {
+          return this.#parseParenOrFunction();
+        } else if (this.#value === "{") {
+          return this.#parseMap();
+        } else if (this.#value === "[") {
+          return this.#parseList();
+        }
+        return void 0;
+      case Kind.COLON:
+        throw new Error('unexpected token ":"');
+      default:
+        return void 0;
+    }
+  }
+  #parseList() {
+    const items = [];
+    do {
+      this.#advance();
+      if (this._matches(Kind.GROUPER, "]"))
+        break;
+      items.push(this.#parseExpression());
+    } while (this._matches(Kind.COMMA));
+    this.#advance(Kind.GROUPER, "]");
+    return this.#ast.list(items);
+  }
+  #parseMap() {
+    const entries = {};
+    do {
+      this.#advance();
+      if (this._matches(Kind.GROUPER, "}"))
+        break;
+      const key = this.#value;
+      if (this._matches(Kind.STRING) || this._matches(Kind.IDENTIFIER)) {
+        this.#advance();
+      }
+      this.#advance(Kind.COLON);
+      entries[key] = this.#parseExpression();
+    } while (this._matches(Kind.COMMA));
+    this.#advance(Kind.GROUPER, "}");
+    return this.#ast.map(entries);
+  }
+  #parseInvokeOrIdentifier() {
+    const value = this.#value;
+    if (value === "true") {
+      this.#advance();
+      return this.#ast.literal(true);
+    }
+    if (value === "false") {
+      this.#advance();
+      return this.#ast.literal(false);
+    }
+    if (value === "null") {
+      this.#advance();
+      return this.#ast.literal(null);
+    }
+    if (value === "undefined") {
+      this.#advance();
+      return this.#ast.literal(void 0);
+    }
+    const identifier = this.#parseIdentifier();
+    const args = this.#parseArguments();
+    return !args ? identifier : this.#ast.invoke(identifier, void 0, args);
+  }
+  #parseIdentifier() {
+    if (!this._matches(Kind.IDENTIFIER)) {
+      throw new Error(`expected identifier: ${this.#value}`);
+    }
+    const value = this.#value;
+    this.#advance();
+    return this.#ast.id(value);
+  }
+  #parseArguments() {
+    if (!this._matches(Kind.GROUPER, "(")) {
+      return void 0;
+    }
+    const args = [];
+    do {
+      this.#advance();
+      if (this._matches(Kind.GROUPER, ")")) {
+        break;
+      }
+      const expr = this.#parseExpression();
+      args.push(expr);
+    } while (this._matches(Kind.COMMA));
+    this.#advance(Kind.GROUPER, ")");
+    return args;
+  }
+  #parseIndex() {
+    this.#advance();
+    const expr = this.#parseExpression();
+    this.#advance(Kind.GROUPER, "]");
+    return expr;
+  }
+  #parseParenOrFunction() {
+    const expressions = this.#parseArguments();
+    if (this._matches(Kind.ARROW)) {
+      this.#advance();
+      const body = this.#parseExpression();
+      const params = expressions?.map((e2) => e2.value) ?? [];
+      return this.#ast.arrowFunction(params, body);
+    } else {
+      return this.#ast.paren(expressions[0]);
+    }
+  }
+  #parseString() {
+    const value = this.#ast.literal(this.#value);
+    this.#advance();
+    return value;
+  }
+  #parseInteger(prefix = "") {
+    const value = this.#ast.literal(parseInt(`${prefix}${this.#value}`, 10));
+    this.#advance();
+    return value;
+  }
+  #parseDecimal(prefix = "") {
+    const value = this.#ast.literal(parseFloat(`${prefix}${this.#value}`));
+    this.#advance();
+    return value;
+  }
+};
+
+// ../../node_modules/.pnpm/@heximal+expressions@0.1.5/node_modules/@heximal/expressions/lib/eval.js
+var { hasOwn, fromEntries } = Object;
+var _BINARY_OPERATORS = {
+  "+": (a, b) => a + b,
+  "-": (a, b) => a - b,
+  "*": (a, b) => a * b,
+  "/": (a, b) => a / b,
+  "%": (a, b) => a % b,
+  "==": (a, b) => a == b,
+  "!=": (a, b) => a != b,
+  "===": (a, b) => a === b,
+  "!==": (a, b) => a !== b,
+  ">": (a, b) => a > b,
+  ">=": (a, b) => a >= b,
+  "<": (a, b) => a < b,
+  "<=": (a, b) => a <= b,
+  "||": (a, b) => a || b,
+  "&&": (a, b) => a && b,
+  "??": (a, b) => a ?? b,
+  "|": (a, f) => f(a),
+  "|>": (a, f) => f(a)
+};
+var _UNARY_OPERATORS = {
+  "+": (a) => a,
+  "-": (a) => -a,
+  "!": (a) => !a
+};
+var EvalAstFactory = class {
+  empty() {
+    return {
+      type: "Empty",
+      evaluate(scope) {
+        return scope;
+      },
+      getIds(idents) {
+        return idents;
+      }
+    };
+  }
+  // TODO(justinfagnani): just use a JS literal?
+  literal(v) {
+    return {
+      type: "Literal",
+      value: v,
+      evaluate(_scope) {
+        return this.value;
+      },
+      getIds(idents) {
+        return idents;
+      }
+    };
+  }
+  id(v) {
+    return {
+      type: "ID",
+      value: v,
+      evaluate(scope) {
+        if (this.value === "this")
+          return scope;
+        return scope?.[this.value];
+      },
+      getIds(idents) {
+        idents.push(this.value);
+        return idents;
+      }
+    };
+  }
+  unary(op, expr) {
+    const f = _UNARY_OPERATORS[op];
+    return {
+      type: "Unary",
+      operator: op,
+      child: expr,
+      evaluate(scope) {
+        return f(this.child.evaluate(scope));
+      },
+      getIds(idents) {
+        return this.child.getIds(idents);
+      }
+    };
+  }
+  binary(l, op, r3) {
+    const f = _BINARY_OPERATORS[op];
+    return {
+      type: "Binary",
+      operator: op,
+      left: l,
+      right: r3,
+      evaluate(scope) {
+        if (this.operator === "=") {
+          if (this.left.type !== "ID" && this.left.type !== "Getter" && this.left.type !== "Index") {
+            throw new Error(`Invalid assignment target: ${this.left}`);
+          }
+          const value = this.right.evaluate(scope);
+          let receiver = void 0;
+          let property;
+          if (this.left.type === "Getter") {
+            receiver = this.left.receiver.evaluate(scope);
+            property = this.left.name;
+          } else if (this.left.type === "Index") {
+            receiver = this.left.receiver.evaluate(scope);
+            property = this.left.argument.evaluate(scope);
+          } else if (this.left.type === "ID") {
+            receiver = scope;
+            property = this.left.value;
+          }
+          return receiver === void 0 ? void 0 : receiver[property] = value;
+        }
+        return f(this.left.evaluate(scope), this.right.evaluate(scope));
+      },
+      getIds(idents) {
+        this.left.getIds(idents);
+        this.right.getIds(idents);
+        return idents;
+      }
+    };
+  }
+  getter(g, n2) {
+    return {
+      type: "Getter",
+      receiver: g,
+      name: n2,
+      evaluate(scope) {
+        return this.receiver.evaluate(scope)?.[this.name];
+      },
+      getIds(idents) {
+        this.receiver.getIds(idents);
+        return idents;
+      }
+    };
+  }
+  invoke(receiver, method, args) {
+    if (method != null && typeof method !== "string") {
+      throw new Error("method not a string");
+    }
+    return {
+      type: "Invoke",
+      receiver,
+      method,
+      arguments: args,
+      evaluate(scope) {
+        const receiver2 = this.receiver.evaluate(scope);
+        const _this = this.method ? receiver2 : scope?.["this"] ?? scope;
+        const f = this.method ? receiver2?.[method] : receiver2;
+        const args2 = this.arguments ?? [];
+        const argValues = args2.map((a) => a?.evaluate(scope));
+        return f?.apply?.(_this, argValues);
+      },
+      getIds(idents) {
+        this.receiver.getIds(idents);
+        this.arguments?.forEach((a) => a?.getIds(idents));
+        return idents;
+      }
+    };
+  }
+  paren(e2) {
+    return e2;
+  }
+  index(e2, a) {
+    return {
+      type: "Index",
+      receiver: e2,
+      argument: a,
+      evaluate(scope) {
+        return this.receiver.evaluate(scope)?.[this.argument.evaluate(scope)];
+      },
+      getIds(idents) {
+        this.receiver.getIds(idents);
+        return idents;
+      }
+    };
+  }
+  ternary(c2, t2, f) {
+    return {
+      type: "Ternary",
+      condition: c2,
+      trueExpr: t2,
+      falseExpr: f,
+      evaluate(scope) {
+        const c3 = this.condition.evaluate(scope);
+        if (c3) {
+          return this.trueExpr.evaluate(scope);
+        } else {
+          return this.falseExpr.evaluate(scope);
+        }
+      },
+      getIds(idents) {
+        this.condition.getIds(idents);
+        this.trueExpr.getIds(idents);
+        this.falseExpr.getIds(idents);
+        return idents;
+      }
+    };
+  }
+  map(entries) {
+    return {
+      type: "Map",
+      entries,
+      evaluate(scope) {
+        const map = {};
+        if (entries && this.entries) {
+          for (const key in entries) {
+            const val = this.entries[key];
+            if (val) {
+              map[key] = val.evaluate(scope);
+            }
+          }
+        }
+        return map;
+      },
+      getIds(idents) {
+        if (entries && this.entries) {
+          for (const key in entries) {
+            const val = this.entries[key];
+            if (val) {
+              val.getIds(idents);
+            }
+          }
+        }
+        return idents;
+      }
+    };
+  }
+  // TODO(justinfagnani): if the list is deeply literal
+  list(l) {
+    return {
+      type: "List",
+      items: l,
+      evaluate(scope) {
+        return this.items?.map((a) => a?.evaluate(scope));
+      },
+      getIds(idents) {
+        this.items?.forEach((i4) => i4?.getIds(idents));
+        return idents;
+      }
+    };
+  }
+  arrowFunction(params, body) {
+    return {
+      type: "ArrowFunction",
+      params,
+      body,
+      evaluate(scope) {
+        const params2 = this.params;
+        const body2 = this.body;
+        return function(...args) {
+          const paramsObj = fromEntries(params2.map((p, i4) => [p, args[i4]]));
+          const newScope = new Proxy(scope ?? {}, {
+            set(target, prop, value) {
+              if (hasOwn(paramsObj, prop)) {
+                paramsObj[prop] = value;
+              }
+              return target[prop] = value;
+            },
+            get(target, prop) {
+              if (hasOwn(paramsObj, prop)) {
+                return paramsObj[prop];
+              }
+              return target[prop];
+            }
+          });
+          return body2.evaluate(newScope);
+        };
+      },
+      getIds(idents) {
+        return this.body.getIds(idents).filter((id) => !this.params.includes(id));
+      }
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/lit-html@3.3.1/node_modules/lit-html/node/private-ssr-support.js
+var r2 = null;
+var i3 = { boundAttributeSuffix: W.M, marker: W.P, markerMatch: W.A, HTML_RESULT: W.C, getTemplateHtml: W.L, overrideDirectiveResolve: (e2, t2) => class extends e2 {
+  _$AS(e3, r3) {
+    return t2(this, r3);
+  }
+}, patchDirectiveResolve: (e2, t2) => {
+  if (e2.prototype._$AS.name !== t2.name) {
+    r2 ??= e2.prototype._$AS.name;
+    for (let i4 = e2.prototype; i4 !== Object.prototype; i4 = Object.getPrototypeOf(i4)) if (i4.hasOwnProperty(r2)) return void (i4[r2] = t2);
+    throw Error("Internal error: It is possible that both dev mode and production mode Lit was mixed together during SSR. Please comment on the issue: https://github.com/lit/lit/issues/4527");
+  }
+}, setDirectiveClass(e2, t2) {
+  e2._$litDirective$ = t2;
+}, getAttributePartCommittedValue: (e2, r3, i4) => {
+  let o = w;
+  return e2.j = (e3) => o = e3, e2._$AI(r3, e2, i4), o;
+}, connectedDisconnectable: (e2) => ({ ...e2, _$AU: true }), resolveDirective: W.V, AttributePart: W.H, PropertyPart: W.B, BooleanAttributePart: W.N, EventPart: W.U, ElementPart: W.F, TemplateInstance: W.R, isIterable: W.D, ChildPart: W.I };
+
+// ../../node_modules/.pnpm/@heximal+templates@0.1.5/node_modules/@heximal/templates/index.js
+var { AttributePart, PropertyPart, BooleanAttributePart, EventPart } = i3;
+var astFactory = new EvalAstFactory();
+var expressionCache = /* @__PURE__ */ new Map();
+var toCamelCase = (s) => s.replace(/-(-|\w)/g, (_, p1) => p1.toUpperCase());
+var getSingleValue = (s, model) => {
+  let ast = expressionCache.get(s);
+  if (ast === void 0) {
+    if (expressionCache.has(s)) {
+      return void 0;
+    }
+    s = s.trim();
+    if (s.startsWith("{{") && s.endsWith("}}")) {
+      const expression = s.substring(2, s.length - 2).trim();
+      ast = new Parser(expression, astFactory).parse();
+      expressionCache.set(s, ast);
+    }
+  }
+  return ast?.evaluate(model);
+};
+var ifHandler = (template, model, handlers, renderers) => {
+  const ifAttribute = template.getAttribute("if");
+  if (ifAttribute !== null && getSingleValue(ifAttribute, model)) {
+    return evaluateTemplate(template, model, handlers, renderers);
+  }
+  return void 0;
+};
+var bindingRegex = /(?<!\\){{(.*?)(?:(?<!\\)}})/g;
+var hasEscapedBindingMarkers = (s) => /(?:\\{{)|(?:\\}})/g.test(s);
+var unescapeBindingMarkers = (s) => s.replaceAll(/\\{{/g, "{{").replace(/\\}}/g, "}}");
+var repeatHandler = (template, model, handlers, renderers) => {
+  const repeatAttribute = template.getAttribute("repeat");
+  if (repeatAttribute !== null) {
+    const items = getSingleValue(repeatAttribute, model);
+    if (!items[Symbol.iterator]) {
+      return E;
+    }
+    const litTemplate = getLitTemplate(template);
+    let index = -1;
+    const result = [];
+    for (const item of items) {
+      index++;
+      const itemModel = Object.create(model);
+      itemModel.item = item;
+      itemModel.index = index;
+      itemModel["this"] = model["this"] ?? model;
+      const values = [];
+      for (const part of litTemplate.parts) {
+        const value = part.update(itemModel, handlers, renderers);
+        if (part.type === 1) {
+          values.push(...value);
+        } else {
+          values.push(value);
+        }
+      }
+      const templateResult = {
+        _$litType$: litTemplate,
+        values
+      };
+      result.push(templateResult);
+    }
+    return result;
+  }
+  return void 0;
+};
+var defaultHandlers = {
+  if: ifHandler,
+  repeat: repeatHandler
+};
+var prepareTemplate = (template, handlers = defaultHandlers, renderers = {}, superTemplate) => {
+  const litTemplate = getLitTemplate(template);
+  const templateRenderers = litTemplate.renderers;
+  if (superTemplate) {
+    const superLitTemplate = getLitTemplate(superTemplate);
+    const superRenderers = superLitTemplate.renderers;
+    const superCallRenderer = templateRenderers["super"];
+    if (superCallRenderer !== void 0) {
+      renderers = {
+        // sub template's own renderes
+        ...templateRenderers,
+        // passed-in renderers
+        ...renderers,
+        // a super call renderer
+        super: (model, handlers2, renderers2) => {
+          renderers2 = {
+            // super template's own blocks
+            ...superRenderers,
+            // passed-in renderers
+            ...renderers2,
+            // sub template's overrides will be added by the inner super call
+            super: (model2, handlers3, renderers3) => {
+              return evaluateTemplate(superTemplate, model2, handlers3, renderers3);
+            }
+          };
+          return superCallRenderer(model, handlers2, renderers2);
+        }
+      };
+    } else {
+      renderers = {
+        // super template's own blocks
+        ...superRenderers,
+        // sub template's overrides
+        ...templateRenderers,
+        // passed-in renderers
+        ...renderers
+      };
+      template = superTemplate;
+    }
+  } else {
+    renderers = {
+      // template's named blocks
+      ...templateRenderers,
+      // passed-in renderers
+      ...renderers
+    };
+  }
+  return (model) => evaluateTemplate(template, model, handlers, renderers);
+};
+var evaluateTemplate = (template, model, handlers = defaultHandlers, renderers = {}) => {
+  const litTemplate = getLitTemplate(template);
+  const values = [];
+  for (const part of litTemplate.parts) {
+    const value = part.update(model, handlers, renderers);
+    if (part.type === 1) {
+      values.push(...value);
+    } else {
+      values.push(value);
+    }
+  }
+  const templateResult = {
+    _$litType$: litTemplate,
+    values
+  };
+  return templateResult;
+};
+var litTemplateCache = /* @__PURE__ */ new Map();
+var getLitTemplate = (template) => {
+  let litTemplate = litTemplateCache.get(template);
+  if (litTemplate === void 0) {
+    litTemplateCache.set(template, litTemplate = makeLitTemplate(template));
+  }
+  return litTemplate;
+};
+var makeLitTemplate = (template) => {
+  const litTemplate = {
+    h: void 0,
+    el: template.cloneNode(true),
+    parts: [],
+    renderers: {}
+  };
+  const walker = document.createTreeWalker(litTemplate.el.content, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_COMMENT);
+  let node = walker.currentNode;
+  let nodeIndex = -1;
+  const elementsToRemove = [];
+  while ((node = walker.nextNode()) !== null) {
+    if (node.nodeType === Node.COMMENT_NODE) {
+      nodeIndex++;
+    } else if (node.nodeType === Node.ELEMENT_NODE) {
+      nodeIndex++;
+      const element = node;
+      if (element.tagName === "TEMPLATE") {
+        const type = element.getAttribute("type");
+        const name = element.getAttribute("name");
+        const call = element.getAttribute("call");
+        if (call !== null || type !== null || name !== null) {
+          element.parentNode.insertBefore(document.createComment(""), element);
+          elementsToRemove.push(element);
+          let update;
+          if (call !== null) {
+            const templateName = call.trim();
+            const templateNameIsExpression = templateName.startsWith("{{") && templateName.endsWith("}}");
+            update = (model, handlers, renderers) => {
+              const dataAttr = element.getAttribute("data");
+              const data = dataAttr === null ? void 0 : getSingleValue(dataAttr, model);
+              const renderer = templateNameIsExpression ? getSingleValue(templateName, model) : renderers[call];
+              return renderer?.(data, handlers, renderers);
+            };
+          } else if (type !== null) {
+            update = (model, handlers, renderers) => {
+              const handler = handlers[type];
+              return handler?.(element, model, handlers, renderers);
+            };
+          } else {
+            if (name === "super") {
+              litTemplate.renderers["super"] = (model, handlers, renderers) => {
+                const superRenderer = renderers["super"];
+                const superCallTemplate = getLitTemplate(element);
+                renderers = {
+                  ...renderers,
+                  ...superCallTemplate.renderers
+                };
+                return superRenderer(model, handlers, renderers);
+              };
+            } else {
+              litTemplate.renderers[name] = (model, handlers, renderers) => {
+                return evaluateTemplate(element, model, handlers, renderers);
+              };
+            }
+            update = (model, handlers, renderers) => {
+              const renderer = renderers[name];
+              return renderer?.(model, handlers, renderers);
+            };
+          }
+          litTemplate.parts.push({
+            type: 2,
+            // text binding
+            index: nodeIndex,
+            update
+          });
+          continue;
+        }
+      }
+      const attributeNames = element.getAttributeNames();
+      for (const attributeName of attributeNames) {
+        const attributeValue = element.getAttribute(attributeName);
+        const splitValue = attributeValue.split(bindingRegex);
+        if (splitValue.length === 1) {
+          if (hasEscapedBindingMarkers(attributeValue)) {
+            element.setAttribute(attributeName, unescapeBindingMarkers(attributeValue));
+          }
+          continue;
+        }
+        element.removeAttribute(attributeName);
+        let name = attributeName;
+        let ctor = AttributePart;
+        const prefix = attributeName[0];
+        if (prefix === ".") {
+          name = toCamelCase(attributeName.substring(1));
+          ctor = PropertyPart;
+        } else if (prefix === "?") {
+          name = attributeName.substring(1);
+          ctor = BooleanAttributePart;
+        } else if (prefix === "@") {
+          name = toCamelCase(attributeName.substring(1));
+          ctor = EventPart;
+        }
+        const strings = [unescapeBindingMarkers(splitValue[0])];
+        const exprs = [];
+        for (let i4 = 1; i4 < splitValue.length; i4 += 2) {
+          const exprText = splitValue[i4];
+          exprs.push(parse(exprText, astFactory));
+          strings.push(unescapeBindingMarkers(splitValue[i4 + 1]));
+        }
+        litTemplate.parts.push({
+          type: 1,
+          // attribute binding
+          index: nodeIndex,
+          name,
+          strings,
+          ctor,
+          update: (model, _handlers, _renderers) => {
+            return exprs.map((expr) => expr.evaluate(model));
+          }
+        });
+      }
+    } else if (node.nodeType === Node.TEXT_NODE) {
+      let textNode = node;
+      const text = textNode.textContent;
+      const strings = text.split(bindingRegex);
+      if (strings.length > 1) {
+        textNode.textContent = unescapeBindingMarkers(strings[0]);
+      } else if (hasEscapedBindingMarkers(text)) {
+        textNode.textContent = unescapeBindingMarkers(text);
+      }
+      for (let i4 = 1; i4 < strings.length; i4 += 2) {
+        const exprText = strings[i4];
+        const expr = parse(exprText, astFactory);
+        litTemplate.parts.push({
+          type: 2,
+          index: ++nodeIndex,
+          update: (model, _handlers) => expr.evaluate(model)
+        });
+        const newTextNode = new Text(strings[i4 + 1].replace("\\{{", "{{"));
+        textNode.parentNode.insertBefore(newTextNode, textNode.nextSibling);
+        textNode.parentNode.insertBefore(document.createComment(""), textNode.nextSibling);
+        textNode = newTextNode;
+        walker.currentNode = newTextNode;
+      }
+    }
+  }
+  for (const e2 of elementsToRemove) {
+    e2.remove();
+  }
+  return litTemplate;
+};
+
+// ../qti-test/src/components/test-paging-buttons-stamp/test-paging-buttons-stamp.ts
+var TestPagingButtonsStamp = class extends i2 {
   createRenderRoot() {
     return this;
   }
@@ -1710,25 +2761,22 @@ var TestPagingButtonsStamp = class extends LitElement13 {
     this.myTemplate = prepareTemplate(templateElement);
   }
   render() {
-    if (!this.computedContext) return html13``;
+    if (!this.computedContext) return x``;
     const items = this.computedContext.testParts.flatMap(
       (testPart) => testPart.sections.flatMap((section) => section.items)
     );
-    return html13` ${items.map((item) => this.myTemplate({ item, view: this.computedContext.view }))} `;
+    return x` ${items.map((item) => this.myTemplate({ item, view: this.computedContext.view }))} `;
   }
 };
 __decorateClass([
-  consume8({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestPagingButtonsStamp.prototype, "computedContext", 2);
 TestPagingButtonsStamp = __decorateClass([
-  customElement12("test-paging-buttons-stamp")
+  t("test-paging-buttons-stamp")
 ], TestPagingButtonsStamp);
 
-// src/lib/qti-test/components/test-container.ts
-import { LitElement as LitElement14, html as html14 } from "lit";
-import { customElement as customElement13, property as property13, state as state3 } from "lit/decorators.js";
-import { until } from "lit/directives/until.js";
-var TestContainer = class extends LitElement14 {
+// ../qti-test/src/components/test-container/test-container.ts
+var TestContainer = class extends i2 {
   constructor() {
     super(...arguments);
     this.testURL = null;
@@ -1775,7 +2823,7 @@ var TestContainer = class extends LitElement14 {
   }
   initializeTemplateContent() {
     const template = this.querySelector("template");
-    this.templateContent = template ? template.content : html14``;
+    this.templateContent = template ? template.content : x``;
   }
   applyStyles() {
     const sheet = new CSSStyleSheet();
@@ -1783,21 +2831,21 @@ var TestContainer = class extends LitElement14 {
     this.shadowRoot.adoptedStyleSheets = [sheet];
   }
   render() {
-    return html14`
+    return x`
       ${this.templateContent}
       <slot></slot>
-      ${until(this.testDoc, html14`<span>Loading...</span>`)}
+      ${m(this.testDoc, x`<span>Loading...</span>`)}
     `;
   }
 };
 __decorateClass([
-  property13({ type: String, attribute: "test-url" })
+  n({ type: String, attribute: "test-url" })
 ], TestContainer.prototype, "testURL", 2);
 __decorateClass([
-  state3()
+  r()
 ], TestContainer.prototype, "testDoc", 2);
 __decorateClass([
-  state3()
+  r()
 ], TestContainer.prototype, "testXML", 2);
 __decorateClass([
   watch("testURL", { waitUntilFirstUpdate: true })
@@ -1806,20 +2854,17 @@ __decorateClass([
   watch("testXML", { waitUntilFirstUpdate: true })
 ], TestContainer.prototype, "handleTestXMLChange", 1);
 TestContainer = __decorateClass([
-  customElement13("test-container")
+  t("test-container")
 ], TestContainer);
 
-// src/lib/qti-test/components/test-print-item-variables.ts
-import { html as html15, css as css8, LitElement as LitElement15 } from "lit";
-import { consume as consume9 } from "@lit/context";
-import { customElement as customElement14 } from "lit/decorators.js";
-var TestPrintVariables = class extends LitElement15 {
+// ../qti-test/src/components/test-print-item-variables/test-print-item-variables.ts
+var TestPrintVariables = class extends i2 {
   render() {
     const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
-    if (!activeItem || !activeItem.variables) return html15``;
+    if (!activeItem || !activeItem.variables) return x``;
     const responseVariables = activeItem.variables.filter((v) => v.type === "response");
     const outcomeVariables = activeItem.variables.filter((v) => v.type === "outcome");
-    const renderTable = (variables, title) => html15`
+    const renderTable = (variables, title) => x`
       <h3>${title}</h3>
       <table>
         <thead>
@@ -1834,9 +2879,9 @@ var TestPrintVariables = class extends LitElement15 {
         <tbody>
           ${variables.map((v) => {
       const correctResponse = v.correctResponse ? Array.isArray(v.correctResponse) ? v.correctResponse.join(", ") : v.correctResponse : "";
-      const mapEntries = v.mapping?.mapEntries?.map((m) => `${m.mapKey}=${m.mappedValue}pt`).join(", ") || "";
-      const areaMapEntries = v.areaMapping?.areaMapEntries?.map((m) => `${m.shape}(${m.coords})=${m.mappedValue}pt`).join(", ") || "";
-      return html15`
+      const mapEntries = v.mapping?.mapEntries?.map((m2) => `${m2.mapKey}=${m2.mappedValue}pt`).join(", ") || "";
+      const areaMapEntries = v.areaMapping?.areaMapEntries?.map((m2) => `${m2.shape}(${m2.coords})=${m2.mappedValue}pt`).join(", ") || "";
+      return x`
               <tr>
                 <td>${v.identifier}</td>
                 <td>${Array.isArray(v.value) ? v.value.join(", ") : v.value}</td>
@@ -1849,12 +2894,12 @@ var TestPrintVariables = class extends LitElement15 {
         </tbody>
       </table>
     `;
-    return html15`
+    return x`
       ${renderTable(responseVariables, "Response Variables")} ${renderTable(outcomeVariables, "Outcome Variables")}
     `;
   }
 };
-TestPrintVariables.styles = css8`
+TestPrintVariables.styles = i`
     table {
       width: 100%;
       border-collapse: collapse;
@@ -1877,18 +2922,14 @@ TestPrintVariables.styles = css8`
     }
   `;
 __decorateClass([
-  consume9({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestPrintVariables.prototype, "computedContext", 2);
 TestPrintVariables = __decorateClass([
-  customElement14("test-print-item-variables")
+  t("test-print-item-variables")
 ], TestPrintVariables);
 
-// src/lib/qti-test/components/test-section-buttons-stamp.ts
-import { html as html16, LitElement as LitElement16 } from "lit";
-import { customElement as customElement15 } from "lit/decorators.js";
-import { prepareTemplate as prepareTemplate2 } from "@heximal/templates";
-import { consume as consume10 } from "@lit/context";
-var TestSectionButtonsStamp = class extends LitElement16 {
+// ../qti-test/src/components/test-section-buttons-stamp/test-section-buttons-stamp.ts
+var TestSectionButtonsStamp = class extends i2 {
   createRenderRoot() {
     return this;
   }
@@ -1900,25 +2941,23 @@ var TestSectionButtonsStamp = class extends LitElement16 {
   connectedCallback() {
     super.connectedCallback();
     const templateElement = this.querySelector("template");
-    this.myTemplate = prepareTemplate2(templateElement);
+    this.myTemplate = prepareTemplate(templateElement);
   }
   render() {
-    if (!this.computedContext) return html16``;
+    if (!this.computedContext) return x``;
     const sections = this.computedContext.testParts.flatMap((testPart) => testPart.sections);
-    return html16` ${sections.map((item) => this.myTemplate({ item }))} `;
+    return x` ${sections.map((item) => this.myTemplate({ item }))} `;
   }
 };
 __decorateClass([
-  consume10({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestSectionButtonsStamp.prototype, "computedContext", 2);
 TestSectionButtonsStamp = __decorateClass([
-  customElement15("test-section-buttons-stamp")
+  t("test-section-buttons-stamp")
 ], TestSectionButtonsStamp);
 
-// src/lib/qti-test/components/test-section-link.ts
-import { css as css9, html as html17, LitElement as LitElement17 } from "lit";
-import { customElement as customElement16, property as property14 } from "lit/decorators.js";
-var TestSectionLink = class extends LitElement17 {
+// ../qti-test/src/components/test-section-link/test-section-link.ts
+var TestSectionLink = class extends i2 {
   constructor() {
     super();
     this.sectionId = null;
@@ -1937,10 +2976,10 @@ var TestSectionLink = class extends LitElement17 {
     );
   }
   render() {
-    return html17` <slot></slot> `;
+    return x` <slot></slot> `;
   }
 };
-TestSectionLink.styles = css9`
+TestSectionLink.styles = i`
     :host {
       ${btn};
     }
@@ -1949,35 +2988,28 @@ TestSectionLink.styles = css9`
     }
   `;
 __decorateClass([
-  property14({ type: String, attribute: "section-id" })
+  n({ type: String, attribute: "section-id" })
 ], TestSectionLink.prototype, "sectionId", 2);
 TestSectionLink = __decorateClass([
-  customElement16("test-section-link")
+  t("test-section-link")
 ], TestSectionLink);
 
-// src/lib/qti-test/components/test-print-context.ts
-import { html as html18, LitElement as LitElement18 } from "lit";
-import { consume as consume11 } from "@lit/context";
-import { customElement as customElement17, state as state4 } from "lit/decorators.js";
-var TestPrintContext = class extends LitElement18 {
+// ../qti-test/src/components/test-print-context/test-print-context.ts
+var TestPrintContext = class extends i2 {
   render() {
-    return html18` <small><pre>${JSON.stringify(this.computedContext, null, 2)}</pre></small> `;
+    return x` <small><pre>${JSON.stringify(this.computedContext, null, 2)}</pre></small> `;
   }
 };
 __decorateClass([
-  state4(),
-  consume11({ context: computedContext, subscribe: true })
+  r(),
+  c({ context: computedContext, subscribe: true })
 ], TestPrintContext.prototype, "computedContext", 2);
 TestPrintContext = __decorateClass([
-  customElement17("test-print-context")
+  t("test-print-context")
 ], TestPrintContext);
 
-// src/lib/qti-test/components/test-stamp.ts
-import { html as html19, LitElement as LitElement19, nothing } from "lit";
-import { customElement as customElement18, property as property15, state as state5 } from "lit/decorators.js";
-import { prepareTemplate as prepareTemplate3 } from "@heximal/templates";
-import { consume as consume12 } from "@lit/context";
-var TestStamp = class extends LitElement19 {
+// ../qti-test/src/components/test-stamp/test-stamp.ts
+var TestStamp = class extends i2 {
   constructor() {
     super(...arguments);
     this.debug = false;
@@ -2004,7 +3036,7 @@ var TestStamp = class extends LitElement19 {
       this.myTemplate = null;
       return;
     }
-    this.myTemplate = prepareTemplate3(templateElement);
+    this.myTemplate = prepareTemplate(templateElement);
   }
   willUpdate(_changedProperties) {
     if (!this.computedContext) {
@@ -2042,37 +3074,33 @@ var TestStamp = class extends LitElement19 {
     );
   }
   render() {
-    return html19` ${this.debug ? html19`<small><pre>${JSON.stringify(this.stampContext, null, 2)}</pre></small>` : nothing}
-    ${this.myTemplate ? this.myTemplate(this.stampContext) : nothing}`;
+    return x` ${this.debug ? x`<small><pre>${JSON.stringify(this.stampContext, null, 2)}</pre></small>` : E}
+    ${this.myTemplate ? this.myTemplate(this.stampContext) : E}`;
   }
 };
 __decorateClass([
-  property15({ type: Boolean, reflect: true })
+  n({ type: Boolean, reflect: true })
 ], TestStamp.prototype, "debug", 2);
 __decorateClass([
-  state5(),
-  consume12({ context: computedContext, subscribe: true })
+  r(),
+  c({ context: computedContext, subscribe: true })
 ], TestStamp.prototype, "computedContext", 2);
 __decorateClass([
-  state5()
+  r()
 ], TestStamp.prototype, "stampContext", 2);
 TestStamp = __decorateClass([
-  customElement18("test-stamp")
+  t("test-stamp")
 ], TestStamp);
 
-// src/lib/qti-test/components/test-scoring-buttons.ts
-import { html as html20, LitElement as LitElement20, nothing as nothing2 } from "lit";
-import { consume as consume13 } from "@lit/context";
-import { customElement as customElement19, property as property16 } from "lit/decorators.js";
-import { prepareTemplate as prepareTemplate4 } from "@heximal/templates";
-var TestScoringButtons = class extends LitElement20 {
+// ../qti-test/src/components/test-scoring-buttons/test-scoring-buttons.ts
+var TestScoringButtons = class extends i2 {
   constructor() {
     super();
     this.view = "";
     this.disabled = false;
     this.myTemplate = null;
-    this.addEventListener("click", (e) => {
-      const target = e.target;
+    this.addEventListener("click", (e2) => {
+      const target = e2.target;
       const value = parseFloat(target.value);
       if (target.tagName === "INPUT") {
         this._changeOutcomeScore(value);
@@ -2089,7 +3117,7 @@ var TestScoringButtons = class extends LitElement20 {
       this.myTemplate = null;
       return;
     }
-    this.myTemplate = prepareTemplate4(templateElement);
+    this.myTemplate = prepareTemplate(templateElement);
   }
   _changeOutcomeScore(value) {
     const testPart = this.computedContext?.testParts.find((testPart2) => testPart2.active);
@@ -2108,35 +3136,31 @@ var TestScoringButtons = class extends LitElement20 {
   }
   render() {
     const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
-    if (!activeItem || !activeItem.variables) return html20``;
+    if (!activeItem || !activeItem.variables) return x``;
     const maxScore = activeItem.variables.find((vr) => vr.identifier == "MAXSCORE")?.value;
     const scoreOutcome = activeItem.variables.find((vr) => vr.identifier == "SCORE");
     const score = scoreOutcome?.value;
     const disabled = !(scoreOutcome?.externalScored === "human");
-    if (!maxScore || !scoreOutcome) return nothing2;
+    if (!maxScore || !scoreOutcome) return E;
     const scores = [...Array(Number(maxScore) + 1).keys()];
-    return html20`${this.myTemplate ? this.myTemplate({ scores, score, disabled }) : nothing2}`;
+    return x`${this.myTemplate ? this.myTemplate({ scores, score, disabled }) : E}`;
   }
 };
 __decorateClass([
-  property16({ type: String, attribute: "view" })
+  n({ type: String, attribute: "view" })
 ], TestScoringButtons.prototype, "view", 2);
 __decorateClass([
-  property16({ type: Boolean })
+  n({ type: Boolean })
 ], TestScoringButtons.prototype, "disabled", 2);
 __decorateClass([
-  consume13({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestScoringButtons.prototype, "computedContext", 2);
 TestScoringButtons = __decorateClass([
-  customElement19("test-scoring-buttons")
+  t("test-scoring-buttons")
 ], TestScoringButtons);
 
-// src/lib/qti-test/components/test-view-toggle.ts
-import { consume as consume14 } from "@lit/context";
-import { html as html21, LitElement as LitElement21, nothing as nothing3 } from "lit";
-import { customElement as customElement20 } from "lit/decorators.js";
-import { prepareTemplate as prepareTemplate5 } from "@heximal/templates";
-var TestViewToggle = class extends LitElement21 {
+// ../qti-test/src/components/test-view-toggle/test-view-toggle.ts
+var TestViewToggle = class extends i2 {
   createRenderRoot() {
     return this;
   }
@@ -2147,7 +3171,7 @@ var TestViewToggle = class extends LitElement21 {
       this.myTemplate = null;
       return;
     }
-    this.myTemplate = prepareTemplate5(templateElement);
+    this.myTemplate = prepareTemplate(templateElement);
   }
   _switchView(view) {
     this.dispatchEvent(
@@ -2168,31 +3192,28 @@ var TestViewToggle = class extends LitElement21 {
     });
   }
   render() {
-    return html21`${this.myTemplate ? this.myTemplate({
+    return x`${this.myTemplate ? this.myTemplate({
       view: this.sessionContext?.view
-    }) : nothing3}`;
+    }) : E}`;
   }
 };
 __decorateClass([
-  consume14({ context: sessionContext, subscribe: true })
+  c({ context: sessionContext, subscribe: true })
 ], TestViewToggle.prototype, "sessionContext", 2);
 TestViewToggle = __decorateClass([
-  customElement20("test-view-toggle")
+  t("test-view-toggle")
 ], TestViewToggle);
 
-// src/lib/qti-test/components/test-scoring-feedback.ts
-import { consume as consume15 } from "@lit/context";
-import { html as html22, LitElement as LitElement22 } from "lit";
-import { customElement as customElement21, property as property17 } from "lit/decorators.js";
-var TestScoringFeedback = class extends LitElement22 {
+// ../qti-test/src/components/test-scoring-feedback/test-scoring-feedback.ts
+var TestScoringFeedback = class extends i2 {
   constructor() {
     super(...arguments);
     this.view = null;
   }
   render() {
     const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
-    if (!activeItem || !activeItem.variables) return html22``;
-    if (activeItem["category"] === "dep-informational") return html22`<div>${this.dataset.informational}</div>`;
+    if (!activeItem || !activeItem.variables) return x``;
+    if (activeItem["category"] === "dep-informational") return x`<div>${this.dataset.informational}</div>`;
     const completionStatus = activeItem?.variables.find((v) => v.identifier === "completionStatus")?.value;
     const scoreOutcome = activeItem?.variables.find((vr) => vr.identifier == "SCORE");
     const score = parseFloat(scoreOutcome?.value);
@@ -2212,23 +3233,21 @@ var TestScoringFeedback = class extends LitElement22 {
       }
       return this.dataset.inProgress;
     };
-    return html22`<div>${feedbackText()}</div>`;
+    return x`<div>${feedbackText()}</div>`;
   }
 };
 __decorateClass([
-  consume15({ context: computedContext, subscribe: true })
+  c({ context: computedContext, subscribe: true })
 ], TestScoringFeedback.prototype, "computedContext", 2);
 __decorateClass([
-  property17({ type: String, attribute: "view" })
+  n({ type: String, attribute: "view" })
 ], TestScoringFeedback.prototype, "view", 2);
 TestScoringFeedback = __decorateClass([
-  customElement21("test-scoring-feedback")
+  t("test-scoring-feedback")
 ], TestScoringFeedback);
 
-// src/lib/qti-test/components/test-check-item.ts
-import { css as css10, html as html23, LitElement as LitElement23 } from "lit";
-import { customElement as customElement22 } from "lit/decorators.js";
-var TestCheckItem = class extends LitElement23 {
+// ../qti-test/src/components/test-check-item/test-check-item.ts
+var TestCheckItem = class extends i2 {
   constructor() {
     super();
     this.addEventListener("click", () => {
@@ -2248,10 +3267,10 @@ var TestCheckItem = class extends LitElement23 {
     });
   }
   render() {
-    return html23` <slot></slot> `;
+    return x` <slot></slot> `;
   }
 };
-TestCheckItem.styles = css10`
+TestCheckItem.styles = i`
     :host {
       ${btn};
     }
@@ -2260,7 +3279,7 @@ TestCheckItem.styles = css10`
     }
   `;
 TestCheckItem = __decorateClass([
-  customElement22("test-check-item")
+  t("test-check-item")
 ], TestCheckItem);
 
 export {
@@ -2289,4 +3308,23 @@ export {
   TestScoringFeedback,
   TestCheckItem
 };
-//# sourceMappingURL=chunk-Z2FFXTKX.js.map
+/*! Bundled license information:
+
+@heximal/expressions/lib/constants.js:
+@heximal/expressions/lib/tokenizer.js:
+@heximal/expressions/lib/parser.js:
+@heximal/expressions/lib/ast_factory.js:
+@heximal/expressions/lib/eval.js:
+  (*
+   * @license
+   * Portions Copyright (c) 2013, the Dart project authors.
+   *)
+
+lit-html/node/private-ssr-support.js:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/
+//# sourceMappingURL=chunk-352OTVTY.js.map