@tfw.in/structura-lib 0.2.0

package/dist/esm/Table.js

@@ -0,0 +1,182 @@
+import { slicedToArray as _slicedToArray, toConsumableArray as _toConsumableArray } from './_virtual/_rollupPluginBabelHelpers.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState } from 'react';
+import TableCell from './TableCell.js';
+
+// Utility function to clean HTML content
+var cleanHtml = function cleanHtml(html) {
+  if (!html) return "";
+  // Log original HTML content
+  if (html.includes("strikethrough")) {
+    console.log("Table - Original HTML with strikethrough:", html);
+  }
+  // Remove newline characters
+  var cleanedHtml = html.replace(/\n/g, " ").replace(/<br\s*\/?>/g, " ")
+  // Replace non-standard strikethrough tag with standard HTML5 <s> tag
+  .replace(/<strikethrough>/g, "<s>").replace(/<\/strikethrough>/g, "</s>")
+  // Remove consecutive spaces
+  .replace(/\s+/g, " ")
+  // Trim leading and trailing spaces
+  .trim();
+  // Log transformed HTML content
+  if (html.includes("strikethrough")) {
+    console.log("Table - Transformed HTML with <s> tags:", cleanedHtml);
+  }
+  return cleanedHtml;
+};
+function Table(_ref) {
+  var node = _ref.node,
+    selectedBboxId = _ref.selectedBboxId,
+    _onJsonClick = _ref.onJsonClick,
+    onContentChange = _ref.onContentChange,
+    _ref$mergedTables = _ref.mergedTables,
+    mergedTables = _ref$mergedTables === void 0 ? [] : _ref$mergedTables,
+    _ref$hasLlmHtml = _ref.hasLlmHtml,
+    hasLlmHtml = _ref$hasLlmHtml === void 0 ? false : _ref$hasLlmHtml,
+    _ref$showJsonIcons = _ref.showJsonIcons,
+    showJsonIcons = _ref$showJsonIcons === void 0 ? true : _ref$showJsonIcons,
+    onNodeClick = _ref.onNodeClick;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    useLlmHtml = _useState2[0],
+    setUseLlmHtml = _useState2[1];
+  // Get the appropriate HTML content
+  var getHtmlContent = function getHtmlContent(node) {
+    if (useLlmHtml && node.llm_table_html) {
+      return cleanHtml(node.llm_table_html);
+    }
+    return cleanHtml(node.html || "");
+  };
+  // Check if we should use individual TableCell contents
+  var shouldUseTableCellContents = function shouldUseTableCellContents() {
+    // Check if any of the TableCell children has llm_table_html
+    if (!node.children) return false;
+    // TODO: to be fixed later
+    return node.children.some(function (child) {
+      return child.block_type === "TableCell" && child.llm_table_html !== undefined;
+    });
+  };
+  // Process the main table
+  var processTable = function processTable(tableNode) {
+    var tempDiv = document.createElement("div");
+    tempDiv.innerHTML = getHtmlContent(tableNode);
+    var tableElement = tempDiv.querySelector("table");
+    if (!tableElement) return null;
+    // Get all rows
+    var rows = Array.from(tableElement.querySelectorAll("tr"));
+    return {
+      rows: rows,
+      tableElement: tableElement,
+      tempDiv: tempDiv
+    };
+  };
+  var mainTable = processTable(node);
+  if (!mainTable) return null;
+  // Process merged tables if any
+  var mergedRows = [];
+  mergedTables.forEach(function (table) {
+    var processedTable = processTable(table);
+    if (processedTable) {
+      mergedRows.push.apply(mergedRows, _toConsumableArray(processedTable.rows));
+    }
+  });
+  // Combine rows from main table and merged tables
+  var allRows = [].concat(_toConsumableArray(mainTable.rows), mergedRows);
+  // Map cells to children
+  var processedRows = allRows.map(function (row, rowIndex) {
+    var cells = Array.from(row.querySelectorAll("th, td"));
+    return cells.map(function (cell, colIndex) {
+      var _a;
+      var globalCellIndex = rowIndex * cells.length + colIndex;
+      var childNode = (_a = node.children) === null || _a === void 0 ? void 0 : _a[globalCellIndex];
+      var cellContent = cleanHtml(cell.innerHTML);
+      var isHeaderCell = cell.tagName.toLowerCase() === "th"; // Check if this is a header cell
+      // If we should use TableCell content and we have a childNode with llm_table_html
+      if (shouldUseTableCellContents() && childNode && childNode.llm_table_html !== undefined) {
+        cellContent = useLlmHtml && childNode.llm_table_html ? cleanHtml(childNode.llm_table_html) : cleanHtml(childNode.html || "");
+      }
+      // TODO: to be fixed later - only apply dubious highlighting if the cell has llm_table_html
+      var isDubious = (childNode === null || childNode === void 0 ? void 0 : childNode.dubious) && (childNode === null || childNode === void 0 ? void 0 : childNode.llm_table_html) !== undefined ? true : false;
+      return {
+        id: (childNode === null || childNode === void 0 ? void 0 : childNode.id) || "".concat(node.id, "-cell-").concat(globalCellIndex),
+        content: cellContent,
+        isHeader: isHeaderCell,
+        isDubious: isDubious,
+        nodeData: childNode || {
+          id: "".concat(node.id, "-cell-").concat(globalCellIndex),
+          html: cellContent,
+          block_type: "TableCell"
+        }
+      };
+    });
+  });
+  var handleCellContentChange = function handleCellContentChange(cellId, newContent) {
+    if (onContentChange) {
+      onContentChange(cellId, newContent);
+    }
+  };
+  var handleTableClick = function handleTableClick(e) {
+    // Only process clicks directly on the table container, not bubbled events from cells
+    if (e.target === e.currentTarget && node.id && onNodeClick) {
+      onNodeClick(node.id);
+    }
+  };
+  return jsxs("div", {
+    onClick: handleTableClick,
+    className: onNodeClick ? "cursor-pointer" : "",
+    children: [hasLlmHtml && jsx("div", {
+      className: "mb-2 flex justify-end",
+      onClick: function onClick(e) {
+        return e.stopPropagation();
+      },
+      children: jsxs("label", {
+        className: "inline-flex items-center cursor-pointer",
+        children: [jsx("input", {
+          type: "checkbox",
+          checked: useLlmHtml,
+          onChange: function onChange() {
+            return setUseLlmHtml(!useLlmHtml);
+          },
+          className: "sr-only peer"
+        }), jsx("div", {
+          className: "relative w-11 h-6 bg-gray-200 peer-focus:outline-none peer-focus:ring-4 peer-focus:ring-blue-300 rounded-full peer peer-checked:after:translate-x-full rtl:peer-checked:after:-translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:top-[2px] after:start-[2px] after:bg-white after:border-gray-300 after:border after:rounded-full after:h-5 after:w-5 after:transition-all peer-checked:bg-blue-600"
+        }), jsx("span", {
+          className: "ms-3 text-sm font-medium text-gray-900",
+          children: "Agentic"
+        })]
+      })
+    }), jsx("div", {
+      className: "w-full overflow-x-auto",
+      children: jsx("table", {
+        className: "min-w-full divide-y divide-gray-200",
+        children: jsx("tbody", {
+          children: processedRows.map(function (row, rowIndex) {
+            return jsx("tr", {
+              children: row.map(function (cell) {
+                return jsx(TableCell, {
+                  id: cell.id,
+                  content: cell.content,
+                  onJsonClick: function onJsonClick() {
+                    return _onJsonClick(cell.nodeData);
+                  },
+                  isSelected: cell.id === selectedBboxId,
+                  isHeader: cell.isHeader,
+                  isDubious: cell.isDubious,
+                  onContentChange: onContentChange ? function (newContent) {
+                    return handleCellContentChange(cell.id, newContent);
+                  } : undefined,
+                  showJsonIcons: showJsonIcons,
+                  onNodeClick: onNodeClick ? function () {
+                    return onNodeClick(cell.id);
+                  } : undefined
+                }, cell.id);
+              })
+            }, rowIndex);
+          })
+        })
+      })
+    })]
+  });
+}
+
+export { Table as default };

package/dist/esm/TableCell.js

@@ -0,0 +1,122 @@
+import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHelpers.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useState, useEffect } from 'react';
+import { VscJson } from 'react-icons/vsc';
+
+// Utility function to clean HTML content
+var cleanHtml = function cleanHtml(html) {
+  if (!html) return "";
+  // Log original HTML content
+  if (html.includes("strikethrough")) {
+    console.log("TableCell - Original HTML with strikethrough:", html);
+  }
+  // Remove newline characters
+  var cleanedHtml = html.replace(/\n/g, " ").replace(/<br\s*\/?>/g, " ")
+  // Replace non-standard strikethrough tag with standard HTML5 <s> tag
+  .replace(/<strikethrough>/g, "<s>").replace(/<\/strikethrough>/g, "</s>")
+  // Remove consecutive spaces
+  .replace(/\s+/g, " ")
+  // Trim leading and trailing spaces
+  .trim();
+  // Log transformed HTML content
+  if (html.includes("strikethrough")) {
+    console.log("TableCell - Transformed HTML with <s> tags:", cleanedHtml);
+  }
+  return cleanedHtml;
+};
+function TableCell(_ref) {
+  var id = _ref.id,
+    content = _ref.content,
+    onJsonClick = _ref.onJsonClick,
+    isSelected = _ref.isSelected,
+    _ref$isHeader = _ref.isHeader,
+    isHeader = _ref$isHeader === void 0 ? false : _ref$isHeader,
+    onContentChange = _ref.onContentChange,
+    _ref$showJsonIcons = _ref.showJsonIcons,
+    showJsonIcons = _ref$showJsonIcons === void 0 ? true : _ref$showJsonIcons,
+    onNodeClick = _ref.onNodeClick,
+    _ref$isDubious = _ref.isDubious,
+    isDubious = _ref$isDubious === void 0 ? false : _ref$isDubious;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isEditing = _useState2[0],
+    setIsEditing = _useState2[1];
+  var _useState3 = useState(cleanHtml(content)),
+    _useState4 = _slicedToArray(_useState3, 2),
+    editedContent = _useState4[0],
+    setEditedContent = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    isEdited = _useState6[0],
+    setIsEdited = _useState6[1];
+  var CellComponent = isHeader ? "th" : "td";
+  // Update content when props change, but preserve edited state
+  useEffect(function () {
+    if (!isEdited) {
+      setEditedContent(cleanHtml(content));
+    }
+  }, [content, isEdited]);
+  // Log content that contains strikethrough when component renders
+  useEffect(function () {
+    if (content.includes("strikethrough")) {
+      console.log("TableCell rendering - Cell ID:", id);
+      console.log("Original content:", content);
+      console.log("Edited content being displayed:", editedContent);
+    }
+  }, [id, content, editedContent]);
+  var handleDoubleClick = function handleDoubleClick() {
+    if (onContentChange) {
+      setIsEditing(true);
+    }
+  };
+  var handleBlur = function handleBlur() {
+    setIsEditing(false);
+    if (editedContent !== content && onContentChange) {
+      setIsEdited(true);
+      onContentChange(id, editedContent);
+    }
+  };
+  var handleClick = function handleClick(e) {
+    if (!isEditing && onNodeClick) {
+      onNodeClick();
+    }
+  };
+  return jsx(CellComponent, {
+    id: id,
+    className: "structura-px-4 structura-py-2 structura-border structura-border-gray-200 structura-transition-colors structura-relative structura-group \n        ".concat(isSelected ? "structura-bg-blue-100 structura-border-2 structura-border-blue-500" : "", " \n        ").concat(isHeader ? "structura-bg-gray-100 structura-font-bold structura-text-gray-800" : "", "\n        ").concat(isEdited ? "structura-bg-yellow-100" : "", "\n        ").concat(isDubious ? "structura-bg-red-500/20" : "", "\n        ").concat(onNodeClick && !isEditing ? "structura-cursor-pointer hover:structura-bg-gray-50" : ""),
+    onDoubleClick: handleDoubleClick,
+    onClick: handleClick,
+    children: jsxs("div", {
+      className: "structura-w-full structura-relative",
+      children: [showJsonIcons && jsx("button", {
+        onClick: function onClick(e) {
+          e.stopPropagation();
+          onJsonClick();
+        },
+        className: "structura-absolute -structura-right-1 structura-top-0 structura-opacity-0 group-hover:structura-opacity-100 structura-transition-opacity structura-text-gray-500 hover:structura-text-gray-700",
+        title: "View JSON",
+        children: jsx(VscJson, {
+          size: 16
+        })
+      }), isEditing ? jsx("textarea", {
+        value: editedContent,
+        onChange: function onChange(e) {
+          return setEditedContent(e.target.value);
+        },
+        onBlur: handleBlur,
+        autoFocus: true,
+        className: "structura-w-full structura-min-h-[24px] structura-p-1 structura-border structura-border-blue-400 structura-rounded focus:structura-outline-none focus:structura-ring-2 focus:structura-ring-blue-500",
+        onClick: function onClick(e) {
+          return e.stopPropagation();
+        }
+      }) : jsx("div", {
+        dangerouslySetInnerHTML: {
+          __html: editedContent
+        },
+        className: "structura-min-w-0 structura-break-words"
+      })]
+    })
+  });
+}
+
+export { TableCell as default };

package/dist/esm/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,305 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (c = i[4] || 3, u = i[5] === e ? i[3] : i[5], i[4] = 3, i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    if (r) i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n;else {
+      function o(r, n) {
+        _regeneratorDefine(e, r, function (e) {
+          return this._invoke(r, n, e);
+        });
+      }
+      o("next", 0), o("throw", 1), o("return", 2);
+    }
+  }, _regeneratorDefine(e, r, n, t);
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _asyncToGenerator as asyncToGenerator, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectSpread2 as objectSpread2, _objectWithoutProperties as objectWithoutProperties, _objectWithoutPropertiesLoose as objectWithoutPropertiesLoose, _regenerator as regenerator, _regeneratorDefine as regeneratorDefine, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };

package/dist/esm/accuracyMetrics.js

@@ -0,0 +1,41 @@
+var calculateDifferences = function calculateDifferences(original, updated) {
+  var cleanText = function cleanText(text) {
+    return text.replace(/<[^>]*>/g, "").trim();
+  };
+  var originalClean = cleanText(original);
+  var updatedClean = cleanText(updated);
+  var originalWords = originalClean.split(/\s+/);
+  var updatedWords = updatedClean.split(/\s+/);
+  return {
+    charactersDifferent: Math.abs(updatedClean.length - originalClean.length),
+    wordsDifferent: Math.abs(updatedWords.length - originalWords.length),
+    // Levenshtein distance for more accurate character difference
+    editDistance: levenshteinDistance(originalClean, updatedClean)
+  };
+};
+function levenshteinDistance(str1, str2) {
+  var m = str1.length;
+  var n = str2.length;
+  var dp = Array(m + 1).fill(0).map(function () {
+    return Array(n + 1).fill(0);
+  });
+  for (var i = 0; i <= m; i++) dp[i][0] = i;
+  for (var j = 0; j <= n; j++) dp[0][j] = j;
+  for (var _i = 1; _i <= m; _i++) {
+    for (var _j = 1; _j <= n; _j++) {
+      if (str1[_i - 1] === str2[_j - 1]) {
+        dp[_i][_j] = dp[_i - 1][_j - 1];
+      } else {
+        dp[_i][_j] = 1 + Math.min(dp[_i - 1][_j],
+        // deletion
+        dp[_i][_j - 1],
+        // insertion
+        dp[_i - 1][_j - 1] // substitution
+        );
+      }
+    }
+  }
+  return dp[m][n];
+}
+
+export { calculateDifferences };