@danielsimonjr/mathts-expression 0.4.5 → 0.5.0

package/dist/index.js

@@ -136,6 +136,9 @@ function isBigNumber(x) {
   }
   return false;
 }
+function isBigInt(x) {
+  return typeof x === "bigint";
+}
 function isComplex(x) {
   return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isComplex === true);
 }
@@ -156,6 +159,14 @@ function isMatrix(x) {
   const obj = x;
   return obj.constructor?.prototype?.isMatrix === true;
 }
+function isCollection(x) {
+  return Array.isArray(x) || isMatrix(x);
+}
+function isRange(x) {
+  if (!x || typeof x !== "object") return false;
+  const obj = x;
+  return obj.constructor?.prototype?.isRange === true;
+}
 function isHelp(x) {
   if (!x || typeof x !== "object") return false;
   const obj = x;
@@ -611,28 +622,28 @@ var MathjsError = class _MathjsError extends Error {
 };
 
 // src/utils/factory.ts
-function factory(name21, dependencies21, create, meta) {
+function factory(name47, dependencies47, create, meta) {
   function assertAndCreate(scope) {
-    const deps = pickShallow(scope, dependencies21.map(stripOptionalNotation));
-    assertDependencies(name21, dependencies21, scope);
+    const deps = pickShallow(scope, dependencies47.map(stripOptionalNotation));
+    assertDependencies(name47, dependencies47, scope);
     return create(deps);
   }
   assertAndCreate.isFactory = true;
-  assertAndCreate.fn = name21;
-  assertAndCreate.dependencies = dependencies21.slice().sort();
+  assertAndCreate.fn = name47;
+  assertAndCreate.dependencies = dependencies47.slice().sort();
   if (meta) {
     assertAndCreate.meta = meta;
   }
   return assertAndCreate;
 }
-function assertDependencies(name21, dependencies21, scope) {
-  const allDefined = dependencies21.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
+function assertDependencies(name47, dependencies47, scope) {
+  const allDefined = dependencies47.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
   if (!allDefined) {
-    const missingDependencies = dependencies21.filter(
+    const missingDependencies = dependencies47.filter(
       (dependency) => scope[dependency] === void 0
     );
     throw new MathjsError(
-      `Cannot create function "${name21}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
+      `Cannot create function "${name47}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
     );
   }
 }
@@ -1404,17 +1415,17 @@ var createParse = /* @__PURE__ */ factory(
       }
     }
     function parseAssignment(state) {
-      let name21;
+      let name47;
       let args;
       let value;
       let valid;
       const node = parseConditional(state);
       if (state.token === "=") {
         if (isSymbolNode(node)) {
-          name21 = node.name;
+          name47 = node.name;
           getTokenSkipNewline(state);
           value = parseAssignment(state);
-          return new AssignmentNode(new SymbolNode(name21), value);
+          return new AssignmentNode(new SymbolNode(name47), value);
         } else if (isAccessorNode(node)) {
           const accessor = node;
           if (accessor.optionalChaining) {
@@ -1427,7 +1438,7 @@ var createParse = /* @__PURE__ */ factory(
           valid = true;
           args = [];
           const fnNode = node;
-          name21 = fnNode.name;
+          name47 = fnNode.name;
           fnNode.args.forEach(function(arg, index) {
             if (isSymbolNode(arg)) {
               args[index] = arg.name;
@@ -1438,7 +1449,7 @@ var createParse = /* @__PURE__ */ factory(
           if (valid) {
             getTokenSkipNewline(state);
             value = parseAssignment(state);
-            return new FunctionAssignmentNode(name21, args, value);
+            return new FunctionAssignmentNode(name47, args, value);
           }
         }
         throw createSyntaxError(state, "Invalid left hand side of assignment operator =");
@@ -1541,7 +1552,7 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseShift(state) {
       let node;
-      let name21;
+      let name47;
       let fn;
       let params;
       node = parseConversion(state);
@@ -1551,17 +1562,17 @@ var createParse = /* @__PURE__ */ factory(
         ">>>": "rightLogShift"
       };
       while (hasOwnProperty(operators, state.token)) {
-        name21 = state.token;
-        fn = operators[name21];
+        name47 = state.token;
+        fn = operators[name47];
         getTokenSkipNewline(state);
         params = [node, parseConversion(state)];
-        node = new OperatorNode(name21, fn, params);
+        node = new OperatorNode(name47, fn, params);
       }
       return node;
     }
     function parseConversion(state) {
       let node;
-      let name21;
+      let name47;
       let fn;
       let params;
       node = parseRange(state);
@@ -1571,14 +1582,14 @@ var createParse = /* @__PURE__ */ factory(
         // alias of 'to'
       };
       while (hasOwnProperty(operators, state.token)) {
-        name21 = state.token;
-        fn = operators[name21];
+        name47 = state.token;
+        fn = operators[name47];
         getTokenSkipNewline(state);
-        if (name21 === "in" && "])},;".includes(state.token)) {
+        if (name47 === "in" && "])},;".includes(state.token)) {
           node = new OperatorNode("*", "multiply", [node, new SymbolNode("in")], true);
         } else {
           params = [node, parseRange(state)];
-          node = new OperatorNode(name21, fn, params);
+          node = new OperatorNode(name47, fn, params);
         }
       }
       return node;
@@ -1618,7 +1629,7 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseAddSubtract(state) {
       let node;
-      let name21;
+      let name47;
       let fn;
       let params;
       node = parseMultiplyDivideModulus(state);
@@ -1627,8 +1638,8 @@ var createParse = /* @__PURE__ */ factory(
         "-": "subtract"
       };
       while (hasOwnProperty(operators, state.token)) {
-        name21 = state.token;
-        fn = operators[name21];
+        name47 = state.token;
+        fn = operators[name47];
         getTokenSkipNewline(state);
         const rightNode = parseMultiplyDivideModulus(state);
         if (rightNode.isPercentage) {
@@ -1636,14 +1647,14 @@ var createParse = /* @__PURE__ */ factory(
         } else {
           params = [node, rightNode];
         }
-        node = new OperatorNode(name21, fn, params);
+        node = new OperatorNode(name47, fn, params);
       }
       return node;
     }
     function parseMultiplyDivideModulus(state) {
       let node;
       let last;
-      let name21;
+      let name47;
       let fn;
       node = parseImplicitMultiplication(state);
       last = node;
@@ -1657,11 +1668,11 @@ var createParse = /* @__PURE__ */ factory(
       };
       while (true) {
         if (hasOwnProperty(operators, state.token)) {
-          name21 = state.token;
-          fn = operators[name21];
+          name47 = state.token;
+          fn = operators[name47];
           getTokenSkipNewline(state);
           last = parseImplicitMultiplication(state);
-          node = new OperatorNode(name21, fn, [node, last]);
+          node = new OperatorNode(name47, fn, [node, last]);
         } else {
           break;
         }
@@ -1735,7 +1746,7 @@ var createParse = /* @__PURE__ */ factory(
       return node;
     }
     function parseUnary(state) {
-      let name21;
+      let name47;
       let params;
       let fn;
       const operators = {
@@ -1746,25 +1757,25 @@ var createParse = /* @__PURE__ */ factory(
       };
       if (hasOwnProperty(operators, state.token)) {
         fn = operators[state.token];
-        name21 = state.token;
+        name47 = state.token;
         getTokenSkipNewline(state);
         params = [parseUnary(state)];
-        return new OperatorNode(name21, fn, params);
+        return new OperatorNode(name47, fn, params);
       }
       return parsePow(state);
     }
     function parsePow(state) {
       let node;
-      let name21;
+      let name47;
       let fn;
       let params;
       node = parseNullishCoalescing(state);
       if (state.token === "^" || state.token === ".^") {
-        name21 = state.token;
-        fn = name21 === "^" ? "pow" : "dotPow";
+        name47 = state.token;
+        fn = name47 === "^" ? "pow" : "dotPow";
         getTokenSkipNewline(state);
         params = [node, parseUnary(state)];
-        node = new OperatorNode(name21, fn, params);
+        node = new OperatorNode(name47, fn, params);
       }
       return node;
     }
@@ -1778,7 +1789,7 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseLeftHandOperators(state) {
       let node;
-      let name21;
+      let name47;
       let fn;
       let params;
       node = parseCustomNodes(state);
@@ -1787,11 +1798,11 @@ var createParse = /* @__PURE__ */ factory(
         "'": "ctranspose"
       };
       while (hasOwnProperty(operators, state.token)) {
-        name21 = state.token;
-        fn = operators[name21];
+        name47 = state.token;
+        fn = operators[name47];
         getToken(state);
         params = [node];
-        node = new OperatorNode(name21, fn, params);
+        node = new OperatorNode(name47, fn, params);
         node = parseAccessors(state, node);
       }
       return node;
@@ -1824,16 +1835,16 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseSymbol(state) {
       let node;
-      let name21;
+      let name47;
       if (state.tokenType === 3 /* SYMBOL */ || state.tokenType === 1 /* DELIMITER */ && state.token in NAMED_DELIMITERS) {
-        name21 = state.token;
+        name47 = state.token;
         getToken(state);
-        if (hasOwnProperty(CONSTANTS, name21)) {
-          node = new ConstantNode(CONSTANTS[name21]);
-        } else if (NUMERIC_CONSTANTS.includes(name21)) {
-          node = new ConstantNode(numeric(name21, "number"));
+        if (hasOwnProperty(CONSTANTS, name47)) {
+          node = new ConstantNode(CONSTANTS[name47]);
+        } else if (NUMERIC_CONSTANTS.includes(name47)) {
+          node = new ConstantNode(numeric(name47, "number"));
         } else {
-          node = new SymbolNode(name21);
+          node = new SymbolNode(name47);
         }
         node = parseAccessors(state, node);
         return node;
@@ -2344,8 +2355,8 @@ var createParserClass = /* @__PURE__ */ factory(
     Parser.prototype.evaluate = function(expr) {
       return evaluate(expr, this.scope);
     };
-    Parser.prototype.get = function(name21) {
-      return this.scope.has(name21) ? this.scope.get(name21) : void 0;
+    Parser.prototype.get = function(name47) {
+      return this.scope.has(name47) ? this.scope.get(name47) : void 0;
     };
     Parser.prototype.getAll = function() {
       return toObject(this.scope);
@@ -2353,14 +2364,14 @@ var createParserClass = /* @__PURE__ */ factory(
     Parser.prototype.getAllAsMap = function() {
       return this.scope;
     };
-    function isValidVariableName(name21) {
-      if (name21.length === 0) {
+    function isValidVariableName(name47) {
+      if (name47.length === 0) {
         return false;
       }
-      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);
+      for (let i = 0; i < name47.length; i++) {
+        const cPrev = name47.charAt(i - 1);
+        const c = name47.charAt(i);
+        const cNext = name47.charAt(i + 1);
         const valid = parse.isAlpha(c, cPrev, cNext) || i > 0 && parse.isDigit(c);
         if (!valid) {
           return false;
@@ -2368,17 +2379,17 @@ var createParserClass = /* @__PURE__ */ factory(
       }
       return true;
     }
-    Parser.prototype.set = function(name21, value) {
-      if (!isValidVariableName(name21)) {
+    Parser.prototype.set = function(name47, value) {
+      if (!isValidVariableName(name47)) {
         throw new Error(
-          `Invalid variable name: '${name21}'. Variable names must follow the specified rules.`
+          `Invalid variable name: '${name47}'. Variable names must follow the specified rules.`
         );
       }
-      this.scope.set(name21, value);
+      this.scope.set(name47, value);
       return value;
     };
-    Parser.prototype.remove = function(name21) {
-      this.scope.delete(name21);
+    Parser.prototype.remove = function(name47) {
+      this.scope.delete(name47);
     };
     Parser.prototype.clear = function() {
       this.scope.clear();
@@ -2389,21 +2400,21 @@ var createParserClass = /* @__PURE__ */ factory(
         variables: {},
         functions: {}
       };
-      for (const [name21, value] of this.scope) {
+      for (const [name47, value] of this.scope) {
         if (isFunction(value)) {
           if (!isExpressionFunction(value)) {
-            throw new Error(`Cannot serialize external function ${name21}`);
+            throw new Error(`Cannot serialize external function ${name47}`);
           }
-          json.functions[name21] = `${value.syntax} = ${value.expr}`;
+          json.functions[name47] = `${value.syntax} = ${value.expr}`;
         } else {
-          json.variables[name21] = value;
+          json.variables[name47] = value;
         }
       }
       return json;
     };
     Parser.fromJSON = function(json) {
       const parser = new Parser();
-      Object.entries(json.variables || {}).forEach(([name21, value]) => parser.set(name21, value));
+      Object.entries(json.variables || {}).forEach(([name47, value]) => parser.set(name47, value));
       Object.entries(json.functions || {}).forEach(([_name, fn]) => parser.evaluate(fn));
       return parser;
     };
@@ -5864,6 +5875,926 @@ var solveODEDocs = {
   seealso: ["derivative", "simplifyCore"]
 };
 
+// src/embeddedDocs/function/algebra/apart.ts
+var apartDocs = {
+  name: "apart",
+  category: "Algebra",
+  syntax: ["apart(expr)"],
+  description: "Partial fraction decomposition of numeric fractions.",
+  examples: ["apart('7/3')"],
+  seealso: ["together", "cancel"]
+};
+
+// src/embeddedDocs/function/algebra/cancel.ts
+var cancelDocs = {
+  name: "cancel",
+  category: "Algebra",
+  syntax: ["cancel(expr)"],
+  description: "Cancel common factors in a rational expression (numeric fractions).",
+  examples: ["cancel('6/4')", "cancel('10/5')"],
+  seealso: ["together", "apart"]
+};
+
+// src/embeddedDocs/function/algebra/coefficientList.ts
+var coefficientListDocs = {
+  name: "coefficientList",
+  category: "Algebra",
+  syntax: ["coefficientList(coeffs)"],
+  description: "Extract the coefficient list of a polynomial, trimming leading zeros from the high end.",
+  examples: ["coefficientList([1, 2, 0, 0])"],
+  seealso: ["degree", "polyval"]
+};
+
+// src/embeddedDocs/function/algebra/collect.ts
+var collectDocs = {
+  name: "collect",
+  category: "Algebra",
+  syntax: ["collect(expr, var)"],
+  description: "Collect like terms with respect to a variable, grouping by powers.",
+  examples: ["collect('2*x + 3*x + 5', 'x')"],
+  seealso: ["expand", "factor"]
+};
+
+// src/embeddedDocs/function/algebra/combine.ts
+var combineDocs = {
+  name: "combine",
+  category: "Algebra",
+  syntax: ["combine(a, b)"],
+  description: "Combine two expressions by addition.",
+  examples: ["combine('x^2', '2*y')"],
+  seealso: ["expand", "collect"]
+};
+
+// src/embeddedDocs/function/algebra/complexExpand.ts
+var complexExpandDocs = {
+  name: "complexExpand",
+  category: "Algebra",
+  syntax: ["complexExpand(expr)"],
+  description: "Expand complex-valued expressions using i^2 = -1.",
+  examples: ["complexExpand('a + b*i^2')"],
+  seealso: ["expand", "trigToExp"]
+};
+
+// src/embeddedDocs/function/algebra/degree.ts
+var degreeDocs = {
+  name: "degree",
+  category: "Algebra",
+  syntax: ["degree(coeffs)"],
+  description: "Return the degree of a polynomial (highest power with non-zero coefficient).",
+  examples: ["degree([1, 2, 3])", "degree([5])"],
+  seealso: ["coefficientList", "polyval"]
+};
+
+// src/embeddedDocs/function/algebra/differences.ts
+var differencesDocs = {
+  name: "differences",
+  category: "Algebra",
+  syntax: ["differences(arr)", "differences(arr, n)"],
+  description: "Compute finite differences of a sequence by applying the forward difference operator.",
+  examples: ["differences([1, 4, 9, 16])", "differences([1, 4, 9, 16], 2)"],
+  seealso: ["polyder"]
+};
+
+// src/embeddedDocs/function/algebra/discriminant.ts
+var discriminantDocs = {
+  name: "discriminant",
+  category: "Algebra",
+  syntax: ["discriminant(coeffs)"],
+  description: "Compute the discriminant of a polynomial. For quadratic ax^2+bx+c: b^2-4ac.",
+  examples: ["discriminant([-1, 0, 1])", "discriminant([1, 1, 1])"],
+  seealso: ["degree", "polynomialRoot"]
+};
+
+// src/embeddedDocs/function/algebra/element.ts
+var elementDocs = {
+  name: "element",
+  category: "Algebra",
+  syntax: ["element(arr, index)"],
+  description: "Extract an element from an array at the specified zero-based index.",
+  examples: ["element([10, 20, 30], 1)"],
+  seealso: ["subset"]
+};
+
+// src/embeddedDocs/function/algebra/eliminate.ts
+var eliminateDocs = {
+  name: "eliminate",
+  category: "Algebra",
+  syntax: ["eliminate(system, var)"],
+  description: "Eliminate a variable from a system of equations using Gaussian elimination.",
+  examples: ["eliminate(['2*x + 3*y = 5', 'x + y = 2'], 'x')"],
+  seealso: ["variables", "substitute"]
+};
+
+// src/embeddedDocs/function/algebra/expToTrig.ts
+var expToTrigDocs = {
+  name: "expToTrig",
+  category: "Algebra",
+  syntax: ["expToTrig(expr)"],
+  description: "Convert exponential expressions to trigonometric form using Euler formula.",
+  examples: ["expToTrig('exp(i*x)')"],
+  seealso: ["trigToExp", "trigExpand"]
+};
+
+// src/embeddedDocs/function/algebra/expand.ts
+var expandDocs = {
+  name: "expand",
+  category: "Algebra",
+  syntax: ["expand(expr)"],
+  description: "Expand an expression by distributing multiplication over addition.",
+  examples: ["expand('(a+b)*(c+d)')"],
+  seealso: ["factor", "collect", "simplify"]
+};
+
+// src/embeddedDocs/function/algebra/factor.ts
+var factorDocs = {
+  name: "factor",
+  category: "Algebra",
+  syntax: ["factor(expr)"],
+  description: "Factor an expression by extracting common numeric factors from terms.",
+  examples: ["factor('6*x + 4*y')"],
+  seealso: ["expand", "collect"]
+};
+
+// src/embeddedDocs/function/algebra/fullSimplify.ts
+var fullSimplifyDocs = {
+  name: "fullSimplify",
+  category: "Algebra",
+  syntax: ["fullSimplify(expr)"],
+  description: "Full simplification with identity removal, constant folding, and numeric reduction.",
+  examples: ["fullSimplify('1 * x + 0')", "fullSimplify('x^1')"],
+  seealso: ["simplify", "reduce"]
+};
+
+// src/embeddedDocs/function/algebra/functionExpand.ts
+var functionExpandDocs = {
+  name: "functionExpand",
+  category: "Algebra",
+  syntax: ["functionExpand(expr)"],
+  description: "Expand special function expressions: exp(a+b) => exp(a)*exp(b), ln(a*b) => ln(a)+ln(b).",
+  examples: ["functionExpand('exp(a+b)')", "functionExpand('ln(a*b)')"],
+  seealso: ["expand", "trigExpand"]
+};
+
+// src/embeddedDocs/function/algebra/normalForm.ts
+var normalFormDocs = {
+  name: "normalForm",
+  category: "Algebra",
+  syntax: ["normalForm(expr)"],
+  description: "Convert expression to canonical normal form by sorting terms alphabetically.",
+  examples: ["normalForm('c + a + b')"],
+  seealso: ["collect", "fullSimplify"]
+};
+
+// src/embeddedDocs/function/algebra/partialDerivative.ts
+var partialDerivativeDocs = {
+  name: "partialDerivative",
+  category: "Algebra",
+  syntax: ["partialDerivative(expr, var)"],
+  description: "Compute a partial derivative of an expression string using basic symbolic rules.",
+  examples: ["partialDerivative('x^2', 'x')"],
+  seealso: ["polyder", "tangentLine", "derivative"]
+};
+
+// src/embeddedDocs/function/algebra/polyadd.ts
+var polyaddDocs = {
+  name: "polyadd",
+  category: "Algebra",
+  syntax: ["polyadd(a, b)"],
+  description: "Add two polynomials represented as coefficient arrays (index = power).",
+  examples: ["polyadd([1, 2], [3, 4, 5])"],
+  seealso: ["polymul", "polyval", "polyder"]
+};
+
+// src/embeddedDocs/function/algebra/polyder.ts
+var polyderDocs = {
+  name: "polyder",
+  category: "Algebra",
+  syntax: ["polyder(coeffs)", "polyder(coeffs, n)"],
+  description: "Compute the n-th derivative of a polynomial. Default n=1.",
+  examples: ["polyder([1, 2, 3])", "polyder([1, 2, 3, 4], 2)"],
+  seealso: ["polyval", "polyadd", "polymul"]
+};
+
+// src/embeddedDocs/function/algebra/polymul.ts
+var polymulDocs = {
+  name: "polymul",
+  category: "Algebra",
+  syntax: ["polymul(a, b)"],
+  description: "Multiply two polynomials (convolution of coefficient arrays).",
+  examples: ["polymul([1, 1], [1, 1])"],
+  seealso: ["polyadd", "polyval", "polyder"]
+};
+
+// src/embeddedDocs/function/algebra/polynomialGCD.ts
+var polynomialGCDDocs = {
+  name: "polynomialGCD",
+  category: "Algebra",
+  syntax: ["polynomialGCD(a, b)"],
+  description: "Compute the GCD of two polynomials using the Euclidean algorithm. Result is monic.",
+  examples: ["polynomialGCD([-1, 0, 1], [-1, 1])"],
+  seealso: ["polynomialLCM", "polynomialQuotient", "polynomialRemainder"]
+};
+
+// src/embeddedDocs/function/algebra/polynomialLCM.ts
+var polynomialLCMDocs = {
+  name: "polynomialLCM",
+  category: "Algebra",
+  syntax: ["polynomialLCM(a, b)"],
+  description: "Compute the LCM of two polynomials: LCM(a, b) = (a * b) / GCD(a, b).",
+  examples: ["polynomialLCM([-1, 1], [1, 1])"],
+  seealso: ["polynomialGCD", "polymul"]
+};
+
+// src/embeddedDocs/function/algebra/polynomialQuotient.ts
+var polynomialQuotientDocs = {
+  name: "polynomialQuotient",
+  category: "Algebra",
+  syntax: ["polynomialQuotient(a, b)"],
+  description: "Compute the quotient of polynomial division a / b.",
+  examples: ["polynomialQuotient([-1, 0, 1], [-1, 1])"],
+  seealso: ["polynomialRemainder", "polynomialGCD"]
+};
+
+// src/embeddedDocs/function/algebra/polynomialRemainder.ts
+var polynomialRemainderDocs = {
+  name: "polynomialRemainder",
+  category: "Algebra",
+  syntax: ["polynomialRemainder(a, b)"],
+  description: "Compute the remainder of polynomial division a / b.",
+  examples: ["polynomialRemainder([1, 0, 1], [-1, 1])"],
+  seealso: ["polynomialQuotient", "polynomialGCD"]
+};
+
+// src/embeddedDocs/function/algebra/polyval.ts
+var polyvalDocs = {
+  name: "polyval",
+  category: "Algebra",
+  syntax: ["polyval(coeffs, x)"],
+  description: "Evaluate a polynomial at a given point using Horner method. Coefficients ordered by ascending power.",
+  examples: ["polyval([1, 2, 3], 2)", "polyval([1, 0, -1], 3)"],
+  seealso: ["polyder", "polyadd", "polymul"]
+};
+
+// src/embeddedDocs/function/algebra/powerExpand.ts
+var powerExpandDocs = {
+  name: "powerExpand",
+  category: "Algebra",
+  syntax: ["powerExpand(expr)"],
+  description: "Expand powers: (a*b)^n => a^n * b^n and (a^m)^n => a^(m*n).",
+  examples: ["powerExpand('(a*b)^3')", "powerExpand('(a^2)^3')"],
+  seealso: ["expand", "fullSimplify"]
+};
+
+// src/embeddedDocs/function/algebra/reduce.ts
+var reduceDocs = {
+  name: "reduce",
+  category: "Algebra",
+  syntax: ["reduce(expr)"],
+  description: "Reduce an expression to its simplest form by evaluating pure-numeric sub-expressions.",
+  examples: ["reduce('2 + 3')", "reduce('2^3')"],
+  seealso: ["fullSimplify", "simplify"]
+};
+
+// src/embeddedDocs/function/algebra/resultant.ts
+var resultantDocs = {
+  name: "resultant",
+  category: "Algebra",
+  syntax: ["resultant(p, q)"],
+  description: "Compute the resultant of two polynomials via the Sylvester matrix determinant.",
+  examples: ["resultant([-1, 0, 1], [-1, 1])"],
+  seealso: ["polynomialGCD", "discriminant"]
+};
+
+// src/embeddedDocs/function/algebra/substitute.ts
+var substituteDocs = {
+  name: "substitute",
+  category: "Algebra",
+  syntax: ["substitute(expr, vars)"],
+  description: "Substitute variables in an expression string with replacement values.",
+  examples: ["substitute('x^2 + y', {x: 3, y: 1})"],
+  seealso: ["variables", "expand"]
+};
+
+// src/embeddedDocs/function/algebra/tangentLine.ts
+var tangentLineDocs = {
+  name: "tangentLine",
+  category: "Algebra",
+  syntax: ["tangentLine(f, x0)"],
+  description: "Compute the tangent line to a function at a given point. Returns [slope, intercept].",
+  examples: ["tangentLine(x => x**2, 3)"],
+  seealso: ["partialDerivative", "polyder"]
+};
+
+// src/embeddedDocs/function/algebra/together.ts
+var togetherDocs = {
+  name: "together",
+  category: "Algebra",
+  syntax: ["together(expr)"],
+  description: "Combine fractions to a common denominator.",
+  examples: ["together('1/2 + 1/3')"],
+  seealso: ["apart", "cancel"]
+};
+
+// src/embeddedDocs/function/algebra/trigExpand.ts
+var trigExpandDocs = {
+  name: "trigExpand",
+  category: "Algebra",
+  syntax: ["trigExpand(expr)"],
+  description: "Expand trigonometric expressions using angle addition formulas.",
+  examples: ["trigExpand('sin(2*x)')", "trigExpand('cos(a+b)')"],
+  seealso: ["trigReduce", "trigToExp"]
+};
+
+// src/embeddedDocs/function/algebra/trigReduce.ts
+var trigReduceDocs = {
+  name: "trigReduce",
+  category: "Algebra",
+  syntax: ["trigReduce(expr)"],
+  description: "Reduce trigonometric expressions using product-to-sum formulas.",
+  examples: ["trigReduce('sin(x)*cos(x)')"],
+  seealso: ["trigExpand", "trigToExp"]
+};
+
+// src/embeddedDocs/function/algebra/trigToExp.ts
+var trigToExpDocs = {
+  name: "trigToExp",
+  category: "Algebra",
+  syntax: ["trigToExp(expr)"],
+  description: "Convert trigonometric functions to exponential form using Euler formula.",
+  examples: ["trigToExp('sin(x)')", "trigToExp('cos(x)')"],
+  seealso: ["expToTrig", "trigExpand"]
+};
+
+// src/embeddedDocs/function/algebra/variables.ts
+var variablesDocs = {
+  name: "variables",
+  category: "Algebra",
+  syntax: ["variables(expr)"],
+  description: "Extract free variable names from an expression string, excluding math keywords.",
+  examples: ["variables('x^2 + 2*y + sin(z)')", "variables('pi * r^2')"],
+  seealso: ["substitute"]
+};
+
+// src/embeddedDocs/function/combinatorics/doubleFactorial.ts
+var doubleFactorialDocs = {
+  name: "doubleFactorial",
+  category: "Combinatorics",
+  syntax: ["doubleFactorial(n)"],
+  description: "Compute the double factorial n!! = n * (n-2) * (n-4) * ... Special cases: 0!! = 1, (-1)!! = 1.",
+  examples: ["doubleFactorial(7)", "doubleFactorial(6)", "doubleFactorial(0)"],
+  seealso: ["factorial", "subfactorial"]
+};
+
+// src/embeddedDocs/function/combinatorics/fallingFactorial.ts
+var fallingFactorialDocs = {
+  name: "fallingFactorial",
+  category: "Combinatorics",
+  syntax: ["fallingFactorial(x, n)"],
+  description: "Compute the falling factorial. x_(n) = x * (x-1) * ... * (x-n+1).",
+  examples: ["fallingFactorial(5, 3)", "fallingFactorial(5, 5)"],
+  seealso: ["risingFactorial", "factorial", "permutations"]
+};
+
+// src/embeddedDocs/function/combinatorics/fibonacci.ts
+var fibonacciDocs = {
+  name: "fibonacci",
+  category: "Combinatorics",
+  syntax: ["fibonacci(n)"],
+  description: "Compute the nth Fibonacci number using the fast doubling method. O(log n) time complexity.",
+  examples: ["fibonacci(10)", "fibonacci(20)", "fibonacci(0)"],
+  seealso: ["lucas", "factorial", "combinations"]
+};
+
+// src/embeddedDocs/function/combinatorics/lucas.ts
+var lucasDocs = {
+  name: "lucas",
+  category: "Combinatorics",
+  syntax: ["lucas(n)"],
+  description: "Compute the nth Lucas number. Lucas numbers follow L(0)=2, L(1)=1, L(n)=L(n-1)+L(n-2).",
+  examples: ["lucas(0)", "lucas(1)", "lucas(10)"],
+  seealso: ["fibonacci", "factorial"]
+};
+
+// src/embeddedDocs/function/combinatorics/risingFactorial.ts
+var risingFactorialDocs = {
+  name: "risingFactorial",
+  category: "Combinatorics",
+  syntax: ["risingFactorial(x, n)"],
+  description: "Compute the rising factorial (Pochhammer symbol). x^(n) = x * (x+1) * ... * (x+n-1).",
+  examples: ["risingFactorial(3, 4)", "risingFactorial(1, 5)"],
+  seealso: ["fallingFactorial", "factorial", "combinations"]
+};
+
+// src/embeddedDocs/function/combinatorics/subfactorial.ts
+var subfactorialDocs = {
+  name: "subfactorial",
+  category: "Combinatorics",
+  syntax: ["subfactorial(n)"],
+  description: "Compute the subfactorial (number of derangements). !n counts permutations with no fixed points.",
+  examples: ["subfactorial(0)", "subfactorial(5)", "subfactorial(6)"],
+  seealso: ["factorial", "doubleFactorial", "combinations"]
+};
+
+// src/embeddedDocs/function/geometry/angle2D.ts
+var angle2DDocs = {
+  name: "angle2D",
+  category: "Geometry",
+  syntax: ["angle2D(v1, v2)"],
+  description: "Compute the angle in radians between two 2D vectors.",
+  examples: ["angle2D([1, 0], [0, 1])"],
+  seealso: ["angle3D", "dot3D", "cross3D"]
+};
+
+// src/embeddedDocs/function/geometry/angle3D.ts
+var angle3DDocs = {
+  name: "angle3D",
+  category: "Geometry",
+  syntax: ["angle3D(v1, v2)"],
+  description: "Compute the angle in radians between two 3D vectors.",
+  examples: ["angle3D([1, 0, 0], [0, 1, 0])"],
+  seealso: ["angle2D", "dot3D", "cross3D"]
+};
+
+// src/embeddedDocs/function/geometry/convexHull.ts
+var convexHullDocs = {
+  name: "convexHull",
+  category: "Geometry",
+  syntax: ["convexHull(points)"],
+  description: "Compute the convex hull of a set of 2D points using Andrew's monotone chain algorithm.",
+  examples: ["convexHull([[0,0], [1,0], [0.5,1], [0.5,0.5]])"],
+  seealso: ["pointInPolygon", "polygonArea"]
+};
+
+// src/embeddedDocs/function/geometry/cross3D.ts
+var cross3DDocs = {
+  name: "cross3D",
+  category: "Geometry",
+  syntax: ["cross3D(a, b)"],
+  description: "Compute the cross product of two 3D vectors.",
+  examples: ["cross3D([1, 0, 0], [0, 1, 0])"],
+  seealso: ["dot3D", "angle3D"]
+};
+
+// src/embeddedDocs/function/geometry/distance2D.ts
+var distance2DDocs = {
+  name: "distance2D",
+  category: "Geometry",
+  syntax: ["distance2D(a, b)"],
+  description: "Compute the Euclidean distance between two 2D points.",
+  examples: ["distance2D([0, 0], [3, 4])"],
+  seealso: ["distance3D", "distanceND", "distance"]
+};
+
+// src/embeddedDocs/function/geometry/distance3D.ts
+var distance3DDocs = {
+  name: "distance3D",
+  category: "Geometry",
+  syntax: ["distance3D(a, b)"],
+  description: "Compute the Euclidean distance between two 3D points.",
+  examples: ["distance3D([0, 0, 0], [1, 2, 2])"],
+  seealso: ["distance2D", "distanceND", "distance"]
+};
+
+// src/embeddedDocs/function/geometry/distanceND.ts
+var distanceNDDocs = {
+  name: "distanceND",
+  category: "Geometry",
+  syntax: ["distanceND(a, b)"],
+  description: "Compute the Euclidean distance between two N-dimensional points.",
+  examples: ["distanceND([0, 0, 0, 0], [1, 1, 1, 1])"],
+  seealso: ["distance2D", "distance3D"]
+};
+
+// src/embeddedDocs/function/geometry/distancePointToLine2D.ts
+var distancePointToLine2DDocs = {
+  name: "distancePointToLine2D",
+  category: "Geometry",
+  syntax: ["distancePointToLine2D(point, lineStart, lineEnd)"],
+  description: "Compute the shortest distance from a point to a 2D line segment.",
+  examples: ["distancePointToLine2D([0, 1], [0, 0], [1, 0])"],
+  seealso: ["distance2D", "intersectLines2D"]
+};
+
+// src/embeddedDocs/function/geometry/dot3D.ts
+var dot3DDocs = {
+  name: "dot3D",
+  category: "Geometry",
+  syntax: ["dot3D(a, b)"],
+  description: "Compute the dot product of two 3D vectors.",
+  examples: ["dot3D([1, 2, 3], [4, 5, 6])"],
+  seealso: ["cross3D", "angle3D"]
+};
+
+// src/embeddedDocs/function/geometry/intersectLines2D.ts
+var intersectLines2DDocs = {
+  name: "intersectLines2D",
+  category: "Geometry",
+  syntax: ["intersectLines2D(p1, d1, p2, d2)"],
+  description: "Find the intersection point of two infinite 2D lines, each defined by a point and direction vector. Returns null if parallel.",
+  examples: ["intersectLines2D([0, 0], [1, 1], [1, 0], [0, 1])"],
+  seealso: ["intersectSegments2D", "distancePointToLine2D"]
+};
+
+// src/embeddedDocs/function/geometry/intersectSegments2D.ts
+var intersectSegments2DDocs = {
+  name: "intersectSegments2D",
+  category: "Geometry",
+  syntax: ["intersectSegments2D(a1, a2, b1, b2)"],
+  description: "Find the intersection point of two 2D line segments. Returns null if they do not intersect.",
+  examples: ["intersectSegments2D([0, 0], [1, 1], [0, 1], [1, 0])"],
+  seealso: ["intersectLines2D", "pointInPolygon"]
+};
+
+// src/embeddedDocs/function/geometry/pointInPolygon.ts
+var pointInPolygonDocs = {
+  name: "pointInPolygon",
+  category: "Geometry",
+  syntax: ["pointInPolygon(point, polygon)"],
+  description: "Determine if a 2D point lies inside a polygon using the ray casting algorithm.",
+  examples: ["pointInPolygon([0.5, 0.5], [[0,0], [1,0], [1,1], [0,1]])"],
+  seealso: ["convexHull", "polygonArea"]
+};
+
+// src/embeddedDocs/function/geometry/polygonArea.ts
+var polygonAreaDocs = {
+  name: "polygonArea",
+  category: "Geometry",
+  syntax: ["polygonArea(vertices)"],
+  description: "Compute the area of a simple polygon given ordered 2D vertices using the shoelace formula.",
+  examples: ["polygonArea([[0,0], [1,0], [1,1], [0,1]])"],
+  seealso: ["triangleArea", "convexHull"]
+};
+
+// src/embeddedDocs/function/geometry/projectVector.ts
+var projectVectorDocs = {
+  name: "projectVector",
+  category: "Geometry",
+  syntax: ["projectVector(v, onto)"],
+  description: "Project vector v onto another vector.",
+  examples: ["projectVector([3, 4], [1, 0])"],
+  seealso: ["reflectVector", "dot3D"]
+};
+
+// src/embeddedDocs/function/geometry/reflectVector.ts
+var reflectVectorDocs = {
+  name: "reflectVector",
+  category: "Geometry",
+  syntax: ["reflectVector(v, normal)"],
+  description: "Reflect a vector across a plane defined by its normal vector.",
+  examples: ["reflectVector([1, 1], [0, 1])"],
+  seealso: ["rotateVector2D", "projectVector"]
+};
+
+// src/embeddedDocs/function/geometry/rotateVector2D.ts
+var rotateVector2DDocs = {
+  name: "rotateVector2D",
+  category: "Geometry",
+  syntax: ["rotateVector2D(v, angle)"],
+  description: "Rotate a 2D vector by a given angle in radians.",
+  examples: ["rotateVector2D([1, 0], pi / 2)"],
+  seealso: ["rotateVector3D", "reflectVector"]
+};
+
+// src/embeddedDocs/function/geometry/rotateVector3D.ts
+var rotateVector3DDocs = {
+  name: "rotateVector3D",
+  category: "Geometry",
+  syntax: ["rotateVector3D(v, axis, angle)"],
+  description: "Rotate a 3D vector around an arbitrary axis by a given angle using Rodrigues' formula.",
+  examples: ["rotateVector3D([1, 0, 0], [0, 0, 1], pi / 2)"],
+  seealso: ["rotateVector2D", "reflectVector"]
+};
+
+// src/embeddedDocs/function/geometry/triangleArea.ts
+var triangleAreaDocs = {
+  name: "triangleArea",
+  category: "Geometry",
+  syntax: ["triangleArea(a, b, c)"],
+  description: "Compute the area of a triangle given three 2D vertices.",
+  examples: ["triangleArea([0, 0], [1, 0], [0, 1])"],
+  seealso: ["polygonArea"]
+};
+
+// src/embeddedDocs/function/numeric/cubicSpline.ts
+var cubicSplineDocs = {
+  name: "cubicSpline",
+  category: "Numeric",
+  syntax: ["cubicSpline(xs, ys)"],
+  description: "Natural cubic spline interpolation. Returns a function that evaluates the spline at any point. Uses natural boundary conditions (second derivative = 0 at endpoints).",
+  examples: ["const s = cubicSpline([0,1,2,3], [0,1,4,9]); s(1.5)"],
+  seealso: ["linearInterp", "pchipInterp", "hermiteInterp"]
+};
+
+// src/embeddedDocs/function/numeric/gaussQuad.ts
+var gaussQuadDocs = {
+  name: "gaussQuad",
+  category: "Numeric",
+  syntax: ["gaussQuad(f, a, b)", "gaussQuad(f, a, b, n)"],
+  description: "Numerical integration using Gauss-Legendre quadrature with n points (2-5, default 5). Exact for polynomials up to degree 2n-1.",
+  examples: ["gaussQuad(x => x**2, 0, 1, 3)", "gaussQuad(Math.exp, 0, 1)"],
+  seealso: ["trapz", "simpson", "romberg"]
+};
+
+// src/embeddedDocs/function/numeric/hermiteInterp.ts
+var hermiteInterpDocs = {
+  name: "hermiteInterp",
+  category: "Numeric",
+  syntax: ["hermiteInterp(xs, ys, dys, x)"],
+  description: "Hermite interpolation using function values and derivatives at data points. Constructs the unique polynomial matching both values and first derivatives.",
+  examples: ["hermiteInterp([0, 1], [0, 1], [1, 1], 0.5)"],
+  seealso: ["lagrangeInterp", "cubicSpline", "pchipInterp"]
+};
+
+// src/embeddedDocs/function/numeric/lagrangeInterp.ts
+var lagrangeInterpDocs = {
+  name: "lagrangeInterp",
+  category: "Numeric",
+  syntax: ["lagrangeInterp(xs, ys, x)"],
+  description: "Lagrange polynomial interpolation. Evaluates the unique polynomial of degree n-1 passing through n data points at the given x.",
+  examples: ["lagrangeInterp([0, 1, 2], [0, 1, 4], 1.5)"],
+  seealso: ["linearInterp", "hermiteInterp", "cubicSpline"]
+};
+
+// src/embeddedDocs/function/numeric/linearInterp.ts
+var linearInterpDocs = {
+  name: "linearInterp",
+  category: "Numeric",
+  syntax: ["linearInterp(xs, ys, x)"],
+  description: "Linear interpolation between data points. Finds the interval containing x and linearly interpolates. Extrapolates outside the data range.",
+  examples: ["linearInterp([0, 1], [0, 1], 0.5)", "linearInterp([0, 1, 2], [0, 1, 4], 1.5)"],
+  seealso: ["lagrangeInterp", "cubicSpline", "pchipInterp"]
+};
+
+// src/embeddedDocs/function/numeric/pchipInterp.ts
+var pchipInterpDocs = {
+  name: "pchipInterp",
+  category: "Numeric",
+  syntax: ["pchipInterp(xs, ys, x)"],
+  description: "Shape-preserving Piecewise Cubic Hermite Interpolating Polynomial (PCHIP). Unlike cubic splines, PCHIP preserves monotonicity and avoids overshoot.",
+  examples: ["pchipInterp([0, 1, 2, 3], [0, 1, 4, 9], 1.5)"],
+  seealso: ["linearInterp", "cubicSpline", "hermiteInterp"]
+};
+
+// src/embeddedDocs/function/numeric/polyFit.ts
+var polyFitDocs = {
+  name: "polyFit",
+  category: "Numeric",
+  syntax: ["polyFit(xs, ys, degree)"],
+  description: "Least-squares polynomial fit. Returns coefficients [a0, a1, ..., ad] for p(x) = a0 + a1*x + ... + ad*x^d.",
+  examples: ["polyFit([0,1,2,3], [0,1,4,9], 2)"],
+  seealso: ["linearInterp", "lagrangeInterp"]
+};
+
+// src/embeddedDocs/function/numeric/romberg.ts
+var rombergDocs = {
+  name: "romberg",
+  category: "Numeric",
+  syntax: ["romberg(f, a, b)", "romberg(f, a, b, tol)"],
+  description: "Adaptive numerical integration using Romberg method (Richardson extrapolation on the trapezoidal rule). Converges to the specified tolerance (default 1e-12).",
+  examples: ["romberg(Math.sin, 0, Math.PI)", "romberg(x => 1/x, 1, 2)"],
+  seealso: ["trapz", "simpson", "gaussQuad"]
+};
+
+// src/embeddedDocs/function/numeric/simpson.ts
+var simpsonDocs = {
+  name: "simpson",
+  category: "Numeric",
+  syntax: ["simpson(f, a, b)", "simpson(f, a, b, n)"],
+  description: "Numerical integration using Simpson's 1/3 rule. Divides [a,b] into n subintervals (default 100, must be even).",
+  examples: ["simpson(x => x**2, 0, 1)", "simpson(Math.sin, 0, Math.PI)"],
+  seealso: ["trapz", "romberg", "gaussQuad"]
+};
+
+// src/embeddedDocs/function/numeric/trapz.ts
+var trapzDocs = {
+  name: "trapz",
+  category: "Numeric",
+  syntax: ["trapz(y)", "trapz(y, x)"],
+  description: "Numerical integration using the trapezoidal rule. If x is omitted, uniform spacing (h=1) is assumed.",
+  examples: ["trapz([1, 2, 3], [0, 1, 2])", "trapz([0, 1, 0])"],
+  seealso: ["simpson", "romberg", "gaussQuad"]
+};
+
+// src/embeddedDocs/function/probability/bernoulliPMF.ts
+var bernoulliPMFDocs = {
+  name: "bernoulliPMF",
+  category: "Probability",
+  syntax: ["bernoulliPMF(k, p)"],
+  description: "Compute the Bernoulli probability mass function: p if k=1, (1-p) if k=0. The simplest discrete distribution.",
+  examples: ["bernoulliPMF(1, 0.7)", "bernoulliPMF(0, 0.7)", "bernoulliPMF(1, 0.5)"],
+  seealso: ["binomialPMF", "geometricPMF"]
+};
+
+// src/embeddedDocs/function/probability/binomialPMF.ts
+var binomialPMFDocs = {
+  name: "binomialPMF",
+  category: "Probability",
+  syntax: ["binomialPMF(k, n, p)"],
+  description: "Compute the binomial probability mass function: C(n, k) * p^k * (1-p)^(n-k). Computed in log-space to avoid overflow.",
+  examples: ["binomialPMF(3, 10, 0.5)", "binomialPMF(0, 5, 0.3)", "binomialPMF(5, 5, 0.3)"],
+  seealso: ["poissonPMF", "bernoulliPMF", "combinations"]
+};
+
+// src/embeddedDocs/function/probability/entropy.ts
+var entropyDocs = {
+  name: "entropy",
+  category: "Probability",
+  syntax: ["entropy(probs)"],
+  description: "Compute the Shannon entropy of a discrete probability distribution in bits: H(P) = -sum(p_i * log2(p_i)).",
+  examples: ["entropy([0.5, 0.5])", "entropy([0.25, 0.25, 0.25, 0.25])", "entropy([1, 0])"],
+  seealso: ["jsDivergence", "kldivergence"]
+};
+
+// src/embeddedDocs/function/probability/exponentialCDF.ts
+var exponentialCDFDocs = {
+  name: "exponentialCDF",
+  category: "Probability",
+  syntax: ["exponentialCDF(x, lambda)"],
+  description: "Compute the exponential cumulative distribution function: 1 - exp(-lambda * x) for x >= 0.",
+  examples: ["exponentialCDF(1, 1)", "exponentialCDF(0, 1)", "exponentialCDF(2, 0.5)"],
+  seealso: ["exponentialPDF"]
+};
+
+// src/embeddedDocs/function/probability/exponentialPDF.ts
+var exponentialPDFDocs = {
+  name: "exponentialPDF",
+  category: "Probability",
+  syntax: ["exponentialPDF(x, lambda)"],
+  description: "Compute the exponential probability density function: lambda * exp(-lambda * x) for x >= 0.",
+  examples: ["exponentialPDF(0, 1)", "exponentialPDF(1, 1)", "exponentialPDF(0, 2)"],
+  seealso: ["exponentialCDF"]
+};
+
+// src/embeddedDocs/function/probability/geometricPMF.ts
+var geometricPMFDocs = {
+  name: "geometricPMF",
+  category: "Probability",
+  syntax: ["geometricPMF(k, p)"],
+  description: "Compute the geometric probability mass function: (1-p)^(k-1) * p for k = 1, 2, 3, ... Models the number of trials until the first success.",
+  examples: ["geometricPMF(1, 0.5)", "geometricPMF(3, 0.5)", "geometricPMF(1, 1)"],
+  seealso: ["bernoulliPMF", "binomialPMF"]
+};
+
+// src/embeddedDocs/function/probability/jsDivergence.ts
+var jsDivergenceDocs = {
+  name: "jsDivergence",
+  category: "Probability",
+  syntax: ["jsDivergence(p, q)"],
+  description: "Compute the Jensen-Shannon divergence between two probability distributions in bits. Always non-negative and symmetric: JSD(P||Q) = JSD(Q||P).",
+  examples: ["jsDivergence([0.5, 0.5], [0.5, 0.5])", "jsDivergence([1, 0], [0, 1])"],
+  seealso: ["entropy", "kldivergence"]
+};
+
+// src/embeddedDocs/function/probability/normalCDF.ts
+var normalCDFDocs = {
+  name: "normalCDF",
+  category: "Probability",
+  syntax: ["normalCDF(x)", "normalCDF(x, mu, sigma)"],
+  description: "Compute the normal (Gaussian) cumulative distribution function P(X <= x). With one argument, uses the standard normal (mu=0, sigma=1).",
+  examples: ["normalCDF(0)", "normalCDF(1.96)", "normalCDF(0, 5, 2)"],
+  seealso: ["normalPDF", "erf", "erfc"]
+};
+
+// src/embeddedDocs/function/probability/normalPDF.ts
+var normalPDFDocs = {
+  name: "normalPDF",
+  category: "Probability",
+  syntax: ["normalPDF(x)", "normalPDF(x, mu, sigma)"],
+  description: "Compute the normal (Gaussian) probability density function. With one argument, uses the standard normal (mu=0, sigma=1).",
+  examples: ["normalPDF(0)", "normalPDF(0, 0, 1)", "normalPDF(1, 0, 2)"],
+  seealso: ["normalCDF", "erf"]
+};
+
+// src/embeddedDocs/function/probability/poissonPMF.ts
+var poissonPMFDocs = {
+  name: "poissonPMF",
+  category: "Probability",
+  syntax: ["poissonPMF(k, lambda)"],
+  description: "Compute the Poisson probability mass function: e^(-lambda) * lambda^k / k!. Computed in log-space to avoid overflow.",
+  examples: ["poissonPMF(0, 1)", "poissonPMF(3, 2.5)", "poissonPMF(5, 5)"],
+  seealso: ["binomialPMF", "exponentialPDF"]
+};
+
+// src/embeddedDocs/function/signal/autoCorrelation.ts
+var autoCorrelationDocs = {
+  name: "autoCorrelation",
+  category: "Signal",
+  syntax: ["autoCorrelation(a)"],
+  description: "Compute the auto-correlation of a signal (cross-correlation with itself).",
+  examples: ["autoCorrelation([1, 2, 3])"],
+  seealso: ["crossCorrelation", "xcorr"]
+};
+
+// src/embeddedDocs/function/signal/crossCorrelation.ts
+var crossCorrelationDocs = {
+  name: "crossCorrelation",
+  category: "Signal",
+  syntax: ["crossCorrelation(a, b)"],
+  description: "Compute the cross-correlation of two real signals via sliding dot product.",
+  examples: ["crossCorrelation([1, 2, 3], [1, 2, 3])"],
+  seealso: ["autoCorrelation", "conv"]
+};
+
+// src/embeddedDocs/function/signal/groupDelay.ts
+var groupDelayDocs = {
+  name: "groupDelay",
+  category: "Signal",
+  syntax: ["groupDelay(b, a)", "groupDelay(b, a, w)"],
+  description: "Compute the group delay of a digital filter defined by numerator (b) and denominator (a) polynomial coefficients.",
+  examples: ["groupDelay([1, 2, 1], [1])"],
+  seealso: ["unwrapPhase", "fft"]
+};
+
+// src/embeddedDocs/function/signal/unwrapPhase.ts
+var unwrapPhaseDocs = {
+  name: "unwrapPhase",
+  category: "Signal",
+  syntax: ["unwrapPhase(phase)"],
+  description: "Unwrap phase angles by adding multiples of 2*pi to remove discontinuities.",
+  examples: ["unwrapPhase([0, 1, 2, 3, -2.28])"],
+  seealso: ["groupDelay", "fft"]
+};
+
+// src/embeddedDocs/function/special/besselJ0.ts
+var besselJ0Docs = {
+  name: "besselJ0",
+  category: "Special",
+  syntax: ["besselJ0(x)"],
+  description: "Compute the Bessel function of the first kind, order 0. Uses polynomial approximation from Hart (1968).",
+  examples: ["besselJ0(0)", "besselJ0(1)", "besselJ0(2.4048)"],
+  seealso: ["besselJ1", "besselY0", "besselY1"]
+};
+
+// src/embeddedDocs/function/special/besselJ1.ts
+var besselJ1Docs = {
+  name: "besselJ1",
+  category: "Special",
+  syntax: ["besselJ1(x)"],
+  description: "Compute the Bessel function of the first kind, order 1. Uses polynomial approximation from Hart (1968).",
+  examples: ["besselJ1(0)", "besselJ1(1)", "besselJ1(3.8317)"],
+  seealso: ["besselJ0", "besselY0", "besselY1"]
+};
+
+// src/embeddedDocs/function/special/besselY0.ts
+var besselY0Docs = {
+  name: "besselY0",
+  category: "Special",
+  syntax: ["besselY0(x)"],
+  description: "Compute the Bessel function of the second kind, order 0. Valid only for x > 0. Uses polynomial approximation from Hart (1968).",
+  examples: ["besselY0(1)", "besselY0(5)", "besselY0(10)"],
+  seealso: ["besselJ0", "besselJ1", "besselY1"]
+};
+
+// src/embeddedDocs/function/special/besselY1.ts
+var besselY1Docs = {
+  name: "besselY1",
+  category: "Special",
+  syntax: ["besselY1(x)"],
+  description: "Compute the Bessel function of the second kind, order 1. Valid only for x > 0. Uses polynomial approximation from Hart (1968).",
+  examples: ["besselY1(1)", "besselY1(5)", "besselY1(10)"],
+  seealso: ["besselJ0", "besselJ1", "besselY0"]
+};
+
+// src/embeddedDocs/function/special/beta.ts
+var betaDocs = {
+  name: "beta",
+  category: "Special",
+  syntax: ["beta(a, b)"],
+  description: "Compute the beta function B(a, b) = Gamma(a) * Gamma(b) / Gamma(a+b). Computed via the log-gamma function to avoid overflow.",
+  examples: ["beta(2, 3)", "beta(0.5, 0.5)", "beta(1, 5)"],
+  seealso: ["gamma", "lgamma"]
+};
+
+// src/embeddedDocs/function/special/digamma.ts
+var digammaDocs = {
+  name: "digamma",
+  category: "Special",
+  syntax: ["digamma(x)"],
+  description: "Compute the digamma (psi) function, the logarithmic derivative of the gamma function: psi(x) = d/dx ln(Gamma(x)). Uses asymptotic expansion with recurrence relation.",
+  examples: ["digamma(1)", "digamma(2)", "digamma(0.5)"],
+  seealso: ["gamma", "lgamma"]
+};
+
+// src/embeddedDocs/function/special/erfc.ts
+var erfcDocs = {
+  name: "erfc",
+  category: "Special",
+  syntax: ["erfc(x)"],
+  description: "Compute the complementary error function erfc(x) = 1 - erf(x). Uses the Abramowitz & Stegun rational approximation.",
+  examples: ["erfc(0)", "erfc(1)", "erfc(0.5)", "erfc(-1)"],
+  seealso: ["erf"]
+};
+
+// src/embeddedDocs/function/special/gammainc.ts
+var gammaincDocs = {
+  name: "gammainc",
+  category: "Special",
+  syntax: ["gammainc(a, x)"],
+  description: "Compute the regularized lower incomplete gamma function P(a, x) = gamma(a, x) / Gamma(a). Uses series expansion for small x and continued fraction for large x.",
+  examples: ["gammainc(1, 1)", "gammainc(0.5, 1)", "gammainc(3, 2)"],
+  seealso: ["gamma", "lgamma"]
+};
+
 // src/embeddedDocs/embeddedDocs.ts
 var embeddedDocs = {
   // construction functions
@@ -6240,7 +7171,100 @@ var embeddedDocs = {
   isZero: isZeroDocs,
   print: printDocs,
   typeOf: typeOfDocs,
-  numeric: numericDocs
+  numeric: numericDocs,
+  // MathTS-native extension docs (wired 2026-07-05)
+  apart: apartDocs,
+  cancel: cancelDocs,
+  coefficientList: coefficientListDocs,
+  collect: collectDocs,
+  combine: combineDocs,
+  complexExpand: complexExpandDocs,
+  degree: degreeDocs,
+  differences: differencesDocs,
+  discriminant: discriminantDocs,
+  element: elementDocs,
+  eliminate: eliminateDocs,
+  expToTrig: expToTrigDocs,
+  expand: expandDocs,
+  factor: factorDocs,
+  fullSimplify: fullSimplifyDocs,
+  functionExpand: functionExpandDocs,
+  normalForm: normalFormDocs,
+  partialDerivative: partialDerivativeDocs,
+  polyadd: polyaddDocs,
+  polyder: polyderDocs,
+  polymul: polymulDocs,
+  polynomialGCD: polynomialGCDDocs,
+  polynomialLCM: polynomialLCMDocs,
+  polynomialQuotient: polynomialQuotientDocs,
+  polynomialRemainder: polynomialRemainderDocs,
+  polyval: polyvalDocs,
+  powerExpand: powerExpandDocs,
+  reduce: reduceDocs,
+  resultant: resultantDocs,
+  substitute: substituteDocs,
+  tangentLine: tangentLineDocs,
+  together: togetherDocs,
+  trigExpand: trigExpandDocs,
+  trigReduce: trigReduceDocs,
+  trigToExp: trigToExpDocs,
+  variables: variablesDocs,
+  doubleFactorial: doubleFactorialDocs,
+  fallingFactorial: fallingFactorialDocs,
+  fibonacci: fibonacciDocs,
+  lucas: lucasDocs,
+  risingFactorial: risingFactorialDocs,
+  subfactorial: subfactorialDocs,
+  angle2D: angle2DDocs,
+  angle3D: angle3DDocs,
+  convexHull: convexHullDocs,
+  cross3D: cross3DDocs,
+  distance2D: distance2DDocs,
+  distance3D: distance3DDocs,
+  distanceND: distanceNDDocs,
+  distancePointToLine2D: distancePointToLine2DDocs,
+  dot3D: dot3DDocs,
+  intersectLines2D: intersectLines2DDocs,
+  intersectSegments2D: intersectSegments2DDocs,
+  pointInPolygon: pointInPolygonDocs,
+  polygonArea: polygonAreaDocs,
+  projectVector: projectVectorDocs,
+  reflectVector: reflectVectorDocs,
+  rotateVector2D: rotateVector2DDocs,
+  rotateVector3D: rotateVector3DDocs,
+  triangleArea: triangleAreaDocs,
+  cubicSpline: cubicSplineDocs,
+  gaussQuad: gaussQuadDocs,
+  hermiteInterp: hermiteInterpDocs,
+  lagrangeInterp: lagrangeInterpDocs,
+  linearInterp: linearInterpDocs,
+  pchipInterp: pchipInterpDocs,
+  polyFit: polyFitDocs,
+  romberg: rombergDocs,
+  simpson: simpsonDocs,
+  trapz: trapzDocs,
+  bernoulliPMF: bernoulliPMFDocs,
+  binomialPMF: binomialPMFDocs,
+  entropy: entropyDocs,
+  exponentialCDF: exponentialCDFDocs,
+  exponentialPDF: exponentialPDFDocs,
+  geometricPMF: geometricPMFDocs,
+  jsDivergence: jsDivergenceDocs,
+  normalCDF: normalCDFDocs,
+  normalPDF: normalPDFDocs,
+  poissonPMF: poissonPMFDocs,
+  autoCorrelation: autoCorrelationDocs,
+  crossCorrelation: crossCorrelationDocs,
+  groupDelay: groupDelayDocs,
+  unwrapPhase: unwrapPhaseDocs,
+  besselJ0: besselJ0Docs,
+  besselJ1: besselJ1Docs,
+  besselY0: besselY0Docs,
+  besselY1: besselY1Docs,
+  beta: betaDocs,
+  digamma: digammaDocs,
+  erfc: erfcDocs,
+  gammainc: gammaincDocs
 };
 
 // src/compiler/compile.ts
@@ -6316,25 +7340,25 @@ function compileConstantNode(node) {
   };
 }
 function compileSymbolNode(node, math, argNames) {
-  const name21 = node.name;
-  if (argNames[name21] === true) {
+  const name47 = node.name;
+  if (argNames[name47] === true) {
     return function evalSymbolArg(_scope, args) {
-      return args[name21];
+      return args[name47];
     };
   }
-  if (Object.prototype.hasOwnProperty.call(math, name21)) {
+  if (Object.prototype.hasOwnProperty.call(math, name47)) {
     return function evalSymbolNode(scope) {
-      if (scope.has(name21)) {
-        return scope.get(name21);
+      if (scope.has(name47)) {
+        return scope.get(name47);
       }
-      return math[name21];
+      return math[name47];
     };
   }
   return function evalSymbolNode(scope) {
-    if (scope.has(name21)) {
-      return scope.get(name21);
+    if (scope.has(name47)) {
+      return scope.get(name47);
     }
-    throw new Error(`Undefined symbol "${name21}"`);
+    throw new Error(`Undefined symbol "${name47}"`);
   };
 }
 function compileOperatorNode(node, math, argNames) {
@@ -6344,6 +7368,12 @@ function compileOperatorNode(node, math, argNames) {
     throw new Error(`Function "${fnName}" missing in provided namespace "math"`);
   }
   const fn = math[fnName];
+  if (fn.rawArgs === true) {
+    const rawNodes = opNode.args;
+    return function evalOperatorNodeRaw(scope) {
+      return fn(rawNodes, math, scope);
+    };
+  }
   const evalArgs = opNode.args.map((arg) => compileNode(arg, math, argNames));
   if (evalArgs.length === 1) {
     const evalArg0 = evalArgs[0];
@@ -6365,51 +7395,70 @@ function compileOperatorNode(node, math, argNames) {
 }
 function compileFunctionNode(node, math, argNames) {
   const fnNodeOuter = node;
-  const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames));
   const fnNode = fnNodeOuter.fn;
   if (fnNode && fnNode.isSymbolNode) {
-    const name21 = fnNode.name;
+    const name47 = fnNode.name;
+    const staticFn = Object.prototype.hasOwnProperty.call(math, name47) ? math[name47] : void 0;
+    if (typeof staticFn === "function" && staticFn.rawArgs === true) {
+      const rawNodes = fnNodeOuter.args;
+      return function evalFunctionNodeRaw(scope) {
+        const shadow = scope.has(name47) ? scope.get(name47) : void 0;
+        if (typeof shadow === "function" && shadow.rawArgs !== true) {
+          const values = rawNodes.map(
+            (rn) => compileNode(rn, math, argNames)(scope, {}, void 0)
+          );
+          return shadow(...values);
+        }
+        return staticFn(rawNodes, math, scope);
+      };
+    }
+    const evalArgs2 = fnNodeOuter.args.map(
+      (arg) => compileNode(arg, math, argNames)
+    );
     const resolveFn = (scope) => {
-      if (scope.has(name21)) {
-        const value = scope.get(name21);
+      if (scope.has(name47)) {
+        const value = scope.get(name47);
         if (typeof value === "function") return value;
-        throw new TypeError(`'${name21}' is not a function; its value is:
+        throw new TypeError(`'${name47}' is not a function; its value is:
   ${value}`);
       }
-      if (Object.prototype.hasOwnProperty.call(math, name21)) {
-        const value = math[name21];
+      if (Object.prototype.hasOwnProperty.call(math, name47)) {
+        const value = math[name47];
         if (typeof value === "function") return value;
-        throw new TypeError(`'${name21}' is not a function; its value is:
+        throw new TypeError(`'${name47}' is not a function; its value is:
   ${value}`);
       }
-      throw new Error(`Undefined function "${name21}"`);
+      throw new Error(`Undefined function "${name47}"`);
     };
-    switch (evalArgs.length) {
+    switch (evalArgs2.length) {
       case 0:
         return function evalFunctionNode(scope, _args, _context) {
           return resolveFn(scope)();
         };
       case 1: {
-        const evalArg0 = evalArgs[0];
+        const evalArg0 = evalArgs2[0];
         return function evalFunctionNode(scope, args, context) {
           return resolveFn(scope)(evalArg0(scope, args, context));
         };
       }
       case 2: {
-        const evalArg0 = evalArgs[0];
-        const evalArg1 = evalArgs[1];
+        const evalArg0 = evalArgs2[0];
+        const evalArg1 = evalArgs2[1];
         return function evalFunctionNode(scope, args, context) {
           return resolveFn(scope)(evalArg0(scope, args, context), evalArg1(scope, args, context));
         };
       }
       default:
         return function evalFunctionNode(scope, args, context) {
-          const values = evalArgs.map((e) => e(scope, args, context));
+          const values = evalArgs2.map((e) => e(scope, args, context));
           return resolveFn(scope)(...values);
         };
     }
   }
   if (fnNode && fnNode.isAccessorNode && fnNode.index && fnNode.index.isObjectProperty && fnNode.index.isObjectProperty()) {
+    const evalArgs2 = fnNodeOuter.args.map(
+      (arg) => compileNode(arg, math, argNames)
+    );
     const evalObject = compileNode(fnNode.object, math, argNames);
     const methodName = fnNode.index.getObjectProperty();
     return function evalFunctionNode(scope, args, context) {
@@ -6418,10 +7467,11 @@ function compileFunctionNode(node, math, argNames) {
       if (typeof fn !== "function") {
         throw new TypeError("Expression does not evaluate to a function");
       }
-      const values = evalArgs.map((e) => e(scope, args, context));
+      const values = evalArgs2.map((e) => e(scope, args, context));
       return fn.apply(obj, values);
     };
   }
+  const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames));
   const evalFn = compileNode(fnNode, math, argNames);
   return function evalFunctionNode(scope, args, context) {
     const fn = evalFn(scope, args, context);
@@ -6443,10 +7493,10 @@ function compileAssignmentNode(node, math, argNames) {
   const asgNode = node;
   const evalValue = compileNode(asgNode.value, math, argNames);
   if (asgNode.object && asgNode.object.isSymbolNode && !asgNode.index) {
-    const name22 = asgNode.object.name;
+    const name48 = asgNode.object.name;
     return function evalAssignmentNode(scope, args, context) {
       const value = evalValue(scope, args, context);
-      scope.set(name22, value);
+      scope.set(name48, value);
       return value;
     };
   }
@@ -6461,11 +7511,11 @@ function compileAssignmentNode(node, math, argNames) {
       };
     }
   }
-  const name21 = asgNode.name || asgNode.object && asgNode.object.name;
-  if (name21) {
+  const name47 = asgNode.name || asgNode.object && asgNode.object.name;
+  if (name47) {
     return function evalAssignmentNode(scope, args, context) {
       const value = evalValue(scope, args, context);
-      scope.set(name21, value);
+      scope.set(name47, value);
       return value;
     };
   }
@@ -6565,7 +7615,7 @@ function compileFunctionAssignmentNode(node, math, argNames) {
     childArgNames[param] = true;
   }
   const evalExpr = compileNode(faNode.expr, math, childArgNames);
-  const name21 = faNode.name;
+  const name47 = faNode.name;
   const params = faNode.params;
   return function evalFunctionAssignmentNode(scope, args, _context) {
     const fn = function(...fnArgs) {
@@ -6575,8 +7625,8 @@ function compileFunctionAssignmentNode(node, math, argNames) {
       }
       return evalExpr(scope, childArgs, void 0);
     };
-    fn.syntax = name21 + "(" + params.join(", ") + ")";
-    scope.set(name21, fn);
+    fn.syntax = name47 + "(" + params.join(", ") + ")";
+    scope.set(name47, fn);
     return fn;
   };
 }
@@ -6595,7 +7645,7 @@ function compileAccessorNode(node, math, argNames) {
   return function evalAccessorNode(scope, args, context) {
     const object = evalObject(scope, args, context);
     if (accNode.optionalChaining && object == null) return void 0;
-    const index = evalIndex(scope, args, context);
+    const index = evalIndex(scope, args, object);
     if (math.subset) {
       return math.subset(object, index);
     }
@@ -6607,11 +7657,36 @@ function compileAccessorNode(node, math, argNames) {
 }
 function compileIndexNode(node, math, argNames) {
   const dimensionNodes = node.dimensions;
-  const evalDimensions = dimensionNodes.map(
-    (dim) => compileNode(dim, math, argNames)
+  const usesEnd = dimensionNodes.map(
+    (dim) => dim.filter?.(
+      (n) => n.isSymbolNode === true && n.name === "end"
+    )?.length ?? 0
   );
+  const evalDimensions = dimensionNodes.map((dim, i) => {
+    if (usesEnd[i]) {
+      const childArgNames = Object.create(argNames);
+      childArgNames.end = true;
+      return compileNode(dim, math, childArgNames);
+    }
+    return compileNode(dim, math, argNames);
+  });
+  const anyEnd = usesEnd.some((n) => n > 0);
   return function evalIndexNode(scope, args, context) {
-    const dimensions = evalDimensions.map((e) => e(scope, args, context));
+    const dimensions = evalDimensions.map((e, i) => {
+      if (usesEnd[i]) {
+        const sizeFn = math.size;
+        if (!sizeFn || context === void 0 || context === null) {
+          throw new Error('Cannot resolve "end": no indexing context');
+        }
+        const s = sizeFn(context);
+        const sizes = Array.isArray(s) ? s : s.valueOf();
+        const childArgs = Object.create(args);
+        childArgs.end = sizes[i];
+        return e(scope, childArgs, context);
+      }
+      return e(scope, args, context);
+    });
+    void anyEnd;
     if (math.index) {
       return math.index(...dimensions);
     }
@@ -6805,18 +7880,18 @@ var INLINE_OP = {
 function escapeMathML(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function mi(name21) {
-  return `<mi>${mathmlSymbols[name21] ?? escapeMathML(name21)}</mi>`;
+function mi(name47) {
+  return `<mi>${mathmlSymbols[name47] ?? escapeMathML(name47)}</mi>`;
 }
-function toMathMLSymbol(name21) {
-  const us = name21.indexOf("_");
-  if (us > 0 && us < name21.length - 1) {
-    const base = name21.slice(0, us);
-    const sub = name21.slice(us + 1);
+function toMathMLSymbol(name47) {
+  const us = name47.indexOf("_");
+  if (us > 0 && us < name47.length - 1) {
+    const base = name47.slice(0, us);
+    const sub = name47.slice(us + 1);
     const subEl = /^\d+$/.test(sub) ? `<mn>${sub}</mn>` : mi(sub);
     return `<msub>${mi(base)}${subEl}</msub>`;
   }
-  return mi(name21);
+  return mi(name47);
 }
 function numberToMathML(value) {
   if (!Number.isFinite(value)) return `<mn>${escapeMathML(String(value))}</mn>`;
@@ -7748,14 +8823,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 name21 = this.object.name;
+        const name47 = 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(name21, value);
+            scope.set(name47, value);
             return value;
           };
         } else if (this.index.isObjectProperty()) {
@@ -7771,7 +8846,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(name21, assign(childObject, index, value));
+            scope.set(name47, assign(childObject, index, value));
             return value;
           };
         } else {
@@ -7890,8 +8965,8 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       _toMathML() {
         const obj = this.object;
         if (obj && isSymbolNode(obj) && !this.index && this.value) {
-          const name21 = obj.name;
-          return `<mrow>${toMathMLSymbol(name21)}<mo>=</mo>${this.value.toMathML()}</mrow>`;
+          const name47 = obj.name;
+          return `<mrow>${toMathMLSymbol(name47)}<mo>=</mo>${this.value.toMathML()}</mrow>`;
         }
         return `<mtext>${escapeMathML(this.toString())}</mtext>`;
       }
@@ -8648,18 +9723,18 @@ var latexUnits = {
 function escapeLatex(string) {
   return (0, import_escape_latex.default)(string, { preserveFormatting: true });
 }
-function toSymbol(name21, isUnit2) {
+function toSymbol(name47, isUnit2) {
   isUnit2 = typeof isUnit2 === "undefined" ? false : isUnit2;
   if (isUnit2) {
-    if (hasOwnProperty(latexUnits, name21)) {
-      return latexUnits[name21];
+    if (hasOwnProperty(latexUnits, name47)) {
+      return latexUnits[name47];
     }
-    return "\\mathrm{" + escapeLatex(name21) + "}";
+    return "\\mathrm{" + escapeLatex(name47) + "}";
   }
-  if (hasOwnProperty(latexSymbols, name21)) {
-    return latexSymbols[name21];
+  if (hasOwnProperty(latexSymbols, name47)) {
+    return latexSymbols[name47];
   }
-  return escapeLatex(name21);
+  return escapeLatex(name47);
 }
 
 // src/node/ConstantNode.ts
@@ -8860,9 +9935,9 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
        *                                and type of the parameter
        * @param {Node} expr             The function expression
        */
-      constructor(name21, params, expr) {
+      constructor(name47, params, expr) {
         super();
-        if (typeof name21 !== "string") {
+        if (typeof name47 !== "string") {
           throw new TypeError('String expected for parameter "name"');
         }
         if (!Array.isArray(params)) {
@@ -8873,8 +9948,8 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
         if (!isNode(expr)) {
           throw new TypeError('Node expected for parameter "expr"');
         }
-        if (keywords.has(name21)) {
-          throw new Error('Illegal function name, "' + name21 + '" is a reserved keyword');
+        if (keywords.has(name47)) {
+          throw new Error('Illegal function name, "' + name47 + '" is a reserved keyword');
         }
         const paramNames = /* @__PURE__ */ new Set();
         for (const param of params) {
@@ -8885,7 +9960,7 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
             paramNames.add(paramName);
           }
         }
-        this.name = name21;
+        this.name = name47;
         this.params = params.map(function(param) {
           return param && param.name || param;
         });
@@ -8921,10 +9996,10 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
         });
         const expr = this.expr;
         const evalExpr = expr._compile(math, childArgNames);
-        const name21 = this.name;
+        const name47 = this.name;
         const params = this.params;
         const signature = join(this.types, ",");
-        const syntax = name21 + "(" + join(this.params, ", ") + ")";
+        const syntax = name47 + "(" + join(this.params, ", ") + ")";
         return function evalFunctionAssignmentNode(scope, args, context) {
           const signatures = {};
           signatures[signature] = function(...fnArgs) {
@@ -8934,10 +10009,10 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
             }
             return evalExpr(scope, childArgs, context);
           };
-          const fn = typed(name21, signatures);
+          const fn = typed(name47, signatures);
           fn.syntax = syntax;
           fn.expr = expr.toString();
-          scope.set(name21, fn);
+          scope.set(name47, fn);
           return fn;
         };
       }
@@ -9187,22 +10262,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 name21 = this.fn.name;
-          if (!argNames[name21]) {
-            const fn = name21 in math2 ? getSafeProperty(math2, name21) : void 0;
+          const name47 = this.fn.name;
+          if (!argNames[name47]) {
+            const fn = name47 in math2 ? getSafeProperty(math2, name47) : void 0;
             const isRaw = typeof fn === "function" && fn.rawArgs === true;
             const resolveFn = (scope) => {
               let value;
-              if (scope.has(name21)) {
-                value = scope.get(name21);
-              } else if (name21 in math2) {
-                value = getSafeProperty(math2, name21);
+              if (scope.has(name47)) {
+                value = scope.get(name47);
+              } else if (name47 in math2) {
+                value = getSafeProperty(math2, name47);
               } else if (fromOptionalChaining) value = void 0;
-              else return FunctionNode.onUndefinedFunction(name21);
+              else return FunctionNode.onUndefinedFunction(name47);
               if (typeof value === "function" || fromOptionalChaining && value === void 0) {
                 return value;
               }
-              throw new TypeError(`'${name21}' is not a function; its value is:
+              throw new TypeError(`'${name47}' is not a function; its value is:
   ${strin(value)}`);
             };
             if (isRaw) {
@@ -9251,11 +10326,11 @@ var createFunctionNode = /* @__PURE__ */ factory(
           } else {
             const rawArgs = this.args;
             return function evalFunctionNode(scope, args, context) {
-              const fn = getSafeProperty(args, name21);
+              const fn = getSafeProperty(args, name47);
               if (fromOptionalChaining && fn === void 0) return void 0;
               if (typeof fn !== "function") {
                 throw new TypeError(
-                  `Argument '${name21}' was not a function; received: ${strin(fn)}`
+                  `Argument '${name47}' was not a function; received: ${strin(fn)}`
                 );
               }
               if (fn.rawArgs) {
@@ -9341,8 +10416,8 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * Throws an error 'Undefined function {name}'
        * @param {string} name
        */
-      static onUndefinedFunction = function(name21) {
-        throw new Error("Undefined function " + name21);
+      static onUndefinedFunction = function(name47) {
+        throw new Error("Undefined function " + name47);
       };
       /**
        * Get string representation. (wrapper function)
@@ -9358,9 +10433,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
        */
       toString(options) {
         let customString;
-        const name21 = this.fn.toString(options);
-        if (options && typeof options.handler === "object" && hasOwnProperty(options.handler, name21)) {
-          customString = options.handler[name21](this, options);
+        const name47 = this.fn.toString(options);
+        if (options && typeof options.handler === "object" && hasOwnProperty(options.handler, name47)) {
+          customString = options.handler[name47](this, options);
         }
         if (typeof customString !== "undefined") {
           return customString;
@@ -9439,20 +10514,20 @@ var createFunctionNode = /* @__PURE__ */ factory(
        */
       _toMathML() {
         const fnNode = this.fn;
-        const name21 = fnNode.name ?? String(this.fn);
+        const name47 = fnNode.name ?? String(this.fn);
         const args = this.args;
-        if (name21 === "sqrt" && args.length === 1) return `<msqrt>${args[0].toMathML()}</msqrt>`;
-        if (name21 === "cbrt" && args.length === 1) {
+        if (name47 === "sqrt" && args.length === 1) return `<msqrt>${args[0].toMathML()}</msqrt>`;
+        if (name47 === "cbrt" && args.length === 1) {
           return `<mroot><mrow>${args[0].toMathML()}</mrow><mn>3</mn></mroot>`;
         }
-        if (name21 === "nthRoot" && args.length === 2) {
+        if (name47 === "nthRoot" && args.length === 2) {
           return `<mroot><mrow>${args[0].toMathML()}</mrow><mrow>${args[1].toMathML()}</mrow></mroot>`;
         }
-        if (name21 === "abs" && args.length === 1) {
+        if (name47 === "abs" && args.length === 1) {
           return `<mrow><mo>|</mo>${args[0].toMathML()}<mo>|</mo></mrow>`;
         }
         const inner = args.map((a) => a.toMathML()).join("<mo>,</mo>");
-        return `<mrow>${toMathMLSymbol(name21)}<mo>&#x2061;</mo><mrow><mo>(</mo>${inner}<mo>)</mo></mrow></mrow>`;
+        return `<mrow>${toMathMLSymbol(name47)}<mo>&#x2061;</mo><mrow><mo>(</mo>${inner}<mo>)</mo></mrow></mrow>`;
       }
       _toTex(options) {
         const args = this.args.map(function(arg) {
@@ -11076,8 +12151,8 @@ var createSymbolNode = /* @__PURE__ */ factory(
   name20,
   dependencies20,
   ({ math, Unit, Node }) => {
-    function isValuelessUnit(name21) {
-      return Unit ? Unit.isValuelessUnit(name21) : false;
+    function isValuelessUnit(name47) {
+      return Unit ? Unit.isValuelessUnit(name47) : false;
     }
     class SymbolNode extends Node {
       name;
@@ -11088,12 +12163,12 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * @param {string} name
        * @extends {Node}
        */
-      constructor(name21) {
+      constructor(name47) {
         super();
-        if (typeof name21 !== "string") {
+        if (typeof name47 !== "string") {
           throw new TypeError('String expected for parameter "name"');
         }
-        this.name = name21;
+        this.name = name47;
       }
       get type() {
         return "SymbolNode";
@@ -11115,19 +12190,19 @@ var createSymbolNode = /* @__PURE__ */ factory(
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math2, argNames) {
-        const name21 = this.name;
-        if (argNames[name21] === true) {
+        const name47 = this.name;
+        if (argNames[name47] === true) {
           return function(_scope, args, _context) {
-            return getSafeProperty(args, name21);
+            return getSafeProperty(args, name47);
           };
-        } else if (name21 in math2) {
+        } else if (name47 in math2) {
           return function(scope, _args, _context) {
-            return scope.has(name21) ? scope.get(name21) : getSafeProperty(math2, name21);
+            return scope.has(name47) ? scope.get(name47) : getSafeProperty(math2, name47);
           };
         } else {
-          const isUnit2 = isValuelessUnit(name21);
+          const isUnit2 = isValuelessUnit(name47);
           return function(scope, _args, _context) {
-            return scope.has(name21) ? scope.get(name21) : isUnit2 ? new Unit(null, name21) : SymbolNode.onUndefinedSymbol(name21);
+            return scope.has(name47) ? scope.get(name47) : isUnit2 ? new Unit(null, name47) : SymbolNode.onUndefinedSymbol(name47);
           };
         }
       }
@@ -11150,8 +12225,8 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * Throws an error 'Undefined symbol {name}'
        * @param {string} name
        */
-      static onUndefinedSymbol(name21) {
-        throw new Error("Undefined symbol " + name21);
+      static onUndefinedSymbol(name47) {
+        throw new Error("Undefined symbol " + name47);
       }
       /**
        * Create a clone of this node, a shallow copy
@@ -11177,21 +12252,21 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * @override
        */
       _toHTML(_options) {
-        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>";
+        const name47 = escape(this.name);
+        if (name47 === "true" || name47 === "false") {
+          return '<span class="math-symbol math-boolean">' + name47 + "</span>";
+        } else if (name47 === "i") {
+          return '<span class="math-symbol math-imaginary-symbol">' + name47 + "</span>";
+        } else if (name47 === "Infinity") {
+          return '<span class="math-symbol math-infinity-symbol">' + name47 + "</span>";
+        } else if (name47 === "NaN") {
+          return '<span class="math-symbol math-nan-symbol">' + name47 + "</span>";
+        } else if (name47 === "null") {
+          return '<span class="math-symbol math-null-symbol">' + name47 + "</span>";
+        } else if (name47 === "undefined") {
+          return '<span class="math-symbol math-undefined-symbol">' + name47 + "</span>";
+        }
+        return '<span class="math-symbol">' + name47 + "</span>";
       }
       /**
        * Get a JSON representation of the node
@@ -11238,30 +12313,830 @@ var createSymbolNode = /* @__PURE__ */ factory(
   },
   { isClass: true, isNode: true }
 );
+
+// src/transform/and.transform.ts
+var name21 = "and";
+var dependencies21 = ["and"];
+var createAndTransform = /* @__PURE__ */ factory(
+  name21,
+  dependencies21,
+  ({ and }) => {
+    function andTransform(args, _math, scope) {
+      const condition1 = args[0].compile().evaluate(scope);
+      if (!isCollection(condition1) && !and(condition1, true)) {
+        return false;
+      }
+      const condition2 = args[1].compile().evaluate(scope);
+      return and(condition1, condition2);
+    }
+    andTransform.rawArgs = true;
+    return andTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/bitAnd.transform.ts
+var name22 = "bitAnd";
+var dependencies22 = ["bitAnd"];
+var createBitAndTransform = /* @__PURE__ */ factory(
+  name22,
+  dependencies22,
+  ({ bitAnd }) => {
+    function bitAndTransform(args, _math, scope) {
+      const condition1 = args[0].compile().evaluate(scope);
+      if (!isCollection(condition1)) {
+        if (isNaN(condition1)) {
+          return NaN;
+        }
+        if (condition1 === 0 || condition1 === false) {
+          return 0;
+        }
+      }
+      const condition2 = args[1].compile().evaluate(scope);
+      return bitAnd(condition1, condition2);
+    }
+    bitAndTransform.rawArgs = true;
+    return bitAndTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/bitOr.transform.ts
+var name23 = "bitOr";
+var dependencies23 = ["bitOr"];
+var createBitOrTransform = /* @__PURE__ */ factory(
+  name23,
+  dependencies23,
+  ({ bitOr }) => {
+    function bitOrTransform(args, _math, scope) {
+      const condition1 = args[0].compile().evaluate(scope);
+      if (!isCollection(condition1)) {
+        if (isNaN(condition1)) {
+          return NaN;
+        }
+        if (condition1 === -1) {
+          return -1;
+        }
+        if (condition1 === true) {
+          return 1;
+        }
+      }
+      const condition2 = args[1].compile().evaluate(scope);
+      return bitOr(condition1, condition2);
+    }
+    bitOrTransform.rawArgs = true;
+    return bitOrTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/column.transform.ts
+var name24 = "column";
+var dependencies24 = ["typed", "column"];
+var createColumnTransform = /* @__PURE__ */ factory(
+  name24,
+  dependencies24,
+  ({ typed, column }) => {
+    return typed("column", {
+      "...any": function(args) {
+        const lastIndex = args.length - 1;
+        const last = args[lastIndex];
+        if (isNumber(last)) {
+          args[lastIndex] = last - 1;
+        }
+        try {
+          return column(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/concat.transform.ts
+var name25 = "concat";
+var dependencies25 = ["typed", "concat"];
+var createConcatTransform = /* @__PURE__ */ factory(
+  name25,
+  dependencies25,
+  ({ typed, concat }) => {
+    return typed("concat", {
+      "...any": function(args) {
+        const lastIndex = args.length - 1;
+        const last = args[lastIndex];
+        if (isNumber(last)) {
+          args[lastIndex] = last - 1;
+        } else if (isBigNumber(last)) {
+          args[lastIndex] = last.minus(1);
+        }
+        try {
+          return concat(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/cumsum.transform.ts
+var name26 = "cumsum";
+var dependencies26 = ["typed", "cumsum"];
+var createCumSumTransform = /* @__PURE__ */ factory(
+  name26,
+  dependencies26,
+  ({ typed, cumsum }) => {
+    return typed(name26, {
+      "...any": function(args) {
+        if (args.length === 2 && isCollection(args[0])) {
+          const dim = args[1];
+          if (isNumber(dim)) {
+            args[1] = dim - 1;
+          } else if (isBigNumber(dim)) {
+            args[1] = dim.minus(1);
+          }
+        }
+        try {
+          return cumsum(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/utils/dimToZeroBase.ts
+function dimToZeroBase(dim) {
+  if (isNumber(dim)) {
+    return dim - 1;
+  } else if (isBigNumber(dim)) {
+    return dim.minus(1);
+  } else {
+    return dim;
+  }
+}
+function isNumberOrBigNumber(n) {
+  return isNumber(n) || isBigNumber(n);
+}
+
+// src/transform/utils/lastDimToZeroBase.ts
+function lastDimToZeroBase(args) {
+  if (args.length === 2 && isCollection(args[0])) {
+    args = args.slice();
+    const dim = args[1];
+    if (isNumberOrBigNumber(dim)) {
+      args[1] = dimToZeroBase(dim);
+    }
+  }
+  return args;
+}
+
+// src/transform/diff.transform.ts
+var name27 = "diff";
+var dependencies27 = ["typed", "diff"];
+var createDiffTransform = /* @__PURE__ */ factory(
+  name27,
+  dependencies27,
+  ({ typed, diff }) => {
+    return typed(name27, {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return diff(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/utils/compileInlineExpression.ts
+function compileInlineExpression(expression, math, scope) {
+  const symbol = expression.filter(function(node) {
+    const named = node;
+    return isSymbolNode(node) && !(named.name in math) && !scope.has(named.name);
+  })[0];
+  if (!symbol) {
+    throw new Error(
+      'No undefined variable found in inline expression "' + String(expression) + '"'
+    );
+  }
+  const name47 = symbol.name;
+  const argsScope = /* @__PURE__ */ new Map();
+  const subScope = new PartitionedMap(scope, argsScope, /* @__PURE__ */ new Set([name47]));
+  const eq = expression.compile();
+  return function inlineExpression(x) {
+    argsScope.set(name47, x);
+    return eq.evaluate(subScope);
+  };
+}
+
+// src/transform/utils/transformCallback.ts
+var name28 = "transformCallback";
+var dependencies28 = ["typed"];
+var createTransformCallback = /* @__PURE__ */ factory(
+  name28,
+  dependencies28,
+  ({ typed }) => {
+    return function(callback, numberOfArrays) {
+      if (typed.isTypedFunction(callback)) {
+        return _transformTypedCallbackFunction(callback, numberOfArrays);
+      } else {
+        const fn = callback;
+        return _transformCallbackFunction(fn, fn.length, numberOfArrays);
+      }
+    };
+    function _transformTypedCallbackFunction(typedFunction, numberOfArrays) {
+      const fn = typedFunction;
+      const signatures = Object.fromEntries(
+        Object.entries(fn.signatures).map(([signature, callbackFunction]) => {
+          const numberOfCallbackInputs = signature.split(",").length;
+          if (typed.isTypedFunction(callbackFunction)) {
+            return [signature, _transformTypedCallbackFunction(callbackFunction, numberOfArrays)];
+          } else {
+            return [
+              signature,
+              _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays)
+            ];
+          }
+        })
+      );
+      if (typeof fn.name === "string") {
+        return typed(fn.name, signatures);
+      } else {
+        return typed(signatures);
+      }
+    }
+  }
+);
+function _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays) {
+  const fn = callbackFunction;
+  if (numberOfCallbackInputs === numberOfArrays) {
+    return callbackFunction;
+  } else if (numberOfCallbackInputs === numberOfArrays + 1) {
+    return function(...args) {
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      return fn(...vals, idx);
+    };
+  } else if (numberOfCallbackInputs > numberOfArrays + 1) {
+    return function(...args) {
+      const vals = args.slice(0, numberOfArrays);
+      const idx = _transformDims(args[numberOfArrays]);
+      const rest = args.slice(numberOfArrays + 1);
+      return fn(...vals, idx, ...rest);
+    };
+  } else {
+    return callbackFunction;
+  }
+}
+function _transformDims(dims) {
+  return dims.map((dim) => dim + 1);
+}
+
+// src/transform/filter.transform.ts
+var name29 = "filter";
+var dependencies29 = ["typed", "filter"];
+var createFilterTransform = /* @__PURE__ */ factory(
+  name29,
+  dependencies29,
+  ({ typed, filter }) => {
+    function filterTransform(args, math, scope) {
+      const transformCallback = createTransformCallback({ typed });
+      if (args.length === 0) {
+        return filter();
+      }
+      let x = args[0];
+      if (args.length === 1) {
+        return filter(x);
+      }
+      const N = args.length - 1;
+      let callback = args[N];
+      if (x) {
+        x = _compileAndEvaluate(x, scope);
+      }
+      if (callback) {
+        if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) {
+          callback = _compileAndEvaluate(callback, scope);
+        } else {
+          callback = compileInlineExpression(
+            callback,
+            math,
+            scope
+          );
+        }
+      }
+      return filter(x, transformCallback(callback, N));
+    }
+    filterTransform.rawArgs = true;
+    function _compileAndEvaluate(arg, scope) {
+      return arg.compile().evaluate(scope);
+    }
+    return filterTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/forEach.transform.ts
+var name30 = "forEach";
+var dependencies30 = ["typed", "forEach"];
+var createForEachTransform = /* @__PURE__ */ factory(
+  name30,
+  dependencies30,
+  ({ typed, forEach: forEach2 }) => {
+    const transformCallback = createTransformCallback({ typed });
+    function forEachTransform(args, math, scope) {
+      if (args.length === 0) {
+        return forEach2();
+      }
+      let x = args[0];
+      if (args.length === 1) {
+        return forEach2(x);
+      }
+      const N = args.length - 1;
+      let callback = args[N];
+      if (x) {
+        x = _compileAndEvaluate(x, scope);
+      }
+      if (callback) {
+        if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) {
+          callback = _compileAndEvaluate(callback, scope);
+        } else {
+          callback = compileInlineExpression(
+            callback,
+            math,
+            scope
+          );
+        }
+      }
+      return forEach2(x, transformCallback(callback, N));
+    }
+    forEachTransform.rawArgs = true;
+    function _compileAndEvaluate(arg, scope) {
+      return arg.compile().evaluate(scope);
+    }
+    return forEachTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/index.transform.ts
+var name31 = "index";
+var dependencies31 = ["Index", "getMatrixDataType"];
+var createIndexTransform = /* @__PURE__ */ factory(
+  name31,
+  dependencies31,
+  ({ Index: Index2, getMatrixDataType }) => {
+    return function indexTransform(...args) {
+      const transformedArgs = [];
+      for (let i = 0, ii = args.length; i < ii; i++) {
+        let arg = args[i];
+        if (isRange(arg)) {
+          arg.start--;
+          arg.end -= arg.step > 0 ? 0 : 2;
+        } else if (arg && arg.isSet === true) {
+          arg = arg.map(function(v) {
+            return v - 1;
+          });
+        } else if (isArray(arg) || isMatrix(arg)) {
+          if (getMatrixDataType(arg) !== "boolean") {
+            arg = arg.map(function(v) {
+              return v - 1;
+            });
+          }
+        } else if (isNumber(arg) || isBigInt(arg)) {
+          arg--;
+        } else if (isBigNumber(arg)) {
+          arg = arg.toNumber() - 1;
+        } else if (typeof arg === "string") {
+        } else {
+          throw new TypeError(
+            "Dimension must be an Array, Matrix, number, bigint, string, or Range"
+          );
+        }
+        transformedArgs[i] = arg;
+      }
+      return new Index2(...transformedArgs);
+    };
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/map.transform.ts
+var name32 = "map";
+var dependencies32 = ["typed", "map"];
+var createMapTransform = /* @__PURE__ */ factory(
+  name32,
+  dependencies32,
+  ({ typed, map: map2 }) => {
+    const transformCallback = createTransformCallback({ typed });
+    function mapTransform(args, math, scope) {
+      if (args.length === 0) {
+        return map2();
+      }
+      if (args.length === 1) {
+        return map2(args[0]);
+      }
+      const N = args.length - 1;
+      let X = args.slice(0, N);
+      let callback = args[N];
+      X = X.map((arg) => _compileAndEvaluate(arg, scope));
+      if (callback) {
+        if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) {
+          callback = _compileAndEvaluate(callback, scope);
+        } else {
+          callback = compileInlineExpression(
+            callback,
+            math,
+            scope
+          );
+        }
+      }
+      return map2(...X, transformCallback(callback, N));
+      function _compileAndEvaluate(arg, scope2) {
+        return arg.compile().evaluate(scope2);
+      }
+    }
+    mapTransform.rawArgs = true;
+    return mapTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/mapSlices.transform.ts
+var name33 = "mapSlices";
+var dependencies33 = ["typed", "mapSlices"];
+var createMapSlicesTransform = /* @__PURE__ */ factory(
+  name33,
+  dependencies33,
+  ({ typed, mapSlices }) => {
+    return typed("mapSlices", {
+      "...any": function(args) {
+        const dim = args[1];
+        if (isNumber(dim)) {
+          args[1] = dim - 1;
+        } else if (isBigNumber(dim)) {
+          args[1] = dim.minus(1);
+        }
+        try {
+          return mapSlices(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/max.transform.ts
+var name34 = "max";
+var dependencies34 = ["typed", "max"];
+var createMaxTransform = /* @__PURE__ */ factory(
+  name34,
+  dependencies34,
+  ({ typed, max }) => {
+    return typed("max", {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return max(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/mean.transform.ts
+var name35 = "mean";
+var dependencies35 = ["typed", "mean"];
+var createMeanTransform = /* @__PURE__ */ factory(
+  name35,
+  dependencies35,
+  ({ typed, mean }) => {
+    return typed("mean", {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return mean(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/min.transform.ts
+var name36 = "min";
+var dependencies36 = ["typed", "min"];
+var createMinTransform = /* @__PURE__ */ factory(
+  name36,
+  dependencies36,
+  ({ typed, min }) => {
+    return typed("min", {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return min(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/nullish.transform.ts
+var name37 = "nullish";
+var dependencies37 = ["nullish"];
+var createNullishTransform = /* @__PURE__ */ factory(
+  name37,
+  dependencies37,
+  ({ nullish }) => {
+    function nullishTransform(args, _math, scope) {
+      const left = args[0].compile().evaluate(scope);
+      if (!isCollection(left) && left != null && left !== void 0) {
+        return left;
+      }
+      const right = args[1].compile().evaluate(scope);
+      return nullish(left, right);
+    }
+    nullishTransform.rawArgs = true;
+    return nullishTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/or.transform.ts
+var name38 = "or";
+var dependencies38 = ["or"];
+var createOrTransform = /* @__PURE__ */ factory(
+  name38,
+  dependencies38,
+  ({ or }) => {
+    function orTransform(args, _math, scope) {
+      const condition1 = args[0].compile().evaluate(scope);
+      if (!isCollection(condition1) && or(condition1, false)) {
+        return true;
+      }
+      const condition2 = args[1].compile().evaluate(scope);
+      return or(condition1, condition2);
+    }
+    orTransform.rawArgs = true;
+    return orTransform;
+  },
+  { isTransformFunction: true }
+);
+
+// src/utils/print.ts
+var printTemplate = /\$([\w.]+)/g;
+
+// src/transform/print.transform.ts
+var name39 = "print";
+var dependencies39 = ["typed", "print"];
+var createPrintTransform = /* @__PURE__ */ factory(
+  name39,
+  dependencies39,
+  ({ typed, print }) => {
+    return typed(name39, {
+      "string, Object | Array": function(template, values) {
+        return print(_convertTemplateToZeroBasedIndex(template), values);
+      },
+      "string, Object | Array, number | Object": function(template, values, options) {
+        return print(_convertTemplateToZeroBasedIndex(template), values, options);
+      }
+    });
+    function _convertTemplateToZeroBasedIndex(template) {
+      return template.replace(printTemplate, (x) => {
+        const parts = x.slice(1).split(".");
+        const result = parts.map(function(part) {
+          if (!isNaN(Number(part)) && part.length > 0) {
+            return parseInt(part) - 1;
+          } else {
+            return part;
+          }
+        });
+        return "$" + result.join(".");
+      });
+    }
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/quantileSeq.transform.ts
+var name40 = "quantileSeq";
+var dependencies40 = ["typed", "quantileSeq"];
+var createQuantileSeqTransform = /* @__PURE__ */ factory(
+  name40,
+  dependencies40,
+  ({ typed, quantileSeq }) => {
+    return typed("quantileSeq", {
+      "Array | Matrix, number | BigNumber": quantileSeq,
+      "Array | Matrix, number | BigNumber, number": (arr, prob, dim) => quantileSeq(arr, prob, dimToZeroBase2(dim)),
+      "Array | Matrix, number | BigNumber, boolean": quantileSeq,
+      "Array | Matrix, number | BigNumber, boolean, number": (arr, prob, sorted, dim) => quantileSeq(arr, prob, sorted, dimToZeroBase2(dim)),
+      "Array | Matrix, Array | Matrix": quantileSeq,
+      "Array | Matrix, Array | Matrix, number": (data, prob, dim) => quantileSeq(data, prob, dimToZeroBase2(dim)),
+      "Array | Matrix, Array | Matrix, boolean": quantileSeq,
+      "Array | Matrix, Array | Matrix, boolean, number": (data, prob, sorted, dim) => quantileSeq(data, prob, sorted, dimToZeroBase2(dim))
+    });
+    function dimToZeroBase2(dim) {
+      return lastDimToZeroBase([[], dim])[1];
+    }
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/range.transform.ts
+var name41 = "range";
+var dependencies41 = ["typed", "range"];
+var createRangeTransform = /* @__PURE__ */ factory(
+  name41,
+  dependencies41,
+  ({ typed, range }) => {
+    return typed("range", {
+      "...any": function(args) {
+        const lastIndex = args.length - 1;
+        const last = args[lastIndex];
+        if (typeof last !== "boolean") {
+          args.push(true);
+        }
+        return range(...args);
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/row.transform.ts
+var name42 = "row";
+var dependencies42 = ["typed", "row"];
+var createRowTransform = /* @__PURE__ */ factory(
+  name42,
+  dependencies42,
+  ({ typed, row }) => {
+    return typed("row", {
+      "...any": function(args) {
+        const lastIndex = args.length - 1;
+        const last = args[lastIndex];
+        if (isNumber(last)) {
+          args[lastIndex] = last - 1;
+        }
+        try {
+          return row(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/std.transform.ts
+var name43 = "std";
+var dependencies43 = ["typed", "std"];
+var createStdTransform = /* @__PURE__ */ factory(
+  name43,
+  dependencies43,
+  ({ typed, std }) => {
+    return typed("std", {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return std(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/subset.transform.ts
+var name44 = "subset";
+var dependencies44 = ["typed", "subset"];
+var createSubsetTransform = /* @__PURE__ */ factory(
+  name44,
+  dependencies44,
+  ({ typed, subset }) => {
+    return typed("subset", {
+      "...any": function(args) {
+        try {
+          return subset(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/sum.transform.ts
+var name45 = "sum";
+var dependencies45 = ["typed", "sum"];
+var createSumTransform = /* @__PURE__ */ factory(
+  name45,
+  dependencies45,
+  ({ typed, sum }) => {
+    return typed(name45, {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return sum(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
+
+// src/transform/variance.transform.ts
+var name46 = "variance";
+var dependencies46 = ["typed", "variance"];
+var createVarianceTransform = /* @__PURE__ */ factory(
+  name46,
+  dependencies46,
+  ({ typed, variance }) => {
+    return typed(name46, {
+      "...any": function(args) {
+        args = lastDimToZeroBase(args);
+        try {
+          return variance(...args);
+        } catch (err) {
+          throw errorTransform(err);
+        }
+      }
+    });
+  },
+  { isTransformFunction: true }
+);
 export {
   compile,
   compileExpression,
   createAccessorNode,
+  createAndTransform,
   createArrayNode,
   createAssignmentNode,
+  createBitAndTransform,
+  createBitOrTransform,
   createBlockNode,
+  createColumnTransform,
+  createConcatTransform,
   createConditionalNode,
   createConstantNode,
+  createCumSumTransform,
+  createDiffTransform,
   createEvaluate,
+  createFilterTransform,
+  createForEachTransform,
   createFunctionAssignmentNode,
   createFunctionNode,
   createHelpClass,
   createIndexNode,
+  createIndexTransform,
+  createMapSlicesTransform,
+  createMapTransform,
+  createMaxTransform,
+  createMeanTransform,
+  createMinTransform,
   createNode,
+  createNullishTransform,
   createObjectNode,
   createOperatorNode,
+  createOrTransform,
   createParenthesisNode,
   createParse,
   createParser,
   createParserClass,
+  createPrintTransform,
+  createQuantileSeqTransform,
   createRangeNode,
+  createRangeTransform,
   createRelationalNode,
+  createRowTransform,
+  createStdTransform,
+  createSubsetTransform,
+  createSumTransform,
   createSymbolNode,
+  createVarianceTransform,
   embeddedDocs,
   escapeMathML,
   getAssociativity,