acsi-core 0.9.6 → 0.9.8

package/dist/components/MarkdownLatexRender/index.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 import "katex/dist/katex.min.css";
-interface MarkdownLatexRenderProps {
+interface MarkdownRendererProps {
     content: string;
 }
-declare const MarkdownLatexRender: React.FC<MarkdownLatexRenderProps>;
-export default MarkdownLatexRender;
+declare const MarkdownRenderer: React.FC<MarkdownRendererProps>;
+export default MarkdownRenderer;

package/dist/index.js

@@ -12,9 +12,7 @@ var ReactSelect = require('react-select');
 var ReactSelect__default = _interopDefault(ReactSelect);
 var ReactMarkdown = _interopDefault(require('react-markdown'));
 var remarkMath = _interopDefault(require('remark-math'));
-var remarkGfm = _interopDefault(require('remark-gfm'));
 var rehypeKatex = _interopDefault(require('rehype-katex'));
-var remarkRehype = _interopDefault(require('remark-rehype'));
 var rehypeRaw = _interopDefault(require('rehype-raw'));
 require('katex/dist/katex.min.css');
 var Cookies = _interopDefault(require('js-cookie'));
@@ -691,6 +689,28 @@ function _catch(body, recover) {
 	return result;
 }
 
+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 _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: !0
+      } : {
+        done: !1,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _extends$1() {
   return _extends$1 = Object.assign ? Object.assign.bind() : function (n) {
     for (var e = 1; e < arguments.length; e++) {
@@ -709,6 +729,13 @@ function _objectWithoutPropertiesLoose(r, e) {
   }
   return t;
 }
+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;
+  }
+}
 
 var styles = {"core-button":"_xvNBN","primary":"_U9Qyp","secondary":"_1VzMy","text":"_pZNuj","danger":"_2uYm1","light":"_wxH5S"};
 
@@ -1670,72 +1697,434 @@ var CoreTooltip = function CoreTooltip(_ref) {
 
 var LatexExtractor = /*#__PURE__*/function () {
   function LatexExtractor() {}
-  LatexExtractor.ApplyLatexFormat = function ApplyLatexFormat(content) {
-    var allComponents = LatexExtractor.extractAllLatexUltimate(content);
-    var multiLineFormulas = LatexExtractor.extractMultiLineFormulas(content);
-    var foundLatexStr = multiLineFormulas[0] || "";
-    if (foundLatexStr && foundLatexStr !== "" && allComponents.length > 0) {
-      var firstPosition = content.indexOf(allComponents[0]);
-      if (firstPosition > 0) {
-        var textPart = content.slice(0, firstPosition).trim();
-        var latexPart = content.slice(firstPosition).trim();
-        return textPart + (" $$" + latexPart + "$$");
+  LatexExtractor.isLatexFormula = function isLatexFormula(text) {
+    if (!text || text.trim().length === 0) {
+      return false;
+    }
+    if (/^[a-zA-Z\s]+$/.test(text.trim()) && !/^[a-zA-Z]_|^[a-zA-Z]\^/.test(text.trim())) {
+      return false;
+    }
+    if (text.length > 100 && text.split(' ').length > 15) {
+      return false;
+    }
+    var englishPhrases = ['the surface of', 'acceleration caused by', 'force of gravity', 'measured value', 'approximately equal to', 'has a', 'is', 'are', 'will be', 'can be', 'may be', 'should be', 'would be'];
+    for (var _i = 0, _englishPhrases = englishPhrases; _i < _englishPhrases.length; _i++) {
+      var phrase = _englishPhrases[_i];
+      if (text.toLowerCase().includes(phrase)) {
+        return false;
+      }
+    }
+    for (var _iterator = _createForOfIteratorHelperLoose(this.LATEX_COMMANDS), _step; !(_step = _iterator()).done;) {
+      var command = _step.value;
+      if (text.includes(command)) {
+        return true;
+      }
+    }
+    if (/_\{[^}]*\}/.test(text) || /\^\{[^}]*\}/.test(text)) {
+      return true;
+    }
+    if (/^[a-zA-Z0-9_{}\\]+\s*[=~≈]\s*[a-zA-Z0-9_{}\\+\-*/^().\s]*$/.test(text.trim())) {
+      return true;
+    }
+    if (/\\/.test(text) && /[=+\-*/^_{}[\]]/.test(text)) {
+      return true;
+    }
+    if (/[≈~±∞∂∇∑∏∫]/.test(text)) {
+      return true;
+    }
+    if (/^[a-zA-Z0-9_{}\\]*[a-zA-Z]_[a-zA-Z0-9{}\\]*$/.test(text.trim()) || /^[a-zA-Z0-9_{}\\]*[a-zA-Z]\^[a-zA-Z0-9{}\\]*$/.test(text.trim())) {
+      return true;
+    }
+    if (/^[a-zA-Z0-9_{}\\]+\/[a-zA-Z0-9_{}\\^]+$/.test(text.trim()) && /[a-zA-Z]/.test(text)) {
+      return true;
+    }
+    return false;
+  };
+  LatexExtractor.hasAnyMathematicalContent = function hasAnyMathematicalContent(content) {
+    if (/\\[a-zA-Z]/.test(content)) return true;
+    if (/_\{|\^\{/.test(content)) return true;
+    if (/[a-zA-Z]\s*=\s*[a-zA-Z0-9]/.test(content)) return true;
+    if (/(?:Relevant|Derived)\s+equation:/i.test(content)) return true;
+    if (/[≈~±∞∂∇∑∏∫\\]/.test(content)) return true;
+    if (/[a-zA-Z]_[a-zA-Z0-9]/.test(content)) return true;
+    if (/[a-zA-Z]\^[a-zA-Z0-9]/.test(content)) return true;
+    if (/\$[^$]+\$/.test(content)) return true;
+    return false;
+  };
+  LatexExtractor.isAlreadyWrapped = function isAlreadyWrapped(content) {
+    if (/^\$[^$]+\$$/.test(content.trim())) return true;
+    if (/^\$\$[^$]+\$\$$/.test(content.trim())) return true;
+    return false;
+  };
+  LatexExtractor.extractExistingMathContent = function extractExistingMathContent(content) {
+    var mathBlocks = [];
+    var displayMathPattern = /\$\$([^$]+)\$\$/g;
+    var displayMatch;
+    while ((displayMatch = displayMathPattern.exec(content)) !== null) {
+      mathBlocks.push({
+        text: displayMatch[1],
+        start: displayMatch.index,
+        end: displayMatch.index + displayMatch[0].length,
+        type: 'display'
+      });
+    }
+    var inlineMathPattern = /\$([^$]+)\$/g;
+    var inlineMatch;
+    var _loop = function _loop() {
+      var matchStart = inlineMatch.index;
+      var isOverlapping = mathBlocks.some(function (block) {
+        return matchStart >= block.start && matchStart < block.end;
+      });
+      if (!isOverlapping) {
+        mathBlocks.push({
+          text: inlineMatch[1],
+          start: inlineMatch.index,
+          end: inlineMatch.index + inlineMatch[0].length,
+          type: 'inline'
+        });
+      }
+    };
+    while ((inlineMatch = inlineMathPattern.exec(content)) !== null) {
+      _loop();
+    }
+    return mathBlocks.sort(function (a, b) {
+      return a.start - b.start;
+    });
+  };
+  LatexExtractor.extractLatexFormulas = function extractLatexFormulas(content) {
+    var _this = this;
+    var formulas = [];
+    for (var _iterator2 = _createForOfIteratorHelperLoose(this.LATEX_PATTERNS), _step2; !(_step2 = _iterator2()).done;) {
+      var pattern = _step2.value;
+      var matches = content.match(pattern);
+      if (matches) {
+        var processedMatches = matches.map(function (match) {
+          if (match.startsWith(',')) {
+            return match.substring(1).trim();
+          }
+          if (match.endsWith(',')) {
+            return match.substring(0, match.length - 1).trim();
+          }
+          return match.trim();
+        });
+        formulas.push.apply(formulas, processedMatches);
+      }
+    }
+    var lines = content.split(/\\\\/);
+    for (var _iterator3 = _createForOfIteratorHelperLoose(lines), _step3; !(_step3 = _iterator3()).done;) {
+      var line = _step3.value;
+      var trimmed = line.trim().replace(/\.$/, '');
+      if (trimmed && this.isLatexFormula(trimmed)) {
+        formulas.push(trimmed);
+      }
+    }
+    var commaSeparatedParts = content.split(',');
+    for (var _iterator4 = _createForOfIteratorHelperLoose(commaSeparatedParts), _step4; !(_step4 = _iterator4()).done;) {
+      var part = _step4.value;
+      var _trimmed = part.trim();
+      if (_trimmed && this.isLatexFormula(_trimmed)) {
+        formulas.push(_trimmed);
+      }
+    }
+    var uniqueFormulas = Array.from(new Set(formulas));
+    return uniqueFormulas.filter(function (formula) {
+      return formula.length > 1 && !formula.match(/^[,\s.]*$/) && _this.isLatexFormula(formula);
+    });
+  };
+  LatexExtractor.findLatexExpressions = function findLatexExpressions(content) {
+    var expressions = [];
+    var mathStartPatterns = [/\\[a-zA-Z]+(?:\s*\{[^}]*\})*|\\[a-zA-Z]+/g, /[a-zA-Z][_^]\{[^}]*\}/g, /[a-zA-Z][_^][a-zA-Z0-9]/g, /[≈~±∞∂∇∑∏∫]/g, /\b[a-zA-Z]+\/[a-zA-Z]+\^?\{?[0-9]+\}?/g];
+    for (var _i2 = 0, _mathStartPatterns = mathStartPatterns; _i2 < _mathStartPatterns.length; _i2++) {
+      var pattern = _mathStartPatterns[_i2];
+      var match = void 0;
+      while ((match = pattern.exec(content)) !== null) {
+        var startPos = match.index;
+        var endPos = startPos + match[0].length;
+        var remaining = content.substring(endPos);
+        var limitedContinuationPattern = /^[\s]*[=~≈]\s*[a-zA-Z0-9_{}\\]+|^[\s]*[+\-*/]\s*[a-zA-Z0-9_{}\\]+/;
+        var continuationMatch = remaining.match(limitedContinuationPattern);
+        if (continuationMatch) {
+          endPos += continuationMatch[0].length;
+        }
+        var expressionText = content.substring(startPos, endPos).trim();
+        if (this.isLatexFormula(expressionText) && expressionText.length > 0) {
+          expressions.push({
+            text: expressionText,
+            start: startPos,
+            end: startPos + expressionText.length
+          });
+        }
+      }
+    }
+    var equationPattern = /\b[a-zA-Z][a-zA-Z0-9_{}\\]*\s*[=~≈]\s*[a-zA-Z0-9_{}\\+\-*/^().\s]*?\b/g;
+    var eqMatch;
+    while ((eqMatch = equationPattern.exec(content)) !== null) {
+      var _expressionText = eqMatch[0].trim();
+      if (this.isLatexFormula(_expressionText) && _expressionText.length > 3) {
+        expressions.push({
+          text: _expressionText,
+          start: eqMatch.index,
+          end: eqMatch.index + eqMatch[0].length
+        });
+      }
+    }
+    this.findKeywordSeparatedExpressions(content, expressions);
+    expressions.sort(function (a, b) {
+      return a.start - b.start;
+    });
+    var merged = [];
+    for (var _i3 = 0, _expressions = expressions; _i3 < _expressions.length; _i3++) {
+      var expr = _expressions[_i3];
+      var last = merged[merged.length - 1];
+      if (last && expr.start <= last.end) {
+        if (this.isLatexFormula(content.substring(last.start, expr.end).trim())) {
+          last.end = Math.max(last.end, expr.end);
+          last.text = content.substring(last.start, last.end).trim();
+        }
+      } else {
+        merged.push(expr);
+      }
+    }
+    return merged;
+  };
+  LatexExtractor.findKeywordSeparatedExpressions = function findKeywordSeparatedExpressions(content, expressions) {
+    var afterCommaPattern = /,\s*([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]*)*)/g;
+    var match;
+    while ((match = afterCommaPattern.exec(content)) !== null) {
+      var expression = match[1].trim();
+      if (this.isLatexFormula(expression) && expression.length > 1) {
+        var startPos = match.index + match[0].indexOf(expression);
+        expressions.push({
+          text: expression,
+          start: startPos,
+          end: startPos + expression.length
+        });
+      }
+    }
+    var beforeCommaPattern = /([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]*)*)\s*,/g;
+    while ((match = beforeCommaPattern.exec(content)) !== null) {
+      var _expression = match[1].trim();
+      if (this.isLatexFormula(_expression) && _expression.length > 1) {
+        var _startPos = match.index;
+        expressions.push({
+          text: _expression,
+          start: _startPos,
+          end: _startPos + _expression.length
+        });
+      }
+    }
+    var afterToPattern = /\bto\s+([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]*)*)/g;
+    while ((match = afterToPattern.exec(content)) !== null) {
+      var _expression2 = match[1].trim();
+      if (this.isLatexFormula(_expression2) && _expression2.length > 1) {
+        var _startPos2 = match.index + match[0].indexOf(_expression2);
+        expressions.push({
+          text: _expression2,
+          start: _startPos2,
+          end: _startPos2 + _expression2.length
+        });
       }
-      return content.replace(foundLatexStr, "$$" + foundLatexStr + "$$");
+    }
+    var beforeToPattern = /([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]*)*)\s+to\b/g;
+    while ((match = beforeToPattern.exec(content)) !== null) {
+      var _expression3 = match[1].trim();
+      if (this.isLatexFormula(_expression3) && _expression3.length > 1) {
+        var _startPos3 = match.index;
+        expressions.push({
+          text: _expression3,
+          start: _startPos3,
+          end: _startPos3 + _expression3.length
+        });
+      }
+    }
+  };
+  LatexExtractor.applyLatexFormat = function applyLatexFormat(content) {
+    if (!content || content.trim().length === 0) {
+      return content;
+    }
+    if (!this.hasAnyMathematicalContent(content)) {
+      return content;
+    }
+    var existingMathBlocks = this.extractExistingMathContent(content);
+    if (existingMathBlocks.length === 1 && existingMathBlocks[0].start === 0 && existingMathBlocks[0].end === content.length) {
+      return content;
+    }
+    if (this.isAlreadyWrapped(content)) {
+      return content;
+    }
+    var trimmedContent = content.trim();
+    if (!trimmedContent.includes('\n') && this.hasAnyMathematicalContent(trimmedContent)) {
+      var words = trimmedContent.toLowerCase().split(/\s+/);
+      var englishWords = words.filter(function (word) {
+        return /^[a-z]{3,}$/.test(word) && !['cos', 'sin', 'tan', 'log', 'exp', 'max', 'min'].includes(word);
+      });
+      if (englishWords.length === 0) {
+        return "$$" + trimmedContent + "$$";
+      }
+    }
+    if (!trimmedContent.includes('\n') && this.isLatexFormula(trimmedContent) && !/\b(?:the|is|are|and|or|of|to|in|on|at|by|for|with|from|into|onto|upon|over|under|above|below|between|among|through|during|before|after|since|until|while|where|when|why|how|what|who|which|that|this|these|those|some|many|few|all|no|not|very|more|most|less|least|better|best|worse|worst)\b/i.test(trimmedContent)) {
+      return "$$" + trimmedContent + "$$";
+    }
+    var expressions = this.findLatexExpressions(content);
+    var newExpressions = expressions.filter(function (expr) {
+      return !existingMathBlocks.some(function (mathBlock) {
+        return expr.start >= mathBlock.start && expr.end <= mathBlock.end;
+      });
+    });
+    if (newExpressions.length === 0) {
+      return content;
+    }
+    var result = content;
+    var offset = 0;
+    for (var _iterator5 = _createForOfIteratorHelperLoose(newExpressions), _step5; !(_step5 = _iterator5()).done;) {
+      var expr = _step5.value;
+      var adjustedStart = expr.start + offset;
+      var adjustedEnd = expr.end + offset;
+      var beforeStart = Math.max(0, adjustedStart - 2);
+      var afterEnd = Math.min(result.length, adjustedEnd + 2);
+      var context = result.substring(beforeStart, afterEnd);
+      if (!context.includes('$$') && !context.includes('$')) {
+        var wrappedExpr = "$$" + expr.text + "$$";
+        result = result.substring(0, adjustedStart) + wrappedExpr + result.substring(adjustedEnd);
+        offset += wrappedExpr.length - expr.text.length;
+      }
+    }
+    return result;
+  };
+  LatexExtractor.applyLatexFormatSimple = function applyLatexFormatSimple(content) {
+    if (!content || content.trim().length === 0) {
+      return content;
+    }
+    if (!this.hasAnyMathematicalContent(content)) {
+      return content;
+    }
+    if (this.isAlreadyWrapped(content)) {
+      return content;
+    }
+    var trimmedContent = content.trim();
+    if (!content.includes('\n') && this.hasAnyMathematicalContent(content)) {
+      var words = content.toLowerCase().split(/\s+/);
+      var englishWords = words.filter(function (word) {
+        return /^[a-z]{3,}$/.test(word) && !['cos', 'sin', 'tan', 'log', 'exp', 'max', 'min'].includes(word);
+      });
+      if (englishWords.length === 0) {
+        return "$$" + content + "$$";
+      }
+    }
+    if (this.isLatexFormula(trimmedContent) && !/\b(?:the|is|are|and|or|of|to|in|on|at|by|for|with|from|that|this|these|those|states|theorem|equation|formula)\b/i.test(trimmedContent)) {
+      return "$$" + trimmedContent + "$$";
+    }
+    if (/(?:Relevant|Derived)\s+equation:/i.test(content)) {
+      var parts = content.split(/(?:Relevant|Derived)\s+equation:\s*/i);
+      if (parts.length === 2) {
+        var textPart = parts[0].trim();
+        var formulaPart = parts[1].trim();
+        if (this.isLatexFormula(formulaPart) && !this.isAlreadyWrapped(formulaPart)) {
+          return textPart + "\n$$" + formulaPart + "$$";
+        }
+      }
+    }
+    var processedContent = this.processCommaSeparatedFormulas(content);
+    if (processedContent !== content) {
+      return processedContent;
+    }
+    var formulas = this.extractLatexFormulas(content);
+    if (formulas.length > 0) {
+      var result = content;
+      var mainFormula = formulas.reduce(function (longest, current) {
+        return current.length > longest.length ? current : longest;
+      });
+      if (!result.includes('$$') && !result.includes('$')) {
+        var formulaIndex = result.indexOf(mainFormula);
+        if (formulaIndex !== -1) {
+          result = result.substring(0, formulaIndex) + ("$$" + mainFormula + "$$") + result.substring(formulaIndex + mainFormula.length);
+        }
+      }
+      return result;
     }
     return content;
   };
+  LatexExtractor.processCommaSeparatedFormulas = function processCommaSeparatedFormulas(content) {
+    var _this2 = this;
+    if (!this.hasAnyMathematicalContent(content)) {
+      return content;
+    }
+    var result = content;
+    var hasChanges = false;
+    var beforeCommaPattern = /([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]+)*)\s*,/g;
+    result = result.replace(beforeCommaPattern, function (match, formula) {
+      if (_this2.isLatexFormula(formula.trim()) && !match.includes('$$') && !match.includes('$')) {
+        hasChanges = true;
+        return "$$" + formula.trim() + "$$,";
+      }
+      return match;
+    });
+    var afterCommaPattern = /,\s*([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]+)*)/g;
+    result = result.replace(afterCommaPattern, function (match, formula) {
+      if (_this2.isLatexFormula(formula.trim()) && !match.includes('$$') && !match.includes('$')) {
+        hasChanges = true;
+        return ", $$" + formula.trim() + "$$";
+      }
+      return match;
+    });
+    return hasChanges ? result : content;
+  };
   return LatexExtractor;
 }();
-LatexExtractor.extractAllLatexUltimate = function (content) {
-  var latexRegex = /(\\[a-zA-Z]+\s*\{[^}]*\}(?:\s*\{[^}]*\})*|\\[a-zA-Z]+|\\[a-zA-Z]+\s*[^\\\s\{]+|[a-zA-Z]+\^{[^}]*}|[a-zA-Z]+\_{[^}]*}|\$[^$]+\$|\\\([^)]+\\\)|\\\[[^\]]+\\\]|\\[a-zA-Z]+\d*|(?:\\[a-zA-Z]+\s*)+[^\\]*(?=\\\\|\.|$))/g;
-  var matches = content.match(latexRegex) || [];
-  return matches.filter(function (match) {
-    return match.length > 1 && !match.match(/^[,\s\.]*$/) && (match.includes("\\") || match.includes("^{") || match.includes("_{") || match.includes("$") || !!match.match(/[a-zA-Z]\s*[=+\-*/]\s*[a-zA-Z0-9]/));
-  });
-};
-LatexExtractor.extractMultiLineFormulas = function (content) {
-  var formulas = content.split(/\\\\/);
-  return formulas.map(function (formula) {
-    var cleaned = formula.trim();
-    cleaned = cleaned.replace(/\.$/, "");
-    return cleaned;
-  }).filter(function (formula) {
-    return formula.length > 0 && LatexExtractor.isMathFormula(formula);
-  });
-};
-LatexExtractor.isMathFormula = function (text) {
-  return !!text && (text.includes("=") || text.includes("\\") || text.includes("^{") || text.includes("_{") || !!text.match(/[a-zA-Z]\s*[=+\-*/]\s*[a-zA-Z0-9]/));
-};
+LatexExtractor.LATEX_COMMANDS = ['\\frac', '\\sqrt', '\\sum', '\\prod', '\\int', '\\oint', '\\lim', '\\sin', '\\cos', '\\tan', '\\log', '\\ln', '\\exp', '\\alpha', '\\beta', '\\gamma', '\\delta', '\\epsilon', '\\varepsilon', '\\zeta', '\\eta', '\\theta', '\\vartheta', '\\iota', '\\kappa', '\\lambda', '\\mu', '\\nu', '\\xi', '\\pi', '\\varpi', '\\rho', '\\varrho', '\\sigma', '\\varsigma', '\\tau', "\\upsilon", '\\phi', '\\varphi', '\\chi', '\\psi', '\\omega', '\\Gamma', '\\Delta', '\\Theta', '\\Lambda', '\\Xi', '\\Pi', '\\Sigma', "\\Upsilon", '\\Phi', '\\Psi', '\\Omega', '\\to', '\\gets', '\\mapsto', '\\implies', '\\iff', '\\leftrightarrow', '\\longleftarrow', '\\longrightarrow', '\\longleftrightarrow', '\\Leftarrow', '\\Rightarrow', '\\Leftrightarrow', '\\le', '\\ge', '\\leq', '\\geq', '\\lt', '\\gt', '\\neq', '\\approx', '\\equiv', '\\sim', '\\cong', '\\leqslant', '\\geqslant', '\\parallel', '\\perp', '\\in', '\\notin', '\\subset', '\\subseteq', '\\cup', '\\cap', '\\emptyset', '\\forall', '\\exists', '\\nexists', '\\wedge', '\\vee', '\\neg', '\\partial', '\\nabla', '\\infty', '\\pm', '\\mp', '\\vec', '\\overrightarrow', "\\underrightarrow", '\\overline', "\\underline", '\\widehat', '\\widetilde', '\\overbrace', "\\underbrace", '\\mathbb', '\\mathrm', '\\mathcal', '\\mathfrak', '\\mathscr', '\\text', '\\textbf', '\\textit', '\\left', '\\right', '\\lfloor', '\\rfloor', '\\lceil', '\\rceil', '\\langle', '\\rangle', '\\cdot', '\\times', '\\div', '\\parallel', '\\angle', '\\bot', '\\newline', '\\ldots', '\\cdots', '\\vdots', '\\ddots'];
+LatexExtractor.LATEX_PATTERNS = [/[a-zA-Z0-9]_\{[^}]*\}/g, /[a-zA-Z0-9]\^\{[^}]*\}/g, /\\[a-zA-Z]+\s*\{[^}]*\}(?:\s*\{[^}]*\})*/g, /\\[a-zA-Z]+(?![a-zA-Z])/g, /\\frac\s*\{[^}]*\}\s*\{[^}]*\}/g, /\\sqrt(?:\[[^\]]*\])?\s*\{[^}]*\}/g, /\\vec\s*\{[^}]*\}/g, /\\(?:alpha|beta|gamma|delta|epsilon|varepsilon|zeta|eta|theta|vartheta|iota|kappa|lambda|mu|nu|xi|pi|varpi|rho|varrho|sigma|varsigma|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?![a-zA-Z])/g, /[a-zA-Z0-9_{}\\]+\s*=\s*[a-zA-Z0-9_{}\\+\-*/^().\s]+/g, /\\Delta\s*[a-zA-Z]/g, /[a-zA-Z]+_\{[a-zA-Z0-9]+\}/g, /[a-zA-Z0-9_{}\\]+\s*[+\-*/]\s*[a-zA-Z0-9_{}\\().\s]+/g, /,\s*([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^]\s*[a-zA-Z0-9_{}\\().\s]*)*)/g, /([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^]\s*[a-zA-Z0-9_{}\\().\s]*)*)\s*,/g, /\bto\s+([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]*)*)/g, /([a-zA-Z0-9_{}\\]+(?:\s*[=+\-*/^~≈]\s*[a-zA-Z0-9_{}\\().\s]*)*)\s+to\b/g];
 
-var _excluded$3 = ["node"];
-var MarkdownLatexRender = function MarkdownLatexRender(_ref) {
+var MarkdownRenderer = function MarkdownRenderer(_ref) {
   var content = _ref.content;
-  var updatedMarkdown = formatContent(content);
-  return React__default.createElement("span", null, React__default.createElement(ReactMarkdown, {
-    remarkPlugins: [remarkMath, remarkGfm, remarkRehype],
-    rehypePlugins: [rehypeKatex, rehypeRaw],
-    components: {
-      p: function p(_ref2) {
-        var props = _objectWithoutPropertiesLoose(_ref2, _excluded$3);
-        return React__default.createElement("span", Object.assign({}, props));
-      }
-    }
-  }, updatedMarkdown));
+  var formattedContent = formatContent(content);
+  return React__default.createElement(ReactMarkdown, {
+    remarkPlugins: [remarkMath],
+    rehypePlugins: [rehypeKatex, rehypeRaw]
+  }, formattedContent);
 };
 function formatContent(content) {
-  var lines = content.split("\n");
+  if (!content || content.trim() === "") {
+    return content;
+  }
+  var processedContent = content.replace(/\s*\\\\\s*/g, '\n');
+  var lines = processedContent.split("\n");
   var result = [];
   var i = 0;
   while (i < lines.length) {
-    var line = lines[i];
-    var appliedLatexFormat = LatexExtractor.ApplyLatexFormat(line);
-    if (appliedLatexFormat !== line) {
-      result.push(appliedLatexFormat);
+    var line = lines[i].trim();
+    if (line === '') {
+      result.push('');
       i++;
       continue;
     }
-    result.push(line);
+    var isEquationLabel = /\\textit\{.*(?:Relevant|Derived).*equation.*\}/i.test(line) || /^(?:Relevant|Derived)\s+equation:\s*$/i.test(line);
+    if (isEquationLabel) {
+      var processedLabel = line;
+      if (line.includes('\\textit{') && !line.startsWith('$')) {
+        processedLabel = "$" + line + "$";
+      }
+      result.push(processedLabel);
+      i++;
+      if (i < lines.length) {
+        var equationLine = lines[i].trim();
+        if (equationLine) {
+          if (LatexExtractor.isAlreadyWrapped(equationLine)) {
+            result.push(equationLine);
+          } else {
+            var formatText = LatexExtractor.applyLatexFormat(equationLine);
+            result.push(formatText);
+          }
+        }
+        i++;
+      }
+      continue;
+    }
+    if (LatexExtractor.isAlreadyWrapped(line)) {
+      result.push(line);
+    } else {
+      var _formatText = LatexExtractor.applyLatexFormatSimple(line);
+      result.push(_formatText);
+    }
     i++;
   }
   return result.join("\n");
@@ -3333,7 +3722,7 @@ var CustomOption = function CustomOption(props) {
   }, props.data.label));
 };
 
-var _excluded$4 = ["isDefault", "defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
+var _excluded$3 = ["isDefault", "defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
 var CustomSelect = function CustomSelect(_ref) {
   var isDefault = _ref.isDefault,
     options = _ref.options,
@@ -3341,7 +3730,7 @@ var CustomSelect = function CustomSelect(_ref) {
     scrollBottom = _ref.scrollBottom,
     value = _ref.value,
     isMulti = _ref.isMulti,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+    rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
   var initialValues = Array.isArray(value) ? options.filter(function (i) {
     return value.includes(i.value);
   }) : isMulti ? options === null || options === void 0 ? void 0 : options.filter(function (i) {
@@ -3368,7 +3757,7 @@ var CustomSelect = function CustomSelect(_ref) {
   }, rest));
 };
 
-var _excluded$5 = ["isDefault", "defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
+var _excluded$4 = ["isDefault", "defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
 var CustomAsyncSelect = function CustomAsyncSelect(_ref) {
   var isDefault = _ref.isDefault,
     options = _ref.options,
@@ -3376,7 +3765,7 @@ var CustomAsyncSelect = function CustomAsyncSelect(_ref) {
     scrollBottom = _ref.scrollBottom,
     value = _ref.value,
     isMulti = _ref.isMulti,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$5);
+    rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
   var initialValues = Array.isArray(value) ? options.filter(function (i) {
     return value.includes(i.value);
   }) : isMulti ? options.filter(function (i) {
@@ -3403,14 +3792,14 @@ var CustomAsyncSelect = function CustomAsyncSelect(_ref) {
   }, rest));
 };
 
-var _excluded$6 = ["defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
+var _excluded$5 = ["defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
 var CustomCreatable = function CustomCreatable(_ref) {
   var options = _ref.options,
     isDisabled = _ref.isDisabled,
     scrollBottom = _ref.scrollBottom,
     value = _ref.value,
     isMulti = _ref.isMulti,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+    rest = _objectWithoutPropertiesLoose(_ref, _excluded$5);
   var initialValues = Array.isArray(value) ? options.filter(function (i) {
     return value.includes(i.value);
   }) : isMulti ? options.filter(function (i) {
@@ -3437,7 +3826,7 @@ var CustomCreatable = function CustomCreatable(_ref) {
   }, rest));
 };
 
-var _excluded$7 = ["defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
+var _excluded$6 = ["defaultValue", "options", "isDisabled", "scrollBottom", "value", "isMulti"];
 var CustomSelectOption = function CustomSelectOption(_ref) {
   var defaultValue = _ref.defaultValue,
     options = _ref.options,
@@ -3445,7 +3834,7 @@ var CustomSelectOption = function CustomSelectOption(_ref) {
     scrollBottom = _ref.scrollBottom,
     value = _ref.value,
     isMulti = _ref.isMulti,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$7);
+    rest = _objectWithoutPropertiesLoose(_ref, _excluded$6);
   var initialValues = defaultValue !== null && typeof defaultValue !== "undefined" ? options.find(function (option) {
     return option.value === defaultValue;
   }) || null : null;
@@ -3525,7 +3914,7 @@ exports.DATE_TIME_MIN_VALUE = DATE_TIME_MIN_VALUE;
 exports.LayoutContext = LayoutContext;
 exports.Loading = Loading;
 exports.Login = Login;
-exports.MarkdownLatexRender = MarkdownLatexRender;
+exports.MarkdownLatexRender = MarkdownRenderer;
 exports.NotFound = NotFound;
 exports.OPENSALT_BASE_URL = OPENSALT_BASE_URL;
 exports.ORGANIZATION_TEAM = ORGANIZATION_TEAM;