@danielsimonjr/mathts-expression 0.2.0 → 0.2.2

package/dist/index.js

@@ -5,7 +5,11 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -649,29 +653,45 @@ function getOperator(fn) {
   return null;
 }
 
+// src/error/MathjsError.ts
+var MathjsError = class _MathjsError extends Error {
+  isMathjsError = true;
+  /**
+   * Create a MathjsError
+   * @param message  Error message
+   */
+  constructor(message) {
+    super(message);
+    this.name = "MathjsError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _MathjsError);
+    }
+  }
+};
+
 // src/utils/factory.ts
-function factory(name20, dependencies20, create, meta) {
+function factory(name21, dependencies21, create, meta) {
   function assertAndCreate(scope) {
-    const deps = pickShallow(scope, dependencies20.map(stripOptionalNotation));
-    assertDependencies(name20, dependencies20, scope);
+    const deps = pickShallow(scope, dependencies21.map(stripOptionalNotation));
+    assertDependencies(name21, dependencies21, scope);
     return create(deps);
   }
   assertAndCreate.isFactory = true;
-  assertAndCreate.fn = name20;
-  assertAndCreate.dependencies = dependencies20.slice().sort();
+  assertAndCreate.fn = name21;
+  assertAndCreate.dependencies = dependencies21.slice().sort();
   if (meta) {
     assertAndCreate.meta = meta;
   }
   return assertAndCreate;
 }
-function assertDependencies(name20, dependencies20, scope) {
-  const allDefined = dependencies20.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
+function assertDependencies(name21, dependencies21, scope) {
+  const allDefined = dependencies21.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
   if (!allDefined) {
-    const missingDependencies = dependencies20.filter(
+    const missingDependencies = dependencies21.filter(
       (dependency) => scope[dependency] === void 0
     );
-    throw new Error(
-      `Cannot create function "${name20}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
+    throw new MathjsError(
+      `Cannot create function "${name21}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
     );
   }
 }
@@ -1690,17 +1710,17 @@ var createParse = /* @__PURE__ */ factory(
       }
     }
     function parseAssignment(state) {
-      let name20;
+      let name21;
       let args;
       let value;
       let valid;
       const node = parseConditional(state);
       if (state.token === "=") {
         if (isSymbolNode(node)) {
-          name20 = node.name;
+          name21 = node.name;
           getTokenSkipNewline(state);
           value = parseAssignment(state);
-          return new AssignmentNode(new SymbolNode(name20), value);
+          return new AssignmentNode(new SymbolNode(name21), value);
         } else if (isAccessorNode(node)) {
           if (node.optionalChaining) {
             throw createSyntaxError(state, "Cannot assign to optional chain");
@@ -1711,7 +1731,7 @@ var createParse = /* @__PURE__ */ factory(
         } else if (isFunctionNode(node) && isSymbolNode(node.fn)) {
           valid = true;
           args = [];
-          name20 = node.name;
+          name21 = node.name;
           node.args.forEach(function(arg, index) {
             if (isSymbolNode(arg)) {
               args[index] = arg.name;
@@ -1722,7 +1742,7 @@ var createParse = /* @__PURE__ */ factory(
           if (valid) {
             getTokenSkipNewline(state);
             value = parseAssignment(state);
-            return new FunctionAssignmentNode(name20, args, value);
+            return new FunctionAssignmentNode(name21, args, value);
           }
         }
         throw createSyntaxError(state, "Invalid left hand side of assignment operator =");
@@ -1825,7 +1845,7 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseShift(state) {
       let node;
-      let name20;
+      let name21;
       let fn;
       let params;
       node = parseConversion(state);
@@ -1835,17 +1855,17 @@ var createParse = /* @__PURE__ */ factory(
         ">>>": "rightLogShift"
       };
       while (hasOwnProperty(operators, state.token)) {
-        name20 = state.token;
-        fn = operators[name20];
+        name21 = state.token;
+        fn = operators[name21];
         getTokenSkipNewline(state);
         params = [node, parseConversion(state)];
-        node = new OperatorNode(name20, fn, params);
+        node = new OperatorNode(name21, fn, params);
       }
       return node;
     }
     function parseConversion(state) {
       let node;
-      let name20;
+      let name21;
       let fn;
       let params;
       node = parseRange(state);
@@ -1855,14 +1875,14 @@ var createParse = /* @__PURE__ */ factory(
         // alias of 'to'
       };
       while (hasOwnProperty(operators, state.token)) {
-        name20 = state.token;
-        fn = operators[name20];
+        name21 = state.token;
+        fn = operators[name21];
         getTokenSkipNewline(state);
-        if (name20 === "in" && "])},;".includes(state.token)) {
+        if (name21 === "in" && "])},;".includes(state.token)) {
           node = new OperatorNode("*", "multiply", [node, new SymbolNode("in")], true);
         } else {
           params = [node, parseRange(state)];
-          node = new OperatorNode(name20, fn, params);
+          node = new OperatorNode(name21, fn, params);
         }
       }
       return node;
@@ -1902,7 +1922,7 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseAddSubtract(state) {
       let node;
-      let name20;
+      let name21;
       let fn;
       let params;
       node = parseMultiplyDivideModulus(state);
@@ -1911,8 +1931,8 @@ var createParse = /* @__PURE__ */ factory(
         "-": "subtract"
       };
       while (hasOwnProperty(operators, state.token)) {
-        name20 = state.token;
-        fn = operators[name20];
+        name21 = state.token;
+        fn = operators[name21];
         getTokenSkipNewline(state);
         const rightNode = parseMultiplyDivideModulus(state);
         if (rightNode.isPercentage) {
@@ -1920,14 +1940,14 @@ var createParse = /* @__PURE__ */ factory(
         } else {
           params = [node, rightNode];
         }
-        node = new OperatorNode(name20, fn, params);
+        node = new OperatorNode(name21, fn, params);
       }
       return node;
     }
     function parseMultiplyDivideModulus(state) {
       let node;
       let last;
-      let name20;
+      let name21;
       let fn;
       node = parseImplicitMultiplication(state);
       last = node;
@@ -1941,11 +1961,11 @@ var createParse = /* @__PURE__ */ factory(
       };
       while (true) {
         if (hasOwnProperty(operators, state.token)) {
-          name20 = state.token;
-          fn = operators[name20];
+          name21 = state.token;
+          fn = operators[name21];
           getTokenSkipNewline(state);
           last = parseImplicitMultiplication(state);
-          node = new OperatorNode(name20, fn, [node, last]);
+          node = new OperatorNode(name21, fn, [node, last]);
         } else {
           break;
         }
@@ -2019,7 +2039,7 @@ var createParse = /* @__PURE__ */ factory(
       return node;
     }
     function parseUnary(state) {
-      let name20;
+      let name21;
       let params;
       let fn;
       const operators = {
@@ -2030,25 +2050,25 @@ var createParse = /* @__PURE__ */ factory(
       };
       if (hasOwnProperty(operators, state.token)) {
         fn = operators[state.token];
-        name20 = state.token;
+        name21 = state.token;
         getTokenSkipNewline(state);
         params = [parseUnary(state)];
-        return new OperatorNode(name20, fn, params);
+        return new OperatorNode(name21, fn, params);
       }
       return parsePow(state);
     }
     function parsePow(state) {
       let node;
-      let name20;
+      let name21;
       let fn;
       let params;
       node = parseNullishCoalescing(state);
       if (state.token === "^" || state.token === ".^") {
-        name20 = state.token;
-        fn = name20 === "^" ? "pow" : "dotPow";
+        name21 = state.token;
+        fn = name21 === "^" ? "pow" : "dotPow";
         getTokenSkipNewline(state);
         params = [node, parseUnary(state)];
-        node = new OperatorNode(name20, fn, params);
+        node = new OperatorNode(name21, fn, params);
       }
       return node;
     }
@@ -2062,7 +2082,7 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseLeftHandOperators(state) {
       let node;
-      let name20;
+      let name21;
       let fn;
       let params;
       node = parseCustomNodes(state);
@@ -2071,11 +2091,11 @@ var createParse = /* @__PURE__ */ factory(
         "'": "ctranspose"
       };
       while (hasOwnProperty(operators, state.token)) {
-        name20 = state.token;
-        fn = operators[name20];
+        name21 = state.token;
+        fn = operators[name21];
         getToken(state);
         params = [node];
-        node = new OperatorNode(name20, fn, params);
+        node = new OperatorNode(name21, fn, params);
         node = parseAccessors(state, node);
       }
       return node;
@@ -2108,16 +2128,16 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseSymbol(state) {
       let node;
-      let name20;
+      let name21;
       if (state.tokenType === 3 /* SYMBOL */ || state.tokenType === 1 /* DELIMITER */ && state.token in NAMED_DELIMITERS) {
-        name20 = state.token;
+        name21 = state.token;
         getToken(state);
-        if (hasOwnProperty(CONSTANTS, name20)) {
-          node = new ConstantNode(CONSTANTS[name20]);
-        } else if (NUMERIC_CONSTANTS.includes(name20)) {
-          node = new ConstantNode(numeric(name20, "number"));
+        if (hasOwnProperty(CONSTANTS, name21)) {
+          node = new ConstantNode(CONSTANTS[name21]);
+        } else if (NUMERIC_CONSTANTS.includes(name21)) {
+          node = new ConstantNode(numeric(name21, "number"));
         } else {
-          node = new SymbolNode(name20);
+          node = new SymbolNode(name21);
         }
         node = parseAccessors(state, node);
         return node;
@@ -2627,9 +2647,9 @@ var createParserClass = /* @__PURE__ */ factory(
     Parser.prototype.evaluate = function(expr) {
       return evaluate(expr, this.scope);
     };
-    Parser.prototype.get = function(name20) {
-      if (this.scope.has(name20)) {
-        return this.scope.get(name20);
+    Parser.prototype.get = function(name21) {
+      if (this.scope.has(name21)) {
+        return this.scope.get(name21);
       }
     };
     Parser.prototype.getAll = function() {
@@ -2638,14 +2658,14 @@ var createParserClass = /* @__PURE__ */ factory(
     Parser.prototype.getAllAsMap = function() {
       return this.scope;
     };
-    function isValidVariableName(name20) {
-      if (name20.length === 0) {
+    function isValidVariableName(name21) {
+      if (name21.length === 0) {
         return false;
       }
-      for (let i = 0; i < name20.length; i++) {
-        const cPrev = name20.charAt(i - 1);
-        const c = name20.charAt(i);
-        const cNext = name20.charAt(i + 1);
+      for (let i = 0; i < name21.length; i++) {
+        const cPrev = name21.charAt(i - 1);
+        const c = name21.charAt(i);
+        const cNext = name21.charAt(i + 1);
         const valid = parse.isAlpha(c, cPrev, cNext) || i > 0 && parse.isDigit(c);
         if (!valid) {
           return false;
@@ -2653,17 +2673,17 @@ var createParserClass = /* @__PURE__ */ factory(
       }
       return true;
     }
-    Parser.prototype.set = function(name20, value) {
-      if (!isValidVariableName(name20)) {
+    Parser.prototype.set = function(name21, value) {
+      if (!isValidVariableName(name21)) {
         throw new Error(
-          `Invalid variable name: '${name20}'. Variable names must follow the specified rules.`
+          `Invalid variable name: '${name21}'. Variable names must follow the specified rules.`
         );
       }
-      this.scope.set(name20, value);
+      this.scope.set(name21, value);
       return value;
     };
-    Parser.prototype.remove = function(name20) {
-      this.scope.delete(name20);
+    Parser.prototype.remove = function(name21) {
+      this.scope.delete(name21);
     };
     Parser.prototype.clear = function() {
       this.scope.clear();
@@ -2674,21 +2694,21 @@ var createParserClass = /* @__PURE__ */ factory(
         variables: {},
         functions: {}
       };
-      for (const [name20, value] of this.scope) {
+      for (const [name21, value] of this.scope) {
         if (isFunction(value)) {
           if (!isExpressionFunction(value)) {
-            throw new Error(`Cannot serialize external function ${name20}`);
+            throw new Error(`Cannot serialize external function ${name21}`);
           }
-          json.functions[name20] = `${value.syntax} = ${value.expr}`;
+          json.functions[name21] = `${value.syntax} = ${value.expr}`;
         } else {
-          json.variables[name20] = value;
+          json.variables[name21] = value;
         }
       }
       return json;
     };
     Parser.fromJSON = function(json) {
       const parser = new Parser();
-      Object.entries(json.variables || {}).forEach(([name20, value]) => parser.set(name20, value));
+      Object.entries(json.variables || {}).forEach(([name21, value]) => parser.set(name21, value));
       Object.entries(json.functions || {}).forEach(([_name, fn]) => parser.evaluate(fn));
       return parser;
     };
@@ -2700,12 +2720,27 @@ function isExpressionFunction(value) {
   return typeof value === "function" && typeof value.syntax === "string" && typeof value.expr === "string";
 }
 
-// src/Help.ts
-var name3 = "Help";
-var dependencies3 = ["evaluate"];
-var createHelpClass = /* @__PURE__ */ factory(
+// src/function/parser.ts
+var name3 = "parser";
+var dependencies3 = ["typed", "Parser"];
+var createParser = /* @__PURE__ */ factory(
   name3,
   dependencies3,
+  ({ typed, Parser }) => {
+    return typed(name3, {
+      "": function() {
+        return new Parser();
+      }
+    });
+  }
+);
+
+// src/Help.ts
+var name4 = "Help";
+var dependencies4 = ["evaluate"];
+var createHelpClass = /* @__PURE__ */ factory(
+  name4,
+  dependencies4,
   ({ evaluate }) => {
     function Help(doc) {
       if (!(this instanceof Help)) {
@@ -2857,25 +2892,25 @@ function compileConstantNode(node) {
   };
 }
 function compileSymbolNode(node, math, argNames) {
-  const name20 = node.name;
-  if (argNames[name20] === true) {
+  const name21 = node.name;
+  if (argNames[name21] === true) {
     return function evalSymbolArg(_scope, args) {
-      return args[name20];
+      return args[name21];
     };
   }
-  if (Object.prototype.hasOwnProperty.call(math, name20)) {
+  if (Object.prototype.hasOwnProperty.call(math, name21)) {
     return function evalSymbolNode(scope) {
-      if (scope.has(name20)) {
-        return scope.get(name20);
+      if (scope.has(name21)) {
+        return scope.get(name21);
       }
-      return math[name20];
+      return math[name21];
     };
   }
   return function evalSymbolNode(scope) {
-    if (scope.has(name20)) {
-      return scope.get(name20);
+    if (scope.has(name21)) {
+      return scope.get(name21);
     }
-    throw new Error(`Undefined symbol "${name20}"`);
+    throw new Error(`Undefined symbol "${name21}"`);
   };
 }
 function compileOperatorNode(node, math, argNames) {
@@ -2907,21 +2942,21 @@ function compileFunctionNode(node, math, argNames) {
   const evalArgs = node.args.map((arg) => compileNode(arg, math, argNames));
   const fnNode = node.fn;
   if (fnNode && fnNode.isSymbolNode) {
-    const name20 = fnNode.name;
+    const name21 = fnNode.name;
     const resolveFn = (scope) => {
-      if (scope.has(name20)) {
-        const value = scope.get(name20);
+      if (scope.has(name21)) {
+        const value = scope.get(name21);
         if (typeof value === "function") return value;
-        throw new TypeError(`'${name20}' is not a function; its value is:
+        throw new TypeError(`'${name21}' is not a function; its value is:
   ${value}`);
       }
-      if (Object.prototype.hasOwnProperty.call(math, name20)) {
-        const value = math[name20];
+      if (Object.prototype.hasOwnProperty.call(math, name21)) {
+        const value = math[name21];
         if (typeof value === "function") return value;
-        throw new TypeError(`'${name20}' is not a function; its value is:
+        throw new TypeError(`'${name21}' is not a function; its value is:
   ${value}`);
       }
-      throw new Error(`Undefined function "${name20}"`);
+      throw new Error(`Undefined function "${name21}"`);
     };
     switch (evalArgs.length) {
       case 0:
@@ -2982,10 +3017,10 @@ function compileArrayNode(node, math, argNames) {
 function compileAssignmentNode(node, math, argNames) {
   const evalValue = compileNode(node.value, math, argNames);
   if (node.object && node.object.isSymbolNode && !node.index) {
-    const name21 = node.object.name;
+    const name22 = node.object.name;
     return function evalAssignmentNode(scope, args, context) {
       const value = evalValue(scope, args, context);
-      scope.set(name21, value);
+      scope.set(name22, value);
       return value;
     };
   }
@@ -3000,11 +3035,11 @@ function compileAssignmentNode(node, math, argNames) {
       };
     }
   }
-  const name20 = node.name || node.object && node.object.name;
-  if (name20) {
+  const name21 = node.name || node.object && node.object.name;
+  if (name21) {
     return function evalAssignmentNode(scope, args, context) {
       const value = evalValue(scope, args, context);
-      scope.set(name20, value);
+      scope.set(name21, value);
       return value;
     };
   }
@@ -3098,7 +3133,7 @@ function compileFunctionAssignmentNode(node, math, argNames) {
     childArgNames[param] = true;
   }
   const evalExpr = compileNode(node.expr, math, childArgNames);
-  const name20 = node.name;
+  const name21 = node.name;
   const params = node.params;
   return function evalFunctionAssignmentNode(scope, args, _context) {
     const fn = function(...fnArgs) {
@@ -3108,8 +3143,8 @@ function compileFunctionAssignmentNode(node, math, argNames) {
       }
       return evalExpr(scope, childArgs, void 0);
     };
-    fn.syntax = name20 + "(" + params.join(", ") + ")";
-    scope.set(name20, fn);
+    fn.syntax = name21 + "(" + params.join(", ") + ")";
+    scope.set(name21, fn);
     return fn;
   };
 }
@@ -3261,11 +3296,11 @@ function compileExpression(parseFn, mathScope, expr, options) {
 }
 
 // src/node/Node.ts
-var name4 = "Node";
-var dependencies4 = ["mathWithTransform"];
+var name5 = "Node";
+var dependencies5 = ["mathWithTransform"];
 var createNode = /* @__PURE__ */ factory(
-  name4,
-  dependencies4,
+  name5,
+  dependencies5,
   ({ mathWithTransform }) => {
     function _validateScope(scope) {
       for (const symbol of [...keywords]) {
@@ -3629,11 +3664,11 @@ function accessFactory({ subset }) {
 }
 
 // src/node/AccessorNode.ts
-var name5 = "AccessorNode";
-var dependencies5 = ["subset", "Node"];
+var name6 = "AccessorNode";
+var dependencies6 = ["subset", "Node"];
 var createAccessorNode = /* @__PURE__ */ factory(
-  name5,
-  dependencies5,
+  name6,
+  dependencies6,
   ({ subset, Node }) => {
     const access = accessFactory({ subset });
     function needParenthesis(node) {
@@ -3677,9 +3712,9 @@ var createAccessorNode = /* @__PURE__ */ factory(
           return this.object.name || "";
         }
       }
-      static name = name5;
+      static name = name6;
       get type() {
-        return name5;
+        return name6;
       }
       get isAccessorNode() {
         return true;
@@ -3803,7 +3838,7 @@ var createAccessorNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name5,
+          mathjs: name6,
           object: this.object,
           index: this.index,
           optionalChaining: this.optionalChaining
@@ -3827,11 +3862,11 @@ var createAccessorNode = /* @__PURE__ */ factory(
 );
 
 // src/node/ArrayNode.ts
-var name6 = "ArrayNode";
-var dependencies6 = ["Node"];
+var name7 = "ArrayNode";
+var dependencies7 = ["Node"];
 var createArrayNode = /* @__PURE__ */ factory(
-  name6,
-  dependencies6,
+  name7,
+  dependencies7,
   ({ Node }) => {
     class ArrayNode extends Node {
       items;
@@ -3848,9 +3883,9 @@ var createArrayNode = /* @__PURE__ */ factory(
           throw new TypeError("Array containing Nodes expected");
         }
       }
-      static name = name6;
+      static name = name7;
       get type() {
-        return name6;
+        return name7;
       }
       get isArrayNode() {
         return true;
@@ -3938,7 +3973,7 @@ var createArrayNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name6,
+          mathjs: name7,
           items: this.items
         };
       }
@@ -3992,13 +4027,13 @@ var createArrayNode = /* @__PURE__ */ factory(
 );
 
 // src/node/utils/assign.ts
-function assignFactory({ subset, matrix }) {
+function assignFactory({ subset }) {
   return function assign(object, index, value) {
     try {
       if (Array.isArray(object)) {
-        const result = matrix(object).subset(index, value).valueOf();
-        result.forEach((item, index2) => {
-          object[index2] = item;
+        const result = subset(object, index, value);
+        result.forEach((item, i) => {
+          object[i] = item;
         });
         return object;
       } else if (object && typeof object.subset === "function") {
@@ -4021,23 +4056,14 @@ function assignFactory({ subset, matrix }) {
 }
 
 // src/node/AssignmentNode.ts
-var name7 = "AssignmentNode";
-var dependencies7 = [
-  "subset",
-  "?matrix",
-  // FIXME: should not be needed at all, should be handled by subset
-  "Node"
-];
+var name8 = "AssignmentNode";
+var dependencies8 = ["subset", "Node"];
 var createAssignmentNode = /* @__PURE__ */ factory(
-  name7,
-  dependencies7,
-  ({
-    subset,
-    matrix,
-    Node
-  }) => {
+  name8,
+  dependencies8,
+  ({ subset, Node }) => {
     const access = accessFactory({ subset });
-    const assign = assignFactory({ subset, matrix });
+    const assign = assignFactory({ subset });
     function needParenthesis(node, parenthesis, implicit) {
       if (!parenthesis) {
         parenthesis = "keep";
@@ -4101,7 +4127,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
         }
       }
       // class name for typing purposes:
-      static name = name7;
+      static name = name8;
       // readonly property name
       get name() {
         if (this.index) {
@@ -4111,7 +4137,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
         }
       }
       get type() {
-        return name7;
+        return name8;
       }
       get isAssignmentNode() {
         return true;
@@ -4133,14 +4159,14 @@ var createAssignmentNode = /* @__PURE__ */ factory(
         const evalObject = this.object._compile(math, argNames);
         const evalIndex = this.index ? this.index._compile(math, argNames) : null;
         const evalValue = this.value._compile(math, argNames);
-        const name20 = this.object.name;
+        const name21 = this.object.name;
         if (!this.index) {
           if (!isSymbolNode(this.object)) {
             throw new TypeError("SymbolNode expected as object");
           }
           return function evalAssignmentNode(scope, args, context) {
             const value = evalValue(scope, args, context);
-            scope.set(name20, value);
+            scope.set(name21, value);
             return value;
           };
         } else if (this.index.isObjectProperty()) {
@@ -4156,7 +4182,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
             const childObject = evalObject(scope, args, context);
             const value = evalValue(scope, args, context);
             const index = evalIndex(scope, args, childObject);
-            scope.set(name20, assign(childObject, index, value));
+            scope.set(name21, assign(childObject, index, value));
             return value;
           };
         } else {
@@ -4235,7 +4261,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name7,
+          mathjs: name8,
           object: this.object,
           index: this.index,
           value: this.value
@@ -4287,11 +4313,11 @@ var createAssignmentNode = /* @__PURE__ */ factory(
 );
 
 // src/node/BlockNode.ts
-var name8 = "BlockNode";
-var dependencies8 = ["ResultSet", "Node"];
+var name9 = "BlockNode";
+var dependencies9 = ["ResultSet", "Node"];
 var createBlockNode = /* @__PURE__ */ factory(
-  name8,
-  dependencies8,
+  name9,
+  dependencies9,
   ({ ResultSet, Node }) => {
     class BlockNode extends Node {
       blocks;
@@ -4318,9 +4344,9 @@ var createBlockNode = /* @__PURE__ */ factory(
           return { node, visible };
         });
       }
-      static name = name8;
+      static name = name9;
       get type() {
-        return name8;
+        return name9;
       }
       get isBlockNode() {
         return true;
@@ -4413,7 +4439,7 @@ var createBlockNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name8,
+          mathjs: name9,
           blocks: this.blocks
         };
       }
@@ -4456,11 +4482,11 @@ var createBlockNode = /* @__PURE__ */ factory(
 );
 
 // src/node/ConditionalNode.ts
-var name9 = "ConditionalNode";
-var dependencies9 = ["Node"];
+var name10 = "ConditionalNode";
+var dependencies10 = ["Node"];
 var createConditionalNode = /* @__PURE__ */ factory(
-  name9,
-  dependencies9,
+  name10,
+  dependencies10,
   ({ Node }) => {
     function testCondition2(condition) {
       if (typeof condition === "number" || typeof condition === "boolean" || typeof condition === "string") {
@@ -4511,9 +4537,9 @@ var createConditionalNode = /* @__PURE__ */ factory(
         this.trueExpr = trueExpr;
         this.falseExpr = falseExpr;
       }
-      static name = name9;
+      static name = name10;
       get type() {
-        return name9;
+        return name10;
       }
       get isConditionalNode() {
         return true;
@@ -4614,7 +4640,7 @@ var createConditionalNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name9,
+          mathjs: name10,
           condition: this.condition,
           trueExpr: this.trueExpr,
           falseExpr: this.falseExpr
@@ -5011,26 +5037,26 @@ var latexUnits = {
 function escapeLatex(string) {
   return (0, import_escape_latex.default)(string, { preserveFormatting: true });
 }
-function toSymbol(name20, isUnit2) {
+function toSymbol(name21, isUnit2) {
   isUnit2 = typeof isUnit2 === "undefined" ? false : isUnit2;
   if (isUnit2) {
-    if (hasOwnProperty(latexUnits, name20)) {
-      return latexUnits[name20];
+    if (hasOwnProperty(latexUnits, name21)) {
+      return latexUnits[name21];
     }
-    return "\\mathrm{" + escapeLatex(name20) + "}";
+    return "\\mathrm{" + escapeLatex(name21) + "}";
   }
-  if (hasOwnProperty(latexSymbols, name20)) {
-    return latexSymbols[name20];
+  if (hasOwnProperty(latexSymbols, name21)) {
+    return latexSymbols[name21];
   }
-  return escapeLatex(name20);
+  return escapeLatex(name21);
 }
 
 // src/node/ConstantNode.ts
-var name10 = "ConstantNode";
-var dependencies10 = ["Node", "isBounded"];
+var name11 = "ConstantNode";
+var dependencies11 = ["Node", "isBounded"];
 var createConstantNode = /* @__PURE__ */ factory(
-  name10,
-  dependencies10,
+  name11,
+  dependencies11,
   ({
     Node,
     isBounded
@@ -5053,9 +5079,9 @@ var createConstantNode = /* @__PURE__ */ factory(
         super();
         this.value = value;
       }
-      static name = name10;
+      static name = name11;
       get type() {
-        return name10;
+        return name11;
       }
       get isConstantNode() {
         return true;
@@ -5139,7 +5165,7 @@ var createConstantNode = /* @__PURE__ */ factory(
        * @returns {Object}
        */
       toJSON() {
-        return { mathjs: name10, value: this.value };
+        return { mathjs: name11, value: this.value };
       }
       /**
        * Instantiate a ConstantNode from its JSON representation
@@ -5189,11 +5215,11 @@ var createConstantNode = /* @__PURE__ */ factory(
 );
 
 // src/node/FunctionAssignmentNode.ts
-var name11 = "FunctionAssignmentNode";
-var dependencies11 = ["typed", "Node"];
+var name12 = "FunctionAssignmentNode";
+var dependencies12 = ["typed", "Node"];
 var createFunctionAssignmentNode = /* @__PURE__ */ factory(
-  name11,
-  dependencies11,
+  name12,
+  dependencies12,
   ({ typed, Node }) => {
     function needParenthesis(node, parenthesis, implicit) {
       const precedence = getPrecedence(node, parenthesis, implicit, void 0);
@@ -5217,9 +5243,9 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
        *                                and type of the parameter
        * @param {Node} expr             The function expression
        */
-      constructor(name20, params, expr) {
+      constructor(name21, params, expr) {
         super();
-        if (typeof name20 !== "string") {
+        if (typeof name21 !== "string") {
           throw new TypeError('String expected for parameter "name"');
         }
         if (!Array.isArray(params)) {
@@ -5230,8 +5256,8 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
         if (!isNode(expr)) {
           throw new TypeError('Node expected for parameter "expr"');
         }
-        if (keywords.has(name20)) {
-          throw new Error('Illegal function name, "' + name20 + '" is a reserved keyword');
+        if (keywords.has(name21)) {
+          throw new Error('Illegal function name, "' + name21 + '" is a reserved keyword');
         }
         const paramNames = /* @__PURE__ */ new Set();
         for (const param of params) {
@@ -5242,7 +5268,7 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
             paramNames.add(paramName);
           }
         }
-        this.name = name20;
+        this.name = name21;
         this.params = params.map(function(param) {
           return param && param.name || param;
         });
@@ -5251,9 +5277,9 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
         });
         this.expr = expr;
       }
-      static name = name11;
+      static name = name12;
       get type() {
-        return name11;
+        return name12;
       }
       get isFunctionAssignmentNode() {
         return true;
@@ -5278,10 +5304,10 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
         });
         const expr = this.expr;
         const evalExpr = expr._compile(math, childArgNames);
-        const name20 = this.name;
+        const name21 = this.name;
         const params = this.params;
         const signature = join(this.types, ",");
-        const syntax = name20 + "(" + join(this.params, ", ") + ")";
+        const syntax = name21 + "(" + join(this.params, ", ") + ")";
         return function evalFunctionAssignmentNode(scope, args, context) {
           const signatures = {};
           signatures[signature] = function(...fnArgs) {
@@ -5291,10 +5317,10 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
             }
             return evalExpr(scope, childArgs, context);
           };
-          const fn = typed(name20, signatures);
+          const fn = typed(name21, signatures);
           fn.syntax = syntax;
           fn.expr = expr.toString();
-          scope.set(name20, fn);
+          scope.set(name21, fn);
           return fn;
         };
       }
@@ -5343,7 +5369,7 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       toJSON() {
         const types = this.types;
         return {
-          mathjs: name11,
+          mathjs: name12,
           name: this.name,
           params: this.params.map(function(param, index) {
             return {
@@ -5416,11 +5442,11 @@ function createSubScope(parentScope, args) {
 }
 
 // src/node/FunctionNode.ts
-var name12 = "FunctionNode";
-var dependencies12 = ["math", "Node", "SymbolNode"];
+var name13 = "FunctionNode";
+var dependencies13 = ["math", "Node", "SymbolNode"];
 var createFunctionNode = /* @__PURE__ */ factory(
-  name12,
-  dependencies12,
+  name13,
+  dependencies13,
   ({
     math,
     Node,
@@ -5518,9 +5544,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
       get name() {
         return this.fn.name || "";
       }
-      static name = name12;
+      static name = name13;
       get type() {
-        return name12;
+        return name13;
       }
       get isFunctionNode() {
         return true;
@@ -5542,22 +5568,22 @@ var createFunctionNode = /* @__PURE__ */ factory(
         const evalArgs = this.args.map((arg) => arg._compile(math2, argNames));
         const fromOptionalChaining = this.optional || isAccessorNode(this.fn) && this.fn.optionalChaining;
         if (isSymbolNode(this.fn)) {
-          const name20 = this.fn.name;
-          if (!argNames[name20]) {
-            const fn = name20 in math2 ? getSafeProperty(math2, name20) : void 0;
+          const name21 = this.fn.name;
+          if (!argNames[name21]) {
+            const fn = name21 in math2 ? getSafeProperty(math2, name21) : void 0;
             const isRaw = typeof fn === "function" && fn.rawArgs === true;
             const resolveFn = (scope) => {
               let value;
-              if (scope.has(name20)) {
-                value = scope.get(name20);
-              } else if (name20 in math2) {
-                value = getSafeProperty(math2, name20);
+              if (scope.has(name21)) {
+                value = scope.get(name21);
+              } else if (name21 in math2) {
+                value = getSafeProperty(math2, name21);
               } else if (fromOptionalChaining) value = void 0;
-              else return FunctionNode.onUndefinedFunction(name20);
+              else return FunctionNode.onUndefinedFunction(name21);
               if (typeof value === "function" || fromOptionalChaining && value === void 0) {
                 return value;
               }
-              throw new TypeError(`'${name20}' is not a function; its value is:
+              throw new TypeError(`'${name21}' is not a function; its value is:
   ${strin(value)}`);
             };
             if (isRaw) {
@@ -5606,11 +5632,11 @@ var createFunctionNode = /* @__PURE__ */ factory(
           } else {
             const rawArgs = this.args;
             return function evalFunctionNode(scope, args, context) {
-              const fn = getSafeProperty(args, name20);
+              const fn = getSafeProperty(args, name21);
               if (fromOptionalChaining && fn === void 0) return void 0;
               if (typeof fn !== "function") {
                 throw new TypeError(
-                  `Argument '${name20}' was not a function; received: ${strin(fn)}`
+                  `Argument '${name21}' was not a function; received: ${strin(fn)}`
                 );
               }
               if (fn.rawArgs) {
@@ -5695,8 +5721,8 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * Throws an error 'Undefined function {name}'
        * @param {string} name
        */
-      static onUndefinedFunction = function(name20) {
-        throw new Error("Undefined function " + name20);
+      static onUndefinedFunction = function(name21) {
+        throw new Error("Undefined function " + name21);
       };
       /**
        * Get string representation. (wrapper function)
@@ -5712,9 +5738,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
        */
       toString(options) {
         let customString;
-        const name20 = this.fn.toString(options);
-        if (options && typeof options.handler === "object" && hasOwnProperty(options.handler, name20)) {
-          customString = options.handler[name20](this, options);
+        const name21 = this.fn.toString(options);
+        if (options && typeof options.handler === "object" && hasOwnProperty(options.handler, name21)) {
+          customString = options.handler[name21](this, options);
         }
         if (typeof customString !== "undefined") {
           return customString;
@@ -5739,7 +5765,7 @@ var createFunctionNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name12,
+          mathjs: name13,
           fn: this.fn,
           args: this.args
         };
@@ -5839,11 +5865,11 @@ var createFunctionNode = /* @__PURE__ */ factory(
 );
 
 // src/node/IndexNode.ts
-var name13 = "IndexNode";
-var dependencies13 = ["Node", "size"];
+var name14 = "IndexNode";
+var dependencies14 = ["Node", "size"];
 var createIndexNode = /* @__PURE__ */ factory(
-  name13,
-  dependencies13,
+  name14,
+  dependencies14,
   ({ Node, size }) => {
     class IndexNode extends Node {
       dimensions;
@@ -5873,9 +5899,9 @@ var createIndexNode = /* @__PURE__ */ factory(
           throw new Error("dotNotation only applicable for object properties");
         }
       }
-      static name = name13;
+      static name = name14;
       get type() {
-        return name13;
+        return name14;
       }
       get isIndexNode() {
         return true;
@@ -5985,7 +6011,7 @@ var createIndexNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name13,
+          mathjs: name14,
           dimensions: this.dimensions,
           dotNotation: this.dotNotation
         };
@@ -6035,11 +6061,11 @@ var createIndexNode = /* @__PURE__ */ factory(
 );
 
 // src/node/ObjectNode.ts
-var name14 = "ObjectNode";
-var dependencies14 = ["Node"];
+var name15 = "ObjectNode";
+var dependencies15 = ["Node"];
 var createObjectNode = /* @__PURE__ */ factory(
-  name14,
-  dependencies14,
+  name15,
+  dependencies15,
   ({ Node }) => {
     class ObjectNode extends Node {
       properties;
@@ -6060,9 +6086,9 @@ var createObjectNode = /* @__PURE__ */ factory(
           }
         }
       }
-      static name = name14;
+      static name = name15;
       get type() {
-        return name14;
+        return name15;
       }
       get isObjectNode() {
         return true;
@@ -6163,7 +6189,7 @@ var createObjectNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name14,
+          mathjs: name15,
           properties: this.properties
         };
       }
@@ -6218,11 +6244,11 @@ var createObjectNode = /* @__PURE__ */ factory(
 );
 
 // src/node/OperatorNode.ts
-var name15 = "OperatorNode";
-var dependencies15 = ["Node"];
+var name16 = "OperatorNode";
+var dependencies16 = ["Node"];
 var createOperatorNode = /* @__PURE__ */ factory(
-  name15,
-  dependencies15,
+  name16,
+  dependencies16,
   ({ Node }) => {
     function startsWithConstant(expr, parenthesis) {
       let curNode = expr;
@@ -6414,9 +6440,9 @@ var createOperatorNode = /* @__PURE__ */ factory(
         this.fn = fn;
         this.args = args || [];
       }
-      static name = name15;
+      static name = name16;
       get type() {
-        return name15;
+        return name16;
       }
       get isOperatorNode() {
         return true;
@@ -6584,7 +6610,7 @@ var createOperatorNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name15,
+          mathjs: name16,
           op: this.op,
           fn: this.fn,
           args: this.args,
@@ -6757,11 +6783,11 @@ var createOperatorNode = /* @__PURE__ */ factory(
 );
 
 // src/node/ParenthesisNode.ts
-var name16 = "ParenthesisNode";
-var dependencies16 = ["Node"];
+var name17 = "ParenthesisNode";
+var dependencies17 = ["Node"];
 var createParenthesisNode = /* @__PURE__ */ factory(
-  name16,
-  dependencies16,
+  name17,
+  dependencies17,
   ({ Node }) => {
     class ParenthesisNode extends Node {
       content;
@@ -6779,9 +6805,9 @@ var createParenthesisNode = /* @__PURE__ */ factory(
         }
         this.content = content;
       }
-      static name = name16;
+      static name = name17;
       get type() {
-        return name16;
+        return name17;
       }
       get isParenthesisNode() {
         return true;
@@ -6853,7 +6879,7 @@ var createParenthesisNode = /* @__PURE__ */ factory(
        * @returns {Object}
        */
       toJSON() {
-        return { mathjs: name16, content: this.content };
+        return { mathjs: name17, content: this.content };
       }
       /**
        * Instantiate an ParenthesisNode from its JSON representation
@@ -6896,11 +6922,11 @@ var createParenthesisNode = /* @__PURE__ */ factory(
 );
 
 // src/node/RangeNode.ts
-var name17 = "RangeNode";
-var dependencies17 = ["Node"];
+var name18 = "RangeNode";
+var dependencies18 = ["Node"];
 var createRangeNode = /* @__PURE__ */ factory(
-  name17,
-  dependencies17,
+  name18,
+  dependencies18,
   ({ Node }) => {
     function calculateNecessaryParentheses(node, parenthesis, implicit) {
       const precedence = getPrecedence(node, parenthesis, implicit, void 0);
@@ -6937,9 +6963,9 @@ var createRangeNode = /* @__PURE__ */ factory(
         this.end = end;
         this.step = step || null;
       }
-      static name = name17;
+      static name = name18;
       get type() {
-        return name17;
+        return name18;
       }
       get isRangeNode() {
         return true;
@@ -7057,7 +7083,7 @@ var createRangeNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name17,
+          mathjs: name18,
           start: this.start,
           end: this.end,
           step: this.step
@@ -7143,11 +7169,11 @@ var createRangeNode = /* @__PURE__ */ factory(
 );
 
 // src/node/RelationalNode.ts
-var name18 = "RelationalNode";
-var dependencies18 = ["Node"];
+var name19 = "RelationalNode";
+var dependencies19 = ["Node"];
 var createRelationalNode = /* @__PURE__ */ factory(
-  name18,
-  dependencies18,
+  name19,
+  dependencies19,
   ({ Node }) => {
     const operatorMap = {
       equal: "==",
@@ -7187,9 +7213,9 @@ var createRelationalNode = /* @__PURE__ */ factory(
         this.conditionals = conditionals;
         this.params = params;
       }
-      static name = name18;
+      static name = name19;
       get type() {
-        return name18;
+        return name19;
       }
       get isRelationalNode() {
         return true;
@@ -7289,7 +7315,7 @@ var createRelationalNode = /* @__PURE__ */ factory(
        */
       toJSON() {
         return {
-          mathjs: name18,
+          mathjs: name19,
           conditionals: this.conditionals,
           params: this.params
         };
@@ -7368,14 +7394,14 @@ var createRelationalNode = /* @__PURE__ */ factory(
 );
 
 // src/node/SymbolNode.ts
-var name19 = "SymbolNode";
-var dependencies19 = ["math", "?Unit", "Node"];
+var name20 = "SymbolNode";
+var dependencies20 = ["math", "?Unit", "Node"];
 var createSymbolNode = /* @__PURE__ */ factory(
-  name19,
-  dependencies19,
+  name20,
+  dependencies20,
   ({ math, Unit, Node }) => {
-    function isValuelessUnit(name20) {
-      return Unit ? Unit.isValuelessUnit(name20) : false;
+    function isValuelessUnit(name21) {
+      return Unit ? Unit.isValuelessUnit(name21) : false;
     }
     class SymbolNode extends Node {
       name;
@@ -7386,12 +7412,12 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * @param {string} name
        * @extends {Node}
        */
-      constructor(name20) {
+      constructor(name21) {
         super();
-        if (typeof name20 !== "string") {
+        if (typeof name21 !== "string") {
           throw new TypeError('String expected for parameter "name"');
         }
-        this.name = name20;
+        this.name = name21;
       }
       get type() {
         return "SymbolNode";
@@ -7413,19 +7439,19 @@ var createSymbolNode = /* @__PURE__ */ factory(
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math2, argNames) {
-        const name20 = this.name;
-        if (argNames[name20] === true) {
+        const name21 = this.name;
+        if (argNames[name21] === true) {
           return function(scope, args, _context) {
-            return getSafeProperty(args, name20);
+            return getSafeProperty(args, name21);
           };
-        } else if (name20 in math2) {
+        } else if (name21 in math2) {
           return function(scope, _args, _context) {
-            return scope.has(name20) ? scope.get(name20) : getSafeProperty(math2, name20);
+            return scope.has(name21) ? scope.get(name21) : getSafeProperty(math2, name21);
           };
         } else {
-          const isUnit2 = isValuelessUnit(name20);
+          const isUnit2 = isValuelessUnit(name21);
           return function(scope, _args, _context) {
-            return scope.has(name20) ? scope.get(name20) : isUnit2 ? new Unit(null, name20) : SymbolNode.onUndefinedSymbol(name20);
+            return scope.has(name21) ? scope.get(name21) : isUnit2 ? new Unit(null, name21) : SymbolNode.onUndefinedSymbol(name21);
           };
         }
       }
@@ -7448,8 +7474,8 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * Throws an error 'Undefined symbol {name}'
        * @param {string} name
        */
-      static onUndefinedSymbol(name20) {
-        throw new Error("Undefined symbol " + name20);
+      static onUndefinedSymbol(name21) {
+        throw new Error("Undefined symbol " + name21);
       }
       /**
        * Create a clone of this node, a shallow copy
@@ -7475,21 +7501,21 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * @override
        */
       _toHTML(_options) {
-        const name20 = escape(this.name);
-        if (name20 === "true" || name20 === "false") {
-          return '<span class="math-symbol math-boolean">' + name20 + "</span>";
-        } else if (name20 === "i") {
-          return '<span class="math-symbol math-imaginary-symbol">' + name20 + "</span>";
-        } else if (name20 === "Infinity") {
-          return '<span class="math-symbol math-infinity-symbol">' + name20 + "</span>";
-        } else if (name20 === "NaN") {
-          return '<span class="math-symbol math-nan-symbol">' + name20 + "</span>";
-        } else if (name20 === "null") {
-          return '<span class="math-symbol math-null-symbol">' + name20 + "</span>";
-        } else if (name20 === "undefined") {
-          return '<span class="math-symbol math-undefined-symbol">' + name20 + "</span>";
-        }
-        return '<span class="math-symbol">' + name20 + "</span>";
+        const name21 = escape(this.name);
+        if (name21 === "true" || name21 === "false") {
+          return '<span class="math-symbol math-boolean">' + name21 + "</span>";
+        } else if (name21 === "i") {
+          return '<span class="math-symbol math-imaginary-symbol">' + name21 + "</span>";
+        } else if (name21 === "Infinity") {
+          return '<span class="math-symbol math-infinity-symbol">' + name21 + "</span>";
+        } else if (name21 === "NaN") {
+          return '<span class="math-symbol math-nan-symbol">' + name21 + "</span>";
+        } else if (name21 === "null") {
+          return '<span class="math-symbol math-null-symbol">' + name21 + "</span>";
+        } else if (name21 === "undefined") {
+          return '<span class="math-symbol math-undefined-symbol">' + name21 + "</span>";
+        }
+        return '<span class="math-symbol">' + name21 + "</span>";
       }
       /**
        * Get a JSON representation of the node
@@ -7552,6 +7578,7 @@ export {
   createOperatorNode,
   createParenthesisNode,
   createParse,
+  createParser,
   createParserClass,
   createRangeNode,
   createRelationalNode,