@examind/block-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2083 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  exportToHtml: () => exportToHtml,
+  importFromHtml: () => importFromHtml
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/NodeHandlerChainBuilder.ts
+var NodeHandlerChainBuilder = class {
+  constructor() {
+    this.handlerConstructors = [];
+  }
+  addHandler(handlerConstructor) {
+    this.handlerConstructors.push(handlerConstructor);
+    return this;
+  }
+  build() {
+    if (this.handlerConstructors.length === 0) {
+      throw new Error(
+        "No handlers have been added to the chain. Call addHandler() at least once."
+      );
+    }
+    const firstHandler = new this.handlerConstructors[0]();
+    let currentHandler = firstHandler;
+    for (let i = 1; i < this.handlerConstructors.length; i++) {
+      const nextHandlerInstance = new this.handlerConstructors[i]();
+      currentHandler.setNext(nextHandlerInstance);
+      currentHandler = nextHandlerInstance;
+    }
+    return firstHandler;
+  }
+};
+
+// src/typeGuards/isSerializedEssayQuestionNode.ts
+function isSerializedEssayQuestionNode(node) {
+  return node?.type === "essay-question" && "id" in node && typeof node.id === "string" && "points" in node && typeof node.points === "number" && "maxWords" in node && typeof node.maxWords === "number" && "hideChat" in node && typeof node.hideChat === "boolean";
+}
+
+// src/exportToHtml/types.ts
+var NodeHandler = class {
+  constructor() {
+    this.nextHandler = null;
+  }
+  setNext(handler) {
+    this.nextHandler = handler;
+    return handler;
+  }
+  handle(node, metadata) {
+    const result = this.processNode(node, metadata);
+    if (result) {
+      return result;
+    } else if (this.nextHandler) {
+      return this.nextHandler.handle(node, metadata);
+    }
+    return null;
+  }
+};
+
+// src/exportToHtml/EssayQuestionNodeHandler.ts
+var EssayQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedEssayQuestionNode(node)) return null;
+    const attributes = [
+      `data-x-points="${node.points}"`,
+      `data-x-max-words="${node.maxWords}"`,
+      `data-x-hide-chat="${node.hideChat}"`,
+      node.aiChatModel ? `data-x-ai-chat-model="${node.aiChatModel}"` : null
+    ].filter(Boolean).join(" ");
+    const aiSystemMessageTag = node.aiSystemMessage ? `<x-ai-system-message>${node.aiSystemMessage}</x-ai-system-message>` : "";
+    return `<x-essay id="${node.id}" data-x-prompt ${attributes.trimEnd()}>${aiSystemMessageTag}</x-essay>`;
+  }
+};
+
+// src/typeGuards/isSerializedFillInTheBlankQuestionNode.ts
+function isSerializedFillInTheBlankQuestionNode(node) {
+  return node?.type === "fill-in-the-blank-question" && "id" in node && typeof node.id === "string" && "content" in node && "pointsPerSpace" in node && typeof node.pointsPerSpace === "number";
+}
+
+// src/typeGuards/isSerializedParagraphNode.ts
+function isSerializedParagraphNode(node) {
+  return node?.type === "paragraph" && "children" in node && Array.isArray(node.children);
+}
+
+// src/exportToHtml/createHtmlFromNestedNodes.ts
+function createHtmlFromNestedNodes(nodes, metadata) {
+  const children = [];
+  let prevWasParagraph = false;
+  nodes.forEach((child) => {
+    const isParagraph = isSerializedParagraphNode(child);
+    const element = traverse(child, metadata);
+    if (element) {
+      if (prevWasParagraph && isParagraph) {
+        children.push("<br>");
+      }
+      children.push(element);
+      prevWasParagraph = isParagraph;
+    }
+  });
+  return children.join("");
+}
+
+// src/exportToHtml/createHtmlFromNestedEditor.ts
+function createHtmlFromNestedEditor(editor, metadata) {
+  const rootNode = editor?.editorState?.root;
+  if (!rootNode) return "";
+  return createHtmlFromNestedNodes(rootNode.children, metadata);
+}
+
+// src/exportToHtml/FillInTheBlankQuestionNodeHandler.ts
+var FillInTheBlankQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedFillInTheBlankQuestionNode(node)) return null;
+    return `<x-fill-in-the-blank id="${node.id}" data-x-prompt data-x-points-per-space="${node.pointsPerSpace}">${createHtmlFromNestedEditor(node.content, { parentNode: node })}</x-fill-in-the-blank>`;
+  }
+};
+
+// src/typeGuards/isSerializedFillInTheBlankSpaceNode.ts
+function isSerializedFillInTheBlankSpaceNode(node) {
+  return node?.type === "space" && "id" in node && typeof node.id === "string" && "spaceType" in node && "matches" in node && typeof node.matches === "string";
+}
+
+// src/exportToHtml/FillInTheBlankSpaceNodeHandler.ts
+var FillInTheBlankSpaceNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedFillInTheBlankSpaceNode(node)) return null;
+    const spaceNode = node;
+    const baseAttributes = this.getBaseAttributes(spaceNode);
+    const spaceTypeAttributes = this.getSpaceTypeAttributes(spaceNode);
+    return `<x-space ${baseAttributes}${spaceTypeAttributes}>${spaceNode.spaceName}</x-space>`;
+  }
+  getBaseAttributes(node) {
+    const attributes = [
+      `id="${node.id}"`,
+      `data-x-type="${node.spaceType}"`,
+      `data-x-matches="${node.matches}"`,
+      `data-x-case-sensitive="${!!node.caseSensitive}"`,
+      `data-x-errors-allowed="${node.errorsAllowed ?? 0}"`,
+      `data-x-min-decimals="${node.minDecimals ?? ""}"`,
+      `data-x-error-tolerance="${node.errorTolerance ?? 0}"`,
+      `data-x-distractors="${node.distractors ?? ""}"`
+    ];
+    return attributes.join(" ");
+  }
+  getSpaceTypeAttributes(node) {
+    switch (node.spaceType) {
+      case "Text":
+        return "";
+      case "Number":
+        return "";
+      case "Dropdown":
+        return "";
+      default:
+        return "";
+    }
+  }
+};
+
+// src/typeGuards/isSerializedFinancialStatementQuestionNode.ts
+function isSerializedFinancialStatementQuestionNode(node) {
+  return node?.type === "financial-statement-question" && "id" in node && typeof node.id === "string" && "header" in node && "rows" in node && Array.isArray(node.rows) && "points" in node && typeof node.points === "number";
+}
+
+// src/exportToHtml/FinancialStatementQuestionNodeHandler.ts
+var isHeading = (row) => {
+  return row.type === "Heading";
+};
+var isLine = (row) => {
+  return row.type === "Line";
+};
+var FinancialStatementQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedFinancialStatementQuestionNode(node))
+      return null;
+    const children = [
+      this.processHeaderSection(node),
+      this.processRowsSection(node),
+      this.processDistractorsSection(node)
+    ];
+    return `<x-financial-statement id="${node.id}" data-x-prompt data-x-points="${node.points}">${children.join("")}</x-financial-statement>`;
+  }
+  processHeaderSection(node) {
+    return `<x-header>${createHtmlFromNestedEditor(node.header, {
+      parentNode: node
+    })}${this.processColumnHeadersSection(node)}</x-header>`;
+  }
+  processColumnHeadersSection(node) {
+    if (node.columnHeaders.length < 2) return "";
+    return `<div style="display:flex; width:100%; margin-top: 16px;"><div style="flex:1; font-weight:bold; text-align:left;">${node.columnHeaders[0]}</div><div style="flex:1; font-weight:bold; text-align:right;">${node.columnHeaders[1]}</div></div>`;
+  }
+  processRowsSection(node) {
+    const rowElements = [];
+    for (const row of node.rows) {
+      if (isHeading(row)) {
+        const isHintAttr = row.isHint ? ' data-x-is-hint="true"' : "";
+        rowElements.push(
+          `<x-heading id="${row.id}" data-x-depth="${row.depth}"${isHintAttr}>${row.entry}</x-heading>`
+        );
+      } else if (isLine(row)) {
+        const entryHintAttr = row.isEntryHint ? ' data-x-is-entry-hint="true"' : "";
+        const amountHintAttr = row.isAmountHint ? ' data-x-is-amount-hint="true"' : "";
+        rowElements.push(
+          `<x-line id="${row.id}" data-x-depth="${row.depth}"${entryHintAttr}${amountHintAttr}>`,
+          `<x-entry>${row.entry}</x-entry>`,
+          `<x-amount>${createHtmlFromNestedEditor(row.amount, {
+            parentNode: node
+          })}</x-amount>`,
+          `</x-line>`
+        );
+      }
+    }
+    return `<x-rows>${rowElements.join("")}</x-rows>`;
+  }
+  processDistractorsSection(node) {
+    if (!node.distractors || node.distractors.length === 0) {
+      return "";
+    }
+    const distractorElements = node.distractors.map(
+      (distractor) => `<x-distractor id="${distractor.id}">${distractor.entry}</x-distractor>`
+    );
+    return `<x-distractors>${distractorElements.join("")}</x-distractors>`;
+  }
+};
+
+// src/typeGuards/isSerializedHorizontalRuleNode.ts
+var isSerializedHorizontalRuleNode = (node) => {
+  return node.type === "horizontalrule";
+};
+
+// src/exportToHtml/HorizontalRuleNodeHandler.ts
+var HorizontalRuleNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedHorizontalRuleNode(node)) return null;
+    return "<hr />";
+  }
+};
+
+// src/typeGuards/isSerializedImageNode.ts
+var isSerializedImageNode = (node) => {
+  return node.type === "image";
+};
+
+// src/exportToHtml/ImageNodeHandler.ts
+var ImageNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedImageNode(node)) return null;
+    const attributes = [
+      `src="${node.src}"`,
+      node.altText ? `alt="${node.altText}"` : null,
+      node.width ? `width="${node.width}"` : null,
+      node.align !== "left" ? `align="${node.align}"` : null
+    ].filter(Boolean).join(" ");
+    return `<img ${attributes} />`;
+  }
+};
+
+// src/typeGuards/isSerializedJournalEntryQuestionNode.ts
+function isSerializedJournalEntryQuestionNode(node) {
+  return node?.type === "journal-entry-question" && "id" in node && typeof node.id === "string" && "lineItems" in node && Array.isArray(node.lineItems) && "points" in node && typeof node.points === "number";
+}
+
+// src/exportToHtml/JournalEntryQuestionNodeHandler.ts
+var JournalEntryQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedJournalEntryQuestionNode(node)) return null;
+    const journalNode = node;
+    const attributes = [
+      `id="${journalNode.id}"`,
+      "data-x-prompt",
+      `data-x-points="${journalNode.points}"`
+    ];
+    if (journalNode.errorTolerance !== void 0) {
+      attributes.push(
+        `data-x-error-tolerance="${journalNode.errorTolerance}"`
+      );
+    }
+    switch (journalNode.journalType) {
+      case "default":
+        attributes.push('data-x-no-entry-required-correct="false"');
+        attributes.push(
+          'data-x-no-entry-required-distractor="false"'
+        );
+        break;
+      case "noEntryRequiredCorrect":
+        attributes.push('data-x-no-entry-required-correct="true"');
+        attributes.push(
+          'data-x-no-entry-required-distractor="false"'
+        );
+        break;
+      case "noEntryRequiredDistractor":
+        attributes.push('data-x-no-entry-required-correct="false"');
+        attributes.push('data-x-no-entry-required-distractor="true"');
+        break;
+    }
+    const lineItems = this.processLineItems(journalNode);
+    const distractors = this.processDistractors(journalNode);
+    return `<x-journal-entry ${attributes.join(" ")}>${lineItems}${distractors}</x-journal-entry>`;
+  }
+  processLineItems(node) {
+    return node.lineItems.filter((item) => item.correct).map(
+      (item) => this.createLineItemHtml(item, { parentNode: node })
+    ).join("");
+  }
+  createLineItemHtml(item, metadata) {
+    if (!item.correct) return "";
+    const accountContent = createHtmlFromNestedEditor(
+      item.account,
+      metadata
+    );
+    const debitContent = item.debit ? createHtmlFromNestedEditor(item.debit, metadata) : "";
+    const creditContent = item.credit ? createHtmlFromNestedEditor(item.credit, metadata) : "";
+    return `<x-line-item id="${item.id}"><x-account>${accountContent}</x-account><x-debit>${debitContent}</x-debit><x-credit>${creditContent}</x-credit></x-line-item>`;
+  }
+  processDistractors(node) {
+    const distractors = node.lineItems.filter((item) => !item.correct).map((item) => {
+      const accountContent = createHtmlFromNestedEditor(
+        item.account,
+        { parentNode: node }
+      );
+      return `<x-distractor id="${item.id}">${accountContent}</x-distractor>`;
+    }).join("");
+    return distractors;
+  }
+};
+
+// src/typeGuards/isSerializedLineBreakNode.ts
+function isSerializedLineBreakNode(node) {
+  return node?.type === "linebreak";
+}
+
+// src/exportToHtml/LineBreakNodeHandler.ts
+var LineBreakNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedLineBreakNode(node)) return null;
+    return `<br>`;
+  }
+};
+
+// src/typeGuards/isSerializedLinkNode.ts
+var isSerializedLinkNode = (node) => {
+  return node.type === "link";
+};
+
+// src/exportToHtml/LinkNodeHandler.ts
+var LinkNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedLinkNode(node)) return null;
+    const childrenHtml = node.children.map((child) => traverse(child)).filter(Boolean).join("");
+    const relAttr = node.rel ? ` rel="${node.rel}"` : "";
+    const targetAttr = node.target ? ` target="${node.target}"` : "";
+    const titleAttr = node.title ? ` title="${node.title}"` : "";
+    return `<a href="${node.url}"${relAttr}${targetAttr}${titleAttr}>${childrenHtml}</a>`;
+  }
+};
+
+// src/typeGuards/isSerializedListItemNode.ts
+var isSerializedListItemNode = (node) => {
+  return node.type === "listitem";
+};
+
+// src/exportToHtml/ListItemNodeHandler.ts
+var ListItemNodeHandler = class extends NodeHandler {
+  processNode(node, metadata) {
+    if (!isSerializedListItemNode(node)) return null;
+    const children = [];
+    node.children.forEach((child) => {
+      const childString = traverse(child, {
+        ...metadata,
+        parentNode: node
+      });
+      if (childString) {
+        children.push(childString);
+      }
+    });
+    return `<li>${children.join("")}</li>`;
+  }
+};
+
+// src/typeGuards/isSerializedListNode.ts
+var isSerializedListNode = (node) => {
+  return node !== void 0 && node.type === "list";
+};
+
+// src/exportToHtml/ListNodeHandler.ts
+var ListNodeHandler = class extends NodeHandler {
+  processNode(node, metadata) {
+    if (!isSerializedListNode(node)) return null;
+    const tag = node.tag;
+    const children = [];
+    node.children.forEach((child) => {
+      const childString = traverse(child, {
+        ...metadata,
+        parentNode: node
+      });
+      if (childString) {
+        children.push(childString);
+      }
+    });
+    return `<${tag}>${children.join("")}</${tag}>`;
+  }
+};
+
+// src/typeGuards/isSerializedMatchingQuestionNode.ts
+function isSerializedMatchingQuestionNode(node) {
+  return node?.type === "matching-question" && "id" in node && typeof node.id === "string" && "items" in node && Array.isArray(node.items) && "pointsPerMatch" in node && typeof node.pointsPerMatch === "number";
+}
+
+// src/exportToHtml/MatchingQuestionNodeHandler.ts
+var MatchingQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedMatchingQuestionNode(node)) return null;
+    const matchingNode = node;
+    const attributes = [
+      `id="${matchingNode.id}"`,
+      "data-x-prompt",
+      `data-x-points-per-match="${matchingNode.pointsPerMatch}"`
+    ];
+    return `<x-matching ${attributes.join(" ")}>${this.createMatchesHtml(matchingNode)}${this.createDistractorsHtml(matchingNode)}</x-matching>`;
+  }
+  createMatchesHtml(node) {
+    const metadata = { parentNode: node };
+    return node.items.filter((item) => item.correct).map(
+      (item) => `<x-match><x-premise id="${item.id}">${createHtmlFromNestedEditor(
+        item.itemPremiseContent,
+        metadata
+      )}</x-premise><x-option id="${item.id}-option">${createHtmlFromNestedEditor(
+        item.itemOptionContent,
+        metadata
+      )}</x-option></x-match>`
+    ).join("");
+  }
+  createDistractorsHtml(node) {
+    const metadata = { parentNode: node };
+    return node.items.filter((item) => !item.correct).map(
+      (item) => `<x-distractor id="${item.id}">${createHtmlFromNestedEditor(
+        item.itemOptionContent,
+        metadata
+      )}</x-distractor>`
+    ).join("");
+  }
+};
+
+// src/typeGuards/isSerializedMultipleOptionQuestionNode.ts
+function isSerializedMultipleOptionQuestionNode(node) {
+  return node?.type === "multiple-option-question" && "id" in node && typeof node.id === "string" && "options" in node && Array.isArray(node.options) && "questionType" in node && typeof node.questionType === "string" && "points" in node && typeof node.points === "number";
+}
+
+// src/exportToHtml/MultipleOptionQuestionNodeHandler.ts
+var MultipleOptionQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedMultipleOptionQuestionNode(node)) return null;
+    if (node.questionType === "multiple-choice") {
+      return this.processMultipleChoiceNode(node);
+    } else if (node.questionType === "multiple-answers") {
+      return this.processMultipleAnswersNode(node);
+    }
+    return null;
+  }
+  processMultipleChoiceNode(node) {
+    const specificAttrs = {
+      choices: `data-x-choices="${node.choices ?? ""}"`
+    };
+    return this.buildQuestionHtml(
+      node,
+      "x-multiple-choice",
+      specificAttrs
+    );
+  }
+  processMultipleAnswersNode(node) {
+    const specificAttrs = {
+      grading: node.grading ? `data-x-exact-match="${node.grading === "exactMatch" ? "true" : "false"}"` : "",
+      correctChoices: `data-x-correct-choices="${node.correctChoices ?? ""}"`,
+      incorrectChoices: `data-x-incorrect-choices="${node.incorrectChoices ?? ""}"`
+    };
+    return this.buildQuestionHtml(
+      node,
+      "x-multiple-answers",
+      specificAttrs
+    );
+  }
+  buildQuestionHtml(node, tagName, specificAttrs) {
+    const options = this.processOptions(node);
+    const commonAttrs = {
+      points: `data-x-points="${node.points}"`,
+      noneOfTheAbove: `data-x-none-of-the-above="${node.noneOfTheAbove ? "true" : "false"}"`
+    };
+    const allAttrs = { ...commonAttrs, ...specificAttrs };
+    const attributes = Object.values(allAttrs).filter(Boolean).join(" ");
+    return `<${tagName} id="${node.id}" data-x-prompt ${attributes}>${options.join("")}</${tagName}>`;
+  }
+  processOptions(node) {
+    const options = [];
+    for (const option of node.options) {
+      options.push(
+        `<x-option id="${option.id}" data-x-correct="${option.correct}">${createHtmlFromNestedEditor(
+          option.content,
+          {
+            parentNode: node
+          }
+        )}</x-option>`
+      );
+    }
+    return options;
+  }
+};
+
+// src/typeGuards/isSerializedShortAnswerQuestionNode.ts
+function isSerializedShortAnswerQuestionNode(node) {
+  return node?.type === "short-answer-question" && "id" in node && typeof node.id === "string" && "points" in node && typeof node.points === "number" && "maxWords" in node && typeof node.maxWords === "number" && "notes" in node;
+}
+
+// src/typeGuards/isSerializedTableCellNode.ts
+function isSerializedTableCellNode(node) {
+  return node?.type === "tablecell";
+}
+
+// src/exportToHtml/ParagraphNodeHandler.ts
+var ELEMENT_TYPE_TO_FORMAT = {
+  center: "center",
+  end: "end",
+  justify: "justify",
+  left: "left",
+  right: "right",
+  start: "start"
+};
+var ParagraphNodeHandler = class extends NodeHandler {
+  shouldAvoidParagraphWrap(node) {
+    if (node === void 0) return false;
+    return isSerializedFillInTheBlankQuestionNode(node) || isSerializedFinancialStatementQuestionNode(node) || isSerializedJournalEntryQuestionNode(node) || isSerializedMatchingQuestionNode(node) || isSerializedMultipleOptionQuestionNode(node) || isSerializedShortAnswerQuestionNode(node) || isSerializedTableCellNode(node);
+  }
+  processNode(node, metadata) {
+    if (!isSerializedParagraphNode(node)) return null;
+    const children = [];
+    node.children.forEach((child) => {
+      const childString = traverse(child, {
+        ...metadata,
+        parentNode: node
+      });
+      if (childString) {
+        children.push(childString);
+      }
+    });
+    const attribute = node.format ? ` style="text-align: ${ELEMENT_TYPE_TO_FORMAT[node.format]}"` : "";
+    if (this.shouldAvoidParagraphWrap(metadata?.parentNode))
+      if (attribute)
+        return `<div${attribute}>${children.join("")}</div>`;
+      else return children.join("");
+    return `<p${attribute}>${children.join("")}</p>`;
+  }
+};
+
+// src/exportToHtml/ShortAnswerQuestionNodeHandler.ts
+var ShortAnswerQuestionNodeHandler = class extends NodeHandler {
+  processNode(node, metadata) {
+    if (!isSerializedShortAnswerQuestionNode(node)) {
+      return null;
+    }
+    const shortAnswerNode = node;
+    const attributes = [
+      `id="${shortAnswerNode.id}"`,
+      `data-x-prompt`,
+      `data-x-points="${shortAnswerNode.points}"`,
+      `data-x-max-words="${shortAnswerNode.maxWords}"`
+    ];
+    const notesContent = createHtmlFromNestedEditor(
+      shortAnswerNode.notes,
+      {
+        ...metadata,
+        parentNode: shortAnswerNode
+      }
+    );
+    return `<x-short-answer ${attributes.join(" ")}><x-notes>${notesContent}</x-notes></x-short-answer>`;
+  }
+};
+
+// src/typeGuards/isSerializedSimulationQuestionNode.ts
+function isSerializedSimulationQuestionNode(node) {
+  return node?.type === "simulation-question" && "id" in node && typeof node.id === "string" && "points" in node && typeof node.points === "number" && "step2Instructions" in node && typeof node.step2Instructions === "string";
+}
+
+// src/exportToHtml/SimulationQuestionNodeHandler.ts
+var SimulationQuestionNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedSimulationQuestionNode(node)) return null;
+    const aiChatModelAttr = node.aiChatModel ? ` data-x-ai-chat-model="${node.aiChatModel}"` : "";
+    const aiSystemMessage = node.aiSystemMessage ? `<x-ai-system-message>${node.aiSystemMessage}</x-ai-system-message>` : "";
+    const step2Instructions = node.step2Instructions ? `<x-step2-instructions>${node.step2Instructions}</x-step2-instructions>` : "";
+    return `<x-simulation id="${node.id}" data-x-prompt data-x-points="${node.points}"${aiChatModelAttr}>${aiSystemMessage}${step2Instructions}</x-simulation>`;
+  }
+};
+
+// src/typeGuards/isSerializedTableRowNode.ts
+function isSerializedTableRowNode(node) {
+  return node?.type === "tablerow" && "children" in node && Array.isArray(node.children);
+}
+
+// src/exportToHtml/TableCellNodeHandler.ts
+var TableCellNodeHandler = class extends NodeHandler {
+  processNode(node, metadata) {
+    if (!isSerializedTableCellNode(node)) return null;
+    const tableCellNode = node;
+    const styles = [];
+    let cellIndex = -1;
+    if (metadata?.parentNode && isSerializedTableRowNode(metadata.parentNode)) {
+      const rowNode = metadata.parentNode;
+      for (let i = 0; i < rowNode.children.length; i++) {
+        if (rowNode.children[i] === node) {
+          cellIndex = i;
+          break;
+        }
+      }
+    }
+    if (metadata?.colWidthPixels && cellIndex >= 0 && cellIndex < metadata.colWidthPixels.length) {
+      styles.push(`width: ${metadata.colWidthPixels[cellIndex]}px;`);
+    } else if (tableCellNode.width) {
+      styles.push(`width: ${tableCellNode.width}px;`);
+    }
+    if (tableCellNode.backgroundColor) {
+      styles.push(
+        `background-color: ${tableCellNode.backgroundColor};`
+      );
+    }
+    if (tableCellNode.verticalAlign) {
+      styles.push(`vertical-align: ${tableCellNode.verticalAlign};`);
+    }
+    const styleAttr = styles.length > 0 ? ` style="${styles.join(" ")}"` : "";
+    const tag = tableCellNode.headerState > 0 ? "th" : "td";
+    return `<${tag}${styleAttr}>${createHtmlFromNestedNodes(tableCellNode.children, { parentNode: tableCellNode })}</${tag}>`;
+  }
+};
+
+// src/typeGuards/isSerializedTableNode.ts
+function isSerializedTableNode(node) {
+  return node?.type === "table" && "children" in node && Array.isArray(node.children);
+}
+
+// src/exportToHtml/TableNodeHandler.ts
+var TableNodeHandler = class extends NodeHandler {
+  processNode(node, metadata) {
+    if (!isSerializedTableNode(node)) return null;
+    const tableNode = node;
+    const tableWidth = tableNode.colWidths?.reduce(
+      (acc, width) => acc + width,
+      0
+    );
+    let tableWidthStyle = "";
+    if (tableWidth) {
+      tableWidthStyle = `width: ${tableWidth}px;`;
+    }
+    const tableStyles = tableWidthStyle ? [tableWidthStyle] : [];
+    if (tableNode.rowStriping) {
+      tableStyles.push("border-collapse: collapse;");
+    }
+    const tableStyleAttr = tableStyles.length > 0 ? ` style="${tableStyles.join(" ")}"` : "";
+    const headerRows = [];
+    const bodyRows = [];
+    const isHeaderRow = (rowString) => {
+      return rowString.includes("<th");
+    };
+    const colWidths = [];
+    if (tableNode.colWidths) {
+      colWidths.push(...tableNode.colWidths);
+    }
+    tableNode.children?.forEach(
+      (child, index) => {
+        const childString = traverse(child, {
+          ...metadata,
+          parentNode: tableNode,
+          colWidthPixels: colWidths
+        });
+        if (childString) {
+          if (index < 2 && isHeaderRow(childString)) {
+            headerRows.push(childString);
+          } else {
+            bodyRows.push(childString);
+          }
+        }
+      }
+    );
+    let tableHtml = `<table${tableStyleAttr}>`;
+    if (headerRows.length > 0) {
+      tableHtml += `<thead>${headerRows.join("")}</thead>`;
+    }
+    if (bodyRows.length > 0) {
+      tableHtml += `<tbody>${bodyRows.join("")}</tbody>`;
+    }
+    tableHtml += "</table>";
+    return tableHtml;
+  }
+};
+
+// src/exportToHtml/TableRowNodeHandler.ts
+var TableRowNodeHandler = class extends NodeHandler {
+  processNode(node, metadata) {
+    if (!isSerializedTableRowNode(node)) return null;
+    const tableRowNode = node;
+    const children = [];
+    tableRowNode.children?.forEach((child) => {
+      const childString = traverse(child, {
+        parentNode: node,
+        colWidthPixels: metadata?.colWidthPixels
+      });
+      if (childString) {
+        children.push(childString);
+      }
+    });
+    const heightAttr = tableRowNode.height ? ` style="height: ${tableRowNode.height}px;"` : "";
+    return `<tr${heightAttr}>${children.join("")}</tr>`;
+  }
+};
+
+// src/typeGuards/isSerializedTextNode.ts
+function isSerializedTextNode(node) {
+  return node?.type === "text" && "text" in node && typeof node.text === "string";
+}
+
+// src/exportToHtml/TextNodeHandler.ts
+var IS_BOLD = 1;
+var IS_ITALIC = 1 << 1;
+var IS_STRIKETHROUGH = 1 << 2;
+var IS_UNDERLINE = 1 << 3;
+var IS_CODE = 1 << 4;
+var IS_SUBSCRIPT = 1 << 5;
+var IS_SUPERSCRIPT = 1 << 6;
+var IS_HIGHLIGHT = 1 << 7;
+var IS_LOWERCASE = 1 << 8;
+var IS_UPPERCASE = 1 << 9;
+var IS_CAPITALIZE = 1 << 10;
+var TEXT_TYPE_TO_FORMAT = {
+  bold: IS_BOLD,
+  capitalize: IS_CAPITALIZE,
+  code: IS_CODE,
+  highlight: IS_HIGHLIGHT,
+  italic: IS_ITALIC,
+  lowercase: IS_LOWERCASE,
+  strikethrough: IS_STRIKETHROUGH,
+  subscript: IS_SUBSCRIPT,
+  superscript: IS_SUPERSCRIPT,
+  underline: IS_UNDERLINE,
+  uppercase: IS_UPPERCASE
+};
+function hasFormat(format, type) {
+  const formatFlag = TEXT_TYPE_TO_FORMAT[type];
+  return (format & formatFlag) !== 0;
+}
+function encodeHTMLEntities(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var TextNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedTextNode(node)) return null;
+    let result = encodeHTMLEntities(node.text);
+    if (hasFormat(node.format, "subscript")) {
+      result = `<sub>${result}</sub>`;
+    } else if (hasFormat(node.format, "superscript")) {
+      result = `<sup>${result}</sup>`;
+    }
+    if (hasFormat(node.format, "code")) {
+      result = `<code>${result}</code>`;
+    }
+    if (hasFormat(node.format, "strikethrough")) {
+      result = `<s>${result}</s>`;
+    }
+    if (hasFormat(node.format, "underline")) {
+      result = `<u>${result}</u>`;
+    }
+    if (hasFormat(node.format, "italic")) {
+      result = `<em>${result}</em>`;
+    }
+    if (hasFormat(node.format, "bold")) {
+      result = `<strong>${result}</strong>`;
+    }
+    const styles = [];
+    if (hasFormat(node.format, "lowercase")) {
+      styles.push("text-transform: lowercase");
+    } else if (hasFormat(node.format, "uppercase")) {
+      styles.push("text-transform: uppercase");
+    } else if (hasFormat(node.format, "capitalize")) {
+      styles.push("text-transform: capitalize");
+    }
+    if (hasFormat(node.format, "highlight")) {
+      styles.push("background-color: yellow");
+    }
+    let styleString = styles.join(";");
+    if (node.style) {
+      styleString = styleString ? `${styleString};${node.style}` : node.style;
+    }
+    if (styleString.trim().length > 0) {
+      result = `<span style="${styleString.trim()}">${result}</span>`;
+    }
+    return result;
+  }
+};
+
+// src/typeGuards/isSerializedVariableNode.ts
+function isSerializedVariableNode(node) {
+  return node?.type === "variable" && typeof node.variableName === "string";
+}
+
+// src/exportToHtml/VariableNodeHandler.ts
+var VariableNodeHandler = class extends NodeHandler {
+  processNode(node) {
+    if (!isSerializedVariableNode(node)) return null;
+    const formatAttribute = node.variableFormat ? ` data-x-format="${node.variableFormat}"` : "";
+    let result = `<x-param data-x-name="${node.variableName}"${formatAttribute}></x-param>`;
+    if (node.isUnderline) {
+      result = `<u>${result}</u>`;
+    }
+    if (node.isItalic) {
+      result = `<em>${result}</em>`;
+    }
+    if (node.isBold) {
+      result = `<strong>${result}</strong>`;
+    }
+    return result;
+  }
+};
+
+// src/exportToHtml/traverse.ts
+var builder = new NodeHandlerChainBuilder();
+var nodeHandlerChain = builder.addHandler(EssayQuestionNodeHandler).addHandler(FillInTheBlankQuestionNodeHandler).addHandler(FillInTheBlankSpaceNodeHandler).addHandler(FinancialStatementQuestionNodeHandler).addHandler(HorizontalRuleNodeHandler).addHandler(ImageNodeHandler).addHandler(JournalEntryQuestionNodeHandler).addHandler(LineBreakNodeHandler).addHandler(LinkNodeHandler).addHandler(ListNodeHandler).addHandler(ListItemNodeHandler).addHandler(MatchingQuestionNodeHandler).addHandler(MultipleOptionQuestionNodeHandler).addHandler(ParagraphNodeHandler).addHandler(ShortAnswerQuestionNodeHandler).addHandler(SimulationQuestionNodeHandler).addHandler(TableCellNodeHandler).addHandler(TableNodeHandler).addHandler(TableRowNodeHandler).addHandler(TextNodeHandler).addHandler(VariableNodeHandler).build();
+var traverse = (node, metadata) => {
+  return nodeHandlerChain.handle(node, metadata);
+};
+
+// src/exportToHtml/index.ts
+function exportToHtml(editorState) {
+  const rootNode = editorState.root;
+  const children = [];
+  for (const childNode of rootNode.children) {
+    const element = traverse(childNode);
+    if (element) {
+      children.push(element);
+    }
+  }
+  return children.join("");
+}
+
+// src/importFromHtml/index.ts
+var import_node_html_parser26 = require("node-html-parser");
+
+// src/importFromHtml/createEmptyParagraphNode.ts
+function createEmptyParagraphNode(format = "") {
+  return {
+    direction: "ltr",
+    format,
+    indent: 0,
+    textFormat: 0,
+    textStyle: "",
+    type: "paragraph",
+    version: 1,
+    children: []
+  };
+}
+
+// src/importFromHtml/DivNodeHandler.ts
+var import_node_html_parser2 = require("node-html-parser");
+
+// src/importFromHtml/createNestedNodesFromHtml.ts
+var import_node_html_parser = require("node-html-parser");
+var wrapInlinesInParagraph = (inlineNodes, format = "") => {
+  const paragraph = createEmptyParagraphNode(format);
+  paragraph.children = inlineNodes;
+  return paragraph;
+};
+var appendInlinesInParagraphIfNotEmptyBR = (results, inlineNodes, format) => {
+  if (!inlineNodes.length) return;
+  if (inlineNodes.length === 1 && isSerializedLineBreakNode(inlineNodes[0]))
+    return;
+  results.push(wrapInlinesInParagraph(inlineNodes, format));
+};
+var extractFormatFromStyle = (styleAttribute) => {
+  if (!styleAttribute) return "";
+  const textAlignMatch = styleAttribute.match(
+    /text-align:\s*(left|right|center)/i
+  );
+  if (textAlignMatch) {
+    const alignment = textAlignMatch[1].toLowerCase();
+    if (alignment === "left") return "left";
+    if (alignment === "right") return "right";
+    if (alignment === "center") return "center";
+  }
+  return "";
+};
+var createNestedNodesFromHtml = (node) => {
+  const parentStyleAttribute = node instanceof import_node_html_parser.HTMLElement ? node.getAttribute("style") : null;
+  const format = extractFormatFromStyle(parentStyleAttribute);
+  if (node.childNodes.length === 1 && node.childNodes[0] instanceof import_node_html_parser.HTMLElement && node.childNodes[0].tagName === "BR") {
+    return [createEmptyParagraphNode(format)];
+  }
+  const results = [];
+  let inlineNodes = [];
+  for (const child of node.childNodes) {
+    const processedChildren = traverse2(child);
+    for (const processedChild of processedChildren) {
+      const isBlockElement = processedChild.type === "paragraph" || processedChild.type === "table" || processedChild.type === "list";
+      if (isBlockElement) {
+        appendInlinesInParagraphIfNotEmptyBR(
+          results,
+          inlineNodes,
+          format
+        );
+        inlineNodes = [];
+        results.push(processedChild);
+      } else {
+        inlineNodes.push(processedChild);
+      }
+    }
+  }
+  appendInlinesInParagraphIfNotEmptyBR(results, inlineNodes, format);
+  if (results.length === 0) return [createEmptyParagraphNode(format)];
+  else return results;
+};
+
+// src/importFromHtml/types.ts
+var NodeHandler2 = class {
+  constructor() {
+    this.nextHandler = null;
+  }
+  getChildNodesTextContent(childNodes) {
+    return childNodes.reduce((acc, item) => {
+      const text = item.textContent || "";
+      return acc + text.trim() + " ";
+    }, "").trimEnd();
+  }
+  setNext(handler) {
+    this.nextHandler = handler;
+    return handler;
+  }
+  handle(node) {
+    const result = this.processNode(node);
+    if (result) {
+      return result;
+    } else if (this.nextHandler) {
+      return this.nextHandler.handle(node);
+    }
+    return null;
+  }
+};
+
+// src/importFromHtml/DivNodeHandler.ts
+var isHtmlDivElement = (node) => {
+  return node instanceof import_node_html_parser2.HTMLElement && node.tagName === "DIV";
+};
+var DivNodeHandler = class extends NodeHandler2 {
+  processNode(node) {
+    if (!isHtmlDivElement(node)) {
+      return null;
+    }
+    return createNestedNodesFromHtml(node);
+  }
+};
+
+// src/importFromHtml/EssayQuestionNodeHandler.ts
+var import_nanoid = require("nanoid");
+var import_node_html_parser3 = require("node-html-parser");
+var TAG_X_ESSAY = "x-essay";
+var TAG_X_SYSTEM_MESSAGE = "x-ai-system-message";
+var EssayQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser3.HTMLElement) || node.tagName !== TAG_X_ESSAY.toUpperCase()) {
+      return null;
+    }
+    const jsonNode = {
+      id: node.getAttribute("id") ?? (0, import_nanoid.nanoid)(),
+      points: Number(node.getAttribute("data-x-points") || 0),
+      maxWords: Number(node.getAttribute("data-x-max-words") || 0),
+      hideChat: node.getAttribute("data-x-hide-chat") === "true",
+      aiChatModel: node.getAttribute("data-x-ai-chat-model") || null,
+      aiSystemMessage: "",
+      type: "essay-question",
+      version: 1
+    };
+    const systemMessageElement = node.querySelector(
+      TAG_X_SYSTEM_MESSAGE
+    );
+    if (systemMessageElement)
+      jsonNode.aiSystemMessage = this.getChildNodesTextContent(
+        systemMessageElement.childNodes
+      );
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/FillInTheBlankQuestionNodeHandler.ts
+var import_nanoid2 = require("nanoid");
+var import_node_html_parser4 = require("node-html-parser");
+
+// src/importFromHtml/createNestedEditorFromHtml.ts
+function createNestedEditorFromHtml(node) {
+  return {
+    editorState: {
+      root: {
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        version: 0,
+        type: "root",
+        children: node ? createNestedNodesFromHtml(node) : [createEmptyParagraphNode()]
+      }
+    }
+  };
+}
+
+// src/importFromHtml/FillInTheBlankQuestionNodeHandler.ts
+var FillInTheBlankQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser4.HTMLElement) || node.tagName !== "x-fill-in-the-blank".toUpperCase())
+      return null;
+    const jsonNode = {
+      id: node.getAttribute("id") ?? (0, import_nanoid2.nanoid)(),
+      pointsPerSpace: Number(
+        node.getAttribute("data-x-points-per-space") ?? 1
+      ),
+      content: createNestedEditorFromHtml(node),
+      type: "fill-in-the-blank-question",
+      version: 1
+    };
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/FillInTheBlankSpaceNodeHandler.ts
+var import_nanoid3 = require("nanoid");
+var import_node_html_parser5 = require("node-html-parser");
+var FillInTheBlankSpaceNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser5.HTMLElement) || node.tagName !== "x-space".toUpperCase())
+      return null;
+    const spaceTypeAttr = node.getAttribute("data-x-type");
+    const spaceType = spaceTypeAttr === "Text" || spaceTypeAttr === "Number" || spaceTypeAttr === "Dropdown" ? spaceTypeAttr : "Text";
+    const baseNode = {
+      id: node.getAttribute("id") ?? (0, import_nanoid3.nanoid)(),
+      spaceName: node.text,
+      // Can probably be removed after this: https://github.com/examind-ai/block-editor/issues/137
+      matches: node.getAttribute("data-x-matches") ?? "",
+      spaceType,
+      type: "space",
+      version: 1
+    };
+    switch (spaceType) {
+      case "Text":
+        return this.processTextSpace(node, baseNode);
+      case "Number":
+        return this.processNumberSpace(node, baseNode);
+      case "Dropdown":
+        return this.processDropdownSpace(node, baseNode);
+      default:
+        throw new Error(`Unsupported space type: ${spaceType}`);
+    }
+  }
+  processTextSpace(node, baseNode) {
+    return {
+      ...baseNode,
+      caseSensitive: node.getAttribute("data-x-case-sensitive") === "true",
+      errorsAllowed: node.getAttribute("data-x-errors-allowed") ? Number(node.getAttribute("data-x-errors-allowed")) : void 0
+    };
+  }
+  processNumberSpace(node, baseNode) {
+    return {
+      ...baseNode,
+      minDecimals: node.getAttribute("data-x-min-decimals") ? Number(node.getAttribute("data-x-min-decimals")) : void 0,
+      errorTolerance: node.getAttribute("data-x-error-tolerance") ? Number(node.getAttribute("data-x-error-tolerance")) : void 0
+    };
+  }
+  processDropdownSpace(node, baseNode) {
+    return {
+      ...baseNode,
+      distractors: node.getAttribute("data-x-distractors") ?? void 0
+    };
+  }
+};
+
+// src/importFromHtml/FinancialStatementQuestionNodeHandler.ts
+var import_nanoid4 = require("nanoid");
+var import_node_html_parser6 = require("node-html-parser");
+var TAG_X_FINANCIAL_STATEMENT = "x-financial-statement";
+var TAG_X_HEADER = "x-header";
+var TAG_X_ROWS = "x-rows";
+var TAG_X_DISTRACTORS = "x-distractors";
+var TAG_X_HEADING = "x-heading";
+var TAG_X_LINE = "x-line";
+var TAG_X_DISTRACTOR = "x-distractor";
+var TAG_X_ENTRY = "x-entry";
+var TAG_X_AMOUNT = "x-amount";
+var FinancialStatementQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser6.HTMLElement) || node.tagName !== TAG_X_FINANCIAL_STATEMENT.toUpperCase()) {
+      return null;
+    }
+    const headerElement = node.querySelector(TAG_X_HEADER);
+    const jsonNode = {
+      id: node.getAttribute("id") ?? (0, import_nanoid4.nanoid)(),
+      points: Number(node.getAttribute("data-x-points") || 10),
+      header: this.processHeaderElement(headerElement),
+      columnHeaders: this.extractColumnHeaders(headerElement),
+      rows: [],
+      distractors: [],
+      type: "financial-statement-question",
+      version: 1
+    };
+    node.childNodes.forEach((child) => {
+      if (!(child instanceof import_node_html_parser6.HTMLElement)) return;
+      if (child.tagName === TAG_X_DISTRACTORS.toUpperCase()) {
+        this.processDistractorsNode(child, jsonNode);
+      } else if (child.tagName === TAG_X_ROWS.toUpperCase()) {
+        this.processRowsNode(child, jsonNode);
+      }
+    });
+    return jsonNode;
+  }
+  processDistractorsNode(distractorsNode, jsonNode) {
+    for (const distractorsChild of distractorsNode.childNodes) {
+      if (!(distractorsChild instanceof import_node_html_parser6.HTMLElement)) continue;
+      if (distractorsChild.tagName !== TAG_X_DISTRACTOR.toUpperCase())
+        continue;
+      jsonNode.distractors.push({
+        id: distractorsChild.getAttribute("id") || (0, import_nanoid4.nanoid)(),
+        entry: this.getChildNodesTextContent(
+          distractorsChild.childNodes
+        )
+      });
+    }
+  }
+  // Using the getChildNodesTextContent method from the base NodeHandler class
+  processHeaderElement(headerElement) {
+    if (!headerElement) return createNestedEditorFromHtml(null);
+    const flexDiv = headerElement.querySelector(
+      'div[style*="display:flex"]'
+    );
+    if (flexDiv) {
+      const contentDiv = headerElement.querySelector(
+        'div > div:not([style*="display:flex"])'
+      );
+      if (contentDiv && contentDiv instanceof import_node_html_parser6.HTMLElement) {
+        const contentDivClone = contentDiv.clone();
+        contentDivClone.setAttribute("style", "text-align: left;");
+        return createNestedEditorFromHtml(contentDivClone);
+      }
+    }
+    return createNestedEditorFromHtml(headerElement);
+  }
+  extractColumnHeaders(headerElement) {
+    if (!headerElement) return [];
+    const flexDiv = headerElement.querySelector(
+      'div[style*="display:flex"]'
+    );
+    if (flexDiv) {
+      return Array.from(flexDiv.querySelectorAll("div")).map((div) => div.textContent?.trim() || "").filter(Boolean);
+    }
+    return [];
+  }
+  processRowsNode(rowsNode, jsonNode) {
+    for (const rowsChild of rowsNode.childNodes) {
+      if (!(rowsChild instanceof import_node_html_parser6.HTMLElement)) continue;
+      if (rowsChild.tagName === TAG_X_HEADING.toUpperCase()) {
+        this.processHeadingRow(rowsChild, jsonNode);
+      } else if (rowsChild.tagName === TAG_X_LINE.toUpperCase()) {
+        this.processLineRow(rowsChild, jsonNode);
+      }
+    }
+  }
+  processHeadingRow(headingNode, jsonNode) {
+    jsonNode.rows.push({
+      id: headingNode.getAttribute("id") || (0, import_nanoid4.nanoid)(),
+      depth: Number(headingNode.getAttribute("data-x-depth") || 0),
+      isHint: headingNode.getAttribute("data-x-is-hint") === "true",
+      type: "Heading",
+      entry: headingNode.rawText
+    });
+  }
+  processLineRow(lineNode, jsonNode) {
+    jsonNode.rows.push({
+      type: "Line",
+      role: "line-item",
+      id: lineNode.getAttribute("id") || "",
+      depth: Number(lineNode.getAttribute("data-x-depth") || 0),
+      entry: lineNode.querySelector(TAG_X_ENTRY)?.textContent || "",
+      amount: createNestedEditorFromHtml(
+        lineNode.querySelector(TAG_X_AMOUNT)
+      ),
+      isAmountHint: lineNode.getAttribute("data-x-is-amount-hint") === "true",
+      isEntryHint: lineNode.getAttribute("data-x-is-entry-hint") === "true"
+    });
+  }
+};
+
+// src/importFromHtml/FormattedNodeHandler.ts
+var import_node_html_parser7 = require("node-html-parser");
+var IS_BOLD2 = 1;
+var IS_ITALIC2 = 1 << 1;
+var IS_STRIKETHROUGH2 = 1 << 2;
+var IS_UNDERLINE2 = 1 << 3;
+var IS_CODE2 = 1 << 4;
+var IS_SUBSCRIPT2 = 1 << 5;
+var IS_SUPERSCRIPT2 = 1 << 6;
+var IS_HIGHLIGHT2 = 1 << 7;
+var IS_LOWERCASE2 = 1 << 8;
+var IS_UPPERCASE2 = 1 << 9;
+var IS_CAPITALIZE2 = 1 << 10;
+var TAG_TO_FORMAT = {
+  B: IS_BOLD2,
+  STRONG: IS_BOLD2,
+  I: IS_ITALIC2,
+  EM: IS_ITALIC2,
+  U: IS_UNDERLINE2,
+  S: IS_STRIKETHROUGH2,
+  STRIKE: IS_STRIKETHROUGH2,
+  DEL: IS_STRIKETHROUGH2,
+  SUB: IS_SUBSCRIPT2,
+  SUP: IS_SUPERSCRIPT2,
+  CODE: IS_CODE2,
+  MARK: IS_HIGHLIGHT2
+};
+function formatToProps(format) {
+  return {
+    isBold: (format & IS_BOLD2) !== 0,
+    isItalic: (format & IS_ITALIC2) !== 0,
+    isStrikethrough: (format & IS_STRIKETHROUGH2) !== 0,
+    isUnderline: (format & IS_UNDERLINE2) !== 0,
+    isCode: (format & IS_CODE2) !== 0,
+    isSubscript: (format & IS_SUBSCRIPT2) !== 0,
+    isSuperscript: (format & IS_SUPERSCRIPT2) !== 0,
+    isHighlight: (format & IS_HIGHLIGHT2) !== 0
+  };
+}
+var FormattedNodeHandler = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser7.HTMLElement)) return null;
+    const tagName = node.tagName;
+    if (!tagName || !(tagName in TAG_TO_FORMAT)) return null;
+    const formatFlag = TAG_TO_FORMAT[tagName];
+    const results = [];
+    for (const childNode of node.childNodes) {
+      const processedChildren = traverse2(childNode);
+      for (const child of processedChildren) {
+        if (isSerializedTextNode(child)) {
+          const result = {
+            ...child,
+            format: (child.format || 0) | formatFlag
+          };
+          results.push(result);
+        } else if (isSerializedVariableNode(child)) {
+          const result = {
+            ...child,
+            isBold: child.isBold || formatToProps(formatFlag).isBold,
+            isItalic: child.isItalic || formatToProps(formatFlag).isItalic,
+            isUnderline: child.isUnderline || formatToProps(formatFlag).isUnderline
+          };
+          results.push(result);
+        } else {
+          results.push(child);
+        }
+      }
+    }
+    if (results.length > 0) {
+      return results;
+    }
+    return null;
+  }
+};
+
+// src/importFromHtml/HorizontalRuleNodeHandler.ts
+var import_node_html_parser8 = require("node-html-parser");
+var TAG_HR = "hr";
+var HorizontalRuleNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser8.HTMLElement) || node.tagName !== TAG_HR.toUpperCase()) {
+      return null;
+    }
+    const horizontalRuleNode = {
+      type: "horizontalrule",
+      version: 1
+    };
+    return horizontalRuleNode;
+  }
+};
+
+// src/importFromHtml/ImageNodeHandler.ts
+var import_node_html_parser9 = require("node-html-parser");
+var TAG_IMG = "img";
+var ImageNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser9.HTMLElement) || node.tagName !== TAG_IMG.toUpperCase()) {
+      return null;
+    }
+    const src = node.getAttribute("src") || "";
+    const altText = node.getAttribute("alt") || "";
+    const width = node.getAttribute("width") || "";
+    const align = node.getAttribute("align") || "left";
+    const imageNode = {
+      src,
+      altText,
+      width,
+      align,
+      showBorder: false,
+      showCaption: false,
+      caption: {
+        editorState: {
+          root: {
+            children: [],
+            direction: null,
+            format: "",
+            indent: 0,
+            type: "root",
+            version: 1
+          }
+        }
+      },
+      type: "image",
+      version: 1
+    };
+    return imageNode;
+  }
+};
+
+// src/importFromHtml/JournalEntryQuestionNodeHandler.ts
+var import_nanoid5 = require("nanoid");
+var import_node_html_parser10 = require("node-html-parser");
+var JournalEntryQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser10.HTMLElement) || node.tagName !== "x-journal-entry".toUpperCase())
+      return null;
+    const noEntryRequiredCorrect = node.getAttribute("data-x-no-entry-required-correct") === "true";
+    const noEntryRequiredDistractor = node.getAttribute("data-x-no-entry-required-distractor") === "true";
+    const journalType = noEntryRequiredCorrect ? "noEntryRequiredCorrect" : noEntryRequiredDistractor ? "noEntryRequiredDistractor" : "default";
+    const jsonNode = {
+      id: node.getAttribute("id") ?? (0, import_nanoid5.nanoid)(),
+      points: Number(node.getAttribute("data-x-points") ?? 1),
+      journalType,
+      errorTolerance: node.getAttribute("data-x-error-tolerance") ? Number(node.getAttribute("data-x-error-tolerance")) : void 0,
+      lineItems: [],
+      type: "journal-entry-question",
+      version: 1
+    };
+    const lineItems = node.querySelectorAll("x-line-item");
+    lineItems.forEach((lineItem) => {
+      if (!(lineItem instanceof import_node_html_parser10.HTMLElement)) return;
+      const accountElement = lineItem.querySelector("x-account");
+      const debitElement = lineItem.querySelector("x-debit");
+      const creditElement = lineItem.querySelector("x-credit");
+      if (!accountElement) return;
+      const item = {
+        id: lineItem.getAttribute("id") ?? (0, import_nanoid5.nanoid)(),
+        correct: true,
+        account: createNestedEditorFromHtml(accountElement)
+      };
+      if (debitElement) {
+        item.debit = createNestedEditorFromHtml(debitElement);
+      }
+      if (creditElement) {
+        item.credit = createNestedEditorFromHtml(creditElement);
+      }
+      jsonNode.lineItems.push(item);
+    });
+    const distractors = node.querySelectorAll("x-distractor");
+    distractors.forEach((distractor) => {
+      if (!(distractor instanceof import_node_html_parser10.HTMLElement)) return;
+      const item = {
+        id: distractor.getAttribute("id") ?? (0, import_nanoid5.nanoid)(),
+        correct: false,
+        account: createNestedEditorFromHtml(distractor)
+      };
+      jsonNode.lineItems.push(item);
+    });
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/LineBreakNodeHandler.ts
+var import_node_html_parser11 = require("node-html-parser");
+var LineBreakNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser11.HTMLElement)) return null;
+    if (node.tagName !== "BR") return null;
+    return {
+      type: "linebreak",
+      version: 1
+    };
+  }
+};
+
+// src/importFromHtml/LinkNodeHandler.ts
+var import_node_html_parser12 = require("node-html-parser");
+var TAG_A = "a";
+var LinkNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser12.HTMLElement) || node.tagName !== TAG_A.toUpperCase()) {
+      return null;
+    }
+    const url = node.getAttribute("href") || "";
+    const rel = node.getAttribute("rel") || null;
+    const target = node.getAttribute("target") || null;
+    const title = node.getAttribute("title") || null;
+    const children = [];
+    for (const childNode of node.childNodes) {
+      const processedChildren = traverse2(childNode);
+      children.push(...processedChildren);
+    }
+    const linkNode = {
+      url,
+      rel,
+      target,
+      title,
+      children,
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "link",
+      version: 1
+    };
+    return linkNode;
+  }
+};
+
+// src/importFromHtml/ListItemNodeHandler.ts
+var import_node_html_parser13 = require("node-html-parser");
+var ListItemNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser13.HTMLElement)) return null;
+    if (node.tagName !== "LI") return null;
+    const jsonNode = {
+      type: "listitem",
+      version: 1,
+      children: [],
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      value: 1,
+      // Default value, will be overridden by parent list
+      checked: void 0
+    };
+    node.childNodes.forEach((child) => {
+      jsonNode.children.push(...traverse2(child));
+    });
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/ListNodeHandler.ts
+var import_node_html_parser14 = require("node-html-parser");
+var ListNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser14.HTMLElement)) return null;
+    if (node.tagName !== "UL" && node.tagName !== "OL") return null;
+    const tag = node.tagName.toLowerCase();
+    const listType = tag === "ol" ? "number" : "bullet";
+    const start = 1;
+    const jsonNode = {
+      type: "list",
+      version: 1,
+      tag,
+      listType,
+      start,
+      children: [],
+      direction: null,
+      format: "",
+      indent: 0
+    };
+    let itemIndex = 1;
+    node.childNodes.forEach((child) => {
+      if (child instanceof import_node_html_parser14.HTMLElement && child.tagName === "LI") {
+        const listItemNode = {
+          type: "listitem",
+          version: 1,
+          children: [],
+          direction: "ltr",
+          format: "",
+          indent: 0,
+          value: itemIndex++,
+          // Increment item index for each list item
+          checked: void 0
+        };
+        child.childNodes.forEach((itemChild) => {
+          const processedChildren = traverse2(itemChild);
+          listItemNode.children.push(...processedChildren);
+        });
+        jsonNode.children.push(listItemNode);
+      }
+    });
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/MatchingQuestionNodeHandler.ts
+var import_nanoid6 = require("nanoid");
+var import_node_html_parser15 = require("node-html-parser");
+var MatchingQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser15.HTMLElement) || node.tagName !== "x-matching".toUpperCase())
+      return null;
+    const jsonNode = {
+      id: node.getAttribute("id") ?? (0, import_nanoid6.nanoid)(),
+      pointsPerMatch: Number(
+        node.getAttribute("data-x-points-per-match") ?? 1
+      ),
+      items: [],
+      type: "matching-question",
+      version: 1
+    };
+    const childNodes = node.childNodes;
+    childNodes.forEach((child) => {
+      if (!(child instanceof import_node_html_parser15.HTMLElement)) return;
+      if (child.tagName === "x-match".toUpperCase()) {
+        const premise = child.querySelector("x-premise");
+        const option = child.querySelector("x-option");
+        if (!premise || !option) return;
+        jsonNode.items.push({
+          id: premise.getAttribute("id") ?? (0, import_nanoid6.nanoid)(),
+          correct: true,
+          itemPremiseContent: createNestedEditorFromHtml(premise),
+          itemOptionContent: createNestedEditorFromHtml(option)
+        });
+      }
+      if (child.tagName === "x-distractor".toUpperCase()) {
+        jsonNode.items.push({
+          id: child.getAttribute("id") ?? (0, import_nanoid6.nanoid)(),
+          correct: false,
+          itemOptionContent: createNestedEditorFromHtml(child)
+        });
+      }
+    });
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/MultipleOptionQuestionNodeHandler.ts
+var import_nanoid7 = require("nanoid");
+var import_node_html_parser16 = require("node-html-parser");
+var MultipleOptionQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser16.HTMLElement)) return null;
+    if (node.tagName === "x-multiple-choice".toUpperCase())
+      return this.processMultipleChoiceNode(node);
+    else if (node.tagName === "x-multiple-answers".toUpperCase())
+      return this.processMultipleAnswersNode(node);
+    else return null;
+  }
+  processMultipleChoiceNode(node) {
+    const jsonNode = {
+      options: [],
+      id: node.getAttribute("id") ?? (0, import_nanoid7.nanoid)(),
+      questionType: "multiple-choice",
+      points: Number(node.getAttribute("data-x-points") || 0),
+      choices: node.getAttribute("data-x-choices") ? Number(node.getAttribute("data-x-choices")) : void 0,
+      noneOfTheAbove: node.getAttribute("data-x-none-of-the-above") === "true",
+      type: "multiple-option-question",
+      version: 1
+    };
+    this.processOptions(node, jsonNode);
+    return jsonNode;
+  }
+  processMultipleAnswersNode(node) {
+    const jsonNode = {
+      options: [],
+      id: node.getAttribute("id") ?? (0, import_nanoid7.nanoid)(),
+      questionType: "multiple-answers",
+      points: Number(node.getAttribute("data-x-points") || 0),
+      correctChoices: node.getAttribute("data-x-correct-choices") ? Number(node.getAttribute("data-x-correct-choices")) : void 0,
+      incorrectChoices: node.getAttribute("data-x-incorrect-choices") ? Number(node.getAttribute("data-x-incorrect-choices")) : void 0,
+      grading: node.getAttribute("data-x-exact-match") === "true" ? "exactMatch" : node.getAttribute("data-x-exact-match") === "false" ? "partialCreditWithPenalty" : void 0,
+      noneOfTheAbove: node.getAttribute("data-x-none-of-the-above") === "true",
+      type: "multiple-option-question",
+      version: 1
+    };
+    this.processOptions(node, jsonNode);
+    return jsonNode;
+  }
+  processOptions(node, jsonNode) {
+    const childNodes = node.childNodes;
+    childNodes.forEach((child) => {
+      if (!(child instanceof import_node_html_parser16.HTMLElement)) return;
+      if (child.tagName !== "x-option".toUpperCase()) return;
+      jsonNode.options.push({
+        id: child.getAttribute("id") ?? (0, import_nanoid7.nanoid)(),
+        correct: child.getAttribute("data-x-correct") === "true",
+        content: createNestedEditorFromHtml(child)
+      });
+    });
+  }
+};
+
+// src/importFromHtml/ParagraphNodeHandler.ts
+var import_node_html_parser17 = require("node-html-parser");
+var TEXT_ALIGN_TO_FORMAT = {
+  center: "center",
+  end: "end",
+  justify: "justify",
+  left: "left",
+  right: "right",
+  start: "start"
+};
+var ParagraphNodeHandler2 = class extends NodeHandler2 {
+  extractTextAlignment(element) {
+    if (!element.hasAttribute("style")) return "";
+    const styleAttr = element.getAttribute("style");
+    const textAlignMatch = styleAttr?.match(/text-align:\s*([^;]+)/i);
+    if (textAlignMatch && textAlignMatch[1]) {
+      const textAlign = textAlignMatch[1].trim();
+      if (textAlign in TEXT_ALIGN_TO_FORMAT) {
+        return TEXT_ALIGN_TO_FORMAT[textAlign];
+      }
+    }
+    return "";
+  }
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser17.HTMLElement)) return null;
+    if (node.tagName !== "P") return null;
+    const jsonNode = createEmptyParagraphNode();
+    jsonNode.format = this.extractTextAlignment(node);
+    if (node.childNodes.length === 1 && node.childNodes[0] instanceof import_node_html_parser17.HTMLElement && node.childNodes[0].tagName === "BR")
+      return jsonNode;
+    node.childNodes.forEach((child) => {
+      const processedChildren = traverse2(child);
+      jsonNode.children.push(...processedChildren);
+    });
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/ShortAnswerQuestionNodeHandler.ts
+var import_nanoid8 = require("nanoid");
+var import_node_html_parser18 = require("node-html-parser");
+var ShortAnswerQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser18.HTMLElement) || node.tagName !== "x-short-answer".toUpperCase())
+      return null;
+    return {
+      id: node.getAttribute("id") ?? (0, import_nanoid8.nanoid)(),
+      points: Number(node.getAttribute("data-x-points") ?? 1),
+      maxWords: Number(node.getAttribute("data-x-max-words") ?? 100),
+      notes: createNestedEditorFromHtml(
+        node.querySelector("x-notes")
+      ),
+      type: "short-answer-question",
+      version: 1
+    };
+  }
+};
+
+// src/importFromHtml/SimulationQuestionNodeHandler.ts
+var import_node_html_parser19 = require("node-html-parser");
+var TAG_X_SIMULATION = "x-simulation";
+var TAG_X_SYSTEM_MESSAGE2 = "x-ai-system-message";
+var TAG_X_STEP2_INSTRUCTIONS = "x-step2-instructions";
+var SimulationQuestionNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser19.HTMLElement) || node.tagName !== TAG_X_SIMULATION.toUpperCase()) {
+      return null;
+    }
+    const jsonNode = {
+      id: node.getAttribute("id") || "",
+      points: Number(node.getAttribute("data-x-points") || 0),
+      aiChatModel: node.getAttribute("data-x-ai-chat-model") || null,
+      step2Instructions: "",
+      aiSystemMessage: "",
+      type: "simulation-question",
+      version: 1
+    };
+    const systemMessageElement = node.querySelector(
+      TAG_X_SYSTEM_MESSAGE2
+    );
+    if (systemMessageElement)
+      jsonNode.aiSystemMessage = systemMessageElement.innerHTML;
+    const step2InstructionsElement = node.querySelector(
+      TAG_X_STEP2_INSTRUCTIONS
+    );
+    if (step2InstructionsElement)
+      jsonNode.step2Instructions = step2InstructionsElement.innerHTML;
+    return jsonNode;
+  }
+};
+
+// src/importFromHtml/SpanNodeHandler.ts
+var import_node_html_parser20 = require("node-html-parser");
+var TextNode = import_node_html_parser20.parse.TextNode;
+var SpanNodeHandler = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser20.HTMLElement)) return null;
+    if (node.tagName !== "SPAN") return null;
+    if (!node.hasAttribute("style")) return null;
+    const styleAttr = node.getAttribute("style");
+    if (!styleAttr) return null;
+    if (node.childNodes.length === 1 && node.childNodes[0] instanceof TextNode) {
+      const textContent2 = node.text;
+      return {
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: styleAttr,
+        text: textContent2,
+        type: "text",
+        version: 1
+      };
+    }
+    let childResult = null;
+    for (const childNode of node.childNodes) {
+      const processedChildren = traverse2(childNode);
+      for (const child of processedChildren) {
+        if (child.type !== "text") continue;
+        const textNode = child;
+        if (!childResult) {
+          childResult = {
+            ...textNode,
+            style: this.mergeStyles(textNode.style, styleAttr)
+          };
+        } else {
+          childResult.text += textNode.text;
+          childResult.format |= textNode.format || 0;
+          if (textNode.style) {
+            childResult.style = this.mergeStyles(
+              childResult.style,
+              textNode.style
+            );
+          }
+        }
+      }
+    }
+    if (childResult) {
+      childResult.style = this.mergeStyles(
+        childResult.style,
+        styleAttr
+      );
+      return childResult;
+    }
+    const textContent = node.text;
+    if (textContent.trim() !== "") {
+      return {
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: styleAttr,
+        text: textContent,
+        type: "text",
+        version: 1
+      };
+    }
+    return null;
+  }
+  mergeStyles(existingStyle, newStyle) {
+    if (!existingStyle) return newStyle;
+    if (!newStyle) return existingStyle;
+    return `${existingStyle};${newStyle}`.replace(/;;/g, ";").replace(/^;/, "").replace(/;$/, "");
+  }
+};
+
+// src/importFromHtml/TableCellNodeHandler.ts
+var import_node_html_parser21 = require("node-html-parser");
+
+// src/utils/styleUtils.ts
+var extractStyleValue = (styleAttr, property, isNumeric = false, unit = "") => {
+  const regex = new RegExp(
+    `${property}:[ ]*([^;]+)${unit ? unit : ""}`,
+    "i"
+  );
+  const match = styleAttr.match(regex);
+  if (!match || !match[1]) return null;
+  const value = match[1].trim();
+  return isNumeric ? parseFloat(value) : value;
+};
+
+// src/importFromHtml/createTableNodes.ts
+function createEmptyTableNode() {
+  return {
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    type: "table",
+    version: 1,
+    children: []
+  };
+}
+function createEmptyTableRowNode() {
+  return {
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    type: "tablerow",
+    version: 1,
+    children: []
+  };
+}
+function createEmptyTableCellNode(isHeader = false) {
+  return {
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    type: "tablecell",
+    version: 1,
+    headerState: isHeader ? 1 : 0,
+    children: []
+  };
+}
+
+// src/importFromHtml/TableCellNodeHandler.ts
+var isHtmlTableCellElement = (node) => {
+  return node instanceof import_node_html_parser21.HTMLElement && (node.tagName === "TD" || node.tagName === "TH");
+};
+var TableCellNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!isHtmlTableCellElement(node)) {
+      return null;
+    }
+    const isHeader = node.tagName === "TH";
+    const cellNode = createEmptyTableCellNode(isHeader);
+    cellNode.headerState = node.tagName === "TH" ? 1 : 0;
+    const styleAttr = node.getAttribute("style") || "";
+    const width = extractStyleValue(styleAttr, "width", true, "%");
+    if (width !== null) {
+      cellNode.width = width;
+    }
+    const backgroundColor = extractStyleValue(
+      styleAttr,
+      "background-color"
+    );
+    if (backgroundColor !== null) {
+      cellNode.backgroundColor = backgroundColor;
+    }
+    const verticalAlign = extractStyleValue(
+      styleAttr,
+      "vertical-align"
+    );
+    if (verticalAlign !== null) {
+      cellNode.verticalAlign = verticalAlign;
+    }
+    cellNode.children = createNestedNodesFromHtml(node);
+    return cellNode;
+  }
+};
+
+// src/importFromHtml/TableNodeHandler.ts
+var import_node_html_parser22 = require("node-html-parser");
+var REFERENCE_TABLE_WIDTH = 720;
+var MINIMUM_REFERENCE_TABLE_WIDTH = 500;
+var isHtmlTableElement = (node) => node instanceof import_node_html_parser22.HTMLElement && node.tagName === "TABLE";
+var TableNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!isHtmlTableElement(node)) return null;
+    const styleAttr = node.getAttribute("style") || "";
+    const tableNode = createEmptyTableNode();
+    tableNode.rowStriping = this.hasRowStriping(styleAttr);
+    const effectiveReferenceWidth = this.getEffectiveReferenceWidth(styleAttr);
+    this.processRows(node, tableNode);
+    const targetRow = this.findTargetRowForWidths(node);
+    if (targetRow) {
+      tableNode.colWidths = this.extractColumnWidths(
+        targetRow,
+        effectiveReferenceWidth
+      );
+    }
+    return tableNode;
+  }
+  hasRowStriping(styleAttr) {
+    const borderCollapse = extractStyleValue(
+      styleAttr,
+      "border-collapse"
+    );
+    return borderCollapse === "collapse";
+  }
+  getEffectiveReferenceWidth(styleAttr) {
+    const tableWidthPx = extractStyleValue(
+      styleAttr,
+      "width",
+      true,
+      "px"
+    );
+    const tableWidthPercent = extractStyleValue(
+      styleAttr,
+      "width",
+      true,
+      "%"
+    );
+    if (tableWidthPx && tableWidthPx > 0) {
+      return tableWidthPx;
+    }
+    if (tableWidthPercent && tableWidthPercent > 0) {
+      return Math.max(
+        MINIMUM_REFERENCE_TABLE_WIDTH,
+        tableWidthPercent / 100 * REFERENCE_TABLE_WIDTH
+      );
+    }
+    return REFERENCE_TABLE_WIDTH;
+  }
+  processRows(node, tableNode) {
+    const rows = node.querySelectorAll("tr");
+    rows.forEach((row) => {
+      const processedRows = traverse2(row);
+      tableNode.children.push(...processedRows);
+    });
+  }
+  findTargetRowForWidths(node) {
+    return node.querySelector("thead tr") || node.querySelector("tbody tr") || node.querySelector("tr");
+  }
+  extractColumnWidths(targetRow, effectiveReferenceWidth) {
+    const cells = targetRow.querySelectorAll("th, td");
+    if (cells.length === 0) return [];
+    const colWidths = [];
+    let totalSpecifiedPercent = 0;
+    let unspecifiedColumns = 0;
+    cells.forEach((cell) => {
+      const result = this.extractCellWidth(
+        cell,
+        effectiveReferenceWidth
+      );
+      colWidths.push(result.width);
+      if (result.width > 0) {
+        totalSpecifiedPercent += result.percentEquivalent;
+      } else {
+        unspecifiedColumns++;
+      }
+    });
+    if (unspecifiedColumns > 0 && totalSpecifiedPercent < 100) {
+      return this.distributeUnspecifiedWidths(
+        colWidths,
+        totalSpecifiedPercent,
+        effectiveReferenceWidth,
+        unspecifiedColumns
+      );
+    }
+    return colWidths.some((width) => width > 0) ? colWidths : [];
+  }
+  extractCellWidth(cell, effectiveReferenceWidth) {
+    const style = cell.getAttribute("style") || "";
+    const widthPx = extractStyleValue(style, "width", true, "px");
+    if (widthPx !== null && widthPx > 0) {
+      return {
+        width: Math.round(widthPx),
+        // Calculate percentage equivalent for consistent distribution calculations
+        percentEquivalent: widthPx / effectiveReferenceWidth * 100
+      };
+    }
+    const widthPercent = extractStyleValue(
+      style,
+      "width",
+      true,
+      "%"
+    );
+    if (widthPercent !== null && widthPercent > 0) {
+      return {
+        width: Math.round(
+          widthPercent / 100 * effectiveReferenceWidth
+        ),
+        percentEquivalent: widthPercent
+      };
+    }
+    return { width: 0, percentEquivalent: 0 };
+  }
+  distributeUnspecifiedWidths(colWidths, totalSpecifiedPercent, effectiveReferenceWidth, unspecifiedColumns) {
+    const remainingPercent = 100 - totalSpecifiedPercent;
+    const percentPerColumn = remainingPercent / unspecifiedColumns;
+    const pixelsPerColumn = Math.round(
+      percentPerColumn / 100 * effectiveReferenceWidth
+    );
+    return colWidths.map(
+      (width) => width === 0 ? pixelsPerColumn : width
+    );
+  }
+};
+
+// src/importFromHtml/TableRowNodeHandler.ts
+var import_node_html_parser23 = require("node-html-parser");
+var isHtmlTableRowElement = (node) => {
+  return node instanceof import_node_html_parser23.HTMLElement && node.tagName === "TR";
+};
+var TableRowNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!isHtmlTableRowElement(node)) {
+      return null;
+    }
+    const rowNode = createEmptyTableRowNode();
+    const cells = node.querySelectorAll("td, th");
+    cells.forEach((cell) => {
+      const processedCells = traverse2(cell);
+      rowNode.children.push(...processedCells);
+    });
+    const styleAttr = node.getAttribute("style") || "";
+    const height = extractStyleValue(styleAttr, "height", true, "px");
+    if (height !== null) {
+      rowNode.height = height;
+    }
+    return rowNode;
+  }
+};
+
+// src/importFromHtml/TextNodeHandler.ts
+var import_node_html_parser24 = require("node-html-parser");
+var TextNode2 = import_node_html_parser24.parse.TextNode;
+var TextNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (node instanceof TextNode2 && !!node.parentNode.tagName) {
+      if (node.isWhitespace) {
+        return null;
+      }
+      const jsonNode = {
+        detail: 0,
+        format: 0,
+        mode: "normal",
+        style: "",
+        text: node.text,
+        type: "text",
+        version: 1
+      };
+      return jsonNode;
+    }
+    return null;
+  }
+};
+
+// src/importFromHtml/VariableNodeHandler.ts
+var import_node_html_parser25 = require("node-html-parser");
+var VariableNodeHandler2 = class extends NodeHandler2 {
+  processNode(node) {
+    if (!(node instanceof import_node_html_parser25.HTMLElement) || !node.tagName) return null;
+    if (node.tagName !== "x-param".toUpperCase()) return null;
+    return {
+      variableName: node.getAttribute("data-x-name") || "undefined",
+      variableFormat: node.getAttribute("data-x-format"),
+      type: "variable",
+      version: 1
+    };
+  }
+};
+
+// src/importFromHtml/traverse.ts
+var builder2 = new NodeHandlerChainBuilder();
+var nodeHandlerChain2 = builder2.addHandler(DivNodeHandler).addHandler(EssayQuestionNodeHandler2).addHandler(FillInTheBlankQuestionNodeHandler2).addHandler(FillInTheBlankSpaceNodeHandler2).addHandler(FinancialStatementQuestionNodeHandler2).addHandler(FormattedNodeHandler).addHandler(ImageNodeHandler2).addHandler(HorizontalRuleNodeHandler2).addHandler(JournalEntryQuestionNodeHandler2).addHandler(LineBreakNodeHandler2).addHandler(LinkNodeHandler2).addHandler(ListNodeHandler2).addHandler(ListItemNodeHandler2).addHandler(MatchingQuestionNodeHandler2).addHandler(MultipleOptionQuestionNodeHandler2).addHandler(ParagraphNodeHandler2).addHandler(ShortAnswerQuestionNodeHandler2).addHandler(SimulationQuestionNodeHandler2).addHandler(SpanNodeHandler).addHandler(TableCellNodeHandler2).addHandler(TableNodeHandler2).addHandler(TableRowNodeHandler2).addHandler(TextNodeHandler2).addHandler(VariableNodeHandler2).build();
+function traverse2(node) {
+  const result = nodeHandlerChain2.handle(node);
+  if (result === null) return [];
+  if (Array.isArray(result)) return result;
+  return [result];
+}
+
+// src/importFromHtml/index.ts
+function processChildren(node) {
+  const result = [];
+  node.childNodes.forEach((node2) => {
+    const processedChildren = traverse2(node2);
+    result.push(...processedChildren);
+  });
+  return result;
+}
+function processHtml(html) {
+  const root = (0, import_node_html_parser26.parse)(html);
+  return processChildren(root);
+}
+function importFromHtml(html) {
+  const children = processHtml(html);
+  const rootJsonNode = {
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    version: 0,
+    type: "root",
+    // Prevent Lexical's 'Ensure the editor state's root node never becomes empty' error
+    children: children.length ? children : [createEmptyParagraphNode()]
+  };
+  return { root: rootJsonNode };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportToHtml,
+  importFromHtml
+});