@latex-math/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1523 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Complex: () => Complex,
+  DimensionMismatchError: () => DimensionMismatchError,
+  DivisionByZeroError: () => DivisionByZeroError,
+  EvaluationError: () => EvaluationError,
+  LatexParseError: () => LatexParseError,
+  LatexTokenError: () => LatexTokenError,
+  MatrixValue: () => MatrixValue,
+  TokenType: () => TokenType,
+  UndefinedVariableError: () => UndefinedVariableError,
+  UnsupportedExpressionError: () => UnsupportedExpressionError,
+  differentiate: () => differentiate,
+  evaluate: () => evaluate,
+  evaluateLatex: () => evaluateLatex,
+  expand: () => expand,
+  factor: () => factor,
+  integrate: () => integrate,
+  mathAdd: () => mathAdd,
+  mathDiv: () => mathDiv,
+  mathMul: () => mathMul,
+  mathPow: () => mathPow,
+  mathSub: () => mathSub,
+  normalizeLatex: () => normalizeLatex,
+  parseLatex: () => parseLatex,
+  simplify: () => simplify,
+  substitute: () => substitute,
+  toLatex: () => toLatex,
+  tokenize: () => tokenize
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/index.ts
+var LatexParseError = class extends Error {
+  constructor(message, position, token) {
+    super(message);
+    this.position = position;
+    this.token = token;
+    this.name = "LatexParseError";
+  }
+  position;
+  token;
+};
+var LatexTokenError = class extends Error {
+  constructor(message, position) {
+    super(message);
+    this.position = position;
+    this.name = "LatexTokenError";
+  }
+  position;
+};
+var EvaluationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvaluationError";
+  }
+};
+var UnsupportedExpressionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedExpressionError";
+  }
+};
+var DimensionMismatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DimensionMismatchError";
+  }
+};
+var UndefinedVariableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UndefinedVariableError";
+  }
+};
+var DivisionByZeroError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DivisionByZeroError";
+  }
+};
+
+// src/tokenizer/index.ts
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["Number"] = "Number";
+  TokenType2["Identifier"] = "Identifier";
+  TokenType2["Command"] = "Command";
+  TokenType2["Operator"] = "Operator";
+  TokenType2["LeftParen"] = "LeftParen";
+  TokenType2["RightParen"] = "RightParen";
+  TokenType2["LeftBrace"] = "LeftBrace";
+  TokenType2["RightBrace"] = "RightBrace";
+  TokenType2["LeftBracket"] = "LeftBracket";
+  TokenType2["RightBracket"] = "RightBracket";
+  TokenType2["Caret"] = "Caret";
+  TokenType2["Underscore"] = "Underscore";
+  TokenType2["EOF"] = "EOF";
+  return TokenType2;
+})(TokenType || {});
+function tokenize(input) {
+  const tokens = [];
+  let current = 0;
+  while (current < input.length) {
+    let char = input[current];
+    if (/\s/.test(char)) {
+      current++;
+      continue;
+    }
+    if (/[0-9]/.test(char)) {
+      let value = "";
+      const start = current;
+      while (current < input.length && /[0-9\.]/.test(input[current])) {
+        value += input[current];
+        current++;
+      }
+      tokens.push({ type: "Number" /* Number */, value, position: start });
+      continue;
+    }
+    if (/[a-zA-Z]/.test(char)) {
+      tokens.push({ type: "Identifier" /* Identifier */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "\\") {
+      let value = "\\";
+      const start = current;
+      current++;
+      if (current < input.length && /^[\\,;!:]$/.test(input[current])) {
+        value += input[current];
+        current++;
+      } else {
+        while (current < input.length && /[a-zA-Z]/.test(input[current])) {
+          value += input[current];
+          current++;
+        }
+      }
+      if (["\\,", "\\;", "\\:", "\\!", "\\quad", "\\qquad"].includes(value)) {
+        continue;
+      }
+      tokens.push({ type: "Command" /* Command */, value, position: start });
+      continue;
+    }
+    if (char === "+") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "-") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "*") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "/") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "|") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "!") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "=") {
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "<") {
+      if (input[current + 1] === "=") {
+        tokens.push({ type: "Operator" /* Operator */, value: "<=", position: current });
+        current += 2;
+        continue;
+      }
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === ">") {
+      if (input[current + 1] === "=") {
+        tokens.push({ type: "Operator" /* Operator */, value: ">=", position: current });
+        current += 2;
+        continue;
+      }
+      tokens.push({ type: "Operator" /* Operator */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "&") {
+      tokens.push({ type: "Command" /* Command */, value: "&", position: current });
+      current++;
+      continue;
+    }
+    if (char === "(") {
+      tokens.push({ type: "LeftParen" /* LeftParen */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === ")") {
+      tokens.push({ type: "RightParen" /* RightParen */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "{") {
+      tokens.push({ type: "LeftBrace" /* LeftBrace */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "}") {
+      tokens.push({ type: "RightBrace" /* RightBrace */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "[") {
+      tokens.push({ type: "LeftBracket" /* LeftBracket */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "]") {
+      tokens.push({ type: "RightBracket" /* RightBracket */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "^") {
+      tokens.push({ type: "Caret" /* Caret */, value: char, position: current });
+      current++;
+      continue;
+    }
+    if (char === "_") {
+      tokens.push({ type: "Underscore" /* Underscore */, value: char, position: current });
+      current++;
+      continue;
+    }
+    throw new LatexTokenError(`Unexpected character: "${char}"`, current);
+  }
+  tokens.push({ type: "EOF" /* EOF */, value: "", position: current });
+  return tokens;
+}
+
+// src/parser/normalizer.ts
+function normalizeLatex(input) {
+  if (!input || typeof input !== "string") return "";
+  let i = 0;
+  function skipWhitespace() {
+    while (i < input.length && /\s/.test(input[i])) {
+      i++;
+    }
+  }
+  function readGroupOrToken() {
+    skipWhitespace();
+    if (i >= input.length) return "";
+    if (input[i] === "{") {
+      let depth = 1;
+      const start = i;
+      i++;
+      while (i < input.length && depth > 0) {
+        if (input[i] === "{") depth++;
+        else if (input[i] === "}") depth--;
+        i++;
+      }
+      const inner = input.slice(start + 1, i - 1);
+      return `{${normalizeLatex(inner)}}`;
+    }
+    if (input[i] === "\\") {
+      const start = i;
+      i++;
+      if (i < input.length && /^[\\,;!:]$/.test(input[i])) {
+        i++;
+      } else {
+        while (i < input.length && /[a-zA-Z]/.test(input[i])) {
+          i++;
+        }
+      }
+      const cmd = input.slice(start, i);
+      return `{${cmd}}`;
+    }
+    const char = input[i];
+    i++;
+    return `{${char}}`;
+  }
+  let result = "";
+  while (i < input.length) {
+    if (input.startsWith("\\sqrt", i) && (i + 5 === input.length || !/[a-zA-Z]/.test(input[i + 5]))) {
+      result += "\\sqrt";
+      i += 5;
+      skipWhitespace();
+      if (i < input.length && input[i] === "[") {
+        const bracketStart = i;
+        while (i < input.length && input[i] !== "]") i++;
+        if (i < input.length) i++;
+        const innerBracket = input.slice(bracketStart + 1, i - 1);
+        result += `[${normalizeLatex(innerBracket)}]`;
+      }
+      skipWhitespace();
+      const hadExplicitBrace = i < input.length && input[i] === "{";
+      const arg = readGroupOrToken();
+      result += arg;
+      if (!hadExplicitBrace && i < input.length && /[+\-*\/=]/.test(input[i])) {
+        const op = input[i];
+        i++;
+        skipWhitespace();
+        result += ` ${op} `;
+      }
+      continue;
+    }
+    if (input.startsWith("\\frac", i) && (i + 5 === input.length || !/[a-zA-Z]/.test(input[i + 5]))) {
+      result += "\\frac";
+      i += 5;
+      skipWhitespace();
+      const hadExplicitBrace = i < input.length && input[i] === "{";
+      const num = readGroupOrToken();
+      const den = readGroupOrToken();
+      result += num + den;
+      if (!hadExplicitBrace && i < input.length && /[+\-*\/=]/.test(input[i])) {
+        const op = input[i];
+        i++;
+        skipWhitespace();
+        result += ` ${op} `;
+      }
+      continue;
+    }
+    if (input.startsWith("\\binom", i) && (i + 6 === input.length || !/[a-zA-Z]/.test(input[i + 6]))) {
+      result += "\\binom";
+      i += 6;
+      skipWhitespace();
+      const n = readGroupOrToken();
+      const k = readGroupOrToken();
+      result += n + k;
+      continue;
+    }
+    result += input[i];
+    i++;
+  }
+  return result;
+}
+
+// src/parser/index.ts
+function extractDx(expr) {
+  if (expr.type === "BinaryOperation" && expr.operator === "*") {
+    if (expr.right.type === "BinaryOperation" && expr.right.operator === "*" && expr.right.implicit && expr.right.left.type === "Variable" && expr.right.left.name === "d" && expr.right.right.type === "Variable") {
+      return { integrand: expr.left, variable: expr.right.right.name };
+    }
+    if (expr.right.type === "Variable" && expr.left.type === "BinaryOperation" && expr.left.operator === "*" && expr.left.right.type === "Variable" && expr.left.right.name === "d") {
+      return { integrand: expr.left.left, variable: expr.right.name };
+    }
+  }
+  return null;
+}
+function parseLatex(input) {
+  const normalized = normalizeLatex(input);
+  const tokens = tokenize(normalized);
+  let current = 0;
+  function peek() {
+    return tokens[current];
+  }
+  function consume(type) {
+    const token = peek();
+    if (type && token.type !== type) {
+      throw new LatexParseError(`Expected token type ${type}, but got ${token.type}`, token.position);
+    }
+    current++;
+    return token;
+  }
+  function parseExpression() {
+    let left = parseAddition();
+    const token = peek();
+    if (token.type === "Operator" /* Operator */ && ["=", "<", ">", "<=", ">="].includes(token.value)) {
+      consume();
+      const right = parseAddition();
+      return { type: "Equation", operator: token.value, left, right };
+    }
+    if (token.type === "Command" /* Command */ && ["\\leq", "\\geq", "\\le", "\\ge"].includes(token.value)) {
+      const cmd = consume().value;
+      const right = parseAddition();
+      let op = "<=";
+      if (cmd === "\\geq" || cmd === "\\ge") op = ">=";
+      return { type: "Equation", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseAddition() {
+    let left = parseMultiplication();
+    while (peek().type === "Operator" /* Operator */ && (peek().value === "+" || peek().value === "-")) {
+      const opToken = consume();
+      const right = parseMultiplication();
+      left = {
+        type: "BinaryOperation",
+        operator: opToken.value,
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  function parseMultiplication() {
+    let left = parseUnary();
+    while (true) {
+      const token = peek();
+      if (token.type === "EOF" /* EOF */) break;
+      if (token.type === "Operator" /* Operator */ && (token.value === "*" || token.value === "/")) {
+        const opToken = consume();
+        const right = parseUnary();
+        left = {
+          type: "BinaryOperation",
+          operator: opToken.value,
+          left,
+          right
+        };
+      } else if (token.type === "Command" /* Command */ && (token.value === "\\cdot" || token.value === "\\times")) {
+        consume();
+        const right = parseUnary();
+        left = {
+          type: "BinaryOperation",
+          operator: "*",
+          left,
+          right
+        };
+      } else if (token.type === "Number" /* Number */ || token.type === "Identifier" /* Identifier */ || token.type === "LeftParen" /* LeftParen */ || token.type === "LeftBrace" /* LeftBrace */ || token.type === "Command" /* Command */ && !["\\right", "\\end", "\\\\", "&"].includes(token.value)) {
+        const right = parseUnary();
+        left = {
+          type: "BinaryOperation",
+          operator: "*",
+          left,
+          right,
+          implicit: true
+        };
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  function parseUnary() {
+    const token = peek();
+    if (token.type === "Operator" /* Operator */ && (token.value === "+" || token.value === "-")) {
+      const opToken = consume();
+      const operand = parsePower();
+      return {
+        type: "UnaryOperation",
+        operator: opToken.value,
+        operand
+      };
+    }
+    return parsePower();
+  }
+  function parsePower() {
+    let left = parsePrimary();
+    if (peek() && peek().type === "Command" /* Command */ && peek().value === "\\!") {
+      consume();
+      left = { type: "Factorial", operand: left };
+    } else if (peek() && peek().type === "Operator" /* Operator */ && peek().value === "!") {
+      consume();
+      left = { type: "Factorial", operand: left };
+    }
+    const token = peek();
+    if (token.type === "Caret" /* Caret */) {
+      consume();
+      let exponent;
+      if (peek().type === "LeftBrace" /* LeftBrace */) {
+        consume();
+        exponent = parseExpression();
+        consume("RightBrace" /* RightBrace */);
+      } else {
+        exponent = parsePrimary();
+      }
+      left = { type: "Power", base: left, exponent };
+    }
+    return left;
+  }
+  function parsePrimary() {
+    const token = peek();
+    if (token.type === "Number" /* Number */) {
+      consume();
+      return {
+        type: "Number",
+        value: parseFloat(token.value)
+      };
+    }
+    if (token.type === "Identifier" /* Identifier */) {
+      consume();
+      if (token.value === "e" || token.value === "i") {
+        return { type: "Constant", name: token.value };
+      }
+      return {
+        type: "Variable",
+        name: token.value
+      };
+    }
+    if (token.type === "LeftParen" /* LeftParen */) {
+      consume();
+      const expr = parseExpression();
+      consume("RightParen" /* RightParen */);
+      return expr;
+    }
+    if (token.type === "LeftBrace" /* LeftBrace */) {
+      consume();
+      const expr = parseExpression();
+      consume("RightBrace" /* RightBrace */);
+      return expr;
+    }
+    if (token.type === "Command" /* Command */ && token.value === "|") {
+      consume();
+      const expr = parseExpression();
+      const nextToken = consume();
+      if (nextToken.type === "Command" /* Command */ && nextToken.value === "|") {
+      } else if (nextToken.type === "Operator" /* Operator */ && nextToken.value === "|") {
+      } else {
+        throw new LatexParseError("Expected closing |", nextToken.position);
+      }
+      return { type: "AbsoluteValue", expression: expr };
+    }
+    if (token.type === "Operator" /* Operator */ && token.value === "|") {
+      consume();
+      const expr = parseExpression();
+      const nextToken = consume();
+      if (nextToken.type === "Command" /* Command */ && nextToken.value === "|") {
+      } else if (nextToken.type === "Operator" /* Operator */ && nextToken.value === "|") {
+      } else {
+        throw new LatexParseError("Expected closing |", nextToken.position);
+      }
+      return { type: "AbsoluteValue", expression: expr };
+    }
+    if (token.type === "Command" /* Command */) {
+      consume();
+      if (token.value === "\\left") {
+        const next = consume();
+        if (next.type === "LeftParen" /* LeftParen */) {
+          const expr = parseExpression();
+          const rightCmd = consume("Command" /* Command */);
+          if (rightCmd.value !== "\\right") throw new LatexParseError("Expected \\right", rightCmd.position);
+          consume("RightParen" /* RightParen */);
+          return expr;
+        } else if (next.type === "Command" /* Command */ && next.value === "|") {
+          const expr = parseExpression();
+          const rightCmd = consume("Command" /* Command */);
+          if (rightCmd.value !== "\\right") throw new LatexParseError("Expected \\right", rightCmd.position);
+          const barCmd = consume();
+          if (barCmd.type !== "Command" /* Command */ || barCmd.value !== "|") throw new LatexParseError("Expected |", barCmd.position);
+          return { type: "AbsoluteValue", expression: expr };
+        } else if (next.type === "Operator" /* Operator */ && next.value === "|") {
+          const expr = parseExpression();
+          const rightCmd = consume("Command" /* Command */);
+          if (rightCmd.value !== "\\right") throw new LatexParseError("Expected \\right", rightCmd.position);
+          const barCmd = consume();
+          if (barCmd.type !== "Operator" /* Operator */ || barCmd.value !== "|") throw new LatexParseError("Expected |", barCmd.position);
+          return { type: "AbsoluteValue", expression: expr };
+        } else {
+          throw new LatexParseError("Unsupported \\left delimiter", next.position);
+        }
+      }
+      if (token.value === "\\pi") return { type: "Constant", name: "pi" };
+      if (token.value === "\\begin") {
+        consume("LeftBrace" /* LeftBrace */);
+        let envNameStr = "";
+        while (peek().type === "Identifier" /* Identifier */) {
+          envNameStr += consume("Identifier" /* Identifier */).value;
+        }
+        consume("RightBrace" /* RightBrace */);
+        if (envNameStr !== "pmatrix" && envNameStr !== "bmatrix" && envNameStr !== "vmatrix") {
+          throw new LatexParseError("Unsupported environment", token.position);
+        }
+        const rows = [];
+        let currentRow = [];
+        while (true) {
+          if (peek().type === "Command" /* Command */ && peek().value === "\\end") {
+            consume();
+            consume("LeftBrace" /* LeftBrace */);
+            let endNameStr = "";
+            while (peek().type === "Identifier" /* Identifier */) {
+              endNameStr += consume("Identifier" /* Identifier */).value;
+            }
+            consume("RightBrace" /* RightBrace */);
+            if (endNameStr !== envNameStr) throw new LatexParseError("Mismatched environment", peek().position);
+            if (currentRow.length > 0) rows.push(currentRow);
+            break;
+          }
+          if (peek().type === "Command" /* Command */ && peek().value === "\\\\") {
+            consume();
+            rows.push(currentRow);
+            currentRow = [];
+            continue;
+          }
+          if (peek().type === "Command" /* Command */ && peek().value === "&") {
+            consume();
+            continue;
+          }
+          currentRow.push(parseExpression());
+        }
+        return { type: "Matrix", rows };
+      }
+      const functions = ["\\sin", "\\cos", "\\tan", "\\arcsin", "\\arccos", "\\arctan", "\\ln", "\\log", "\\exp", "\\det", "\\transpose", "\\arg"];
+      if (functions.includes(token.value)) {
+        let funcName = token.value.substring(1);
+        let power = null;
+        if (peek().type === "Caret" /* Caret */) {
+          consume();
+          const hasBrace = peek().type === "LeftBrace" /* LeftBrace */;
+          if (hasBrace) {
+            consume();
+            power = parseExpression();
+            consume("RightBrace" /* RightBrace */);
+          } else {
+            power = parsePrimary();
+          }
+        }
+        let isInverse = false;
+        if (power) {
+          if (power.type === "Number" && power.value === -1) {
+            isInverse = true;
+          } else if (power.type === "UnaryOperation" && power.operator === "-" && power.operand.type === "Number" && power.operand.value === 1) {
+            isInverse = true;
+          }
+        }
+        if (isInverse) {
+          if (funcName === "sin") {
+            funcName = "arcsin";
+            power = null;
+          } else if (funcName === "cos") {
+            funcName = "arccos";
+            power = null;
+          } else if (funcName === "tan") {
+            funcName = "arctan";
+            power = null;
+          }
+        }
+        let arg;
+        if (peek().type === "LeftParen" /* LeftParen */) {
+          consume();
+          arg = parseExpression();
+          consume("RightParen" /* RightParen */);
+        } else if (peek().type === "LeftBrace" /* LeftBrace */) {
+          consume();
+          arg = parseExpression();
+          consume("RightBrace" /* RightBrace */);
+        } else if (peek().type === "Command" /* Command */ && peek().value === "\\left") {
+          arg = parsePrimary();
+        } else {
+          arg = parsePrimary();
+        }
+        const funcNode = { type: "Function", name: funcName, args: [arg] };
+        if (power) {
+          return { type: "Power", base: funcNode, exponent: power };
+        }
+        return funcNode;
+      }
+      if (token.value === "\\binom") {
+        let n;
+        if (peek().type === "LeftBrace" /* LeftBrace */) {
+          consume("LeftBrace" /* LeftBrace */);
+          n = parseExpression();
+          consume("RightBrace" /* RightBrace */);
+        } else {
+          n = parsePrimary();
+        }
+        let k;
+        if (peek().type === "LeftBrace" /* LeftBrace */) {
+          consume("LeftBrace" /* LeftBrace */);
+          k = parseExpression();
+          consume("RightBrace" /* RightBrace */);
+        } else {
+          k = parsePrimary();
+        }
+        return { type: "Combinatorics", n, k };
+      }
+      if (token.value === "\\frac") {
+        let numerator;
+        if (peek().type === "LeftBrace" /* LeftBrace */) {
+          consume("LeftBrace" /* LeftBrace */);
+          numerator = parseExpression();
+          consume("RightBrace" /* RightBrace */);
+        } else {
+          numerator = parsePrimary();
+        }
+        let denominator;
+        if (peek().type === "LeftBrace" /* LeftBrace */) {
+          consume("LeftBrace" /* LeftBrace */);
+          denominator = parseExpression();
+          consume("RightBrace" /* RightBrace */);
+        } else {
+          denominator = parsePrimary();
+        }
+        if (numerator.type === "Variable" && numerator.name === "d") {
+          if (denominator.type === "BinaryOperation" && denominator.operator === "*" && denominator.implicit && denominator.left.type === "Variable" && denominator.left.name === "d" && denominator.right.type === "Variable") {
+            const variable = denominator.right.name;
+            const expr = parsePower();
+            return { type: "Derivative", variable, expression: expr };
+          }
+        }
+        return { type: "Fraction", numerator, denominator };
+      }
+      if (token.value === "\\int") {
+        let lowerBound = null;
+        let upperBound = null;
+        if (peek().type === "Underscore" /* Underscore */) {
+          consume();
+          lowerBound = peek().type === "LeftBrace" /* LeftBrace */ ? parsePrimary() : parsePrimary();
+        }
+        if (peek().type === "Caret" /* Caret */) {
+          consume();
+          upperBound = peek().type === "LeftBrace" /* LeftBrace */ ? parsePrimary() : parsePrimary();
+        }
+        const body = parseExpression();
+        const extracted = extractDx(body);
+        let integrand = body;
+        let variable = "x";
+        if (extracted) {
+          integrand = extracted.integrand;
+          variable = extracted.variable;
+        }
+        return { type: "Integral", variable, lowerBound, upperBound, expression: integrand };
+      }
+      if (token.value === "\\sum") {
+        let indexVariable = "";
+        let lowerBound = null;
+        let upperBound = null;
+        if (peek().type === "Underscore" /* Underscore */) {
+          consume();
+          if (peek().type === "LeftBrace" /* LeftBrace */) {
+            consume();
+            const eq = parseExpression();
+            if (eq.type === "Equation" && eq.operator === "=" && eq.left.type === "Variable") {
+              indexVariable = eq.left.name;
+              lowerBound = eq.right;
+            } else {
+              throw new LatexParseError("Expected equation in summation subscript", peek().position);
+            }
+            consume("RightBrace" /* RightBrace */);
+          } else {
+            throw new LatexParseError("Expected { after _ in \\sum", peek().position);
+          }
+        }
+        if (peek().type === "Caret" /* Caret */) {
+          consume();
+          if (peek().type === "LeftBrace" /* LeftBrace */) {
+            consume();
+            upperBound = parseExpression();
+            consume("RightBrace" /* RightBrace */);
+          } else {
+            upperBound = parsePrimary();
+          }
+        }
+        if (!lowerBound || !upperBound) {
+          throw new LatexParseError("Summation requires lower and upper bounds", token.position);
+        }
+        const body = parseExpression();
+        return { type: "Summation", indexVariable, lowerBound, upperBound, expression: body };
+      }
+      if (token.value === "\\sqrt") {
+        let index = { type: "Number", value: 2 };
+        if (peek().type === "LeftBracket" /* LeftBracket */) {
+          consume();
+          index = parseExpression();
+          consume("RightBracket" /* RightBracket */);
+        }
+        let radicand;
+        if (peek().type === "LeftBrace" /* LeftBrace */) {
+          consume("LeftBrace" /* LeftBrace */);
+          radicand = parseExpression();
+          consume("RightBrace" /* RightBrace */);
+        } else {
+          radicand = parsePrimary();
+        }
+        return { type: "Root", radicand, index };
+      }
+      if (token.value === "\\left") {
+        const delim = consume();
+        if (delim.type === "LeftParen" /* LeftParen */) {
+          const expr = parseExpression();
+          const rightDelim = consume("Command" /* Command */);
+          if (rightDelim.value !== "\\right") throw new LatexParseError("Expected \\right", rightDelim.position);
+          consume("RightParen" /* RightParen */);
+          return expr;
+        } else if (delim.type === "Operator" /* Operator */ && delim.value === "|") {
+          const expr = parseExpression();
+          const rightDelim = consume("Command" /* Command */);
+          if (rightDelim.value !== "\\right") throw new LatexParseError("Expected \\right", rightDelim.position);
+          const rightPipe = consume("Operator" /* Operator */);
+          if (rightPipe.value !== "|") throw new LatexParseError("Expected |", rightPipe.position);
+          return { type: "AbsoluteValue", expression: expr };
+        } else {
+          throw new LatexParseError(`Unsupported \\left delimiter: ${delim.value}`, delim.position);
+        }
+      }
+    }
+    if (token.type === "Operator" /* Operator */ && token.value === "|") {
+      consume();
+      const expr = parseExpression();
+      const right = consume("Operator" /* Operator */);
+      if (right.value !== "|") throw new LatexParseError("Expected |", right.position);
+      return { type: "AbsoluteValue", expression: expr };
+    }
+    throw new LatexParseError(`Unexpected token: ${token.value}`, token.position);
+  }
+  const ast = parseExpression();
+  if (peek().type !== "EOF" /* EOF */) {
+    throw new LatexParseError(`Unexpected token at end of input: ${peek().value}`, peek().position);
+  }
+  return ast;
+}
+
+// src/math/index.ts
+var Complex = class _Complex {
+  constructor(re, im) {
+    this.re = re;
+    this.im = im;
+  }
+  re;
+  im;
+  add(other) {
+    if (typeof other === "number") return new _Complex(this.re + other, this.im);
+    return new _Complex(this.re + other.re, this.im + other.im);
+  }
+  sub(other) {
+    if (typeof other === "number") return new _Complex(this.re - other, this.im);
+    return new _Complex(this.re - other.re, this.im - other.im);
+  }
+  mul(other) {
+    if (typeof other === "number") return new _Complex(this.re * other, this.im * other);
+    return new _Complex(
+      this.re * other.re - this.im * other.im,
+      this.re * other.im + this.im * other.re
+    );
+  }
+  div(other) {
+    if (typeof other === "number") return new _Complex(this.re / other, this.im / other);
+    const denom = other.re * other.re + other.im * other.im;
+    if (denom === 0) throw new Error("Division by zero in complex numbers");
+    return new _Complex(
+      (this.re * other.re + this.im * other.im) / denom,
+      (this.im * other.re - this.re * other.im) / denom
+    );
+  }
+  exp() {
+    const r = Math.exp(this.re);
+    return new _Complex(r * Math.cos(this.im), r * Math.sin(this.im));
+  }
+  ln() {
+    const r = Math.sqrt(this.re * this.re + this.im * this.im);
+    const theta = Math.atan2(this.im, this.re);
+    return new _Complex(Math.log(r), theta);
+  }
+  pow(other) {
+    if (typeof other === "number") {
+      if (other === 0) return new _Complex(1, 0);
+      if (this.re === 0 && this.im === 0) return new _Complex(0, 0);
+      const r = Math.sqrt(this.re * this.re + this.im * this.im);
+      const theta = Math.atan2(this.im, this.re);
+      const r_n = Math.pow(r, other);
+      return new _Complex(r_n * Math.cos(other * theta), r_n * Math.sin(other * theta));
+    }
+    if (this.re === 0 && this.im === 0) return new _Complex(0, 0);
+    return this.ln().mul(other).exp();
+  }
+};
+var MatrixValue = class _MatrixValue {
+  constructor(rows) {
+    this.rows = rows;
+  }
+  rows;
+  add(other) {
+    if (this.rows.length !== other.rows.length || this.rows[0].length !== other.rows[0].length) {
+      throw new Error("DimensionMismatchError: Cannot add matrices of different dimensions");
+    }
+    const newRows = this.rows.map(
+      (row, i) => row.map((val, j) => mathAdd(val, other.rows[i][j]))
+    );
+    return new _MatrixValue(newRows);
+  }
+  mul(other) {
+    if (other instanceof _MatrixValue) {
+      if (this.rows[0].length !== other.rows.length) {
+        throw new Error("DimensionMismatchError: Invalid dimensions for matrix multiplication");
+      }
+      const newRows = [];
+      for (let i = 0; i < this.rows.length; i++) {
+        const row = [];
+        for (let j = 0; j < other.rows[0].length; j++) {
+          let sum = 0;
+          for (let k = 0; k < this.rows[0].length; k++) {
+            sum = mathAdd(sum, mathMul(this.rows[i][k], other.rows[k][j]));
+          }
+          row.push(sum);
+        }
+        newRows.push(row);
+      }
+      return new _MatrixValue(newRows);
+    } else {
+      const newRows = this.rows.map(
+        (row) => row.map((val) => mathMul(val, other))
+      );
+      return new _MatrixValue(newRows);
+    }
+  }
+  transpose() {
+    const newRows = [];
+    for (let i = 0; i < this.rows[0].length; i++) {
+      newRows.push(this.rows.map((row) => row[i]));
+    }
+    return new _MatrixValue(newRows);
+  }
+  det() {
+    if (this.rows.length !== this.rows[0].length) {
+      throw new Error("DimensionMismatchError: Matrix must be square");
+    }
+    return this._det(this.rows);
+  }
+  _det(matrix) {
+    const n = matrix.length;
+    if (n === 1) return matrix[0][0];
+    if (n === 2) {
+      return mathSub(
+        mathMul(matrix[0][0], matrix[1][1]),
+        mathMul(matrix[0][1], matrix[1][0])
+      );
+    }
+    let d = 0;
+    for (let j = 0; j < n; j++) {
+      const subMatrix = matrix.slice(1).map((row) => row.filter((_, col) => col !== j));
+      const cofactor = mathMul(matrix[0][j], this._det(subMatrix));
+      if (j % 2 === 0) d = mathAdd(d, cofactor);
+      else d = mathSub(d, cofactor);
+    }
+    return d;
+  }
+  inv() {
+    const d = this.det();
+    if (d === 0) throw new Error("Matrix is singular");
+    const n = this.rows.length;
+    if (n === 1) return new _MatrixValue([[mathDiv(1, this.rows[0][0])]]);
+    const cofactors = [];
+    for (let i = 0; i < n; i++) {
+      const row = [];
+      for (let j = 0; j < n; j++) {
+        const sub = this.rows.filter((_, rowIdx) => rowIdx !== i).map((r) => r.filter((_, colIdx) => colIdx !== j));
+        let c = this._det(sub);
+        if ((i + j) % 2 !== 0) c = mathMul(-1, c);
+        row.push(c);
+      }
+      cofactors.push(row);
+    }
+    const adjugate = new _MatrixValue(cofactors).transpose();
+    return adjugate.mul(mathDiv(1, d));
+  }
+};
+function mathAdd(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a + b;
+  if (a instanceof Complex) return a.add(b);
+  if (b instanceof Complex) return b.add(a);
+  if (a instanceof MatrixValue && b instanceof MatrixValue) return a.add(b);
+  throw new Error("Unsupported addition");
+}
+function mathSub(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (a instanceof Complex) return a.sub(b);
+  if (b instanceof Complex) return new Complex(-b.re, -b.im).add(a);
+  throw new Error("Unsupported subtraction");
+}
+function mathMul(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a * b;
+  if (a instanceof Complex) return a.mul(b);
+  if (b instanceof Complex) return b.mul(a);
+  if (a instanceof MatrixValue) return a.mul(b);
+  if (b instanceof MatrixValue) return b.mul(a);
+  throw new Error("Unsupported multiplication");
+}
+function mathDiv(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    if (b === 0) throw new Error("Division by zero");
+    return a / b;
+  }
+  if (a instanceof Complex) return a.div(b);
+  if (b instanceof Complex && typeof a === "number") {
+    return new Complex(a, 0).div(b);
+  }
+  throw new Error("Unsupported division");
+}
+function mathPow(base, exponent) {
+  if (base instanceof MatrixValue && typeof exponent === "number" && exponent === -1) {
+    return base.inv();
+  }
+  if (typeof base === "number" && typeof exponent === "number") {
+    if (base < 0 && !Number.isInteger(exponent)) {
+      return new Complex(base, 0).pow(exponent);
+    }
+    return Math.pow(base, exponent);
+  }
+  if (base instanceof Complex) {
+    return base.pow(exponent);
+  }
+  if (typeof base === "number" && exponent instanceof Complex) {
+    return new Complex(base, 0).pow(exponent);
+  }
+  throw new Error("Unsupported power operation");
+}
+
+// src/evaluator/index.ts
+function evaluateLatex(input, options = {}) {
+  let ast;
+  if (typeof input === "string") {
+    ast = parseLatex(input);
+  } else {
+    ast = input;
+  }
+  return evaluate(ast, options);
+}
+function cleanFloat(val) {
+  return Math.abs(val) < 1e-14 ? 0 : val;
+}
+function evaluate(node, options = {}) {
+  switch (node.type) {
+    case "Number":
+      return node.value;
+    case "Variable": {
+      const val = options.variables?.[node.name];
+      if (val === void 0) {
+        throw new EvaluationError(`Undefined variable: ${node.name}`);
+      }
+      return val;
+    }
+    case "Constant": {
+      if (node.name === "pi") return Math.PI;
+      if (node.name === "e") return Math.E;
+      if (node.name === "i") return new Complex(0, 1);
+      throw new EvaluationError(`Unknown constant: ${node.name}`);
+    }
+    case "BinaryOperation": {
+      const left = evaluate(node.left, options);
+      const right = evaluate(node.right, options);
+      switch (node.operator) {
+        case "+":
+          return mathAdd(left, right);
+        case "-":
+          return mathSub(left, right);
+        case "*":
+          return mathMul(left, right);
+        case "/":
+          return mathDiv(left, right);
+        default:
+          throw new EvaluationError(`Unknown operator: ${node.operator}`);
+      }
+    }
+    case "UnaryOperation": {
+      const operand = evaluate(node.operand, options);
+      if (node.operator === "-") {
+        if (typeof operand === "number") return -operand;
+        if (operand instanceof Complex) return new Complex(-operand.re, -operand.im);
+        throw new EvaluationError("Unary minus not implemented for this type");
+      }
+      if (node.operator === "+") return operand;
+      throw new EvaluationError(`Unknown unary operator: ${node.operator}`);
+    }
+    case "Fraction": {
+      const num = evaluate(node.numerator, options);
+      const den = evaluate(node.denominator, options);
+      return mathDiv(num, den);
+    }
+    case "Power": {
+      const base = evaluate(node.base, options);
+      const exponent = evaluate(node.exponent, options);
+      return mathPow(base, exponent);
+    }
+    case "Root": {
+      const index = evaluate(node.index, options);
+      const radicand = evaluate(node.radicand, options);
+      if (typeof index === "number" && typeof radicand === "number") {
+        if (index % 2 === 0 && radicand < 0) {
+          throw new EvaluationError("Even root of negative number");
+        }
+        if (radicand < 0) {
+          return -Math.pow(-radicand, 1 / index);
+        }
+        return Math.pow(radicand, 1 / index);
+      }
+      throw new EvaluationError("Root not implemented for complex/matrices");
+    }
+    case "Function": {
+      const arg = evaluate(node.args[0], options);
+      if (node.name === "det" || node.name === "transpose") {
+        if (!(arg instanceof MatrixValue)) throw new EvaluationError(`${node.name} requires a matrix`);
+        if (node.name === "det") return arg.det();
+        return arg.transpose();
+      }
+      if (node.name === "arg") {
+        if (arg instanceof Complex) return Math.atan2(arg.im, arg.re);
+        if (typeof arg === "number") return arg >= 0 ? 0 : Math.PI;
+        throw new EvaluationError(`arg requires a number or complex number`);
+      }
+      if (typeof arg !== "number") {
+        throw new EvaluationError(`Function ${node.name} not implemented for complex/matrices`);
+      }
+      switch (node.name) {
+        case "sin":
+          return cleanFloat(Math.sin(arg));
+        case "cos":
+          return cleanFloat(Math.cos(arg));
+        case "tan":
+          return cleanFloat(Math.tan(arg));
+        case "arcsin":
+          return cleanFloat(Math.asin(arg));
+        case "arccos":
+          return cleanFloat(Math.acos(arg));
+        case "arctan":
+          return cleanFloat(Math.atan(arg));
+        case "ln":
+          return cleanFloat(Math.log(arg));
+        case "log":
+          return cleanFloat(Math.log10(arg));
+        case "exp":
+          return cleanFloat(Math.exp(arg));
+        default:
+          throw new EvaluationError(`Unknown function: ${node.name}`);
+      }
+    }
+    case "AbsoluteValue": {
+      const val = evaluate(node.expression, options);
+      if (typeof val === "number") return Math.abs(val);
+      if (val instanceof Complex) return Math.sqrt(val.re * val.re + val.im * val.im);
+      throw new EvaluationError("Absolute value not implemented for matrices");
+    }
+    case "Matrix": {
+      const evaluatedRows = node.rows.map(
+        (row) => row.map((cell) => evaluate(cell, options))
+      );
+      return new MatrixValue(evaluatedRows);
+    }
+    case "Derivative": {
+      throw new EvaluationError("Cannot numerically evaluate symbolic derivative. Use simplify(differentiate(ast, var)) instead.");
+    }
+    case "Summation": {
+      const lowerBound = evaluate(node.lowerBound, options);
+      const upperBound = evaluate(node.upperBound, options);
+      if (typeof lowerBound !== "number" || typeof upperBound !== "number") {
+        throw new EvaluationError("Summation bounds must be real numbers");
+      }
+      let sum = 0;
+      for (let i = lowerBound; i <= upperBound; i++) {
+        const iterOptions = { ...options, variables: { ...options?.variables, [node.indexVariable]: i } };
+        const val = evaluate(node.expression, iterOptions);
+        if (typeof val !== "number") {
+          throw new EvaluationError("Summation body must evaluate to a real number");
+        }
+        sum += val;
+      }
+      return cleanFloat(sum);
+    }
+    case "Integral": {
+      if (node.lowerBound && node.upperBound) {
+        const a = evaluate(node.lowerBound, options);
+        const b = evaluate(node.upperBound, options);
+        if (typeof a !== "number" || typeof b !== "number") throw new EvaluationError("Integral bounds must be real numbers");
+        const steps = 1e3;
+        const h = (b - a) / steps;
+        let sum = 0;
+        for (let i = 0; i <= steps; i++) {
+          const x = a + i * h;
+          const val = evaluate(node.expression, { ...options, variables: { ...options?.variables, [node.variable]: x } });
+          if (typeof val !== "number") throw new EvaluationError("Integrand must evaluate to real number");
+          const weight = i === 0 || i === steps ? 1 : i % 2 === 0 ? 2 : 4;
+          sum += weight * val;
+        }
+        return sum * h / 3;
+      }
+      throw new EvaluationError("Cannot numerically evaluate indefinite integral");
+    }
+    default:
+      throw new EvaluationError(`Unsupported evaluation for node type: ${node.type}`);
+  }
+}
+
+// src/simplifier/index.ts
+function simplify(node) {
+  switch (node.type) {
+    case "BinaryOperation": {
+      const left = simplify(node.left);
+      const right = simplify(node.right);
+      if (left.type === "Number" && right.type === "Number") {
+        switch (node.operator) {
+          case "+":
+            return { type: "Number", value: left.value + right.value };
+          case "-":
+            return { type: "Number", value: left.value - right.value };
+          case "*":
+            return { type: "Number", value: left.value * right.value };
+          case "/":
+            if (right.value !== 0) return { type: "Number", value: left.value / right.value };
+            break;
+        }
+      }
+      if (node.operator === "*") {
+        if (left.type === "Number") {
+          if (left.value === 0) return { type: "Number", value: 0 };
+          if (left.value === 1) return right;
+        }
+        if (right.type === "Number") {
+          if (right.value === 0) return { type: "Number", value: 0 };
+          if (right.value === 1) return left;
+        }
+      }
+      if (node.operator === "+") {
+        if (left.type === "Number" && left.value === 0) return right;
+        if (right.type === "Number" && right.value === 0) return left;
+      }
+      if (node.operator === "-") {
+        if (right.type === "Number" && right.value === 0) return left;
+        if (left.type === "Number" && left.value === 0) {
+          return { type: "UnaryOperation", operator: "-", operand: right };
+        }
+      }
+      if (node.operator === "/") {
+        if (right.type === "Number" && right.value === 1) return left;
+      }
+      return { ...node, left, right };
+    }
+    case "UnaryOperation": {
+      const operand = simplify(node.operand);
+      if (operand.type === "Number") {
+        if (node.operator === "-") return { type: "Number", value: -operand.value };
+        if (node.operator === "+") return { type: "Number", value: operand.value };
+      }
+      return { ...node, operand };
+    }
+    case "Fraction": {
+      const numerator = simplify(node.numerator);
+      const denominator = simplify(node.denominator);
+      if (numerator.type === "Number" && numerator.value === 0 && (denominator.type !== "Number" || denominator.value !== 0)) {
+        return { type: "Number", value: 0 };
+      }
+      return { ...node, numerator, denominator };
+    }
+    case "Power": {
+      const base = simplify(node.base);
+      const exponent = simplify(node.exponent);
+      if (exponent.type === "Number" && exponent.value === 1) return base;
+      if (exponent.type === "Number" && exponent.value === 0) return { type: "Number", value: 1 };
+      if (base.type === "Number" && base.value === 1) return { type: "Number", value: 1 };
+      return { ...node, base, exponent };
+    }
+    case "Root": {
+      const radicand = simplify(node.radicand);
+      const index = simplify(node.index);
+      return { ...node, radicand, index };
+    }
+    case "AbsoluteValue": {
+      const expression = simplify(node.expression);
+      if (expression.type === "Number") {
+        return { type: "Number", value: Math.abs(expression.value) };
+      }
+      return { ...node, expression };
+    }
+    case "Function": {
+      const args = node.args.map(simplify);
+      return { ...node, args };
+    }
+    default:
+      return node;
+  }
+}
+function expand(node) {
+  throw new UnsupportedExpressionError("Algebraic expansion is not fully implemented yet.");
+}
+function factor(node) {
+  throw new UnsupportedExpressionError("Algebraic factorization is not fully implemented yet.");
+}
+function substitute(node, variables) {
+  switch (node.type) {
+    case "Variable": {
+      const sub = variables[node.name];
+      if (sub !== void 0) {
+        if (typeof sub === "number") {
+          return { type: "Number", value: sub };
+        }
+        return JSON.parse(JSON.stringify(sub));
+      }
+      return { ...node };
+    }
+    case "BinaryOperation":
+      return {
+        ...node,
+        left: substitute(node.left, variables),
+        right: substitute(node.right, variables)
+      };
+    case "UnaryOperation":
+      return {
+        ...node,
+        operand: substitute(node.operand, variables)
+      };
+    case "Fraction":
+      return {
+        ...node,
+        numerator: substitute(node.numerator, variables),
+        denominator: substitute(node.denominator, variables)
+      };
+    case "Power":
+      return {
+        ...node,
+        base: substitute(node.base, variables),
+        exponent: substitute(node.exponent, variables)
+      };
+    case "Root":
+      return {
+        ...node,
+        radicand: substitute(node.radicand, variables),
+        index: substitute(node.index, variables)
+      };
+    case "AbsoluteValue":
+      return {
+        ...node,
+        expression: substitute(node.expression, variables)
+      };
+    case "Function":
+      return {
+        ...node,
+        args: node.args.map((arg) => substitute(arg, variables))
+      };
+    default:
+      return { ...node };
+  }
+}
+
+// src/printer/index.ts
+function toLatex(node) {
+  switch (node.type) {
+    case "Number":
+      return node.value.toString();
+    case "Variable":
+      return node.name;
+    case "Constant":
+      if (node.name === "pi") return "\\pi";
+      return node.name;
+    // e.g. e, i
+    case "BinaryOperation": {
+      const left = toLatex(node.left);
+      const right = toLatex(node.right);
+      const wrapLeft = (node.operator === "*" || node.operator === "/") && (node.left.type === "BinaryOperation" && (node.left.operator === "+" || node.left.operator === "-"));
+      const wrapRight = (node.operator === "*" || node.operator === "/") && (node.right.type === "BinaryOperation" && (node.right.operator === "+" || node.right.operator === "-"));
+      const leftStr = wrapLeft ? `\\left(${left}\\right)` : left;
+      const rightStr = wrapRight ? `\\left(${right}\\right)` : right;
+      if (node.operator === "*") {
+        if (node.implicit) {
+          if (node.left.type === "Number" && node.right.type === "Number") {
+            return `${leftStr} \\cdot ${rightStr}`;
+          }
+          return `${leftStr}${rightStr}`;
+        }
+        return `${leftStr} \\cdot ${rightStr}`;
+      }
+      if (node.operator === "/") {
+        return `\\frac{${leftStr}}{${rightStr}}`;
+      }
+      return `${leftStr} ${node.operator} ${rightStr}`;
+    }
+    case "UnaryOperation": {
+      const operand = toLatex(node.operand);
+      const wrap = node.operand.type === "BinaryOperation" && (node.operand.operator === "+" || node.operand.operator === "-");
+      const opStr = wrap ? `\\left(${operand}\\right)` : operand;
+      return `${node.operator}${opStr}`;
+    }
+    case "Fraction":
+      return `\\frac{${toLatex(node.numerator)}}{${toLatex(node.denominator)}}`;
+    case "Power": {
+      const base = toLatex(node.base);
+      const wrapBase = node.base.type === "BinaryOperation" || node.base.type === "Fraction" || node.base.type === "Root";
+      const baseStr = wrapBase ? `\\left(${base}\\right)` : base;
+      return `${baseStr}^{${toLatex(node.exponent)}}`;
+    }
+    case "Root": {
+      const radicand = toLatex(node.radicand);
+      if (node.index.type === "Number" && node.index.value === 2) {
+        return `\\sqrt{${radicand}}`;
+      }
+      return `\\sqrt[${toLatex(node.index)}]{${radicand}}`;
+    }
+    case "AbsoluteValue":
+      return `\\left|${toLatex(node.expression)}\\right|`;
+    case "Function":
+      return `\\${node.name}\\left(${toLatex(node.args[0])}\\right)`;
+    default:
+      return "";
+  }
+}
+
+// src/calculus/index.ts
+function differentiate(node, variable) {
+  switch (node.type) {
+    case "Number":
+    case "Constant":
+      return { type: "Number", value: 0 };
+    case "Variable":
+      return node.name === variable ? { type: "Number", value: 1 } : { type: "Number", value: 0 };
+    case "BinaryOperation":
+      if (node.operator === "+") {
+        return { type: "BinaryOperation", operator: "+", left: differentiate(node.left, variable), right: differentiate(node.right, variable), implicit: false };
+      }
+      if (node.operator === "-") {
+        return { type: "BinaryOperation", operator: "-", left: differentiate(node.left, variable), right: differentiate(node.right, variable), implicit: false };
+      }
+      if (node.operator === "*") {
+        return {
+          type: "BinaryOperation",
+          operator: "+",
+          implicit: false,
+          left: { type: "BinaryOperation", operator: "*", implicit: false, left: differentiate(node.left, variable), right: node.right },
+          right: { type: "BinaryOperation", operator: "*", implicit: false, left: node.left, right: differentiate(node.right, variable) }
+        };
+      }
+      if (node.operator === "/") {
+        const num = {
+          type: "BinaryOperation",
+          operator: "-",
+          implicit: false,
+          left: { type: "BinaryOperation", operator: "*", implicit: false, left: differentiate(node.left, variable), right: node.right },
+          right: { type: "BinaryOperation", operator: "*", implicit: false, left: node.left, right: differentiate(node.right, variable) }
+        };
+        const den = { type: "Power", base: node.right, exponent: { type: "Number", value: 2 } };
+        return { type: "BinaryOperation", operator: "/", implicit: false, left: num, right: den };
+      }
+      break;
+    case "Power":
+      const n = node.exponent;
+      const baseDeriv = differentiate(node.base, variable);
+      const newExponent = { type: "BinaryOperation", operator: "-", implicit: false, left: n, right: { type: "Number", value: 1 } };
+      return {
+        type: "BinaryOperation",
+        operator: "*",
+        implicit: false,
+        left: {
+          type: "BinaryOperation",
+          operator: "*",
+          implicit: false,
+          left: n,
+          right: { type: "Power", base: node.base, exponent: newExponent }
+        },
+        right: baseDeriv
+      };
+    case "Function":
+      const arg = node.args[0];
+      const argDeriv = differentiate(arg, variable);
+      let outer;
+      switch (node.name) {
+        case "sin":
+          outer = { type: "Function", name: "cos", args: [arg] };
+          break;
+        case "cos":
+          outer = { type: "BinaryOperation", operator: "*", implicit: false, left: { type: "Number", value: -1 }, right: { type: "Function", name: "sin", args: [arg] } };
+          break;
+        case "tan":
+          outer = { type: "Power", base: { type: "Function", name: "cos", args: [arg] }, exponent: { type: "Number", value: -2 } };
+          break;
+        case "exp":
+          outer = node;
+          break;
+        case "ln":
+          outer = { type: "BinaryOperation", operator: "/", implicit: false, left: { type: "Number", value: 1 }, right: arg };
+          break;
+        default:
+          throw new Error(`Derivative not implemented for ${node.name}`);
+      }
+      return { type: "BinaryOperation", operator: "*", implicit: false, left: outer, right: argDeriv };
+  }
+  throw new Error(`Derivative not implemented for ${node.type}`);
+}
+function integrate(node, variable) {
+  throw new UnsupportedExpressionError("Symbolic integration is not fully implemented yet.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Complex,
+  DimensionMismatchError,
+  DivisionByZeroError,
+  EvaluationError,
+  LatexParseError,
+  LatexTokenError,
+  MatrixValue,
+  TokenType,
+  UndefinedVariableError,
+  UnsupportedExpressionError,
+  differentiate,
+  evaluate,
+  evaluateLatex,
+  expand,
+  factor,
+  integrate,
+  mathAdd,
+  mathDiv,
+  mathMul,
+  mathPow,
+  mathSub,
+  normalizeLatex,
+  parseLatex,
+  simplify,
+  substitute,
+  toLatex,
+  tokenize
+});