crosstex 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Muhammad Saad Amin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/LatexToMathJs.js

@@ -0,0 +1,261 @@
+// Convert LaTeX to math.js expression
+export const latexToMathJs = (latex) => {
+    let expr = latex.trim();
+
+    // Handle absolute values FIRST (before other conversions)
+    // Match \left| ... \right| or just | ... |
+    expr = expr.replace(/\\left\|([^|]+)\\right\|/g, 'abs($1)');
+    // Handle simple | ... | patterns (non-greedy)
+    let absCount = 0;
+    expr = expr.replace(/\|/g, () => {
+        absCount++;
+        return absCount % 2 === 1 ? '(abs(' : '))';
+    });
+
+    // Handle fractions recursively for nested cases
+    let prevExpr;
+    do {
+        prevExpr = expr;
+        expr = expr.replace(/\\frac\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g,
+            '(($1)/($2))');
+    } while (expr !== prevExpr);
+
+    // Handle roots
+    expr = expr.replace(/\\sqrt\[([^\]]+)\]\{([^}]+)\}/g, '(($2)^(1/($1)))');
+    expr = expr.replace(/\\sqrt\{([^}]+)\}/g, '(sqrt($1))');
+
+    // **CRITICAL: Handle inverse trig with arguments BEFORE converting to short forms**
+    // Handle patterns like \tan^{-1}xyz or \sin^{-1}abc
+    expr = expr.replace(/\\tan\^\{-1\}\s*([a-zA-Z]+)/g, (match, vars) => {
+        return 'atan(' + vars.split('').join('*') + ')';
+    });
+    expr = expr.replace(/\\sin\^\{-1\}\s*([a-zA-Z]+)/g, (match, vars) => {
+        return 'asin(' + vars.split('').join('*') + ')';
+    });
+    expr = expr.replace(/\\cos\^\{-1\}\s*([a-zA-Z]+)/g, (match, vars) => {
+        return 'acos(' + vars.split('').join('*') + ')';
+    });
+
+    // Handle inverse trig with explicit arguments in braces
+    expr = expr.replace(/\\tan\^\{-1\}\{([^}]+)\}/g, 'atan($1)');
+    expr = expr.replace(/\\sin\^\{-1\}\{([^}]+)\}/g, 'asin($1)');
+    expr = expr.replace(/\\cos\^\{-1\}\{([^}]+)\}/g, 'acos($1)');
+
+    // Handle inverse trig BEFORE regular trig (order matters!)
+    expr = expr.replace(/\\arctan/g, 'atan');
+    expr = expr.replace(/\\arcsin/g, 'asin');
+    expr = expr.replace(/\\arccos/g, 'acos');
+    expr = expr.replace(/\\tan\^\{-1\}/g, 'atan');
+    expr = expr.replace(/\\sin\^\{-1\}/g, 'asin');
+    expr = expr.replace(/\\cos\^\{-1\}/g, 'acos');
+
+    // Handle regular trig functions (but NOT reciprocal trig yet!)
+    expr = expr.replace(/\\tan/g, 'tan');
+    expr = expr.replace(/\\sin/g, 'sin');
+    expr = expr.replace(/\\cos/g, 'cos');
+
+    // Replace \sec, \csc, \cot with temporary placeholders
+    expr = expr.replace(/\\sec/g, 'SEC');
+    expr = expr.replace(/\\csc/g, 'CSC');
+    expr = expr.replace(/\\cot/g, 'COT');
+
+    // IMPORTANT: Handle trig functions with space and variable BEFORE removing spaces
+    expr = expr.replace(/tan\s+([a-zA-Z])/g, 'tan($1)');
+    expr = expr.replace(/sin\s+([a-zA-Z])/g, 'sin($1)');
+    expr = expr.replace(/cos\s+([a-zA-Z])/g, 'cos($1)');
+    expr = expr.replace(/atan\s+([a-zA-Z])/g, 'atan($1)');
+    expr = expr.replace(/asin\s+([a-zA-Z])/g, 'asin($1)');
+    expr = expr.replace(/acos\s+([a-zA-Z])/g, 'acos($1)');
+    expr = expr.replace(/SEC\s+([a-zA-Z])/g, 'SEC($1)');
+    expr = expr.replace(/CSC\s+([a-zA-Z])/g, 'CSC($1)');
+    expr = expr.replace(/COT\s+([a-zA-Z])/g, 'COT($1)');
+    expr = expr.replace(/log\s+([a-zA-Z])/g, 'log($1)');
+    expr = expr.replace(/log10\s+([a-zA-Z])/g, 'log10($1)');
+    expr = expr.replace(/sqrt\s+([a-zA-Z])/g, 'sqrt($1)');
+    expr = expr.replace(/exp\s+([a-zA-Z])/g, 'exp($1)');
+    expr = expr.replace(/abs\s+([a-zA-Z])/g, 'abs($1)');
+
+    // **NEW: Handle trig functions followed by numbers and variables (e.g., cos2x, sin3y)**
+    expr = expr.replace(/(sin|cos|tan|asin|acos|atan|SEC|CSC|COT)([0-9]+)([a-zA-Z]+)/g, '$1($2*$3)');
+    expr = expr.replace(/(sin|cos|tan|asin|acos|atan|SEC|CSC|COT)([0-9]+)/g, '$1($2)');
+
+    // Handle logarithms
+    expr = expr.replace(/\\ln/g, 'log');
+    expr = expr.replace(/\\log/g, 'log10');
+
+    // Handle constants
+    expr = expr.replace(/\\pi/g, 'pi');
+    expr = expr.replace(/\\e(?![a-zA-Z])/g, 'e');
+    expr = expr.replace(/\\infty/g, 'Infinity');
+
+    // **CRITICAL: Handle function^power variable patterns BEFORE general power handling**
+    // This catches patterns like sin^2 x, cos^2 y, SEC^2 z, etc.
+    expr = expr.replace(/(sin|cos|tan|asin|acos|atan|SEC|CSC|COT)\^([0-9]+)\s*([a-zA-Z])/g, '($1($3)^$2)');
+    expr = expr.replace(/(sin|cos|tan|asin|acos|atan|SEC|CSC|COT)\^\{([^}]+)\}\s*([a-zA-Z])/g, '($1($3)^($2))');
+
+    // NOW convert SEC, CSC, COT to their reciprocal forms
+    expr = expr.replace(/SEC\(([^)]+)\)/g, '(1/cos($1))');
+    expr = expr.replace(/CSC\(([^)]+)\)/g, '(1/sin($1))');
+    expr = expr.replace(/COT\(([^)]+)\)/g, '(1/tan($1))');
+
+    // Handle brackets and braces
+    expr = expr.replace(/\\left\(/g, '(');
+    expr = expr.replace(/\\right\)/g, ')');
+    expr = expr.replace(/\\left\[/g, '(');
+    expr = expr.replace(/\\right\]/g, ')');
+    expr = expr.replace(/\\left\\{/g, '(');
+    expr = expr.replace(/\\right\\}/g, ')');
+
+    // Handle operators
+    expr = expr.replace(/\\cdot/g, '*');
+    expr = expr.replace(/\\times/g, '*');
+    expr = expr.replace(/\\div/g, '/');
+    expr = expr.replace(/\\pm/g, '+');
+
+    // Handle exponentials and powers
+    expr = expr.replace(/\\exp\{([^}]+)\}/g, 'exp($1)');
+    // Handle e^{...} before general powers
+    expr = expr.replace(/e\^\{([^}]+)\}/g, 'exp($1)');
+    // Handle general powers with braces
+    expr = expr.replace(/([a-zA-Z0-9]+)\^\{([^}]+)\}/g, '($1^($2))');
+    // Handle simple powers without braces (e.g., x^2)
+    expr = expr.replace(/([a-zA-Z0-9]+)\^([a-zA-Z0-9])/g, '($1^$2)');
+
+    // IMPORTANT: Handle implicit multiplication BEFORE converting braces to parens
+    // This preserves the structure and prevents )(  patterns
+
+    // Handle {expr1}{expr2} -> convert to (expr1)*(expr2) before general brace conversion
+    expr = expr.replace(/\}\s*\{/g, ')*(');
+
+    // Clean up remaining braces (convert to parentheses)
+    expr = expr.replace(/\{/g, '(');
+    expr = expr.replace(/\}/g, ')');
+
+    // Remove extra spaces BEFORE processing implicit multiplication
+    expr = expr.replace(/\s+/g, '');
+
+    // SMARTER APPROACH: Add multiplication between adjacent variables, but NOT within function names
+    const knownFuncs = ['sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'log', 'log10', 'sqrt', 'exp', 'abs', 'pi'];
+
+    // Step 1: Add implicit multiplication between consecutive single-letter variables
+    let newExpr = '';
+    let i = 0;
+
+    while (i < expr.length) {
+        // Check if current position starts a known function
+        let matchedFunc = null;
+        for (let func of knownFuncs) {
+            if (expr.substr(i, func.length) === func) {
+                // Verify it's actually the function (check what comes after)
+                const nextIdx = i + func.length;
+                const nextChar = expr[nextIdx];
+                // Function if followed by '(' or operator or end
+                if (!nextChar || nextChar === '(' || '+-*/^),'.includes(nextChar)) {
+                    matchedFunc = func;
+                    break;
+                }
+            }
+        }
+
+        if (matchedFunc) {
+            // Copy the entire function name
+            newExpr += matchedFunc;
+            i += matchedFunc.length;
+        } else if (/[a-z]/i.test(expr[i])) {
+            // Single letter variable
+            newExpr += expr[i];
+            // Check if next char is also a single letter (not start of function)
+            if (i + 1 < expr.length && /[a-z]/i.test(expr[i + 1])) {
+                // Check if next position starts a function
+                let nextIsFunc = false;
+                for (let func of knownFuncs) {
+                    if (expr.substr(i + 1, func.length) === func) {
+                        const afterIdx = i + 1 + func.length;
+                        const afterChar = expr[afterIdx];
+                        if (!afterChar || afterChar === '(' || '+-*/^),'.includes(afterChar)) {
+                            nextIsFunc = true;
+                            break;
+                        }
+                    }
+                }
+                // If next is NOT a function, add multiplication
+                if (!nextIsFunc) {
+                    newExpr += '*';
+                }
+            }
+            i++;
+        } else {
+            // Not a letter, just copy
+            newExpr += expr[i];
+            i++;
+        }
+    }
+
+    expr = newExpr;
+
+    // Now handle other implicit multiplication cases
+    // 1. Number followed by letter
+    expr = expr.replace(/(\d+\.?\d*)([a-zA-Z])/g, '$1*$2');
+    // 2. Closing paren followed by number
+    expr = expr.replace(/\)(\d)/g, ')*$1');
+    // 3. Number followed by opening paren
+    expr = expr.replace(/(\d)\(/g, '$1*(');
+    // 4. Closing paren followed by opening paren (but not for functions)
+    expr = expr.replace(/\)\s*\(/g, (match, offset) => {
+        const before = expr.substring(Math.max(0, offset - 15), offset);
+        for (let func of knownFuncs) {
+            if (before.endsWith(func)) {
+                return match;
+            }
+        }
+        return ')*(';
+    });
+    // 5. Closing paren followed by letter (variable, not function)
+    expr = expr.replace(/\)([a-zA-Z])/g, (match, letter, offset) => {
+        const afterMatch = expr.substring(offset + match.length);
+        if (afterMatch.startsWith('(')) {
+            const potentialFunc = expr.substring(offset + 1).match(/^[a-zA-Z]+/);
+            if (potentialFunc && knownFuncs.includes(potentialFunc[0])) {
+                return match;
+            }
+        }
+        return ')*' + letter;
+    });
+    // 6. Letter followed by opening paren (only for variables, not functions)
+    expr = expr.replace(/([a-zA-Z])(\()/g, (match, letter, paren, offset) => {
+        const before = expr.substring(Math.max(0, offset - 15), offset + 1);
+        for (let func of knownFuncs) {
+            if (before.endsWith(func)) {
+                return match;
+            }
+        }
+        return letter + '*' + paren;
+    });
+
+    // Clean up any remaining LaTeX backslashes
+    expr = expr.replace(/\\/g, '');
+
+    // Fix sqrt
+    expr = expr.replace(/sqrt\*/g, "sqrt");
+
+    // Fix exp patterns - handle cases where exp got concatenated
+    // zexp -> z*exp, 2exp -> 2*exp, etc.
+    expr = expr.replace(/([a-z0-9])exp/gi, '$1*exp');
+
+    // Convert exp to e^
+    expr = expr.replace(/exp\*/g, "e^");
+    expr = expr.replace(/exp\(/g, "e^(");
+
+    // Add explicit multiplication between variable/number and e
+    expr = expr.replace(/([a-z0-9])e\^/gi, '$1*e^');
+
+    // Fix cos*, sin*, tan*, etc (remove the *)
+    expr = expr.replace(/(cos|sin|tan|log|ln)\*/g, '$1');
+
+    // Add multiplication between number and letter/function
+    expr = expr.replace(/([0-9])([a-z])/gi, '$1*$2');
+
+    // Add multiplication between closing paren and letter/number
+    expr = expr.replace(/\)([a-z0-9(])/gi, ')*$1');
+    return expr;
+};

package/README.md

@@ -0,0 +1,295 @@
+# LaTeX to Math.js Converter
+
+A robust JavaScript utility that converts LaTeX mathematical expressions into Math.js compatible syntax. This converter handles a wide range of mathematical notation including fractions, roots, trigonometric functions, logarithms, and complex nested expressions.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 📋 Table of Contents
+
+- [Features](#-features)
+- [Installation](#-installation)
+- [Usage](#-usage)
+- [Supported LaTeX Commands](#-supported-latex-commands)
+- [How It Works](#-how-it-works)
+- [Examples](#-examples)
+- [Contributing](#-contributing)
+- [License](#-license)
+- [Star the Repository](#-star-the-repository)
+
+## ✨ Features
+
+- **Comprehensive LaTeX Support**: Handles fractions, roots, exponents, trigonometric functions, logarithms, and more
+- **Nested Expression Handling**: Properly processes deeply nested mathematical expressions
+- **Implicit Multiplication**: Automatically adds multiplication operators where needed (e.g., `2x` → `2*x`)
+- **Smart Function Recognition**: Distinguishes between mathematical functions and variable names
+- **Absolute Value Support**: Converts both `\left| \right|` and simple `| |` notation
+- **Reciprocal Trig Functions**: Handles `\sec`, `\csc`, `\cot` by converting to their reciprocal forms
+
+## 📦 Installation
+
+Simply import the function into your JavaScript project:
+
+```javascript
+import { latexToMathJs } from './LatexToMathJs.js';
+```
+
+Or if using CommonJS:
+
+```javascript
+const { latexToMathJs } = require('./LatexToMathJs.js');
+```
+
+## 🚀 Usage
+
+```javascript
+import { latexToMathJs } from './LatexToMathJs.js';
+
+// Basic usage
+const latex = '\\frac{x^2 + 1}{2}';
+const mathJs = latexToMathJs(latex);
+console.log(mathJs); // Output: ((x^(2))+1)/(2))
+
+// With Math.js evaluation
+import { evaluate } from 'mathjs';
+
+const result = evaluate(mathJs, { x: 3 });
+console.log(result); // Output: 5
+```
+
+## 📚 Supported LaTeX Commands
+
+### Fractions
+- `\frac{numerator}{denominator}` → `((numerator)/(denominator))`
+
+### Roots
+- `\sqrt{x}` → `sqrt(x)`
+- `\sqrt[n]{x}` → `(x^(1/n))`
+
+### Trigonometric Functions
+- **Standard**: `\sin`, `\cos`, `\tan`
+- **Inverse**: `\arcsin`, `\arccos`, `\arctan`, `\sin^{-1}`, `\cos^{-1}`, `\tan^{-1}`
+- **Reciprocal**: `\sec`, `\csc`, `\cot` (converted to `1/cos`, `1/sin`, `1/tan`)
+
+### Logarithms
+- `\ln{x}` → `log(x)` (natural logarithm)
+- `\log{x}` → `log10(x)` (base 10)
+
+### Exponentials and Powers
+- `\exp{x}` → `exp(x)`
+- `e^{x}` → `exp(x)`
+- `x^{n}` → `(x^(n))`
+- `x^2` → `(x^2)`
+
+### Absolute Value
+- `\left| x \right|` → `abs(x)`
+- `|x|` → `abs(x)`
+
+### Constants
+- `\pi` → `pi`
+- `\e` → `e`
+- `\infty` → `Infinity`
+
+### Operators
+- `\cdot` → `*`
+- `\times` → `*`
+- `\div` → `/`
+- `\pm` → `+` (plus-minus treated as plus)
+
+### Brackets
+- `\left(`, `\right)`, `\left[`, `\right]`, `\left\{`, `\right\}` → `()`
+
+## 🔧 How It Works
+
+The converter processes LaTeX expressions through several carefully ordered stages:
+
+### 1. **Absolute Value Conversion** (First Priority)
+```javascript
+// Handles \left| ... \right| and | ... |
+expr = expr.replace(/\\left\|([^|]+)\\right\|/g, 'abs($1)');
+```
+Absolute values are processed first to prevent interference with other operators.
+
+### 2. **Fraction Handling** (Recursive)
+```javascript
+// Recursively handles nested fractions
+do {
+    prevExpr = expr;
+    expr = expr.replace(/\\frac\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g,
+        '(($1)/($2))');
+} while (expr !== prevExpr);
+```
+Uses a loop to handle deeply nested fractions like `\frac{\frac{a}{b}}{c}`.
+
+### 3. **Root Conversion**
+```javascript
+// nth roots and square roots
+expr = expr.replace(/\\sqrt\[([^\]]+)\]\{([^}]+)\}/g, '(($2)^(1/($1)))');
+expr = expr.replace(/\\sqrt\{([^}]+)\}/g, '(sqrt($1))');
+```
+
+### 4. **Trigonometric Functions** (Order Matters!)
+Inverse functions are processed **before** regular ones to prevent incorrect conversions:
+```javascript
+// Inverse trig first
+expr = expr.replace(/\\arctan/g, 'atan');
+// Then regular trig
+expr = expr.replace(/\\tan/g, 'tan');
+```
+
+### 5. **Function Arguments**
+Handles functions with explicit arguments and space-separated notation:
+```javascript
+// sin x → sin(x)
+expr = expr.replace(/sin\s+([a-zA-Z])/g, 'sin($1)');
+```
+
+### 6. **Power and Exponent Handling**
+```javascript
+// Special case: e^{...} → exp(...)
+expr = expr.replace(/e\^\{([^}]+)\}/g, 'exp($1)');
+// General powers: x^{n} → (x^(n))
+expr = expr.replace(/([a-zA-Z0-9]+)\^\{([^}]+)\}/g, '($1^($2))');
+```
+
+### 7. **Implicit Multiplication** (Smart Detection)
+This is the most complex part, using a state machine approach:
+
+```javascript
+const knownFuncs = ['sin', 'cos', 'tan', 'asin', 'acos', 'atan', ...];
+
+while (i < expr.length) {
+    // Check if current position starts a known function
+    if (matchedFunc) {
+        // Don't add multiplication within function names
+    } else if (isVariable) {
+        // Add * between consecutive variables (xy → x*y)
+        // But NOT between variable and function (xsin → x*sin, not xs*in)
+    }
+}
+```
+
+The algorithm handles:
+- Number + variable: `2x` → `2*x`
+- Variable + variable: `xy` → `x*y` (but preserves function names like `sin`)
+- Number + parenthesis: `2(x)` → `2*(x)`
+- Closing + opening parens: `)(` → `)*(`
+- Variable + parenthesis: `x(y)` → `x*(y)` (except for functions)
+
+### 8. **Cleanup**
+Final step removes remaining LaTeX backslashes and extra spaces.
+
+## 📖 Examples
+
+### Basic Expressions
+```javascript
+latexToMathJs('x^2 + 2x + 1');
+// Output: (x^2)+2*x+1
+
+latexToMathJs('\\frac{1}{2}x');
+// Output: ((1)/(2))*x
+```
+
+### Trigonometric
+```javascript
+latexToMathJs('\\sin(x) + \\cos(x)');
+// Output: sin(x)+cos(x)
+
+latexToMathJs('\\sec(x)');
+// Output: (1/cos(x))
+
+latexToMathJs('\\arctan(y)');
+// Output: atan(y)
+```
+
+### Complex Nested Expressions
+```javascript
+latexToMathJs('\\frac{\\sin(x)}{\\cos(x)}');
+// Output: ((sin(x))/(cos(x)))
+
+latexToMathJs('\\sqrt{\\frac{a^2 + b^2}{c}}');
+// Output: (sqrt(((a^(2))+(b^(2)))/(c)))
+
+latexToMathJs('e^{-\\frac{x^2}{2}}');
+// Output: exp(-((x^(2))/(2)))
+```
+
+### Absolute Values
+```javascript
+latexToMathJs('\\left| x - 1 \\right|');
+// Output: abs(x-1)
+
+latexToMathJs('|x| + |y|');
+// Output: abs(x)+abs(y)
+```
+
+### Implicit Multiplication
+```javascript
+latexToMathJs('2xy');
+// Output: 2*x*y
+
+latexToMathJs('(x+1)(x-1)');
+// Output: (x+1)*(x-1)
+
+latexToMathJs('\\pi r^2');
+// Output: pi*r^(2)
+```
+
+## 🤝 Contributing
+
+We welcome contributions! If you find any bugs or have suggestions for improvements, please:
+
+### Reporting Bugs
+1. **Check existing issues** to avoid duplicates
+2. **Create a new issue** with:
+   - Clear description of the bug
+   - Input LaTeX expression
+   - Expected output
+   - Actual output
+   - Steps to reproduce
+
+### Submitting Pull Requests
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature/your-feature-name`)
+3. Make your changes
+4. Add tests if applicable
+5. Commit your changes (`git commit -m 'Add some feature'`)
+6. Push to the branch (`git push origin feature/your-feature-name`)
+7. Open a Pull Request
+
+### Development Guidelines
+- Maintain the existing code style
+- Add comments for complex logic
+- Update the README if adding new features
+- Test with various LaTeX expressions
+
+### Areas for Contribution
+- Additional LaTeX command support
+- Performance optimizations
+- Better error handling
+- More comprehensive test coverage
+- Documentation improvements
+
+## ⭐ Star the Repository
+
+If you find this project useful, please consider giving it a star on GitHub! It helps others discover the project and motivates continued development.
+
+**[⭐ Star this repository](https://github.com/SENODROOM/LaTeX-To-MathJs)** 
+
+---
+
+## 🔗 Related Projects
+
+- [Math.js](https://mathjs.org/) - Extensive math library for JavaScript
+- [KaTeX](https://katex.org/) - Fast math typesetting library
+- [MathJax](https://www.mathjax.org/) - Beautiful math in all browsers
+
+## 📞 Support
+
+If you need help or have questions:
+- Open an issue on GitHub
+- Check existing documentation
+- Review the examples above
+
+---
+
+**Made with ❤️ for the mathematical community**

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "crosstex",
+  "version": "1.0.0",
+  "description": "A robust JavaScript utility that converts LaTeX mathematical expressions into Math.js compatible syntax. This converter handles a wide range of mathematical notation including fractions, roots, trigonometric functions, logarithms, and complex nested expressions.",
+  "main": "LatexToMathJs.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SENODROOM/LaTeX-To-MathJs.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/SENODROOM/LaTeX-To-MathJs/issues"
+  },
+  "homepage": "https://github.com/SENODROOM/LaTeX-To-MathJs#readme"
+}