@tfw.in/structura-lib 0.2.0

package/dist/cjs/Table.js

@@ -0,0 +1,164 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var TableCell = require('./TableCell.js');
+
+// Utility function to clean HTML content
+const cleanHtml = html => {
+  if (!html) return "";
+  // Log original HTML content
+  if (html.includes("strikethrough")) {
+    console.log("Table - Original HTML with strikethrough:", html);
+  }
+  // Remove newline characters
+  const 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({
+  node,
+  selectedBboxId,
+  onJsonClick,
+  onContentChange,
+  mergedTables = [],
+  hasLlmHtml = false,
+  showJsonIcons = true,
+  onNodeClick
+}) {
+  const [useLlmHtml, setUseLlmHtml] = React.useState(false);
+  // Get the appropriate HTML content
+  const 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
+  const 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(child => child.block_type === "TableCell" && child.llm_table_html !== undefined);
+  };
+  // Process the main table
+  const processTable = tableNode => {
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = getHtmlContent(tableNode);
+    const tableElement = tempDiv.querySelector("table");
+    if (!tableElement) return null;
+    // Get all rows
+    const rows = Array.from(tableElement.querySelectorAll("tr"));
+    return {
+      rows,
+      tableElement,
+      tempDiv
+    };
+  };
+  const mainTable = processTable(node);
+  if (!mainTable) return null;
+  // Process merged tables if any
+  const mergedRows = [];
+  mergedTables.forEach(table => {
+    const processedTable = processTable(table);
+    if (processedTable) {
+      mergedRows.push(...processedTable.rows);
+    }
+  });
+  // Combine rows from main table and merged tables
+  const allRows = [...mainTable.rows, ...mergedRows];
+  // Map cells to children
+  const processedRows = allRows.map((row, rowIndex) => {
+    const cells = Array.from(row.querySelectorAll("th, td"));
+    return cells.map((cell, colIndex) => {
+      var _a;
+      const globalCellIndex = rowIndex * cells.length + colIndex;
+      const childNode = (_a = node.children) === null || _a === void 0 ? void 0 : _a[globalCellIndex];
+      let cellContent = cleanHtml(cell.innerHTML);
+      const 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
+      const 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) || `${node.id}-cell-${globalCellIndex}`,
+        content: cellContent,
+        isHeader: isHeaderCell,
+        isDubious: isDubious,
+        nodeData: childNode || {
+          id: `${node.id}-cell-${globalCellIndex}`,
+          html: cellContent,
+          block_type: "TableCell"
+        }
+      };
+    });
+  });
+  const handleCellContentChange = (cellId, newContent) => {
+    if (onContentChange) {
+      onContentChange(cellId, newContent);
+    }
+  };
+  const 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 jsxRuntime.jsxs("div", {
+    onClick: handleTableClick,
+    className: onNodeClick ? "cursor-pointer" : "",
+    children: [hasLlmHtml && jsxRuntime.jsx("div", {
+      className: "mb-2 flex justify-end",
+      onClick: e => e.stopPropagation(),
+      children: jsxRuntime.jsxs("label", {
+        className: "inline-flex items-center cursor-pointer",
+        children: [jsxRuntime.jsx("input", {
+          type: "checkbox",
+          checked: useLlmHtml,
+          onChange: () => setUseLlmHtml(!useLlmHtml),
+          className: "sr-only peer"
+        }), jsxRuntime.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"
+        }), jsxRuntime.jsx("span", {
+          className: "ms-3 text-sm font-medium text-gray-900",
+          children: "Agentic"
+        })]
+      })
+    }), jsxRuntime.jsx("div", {
+      className: "w-full overflow-x-auto",
+      children: jsxRuntime.jsx("table", {
+        className: "min-w-full divide-y divide-gray-200",
+        children: jsxRuntime.jsx("tbody", {
+          children: processedRows.map((row, rowIndex) => jsxRuntime.jsx("tr", {
+            children: row.map(cell => jsxRuntime.jsx(TableCell.default, {
+              id: cell.id,
+              content: cell.content,
+              onJsonClick: () => onJsonClick(cell.nodeData),
+              isSelected: cell.id === selectedBboxId,
+              isHeader: cell.isHeader,
+              isDubious: cell.isDubious,
+              onContentChange: onContentChange ? newContent => handleCellContentChange(cell.id, newContent) : undefined,
+              showJsonIcons: showJsonIcons,
+              onNodeClick: onNodeClick ? () => onNodeClick(cell.id) : undefined
+            }, cell.id))
+          }, rowIndex))
+        })
+      })
+    })]
+  });
+}
+
+exports.default = Table;

package/dist/cjs/TableCell.js

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var vsc = require('react-icons/vsc');
+
+// Utility function to clean HTML content
+const cleanHtml = html => {
+  if (!html) return "";
+  // Log original HTML content
+  if (html.includes("strikethrough")) {
+    console.log("TableCell - Original HTML with strikethrough:", html);
+  }
+  // Remove newline characters
+  const 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({
+  id,
+  content,
+  onJsonClick,
+  isSelected,
+  isHeader = false,
+  onContentChange,
+  showJsonIcons = true,
+  onNodeClick,
+  isDubious = false
+}) {
+  const [isEditing, setIsEditing] = React.useState(false);
+  const [editedContent, setEditedContent] = React.useState(cleanHtml(content));
+  const [isEdited, setIsEdited] = React.useState(false);
+  const CellComponent = isHeader ? "th" : "td";
+  // Update content when props change, but preserve edited state
+  React.useEffect(() => {
+    if (!isEdited) {
+      setEditedContent(cleanHtml(content));
+    }
+  }, [content, isEdited]);
+  // Log content that contains strikethrough when component renders
+  React.useEffect(() => {
+    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]);
+  const handleDoubleClick = () => {
+    if (onContentChange) {
+      setIsEditing(true);
+    }
+  };
+  const handleBlur = () => {
+    setIsEditing(false);
+    if (editedContent !== content && onContentChange) {
+      setIsEdited(true);
+      onContentChange(id, editedContent);
+    }
+  };
+  const handleClick = e => {
+    if (!isEditing && onNodeClick) {
+      onNodeClick();
+    }
+  };
+  return jsxRuntime.jsx(CellComponent, {
+    id: id,
+    className: `structura-px-4 structura-py-2 structura-border structura-border-gray-200 structura-transition-colors structura-relative structura-group 
+        ${isSelected ? "structura-bg-blue-100 structura-border-2 structura-border-blue-500" : ""} 
+        ${isHeader ? "structura-bg-gray-100 structura-font-bold structura-text-gray-800" : ""}
+        ${isEdited ? "structura-bg-yellow-100" : ""}
+        ${isDubious ? "structura-bg-red-500/20" : ""}
+        ${onNodeClick && !isEditing ? "structura-cursor-pointer hover:structura-bg-gray-50" : ""}`,
+    onDoubleClick: handleDoubleClick,
+    onClick: handleClick,
+    children: jsxRuntime.jsxs("div", {
+      className: "structura-w-full structura-relative",
+      children: [showJsonIcons && jsxRuntime.jsx("button", {
+        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: jsxRuntime.jsx(vsc.VscJson, {
+          size: 16
+        })
+      }), isEditing ? jsxRuntime.jsx("textarea", {
+        value: editedContent,
+        onChange: e => 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: e => e.stopPropagation()
+      }) : jsxRuntime.jsx("div", {
+        dangerouslySetInnerHTML: {
+          __html: editedContent
+        },
+        className: "structura-min-w-0 structura-break-words"
+      })]
+    })
+  });
+}
+
+exports.default = TableCell;

package/dist/cjs/accuracyMetrics.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const calculateDifferences = (original, updated) => {
+  const cleanText = text => text.replace(/<[^>]*>/g, "").trim();
+  const originalClean = cleanText(original);
+  const updatedClean = cleanText(updated);
+  const originalWords = originalClean.split(/\s+/);
+  const 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) {
+  const m = str1.length;
+  const n = str2.length;
+  const dp = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let 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];
+}
+
+exports.calculateDifferences = calculateDifferences;

package/dist/cjs/helpers/preprocessData.js

@@ -0,0 +1,143 @@
+'use strict';
+
+// Helper function to sort table cells by page number and bounding box coordinates
+function sortTableCells(tableCells) {
+  // console.log("Table cells to sort:", tableCells);
+  // Helper function to extract page number and block number from ID (e.g., '/page/2/TableCell/10')
+  const getPageAndBlockNumber = id => {
+    const match = id.match(/^\/page\/(\d+)\/TableCell\/(\d+)$/);
+    if (match) {
+      return [parseInt(match[1]), parseInt(match[2])];
+    }
+    return [0, 0]; // Default to (0,0) if pattern not found
+  };
+  // Sort by page number first, then by block number
+  tableCells.sort((a, b) => {
+    const [pageA, blockA] = getPageAndBlockNumber(a.id);
+    const [pageB, blockB] = getPageAndBlockNumber(b.id);
+    return pageA !== pageB ? pageA - pageB : blockA - blockB;
+  });
+  // console.log("Table cells sorted:", tableCells);
+  return tableCells;
+}
+// Strikethrough correction function
+function strikethroughCorrection(jsonData) {
+  // Deep clone to avoid mutating the original
+  const modifiedJson = JSON.parse(JSON.stringify(jsonData));
+  // Helper function to process HTML content
+  const processHtml = html => {
+    if (!html) return html;
+    return html.replace(/<strikethrough>/g, "<del>").replace(/<\/strikethrough>/g, "</del>");
+  };
+  // Helper function to recursively process nodes
+  const processNode = node => {
+    // Process HTML content if it exists
+    if (node.html) {
+      node.html = processHtml(node.html);
+    }
+    // Process LLM table HTML if it exists
+    if (node.llm_table_html) {
+      node.llm_table_html = processHtml(node.llm_table_html);
+    }
+    // Process children recursively
+    if (node.children && Array.isArray(node.children)) {
+      node.children.forEach(processNode);
+    }
+  };
+  // Start processing from the root
+  processNode(modifiedJson);
+  return modifiedJson;
+}
+// Remove picture nodes function
+function removePictureNodes(jsonData) {
+  // Deep clone to avoid mutating the original
+  const modifiedJson = JSON.parse(JSON.stringify(jsonData));
+  // Helper function to recursively filter out picture nodes
+  const processPictureNodes = node => {
+    // If the node has children, filter out Picture nodes and process remaining children
+    if (node.children && Array.isArray(node.children)) {
+      node.children = node.children.filter(child => child.block_type !== "Picture").map(processPictureNodes);
+    }
+    return node;
+  };
+  // Start processing from the root
+  processPictureNodes(modifiedJson);
+  return modifiedJson;
+}
+// MAP 'html' and 'llm_table_html' (if present) of block_type 'Table' to their respective children i.e 'TableCell'
+function mapTableChildren(jsonData) {
+  // Skip if there's no JSON data or no pages
+  if (!jsonData || !jsonData.children) {
+    console.log("No valid JSON data to process");
+    return jsonData;
+  }
+  // Create a deep copy to avoid modifying the original
+  const modifiedJsonData = JSON.parse(JSON.stringify(jsonData));
+  // Process each page in the document
+  modifiedJsonData.children = modifiedJsonData.children.map(page => {
+    // Skip if page has no children
+    if (!page.children) {
+      return page;
+    }
+    // Process each block in the page
+    page.children = page.children.map(block => {
+      // Only process Table and TableOfContents blocks
+      if (block.block_type === "Table" || block.block_type === "TableOfContents") {
+        // Skip if block has no children or no HTML
+        if (!block.children || !block.html) {
+          return block;
+        }
+        // Get all TableCell children and sort them by position
+        const tableCells = sortTableCells(block.children.filter(cell => cell.block_type === "TableCell"));
+        // Skip if no table cells found
+        if (tableCells.length === 0) {
+          return block;
+        }
+        // Create DOM parser to extract td/th elements from table HTML
+        const parser = new DOMParser();
+        // Process main HTML
+        const htmlDoc = parser.parseFromString(block.html, "text/html");
+        const htmlCells = Array.from(htmlDoc.querySelectorAll("td, th"));
+        // Process LLM table HTML if it exists
+        let llmHtmlCells = [];
+        if (block.llm_table_html) {
+          const llmHtmlDoc = parser.parseFromString(block.llm_table_html, "text/html");
+          llmHtmlCells = Array.from(llmHtmlDoc.querySelectorAll("td, th"));
+        }
+        // Safety check: log warning if HTML cells count doesn't match TableCell nodes
+        if (htmlCells.length !== tableCells.length) {
+          console.warn(`Warning: Cell count mismatch in ${block.block_type} ${block.id}. ` + `JSON has ${tableCells.length} cells, HTML has ${htmlCells.length} cells.`);
+        }
+        // Map HTML content to table cells
+        const maxCells = Math.min(tableCells.length, htmlCells.length);
+        for (let i = 0; i < maxCells; i++) {
+          // Update the table cell's HTML with content from the HTML table
+          tableCells[i].html = htmlCells[i].outerHTML;
+          // If LLM table HTML exists and has matching cell, update that too
+          if (block.llm_table_html && i < llmHtmlCells.length) {
+            tableCells[i].llm_table_html = llmHtmlCells[i].outerHTML;
+          }
+        }
+      }
+      return block;
+    });
+    return page;
+  });
+  console.log("Finished mapping table HTML to table cells");
+  return modifiedJsonData;
+}
+function preprocessData(jsonData) {
+  // Replace 'strikethrough' with 'del'
+  let processedJson = strikethroughCorrection(jsonData);
+  // Remove picture nodes
+  processedJson = removePictureNodes(processedJson);
+  // TODO: Uncomment this after correcting the the table enrichment and mapping.
+  // // Enrich tables with missing cells
+  // processedJson = processTablesForEnrichment(processedJson);
+  // // Map table HTML to table cells
+  processedJson = mapTableChildren(processedJson);
+  return processedJson;
+}
+
+exports.preprocessData = preprocessData;
+exports.sortTableCells = sortTableCells;

package/dist/cjs/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var Structura = require('./Structura.js');
+
+
+
+exports.Structura = Structura.default;

package/dist/cjs/lib/polyfills.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Polyfill for Promise.withResolvers
+// This is needed for Next.js build compatibility
+if (typeof Promise.withResolvers !== 'function') {
+    Promise.withResolvers = function () {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { promise, resolve, reject };
+    };
+}

package/dist/cjs/lib/utils.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+
+function cn(...inputs) {
+    return tailwindMerge.twMerge(clsx(inputs));
+}
+
+exports.cn = cn;

package/dist/cjs/node_modules/react-icons/fa/index.esm.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var iconBase = require('../lib/esm/iconBase.js');
+require('../lib/esm/iconContext.js');
+
+// THIS FILE IS AUTO GENERATED
+function FaChartBar (props) {
+  return iconBase.GenIcon({"attr":{"viewBox":"0 0 512 512"},"child":[{"tag":"path","attr":{"d":"M332.8 320h38.4c6.4 0 12.8-6.4 12.8-12.8V172.8c0-6.4-6.4-12.8-12.8-12.8h-38.4c-6.4 0-12.8 6.4-12.8 12.8v134.4c0 6.4 6.4 12.8 12.8 12.8zm96 0h38.4c6.4 0 12.8-6.4 12.8-12.8V76.8c0-6.4-6.4-12.8-12.8-12.8h-38.4c-6.4 0-12.8 6.4-12.8 12.8v230.4c0 6.4 6.4 12.8 12.8 12.8zm-288 0h38.4c6.4 0 12.8-6.4 12.8-12.8v-70.4c0-6.4-6.4-12.8-12.8-12.8h-38.4c-6.4 0-12.8 6.4-12.8 12.8v70.4c0 6.4 6.4 12.8 12.8 12.8zm96 0h38.4c6.4 0 12.8-6.4 12.8-12.8V108.8c0-6.4-6.4-12.8-12.8-12.8h-38.4c-6.4 0-12.8 6.4-12.8 12.8v198.4c0 6.4 6.4 12.8 12.8 12.8zM496 384H64V80c0-8.84-7.16-16-16-16H16C7.16 64 0 71.16 0 80v336c0 17.67 14.33 32 32 32h464c8.84 0 16-7.16 16-16v-32c0-8.84-7.16-16-16-16z"}}]})(props);
+}function FaFileDownload (props) {
+  return iconBase.GenIcon({"attr":{"viewBox":"0 0 384 512"},"child":[{"tag":"path","attr":{"d":"M224 136V0H24C10.7 0 0 10.7 0 24v464c0 13.3 10.7 24 24 24h336c13.3 0 24-10.7 24-24V160H248c-13.2 0-24-10.8-24-24zm76.45 211.36l-96.42 95.7c-6.65 6.61-17.39 6.61-24.04 0l-96.42-95.7C73.42 337.29 80.54 320 94.82 320H160v-80c0-8.84 7.16-16 16-16h32c8.84 0 16 7.16 16 16v80h65.18c14.28 0 21.4 17.29 11.27 27.36zM377 105L279.1 7c-4.5-4.5-10.6-7-17-7H256v128h128v-6.1c0-6.3-2.5-12.4-7-16.9z"}}]})(props);
+}
+
+exports.FaChartBar = FaChartBar;
+exports.FaFileDownload = FaFileDownload;

package/dist/cjs/node_modules/react-icons/lib/esm/iconBase.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var React = require('react');
+var iconContext = require('./iconContext.js');
+
+var __assign = undefined && undefined.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __rest = undefined && undefined.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+function Tree2Element(tree) {
+  return tree && tree.map(function (node, i) {
+    return React.createElement(node.tag, __assign({
+      key: i
+    }, node.attr), Tree2Element(node.child));
+  });
+}
+function GenIcon(data) {
+  // eslint-disable-next-line react/display-name
+  return function (props) {
+    return React.createElement(IconBase, __assign({
+      attr: __assign({}, data.attr)
+    }, props), Tree2Element(data.child));
+  };
+}
+function IconBase(props) {
+  var elem = function (conf) {
+    var attr = props.attr,
+      size = props.size,
+      title = props.title,
+      svgProps = __rest(props, ["attr", "size", "title"]);
+    var computedSize = size || conf.size || "1em";
+    var className;
+    if (conf.className) className = conf.className;
+    if (props.className) className = (className ? className + " " : "") + props.className;
+    return React.createElement("svg", __assign({
+      stroke: "currentColor",
+      fill: "currentColor",
+      strokeWidth: "0"
+    }, conf.attr, attr, svgProps, {
+      className: className,
+      style: __assign(__assign({
+        color: props.color || conf.color
+      }, conf.style), props.style),
+      height: computedSize,
+      width: computedSize,
+      xmlns: "http://www.w3.org/2000/svg"
+    }), title && React.createElement("title", null, title), props.children);
+  };
+  return iconContext.IconContext !== undefined ? React.createElement(iconContext.IconContext.Consumer, null, function (conf) {
+    return elem(conf);
+  }) : elem(iconContext.DefaultContext);
+}
+
+exports.GenIcon = GenIcon;
+exports.IconBase = IconBase;

package/dist/cjs/node_modules/react-icons/lib/esm/iconContext.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var React = require('react');
+
+var DefaultContext = {
+  color: undefined,
+  size: undefined,
+  className: undefined,
+  style: undefined,
+  attr: undefined
+};
+var IconContext = React.createContext && React.createContext(DefaultContext);
+
+exports.DefaultContext = DefaultContext;
+exports.IconContext = IconContext;

package/dist/cjs/polyfills.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// Polyfill for Promise.withResolvers
+// This is needed for Next.js build compatibility
+if (typeof Promise.withResolvers !== 'function') {
+  Promise.withResolvers = function () {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return {
+      promise,
+      resolve,
+      reject
+    };
+  };
+}