@danielsimonjr/mathts-expression 0.3.0 → 0.4.0

package/dist/index.js

@@ -2842,6 +2842,3730 @@ var createHelpClass = /* @__PURE__ */ factory(
   { isClass: true }
 );
 
+// src/embeddedDocs/constants/e.ts
+var eDocs = {
+  name: "e",
+  category: "Constants",
+  syntax: ["e"],
+  description: "Euler's number, the base of the natural logarithm. Approximately equal to 2.71828",
+  examples: ["e", "e ^ 2", "exp(2)", "log(e)"],
+  seealso: ["exp"]
+};
+
+// src/embeddedDocs/constants/false.ts
+var falseDocs = {
+  name: "false",
+  category: "Constants",
+  syntax: ["false"],
+  description: "Boolean value false",
+  examples: ["false"],
+  seealso: ["true"]
+};
+
+// src/embeddedDocs/constants/i.ts
+var iDocs = {
+  name: "i",
+  category: "Constants",
+  syntax: ["i"],
+  description: "Imaginary unit, defined as i*i=-1. A complex number is described as a + b*i, where a is the real part, and b is the imaginary part.",
+  examples: ["i", "i * i", "sqrt(-1)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/Infinity.ts
+var InfinityDocs = {
+  name: "Infinity",
+  category: "Constants",
+  syntax: ["Infinity"],
+  description: "Infinity, a number which is larger than the maximum number that can be handled by a floating point number.",
+  examples: ["Infinity", "1 / 0"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/LN10.ts
+var LN10Docs = {
+  name: "LN10",
+  category: "Constants",
+  syntax: ["LN10"],
+  description: "Returns the natural logarithm of 10, approximately equal to 2.302",
+  examples: ["LN10", "log(10)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/LN2.ts
+var LN2Docs = {
+  name: "LN2",
+  category: "Constants",
+  syntax: ["LN2"],
+  description: "Returns the natural logarithm of 2, approximately equal to 0.693",
+  examples: ["LN2", "log(2)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/LOG10E.ts
+var LOG10EDocs = {
+  name: "LOG10E",
+  category: "Constants",
+  syntax: ["LOG10E"],
+  description: "Returns the base-10 logarithm of E, approximately equal to 0.434",
+  examples: ["LOG10E", "log(e, 10)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/LOG2E.ts
+var LOG2EDocs = {
+  name: "LOG2E",
+  category: "Constants",
+  syntax: ["LOG2E"],
+  description: "Returns the base-2 logarithm of E, approximately equal to 1.442",
+  examples: ["LOG2E", "log(e, 2)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/NaN.ts
+var NaNDocs = {
+  name: "NaN",
+  category: "Constants",
+  syntax: ["NaN"],
+  description: "Not a number",
+  examples: ["NaN", "0 / 0"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/null.ts
+var nullDocs = {
+  name: "null",
+  category: "Constants",
+  syntax: ["null"],
+  description: "Value null",
+  examples: ["null"],
+  seealso: ["true", "false"]
+};
+
+// src/embeddedDocs/constants/phi.ts
+var phiDocs = {
+  name: "phi",
+  category: "Constants",
+  syntax: ["phi"],
+  description: "Phi is the golden ratio. Two quantities are in the golden ratio if their ratio is the same as the ratio of their sum to the larger of the two quantities. Phi is defined as `(1 + sqrt(5)) / 2` and is approximately 1.618034...",
+  examples: ["phi"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/pi.ts
+var piDocs = {
+  name: "pi",
+  category: "Constants",
+  syntax: ["pi"],
+  description: "The number pi is a mathematical constant that is the ratio of a circle's circumference to its diameter, and is approximately equal to 3.14159",
+  examples: ["pi", "sin(pi/2)"],
+  seealso: ["tau"]
+};
+
+// src/embeddedDocs/constants/SQRT1_2.ts
+var SQRT12Docs = {
+  name: "SQRT1_2",
+  category: "Constants",
+  syntax: ["SQRT1_2"],
+  description: "Returns the square root of 1/2, approximately equal to 0.707",
+  examples: ["SQRT1_2", "sqrt(1/2)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/SQRT2.ts
+var SQRT2Docs = {
+  name: "SQRT2",
+  category: "Constants",
+  syntax: ["SQRT2"],
+  description: "Returns the square root of 2, approximately equal to 1.414",
+  examples: ["SQRT2", "sqrt(2)"],
+  seealso: []
+};
+
+// src/embeddedDocs/constants/tau.ts
+var tauDocs = {
+  name: "tau",
+  category: "Constants",
+  syntax: ["tau"],
+  description: "Tau is the ratio constant of a circle's circumference to radius, equal to 2 * pi, approximately 6.2832.",
+  examples: ["tau", "2 * pi"],
+  seealso: ["pi"]
+};
+
+// src/embeddedDocs/constants/true.ts
+var trueDocs = {
+  name: "true",
+  category: "Constants",
+  syntax: ["true"],
+  description: "Boolean value true",
+  examples: ["true"],
+  seealso: ["false"]
+};
+
+// src/embeddedDocs/constants/version.ts
+var versionDocs = {
+  name: "version",
+  category: "Constants",
+  syntax: ["version"],
+  description: "A string with the version number of math.js",
+  examples: ["version"],
+  seealso: []
+};
+
+// src/embeddedDocs/construction/bignumber.ts
+var bignumberDocs = {
+  name: "bignumber",
+  category: "Construction",
+  syntax: ["bignumber(x)"],
+  description: "Create a big number from a number or string.",
+  examples: [
+    "0.1 + 0.2",
+    "bignumber(0.1) + bignumber(0.2)",
+    'bignumber("7.2")',
+    'bignumber("7.2e500")',
+    "bignumber([0.1, 0.2, 0.3])"
+  ],
+  seealso: ["boolean", "bigint", "complex", "fraction", "index", "matrix", "string", "unit"]
+};
+
+// src/embeddedDocs/construction/bigint.ts
+var bigintDocs = {
+  name: "bigint",
+  category: "Construction",
+  syntax: ["bigint(x)"],
+  description: "Create a bigint, an integer with an arbitrary number of digits, from a number or string.",
+  examples: [
+    "123123123123123123 # a large number will lose digits",
+    'bigint("123123123123123123")',
+    'bignumber(["1", "3", "5"])'
+  ],
+  seealso: [
+    "boolean",
+    "bignumber",
+    "number",
+    "complex",
+    "fraction",
+    "index",
+    "matrix",
+    "string",
+    "unit"
+  ]
+};
+
+// src/embeddedDocs/construction/boolean.ts
+var booleanDocs = {
+  name: "boolean",
+  category: "Construction",
+  syntax: ["x", "boolean(x)"],
+  description: "Convert a string or number into a boolean.",
+  examples: [
+    "boolean(0)",
+    "boolean(1)",
+    "boolean(3)",
+    'boolean("true")',
+    'boolean("false")',
+    "boolean([1, 0, 1, 1])"
+  ],
+  seealso: ["bignumber", "complex", "index", "matrix", "number", "string", "unit"]
+};
+
+// src/embeddedDocs/construction/complex.ts
+var complexDocs = {
+  name: "complex",
+  category: "Construction",
+  syntax: ["complex()", "complex(re, im)", "complex(string)"],
+  description: "Create a complex number.",
+  examples: ["complex()", "complex(2, 3)", 'complex("7 - 2i")'],
+  seealso: ["bignumber", "boolean", "index", "matrix", "number", "string", "unit"]
+};
+
+// src/embeddedDocs/construction/createUnit.ts
+var createUnitDocs = {
+  name: "createUnit",
+  category: "Construction",
+  syntax: ["createUnit(definitions)", "createUnit(name, definition)"],
+  description: "Create a user-defined unit and register it with the Unit type.",
+  examples: [
+    'createUnit("foo")',
+    'createUnit("knot", {definition: "0.514444444 m/s", aliases: ["knots", "kt", "kts"]})',
+    'createUnit("mph", "1 mile/hour")'
+  ],
+  seealso: ["unit", "splitUnit"]
+};
+
+// src/embeddedDocs/construction/fraction.ts
+var fractionDocs = {
+  name: "fraction",
+  category: "Construction",
+  syntax: ["fraction(num)", "fraction(matrix)", "fraction(num,den)", "fraction({n: num, d: den})"],
+  description: "Create a fraction from a number or from integer numerator and denominator.",
+  examples: [
+    "fraction(0.125)",
+    "fraction(1, 3) + fraction(2, 5)",
+    "fraction({n: 333, d: 53})",
+    "fraction([sqrt(9), sqrt(10), sqrt(11)])"
+  ],
+  seealso: ["bignumber", "boolean", "complex", "index", "matrix", "string", "unit"]
+};
+
+// src/embeddedDocs/construction/index.ts
+var indexDocs = {
+  name: "index",
+  category: "Construction",
+  syntax: [
+    "[start]",
+    "[start:end]",
+    "[start:step:end]",
+    "[start1, start 2, ...]",
+    "[start1:end1, start2:end2, ...]",
+    "[start1:step1:end1, start2:step2:end2, ...]"
+  ],
+  description: "Create an index to get or replace a subset of a matrix",
+  examples: [
+    "A = [1, 2, 3; 4, 5, 6]",
+    "A[1, :]",
+    "A[1, 2] = 50",
+    "A[1:2, 1:2] = 1",
+    "B = [1, 2, 3]",
+    "B[B>1 and B<3]"
+  ],
+  seealso: ["bignumber", "boolean", "complex", "matrix", "number", "range", "string", "unit"]
+};
+
+// src/embeddedDocs/construction/matrix.ts
+var matrixDocs = {
+  name: "matrix",
+  category: "Construction",
+  syntax: ["[]", "[a1, b1, ...; a2, b2, ...]", "matrix()", 'matrix("dense")', "matrix([...])"],
+  description: "Create a matrix.",
+  examples: [
+    "[]",
+    "[1, 2, 3]",
+    "[1, 2, 3; 4, 5, 6]",
+    "matrix()",
+    "matrix([3, 4])",
+    'matrix([3, 4; 5, 6], "sparse")',
+    'matrix([3, 4; 5, 6], "sparse", "number")'
+  ],
+  seealso: ["bignumber", "boolean", "complex", "index", "number", "string", "unit", "sparse"]
+};
+
+// src/embeddedDocs/construction/number.ts
+var numberDocs = {
+  name: "number",
+  category: "Construction",
+  syntax: ["x", "number(x)", "number(unit, valuelessUnit)"],
+  description: "Create a number or convert a string or boolean into a number.",
+  examples: [
+    "2",
+    "2e3",
+    "4.05",
+    "number(2)",
+    'number("7.2")',
+    "number(true)",
+    "number([true, false, true, true])",
+    'number(unit("52cm"), "m")'
+  ],
+  seealso: [
+    "bignumber",
+    "bigint",
+    "boolean",
+    "complex",
+    "fraction",
+    "index",
+    "matrix",
+    "string",
+    "unit"
+  ]
+};
+
+// src/embeddedDocs/construction/sparse.ts
+var sparseDocs = {
+  name: "sparse",
+  category: "Construction",
+  syntax: [
+    "sparse()",
+    "sparse([a1, b1, ...; a1, b2, ...])",
+    'sparse([a1, b1, ...; a1, b2, ...], "number")'
+  ],
+  description: "Create a sparse matrix.",
+  examples: ["sparse()", "sparse([3, 4; 5, 6])", 'sparse([3, 0; 5, 0], "number")'],
+  seealso: ["bignumber", "boolean", "complex", "index", "number", "string", "unit", "matrix"]
+};
+
+// src/embeddedDocs/construction/splitUnit.ts
+var splitUnitDocs = {
+  name: "splitUnit",
+  category: "Construction",
+  syntax: ["splitUnit(unit: Unit, parts: Unit[])"],
+  description: "Split a unit in an array of units whose sum is equal to the original unit.",
+  examples: ['splitUnit(1 m, ["feet", "inch"])'],
+  seealso: ["unit", "createUnit"]
+};
+
+// src/embeddedDocs/construction/string.ts
+var stringDocs = {
+  name: "string",
+  category: "Construction",
+  syntax: ['"text"', "string(x)"],
+  description: "Create a string or convert a value to a string",
+  examples: ['"Hello World!"', "string(4.2)", "string(3 + 2i)"],
+  seealso: ["bignumber", "boolean", "complex", "index", "matrix", "number", "unit"]
+};
+
+// src/embeddedDocs/construction/unit.ts
+var unitDocs = {
+  name: "unit",
+  category: "Construction",
+  syntax: ["value unit", "unit(value, unit)", "unit(string)"],
+  description: "Create a unit.",
+  examples: ["5.5 mm", "3 inch", 'unit(7.1, "kilogram")', 'unit("23 deg")'],
+  seealso: ["bignumber", "boolean", "complex", "index", "matrix", "number", "string"]
+};
+
+// src/embeddedDocs/core/config.ts
+var configDocs = {
+  name: "config",
+  category: "Core",
+  syntax: ["config()", "config(options)"],
+  description: "Get configuration or change configuration.",
+  examples: ["config()", "1/3 + 1/4", 'config({number: "Fraction"})', "1/3 + 1/4"],
+  seealso: []
+};
+
+// src/embeddedDocs/core/import.ts
+var importDocs = {
+  name: "import",
+  category: "Core",
+  syntax: ["import(functions)", "import(functions, options)"],
+  description: "Import functions or constants from an object.",
+  examples: ["import({myFn: f(x)=x^2, myConstant: 32 })", "myFn(2)", "myConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/core/typed.ts
+var typedDocs = {
+  name: "typed",
+  category: "Core",
+  syntax: ["typed(signatures)", "typed(name, signatures)"],
+  description: "Create a typed function.",
+  examples: [
+    'double = typed({ "number": f(x)=x+x, "string": f(x)=concat(x,x) })',
+    "double(2)",
+    'double("hello")'
+  ],
+  seealso: []
+};
+
+// src/embeddedDocs/function/algebra/derivative.ts
+var derivativeDocs = {
+  name: "derivative",
+  category: "Algebra",
+  syntax: ["derivative(expr, variable)", "derivative(expr, variable, {simplify: boolean})"],
+  description: "Takes the derivative of an expression expressed in parser Nodes. The derivative will be taken over the supplied variable in the second parameter. If there are multiple variables in the expression, it will return a partial derivative.",
+  examples: [
+    'derivative("2x^3", "x")',
+    'derivative("2x^3", "x", {simplify: false})',
+    'derivative("2x^2 + 3x + 4", "x")',
+    'derivative("sin(2x)", "x")',
+    'f = parse("x^2 + x")',
+    'x = parse("x")',
+    "df = derivative(f, x)",
+    "df.evaluate({x: 3})"
+  ],
+  seealso: ["simplify", "parse", "evaluate"]
+};
+
+// src/embeddedDocs/function/algebra/leafCount.ts
+var leafCountDocs = {
+  name: "leafCount",
+  category: "Algebra",
+  syntax: ["leafCount(expr)"],
+  description: "Computes the number of leaves in the parse tree of the given expression",
+  examples: ['leafCount("e^(i*pi)-1")', 'leafCount(parse("{a: 22/7, b: 10^(1/2)}"))'],
+  seealso: ["simplify"]
+};
+
+// src/embeddedDocs/function/algebra/lsolve.ts
+var lsolveDocs = {
+  name: "lsolve",
+  category: "Algebra",
+  syntax: ["x=lsolve(L, b)"],
+  description: "Finds one solution of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.",
+  examples: ["a = [-2, 3; 2, 1]", "b = [11, 9]", "x = lsolve(a, b)"],
+  seealso: ["lsolveAll", "lup", "lusolve", "usolve", "matrix", "sparse"]
+};
+
+// src/embeddedDocs/function/algebra/lsolveAll.ts
+var lsolveAllDocs = {
+  name: "lsolveAll",
+  category: "Algebra",
+  syntax: ["x=lsolveAll(L, b)"],
+  description: "Finds all solutions of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.",
+  examples: ["a = [-2, 3; 2, 1]", "b = [11, 9]", "x = lsolve(a, b)"],
+  seealso: ["lsolve", "lup", "lusolve", "usolve", "matrix", "sparse"]
+};
+
+// src/embeddedDocs/function/algebra/lup.ts
+var lupDocs = {
+  name: "lup",
+  category: "Algebra",
+  syntax: ["lup(m)"],
+  description: "Calculate the Matrix LU decomposition with partial pivoting. Matrix A is decomposed in three matrices (L, U, P) where P * A = L * U",
+  examples: [
+    "lup([[2, 1], [1, 4]])",
+    "lup(matrix([[2, 1], [1, 4]]))",
+    "lup(sparse([[2, 1], [1, 4]]))"
+  ],
+  seealso: ["lusolve", "lsolve", "usolve", "matrix", "sparse", "slu", "qr"]
+};
+
+// src/embeddedDocs/function/algebra/lusolve.ts
+var lusolveDocs = {
+  name: "lusolve",
+  category: "Algebra",
+  syntax: ["x=lusolve(A, b)", "x=lusolve(lu, b)"],
+  description: "Solves the linear system A * x = b where A is an [n x n] matrix and b is a [n] column vector.",
+  examples: ["a = [-2, 3; 2, 1]", "b = [11, 9]", "x = lusolve(a, b)"],
+  seealso: ["lup", "slu", "lsolve", "usolve", "matrix", "sparse"]
+};
+
+// src/embeddedDocs/function/algebra/polynomialRoot.ts
+var polynomialRootDocs = {
+  name: "polynomialRoot",
+  category: "Algebra",
+  syntax: [
+    "x=polynomialRoot(-6, 3)",
+    "x=polynomialRoot(4, -4, 1)",
+    "x=polynomialRoot(-8, 12, -6, 1)"
+  ],
+  description: "Finds the roots of a univariate polynomial given by its coefficients starting from constant, linear, and so on, increasing in degree.",
+  examples: ["a = polynomialRoot(-6, 11, -6, 1)"],
+  seealso: ["cbrt", "sqrt"]
+};
+
+// src/embeddedDocs/function/algebra/qr.ts
+var qrDocs = {
+  name: "qr",
+  category: "Algebra",
+  syntax: ["qr(A)"],
+  description: "Calculates the Matrix QR decomposition. Matrix `A` is decomposed in two matrices (`Q`, `R`) where `Q` is an orthogonal matrix and `R` is an upper triangular matrix.",
+  examples: ["qr([[1, -1,  4], [1,  4, -2], [1,  4,  2], [1,  -1, 0]])"],
+  seealso: ["lup", "slu", "matrix"]
+};
+
+// src/embeddedDocs/function/algebra/rationalize.ts
+var rationalizeDocs = {
+  name: "rationalize",
+  category: "Algebra",
+  syntax: ["rationalize(expr)", "rationalize(expr, scope)", "rationalize(expr, scope, detailed)"],
+  description: "Transform a rationalizable expression in a rational fraction. If rational fraction is one variable polynomial then converts the numerator and denominator in canonical form, with decreasing exponents, returning the coefficients of numerator.",
+  examples: ['rationalize("2x/y - y/(x+1)")', 'rationalize("2x/y - y/(x+1)", true)'],
+  seealso: ["simplify"]
+};
+
+// src/embeddedDocs/function/algebra/resolve.ts
+var resolveDocs = {
+  name: "resolve",
+  category: "Algebra",
+  syntax: ["resolve(node, scope)"],
+  description: "Recursively substitute variables in an expression tree.",
+  examples: [
+    'resolve(parse("1 + x"), { x: 7 })',
+    'resolve(parse("size(text)"), { text: "Hello World" })',
+    'resolve(parse("x + y"), { x: parse("3z") })',
+    'resolve(parse("3x"), { x: parse("y+z"), z: parse("w^y") })'
+  ],
+  seealso: ["simplify", "evaluate"],
+  mayThrow: ["ReferenceError"]
+};
+
+// src/embeddedDocs/function/algebra/simplify.ts
+var simplifyDocs = {
+  name: "simplify",
+  category: "Algebra",
+  syntax: ["simplify(expr)", "simplify(expr, rules)"],
+  description: "Simplify an expression tree.",
+  examples: [
+    'simplify("3 + 2 / 4")',
+    'simplify("2x + x")',
+    'f = parse("x * (x + 2 + x)")',
+    "simplified = simplify(f)",
+    "simplified.evaluate({x: 2})"
+  ],
+  seealso: ["simplifyCore", "derivative", "evaluate", "parse", "rationalize", "resolve"]
+};
+
+// src/embeddedDocs/function/algebra/simplifyConstant.ts
+var simplifyConstantDocs = {
+  name: "simplifyConstant",
+  category: "Algebra",
+  syntax: ["simplifyConstant(expr)", "simplifyConstant(expr, options)"],
+  description: "Replace constant subexpressions of node with their values.",
+  examples: ['simplifyConstant("(3-3)*x")', 'simplifyConstant(parse("z-cos(tau/8)"))'],
+  seealso: ["simplify", "simplifyCore", "evaluate"]
+};
+
+// src/embeddedDocs/function/algebra/simplifyCore.ts
+var simplifyCoreDocs = {
+  name: "simplifyCore",
+  category: "Algebra",
+  syntax: ["simplifyCore(node)"],
+  description: "Perform simple one-pass simplifications on an expression tree.",
+  examples: ['simplifyCore(parse("0*x"))', 'simplifyCore(parse("(x+0)*2"))'],
+  seealso: ["simplify", "simplifyConstant", "evaluate"]
+};
+
+// src/embeddedDocs/function/algebra/slu.ts
+var sluDocs = {
+  name: "slu",
+  category: "Algebra",
+  syntax: ["slu(A, order, threshold)"],
+  description: "Calculate the Matrix LU decomposition with full pivoting. Matrix A is decomposed in two matrices (L, U) and two permutation vectors (pinv, q) where P * A * Q = L * U",
+  examples: [
+    "slu(sparse([4.5, 0, 3.2, 0; 3.1, 2.9, 0, 0.9; 0, 1.7, 3, 0; 3.5, 0.4, 0, 1]), 1, 0.001)"
+  ],
+  seealso: ["lusolve", "lsolve", "usolve", "matrix", "sparse", "lup", "qr"]
+};
+
+// src/embeddedDocs/function/algebra/symbolicEqual.ts
+var symbolicEqualDocs = {
+  name: "symbolicEqual",
+  category: "Algebra",
+  syntax: ["symbolicEqual(expr1, expr2)", "symbolicEqual(expr1, expr2, options)"],
+  description: "Returns true if the difference of the expressions simplifies to 0",
+  examples: [
+    'symbolicEqual("x*y","y*x")',
+    'symbolicEqual("abs(x^2)", "x^2")',
+    'symbolicEqual("abs(x)", "x", {context: {abs: {trivial: true}}})'
+  ],
+  seealso: ["simplify", "evaluate"]
+};
+
+// src/embeddedDocs/function/algebra/usolve.ts
+var usolveDocs = {
+  name: "usolve",
+  category: "Algebra",
+  syntax: ["x=usolve(U, b)"],
+  description: "Finds one solution of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.",
+  examples: ["x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])"],
+  seealso: ["usolveAll", "lup", "lusolve", "lsolve", "matrix", "sparse"]
+};
+
+// src/embeddedDocs/function/algebra/usolveAll.ts
+var usolveAllDocs = {
+  name: "usolveAll",
+  category: "Algebra",
+  syntax: ["x=usolve(U, b)"],
+  description: "Finds all solutions of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.",
+  examples: ["x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])"],
+  seealso: ["usolve", "lup", "lusolve", "lsolve", "matrix", "sparse"]
+};
+
+// src/embeddedDocs/function/arithmetic/abs.ts
+var absDocs = {
+  name: "abs",
+  category: "Arithmetic",
+  syntax: ["abs(x)"],
+  description: "Compute the absolute value.",
+  examples: ["abs(3.5)", "abs(-4.2)"],
+  seealso: ["sign"]
+};
+
+// src/embeddedDocs/function/arithmetic/add.ts
+var addDocs = {
+  name: "add",
+  category: "Operators",
+  syntax: ["x + y", "add(x, y)"],
+  description: "Add two values.",
+  examples: ["a = 2.1 + 3.6", "a - 3.6", "3 + 2i", "3 cm + 2 inch", '"2.3" + "4"'],
+  seealso: ["subtract"]
+};
+
+// src/embeddedDocs/function/arithmetic/cbrt.ts
+var cbrtDocs = {
+  name: "cbrt",
+  category: "Arithmetic",
+  syntax: ["cbrt(x)", "cbrt(x, allRoots)"],
+  description: "Compute the cubic root value. If x = y * y * y, then y is the cubic root of x. When `x` is a number or complex number, an optional second argument `allRoots` can be provided to return all three cubic roots. If not provided, the principal root is returned",
+  examples: [
+    "cbrt(64)",
+    "cube(4)",
+    "cbrt(-8)",
+    "cbrt(2 + 3i)",
+    "cbrt(8i)",
+    "cbrt(8i, true)",
+    "cbrt(27 m^3)"
+  ],
+  seealso: ["square", "sqrt", "cube", "multiply"]
+};
+
+// src/embeddedDocs/function/arithmetic/ceil.ts
+var ceilDocs = {
+  name: "ceil",
+  category: "Arithmetic",
+  syntax: ["ceil(x)", "ceil(x, n)", "ceil(unit, valuelessUnit)", "ceil(unit, n, valuelessUnit)"],
+  description: "Round a value towards plus infinity. If x is complex, both real and imaginary part are rounded towards plus infinity.",
+  examples: ["ceil(3.2)", "ceil(3.8)", "ceil(-4.2)", "ceil(3.241cm, cm)", "ceil(3.241cm, 2, cm)"],
+  seealso: ["floor", "fix", "round"]
+};
+
+// src/embeddedDocs/function/arithmetic/cube.ts
+var cubeDocs = {
+  name: "cube",
+  category: "Arithmetic",
+  syntax: ["cube(x)"],
+  description: "Compute the cube of a value. The cube of x is x * x * x.",
+  examples: ["cube(2)", "2^3", "2 * 2 * 2"],
+  seealso: ["multiply", "square", "pow"]
+};
+
+// src/embeddedDocs/function/arithmetic/divide.ts
+var divideDocs = {
+  name: "divide",
+  category: "Operators",
+  syntax: ["x / y", "divide(x, y)"],
+  description: "Divide two values.",
+  examples: ["a = 2 / 3", "a * 3", "4.5 / 2", "3 + 4 / 2", "(3 + 4) / 2", "18 km / 4.5"],
+  seealso: ["multiply"]
+};
+
+// src/embeddedDocs/function/arithmetic/dotDivide.ts
+var dotDivideDocs = {
+  name: "dotDivide",
+  category: "Operators",
+  syntax: ["x ./ y", "dotDivide(x, y)"],
+  description: "Divide two values element wise.",
+  examples: ["a = [1, 2, 3; 4, 5, 6]", "b = [2, 1, 1; 3, 2, 5]", "a ./ b"],
+  seealso: ["multiply", "dotMultiply", "divide"]
+};
+
+// src/embeddedDocs/function/arithmetic/dotMultiply.ts
+var dotMultiplyDocs = {
+  name: "dotMultiply",
+  category: "Operators",
+  syntax: ["x .* y", "dotMultiply(x, y)"],
+  description: "Multiply two values element wise.",
+  examples: ["a = [1, 2, 3; 4, 5, 6]", "b = [2, 1, 1; 3, 2, 5]", "a .* b"],
+  seealso: ["multiply", "divide", "dotDivide"]
+};
+
+// src/embeddedDocs/function/arithmetic/dotPow.ts
+var dotPowDocs = {
+  name: "dotPow",
+  category: "Operators",
+  syntax: ["x .^ y", "dotPow(x, y)"],
+  description: "Calculates the power of x to y element wise.",
+  examples: ["a = [1, 2, 3; 4, 5, 6]", "a .^ 2"],
+  seealso: ["pow"]
+};
+
+// src/embeddedDocs/function/arithmetic/exp.ts
+var expDocs = {
+  name: "exp",
+  category: "Arithmetic",
+  syntax: ["exp(x)"],
+  description: "Calculate the exponent of a value.",
+  examples: [
+    "exp(1.3)",
+    "e ^ 1.3",
+    "log(exp(1.3))",
+    "x = 2.4",
+    "(exp(i*x) == cos(x) + i*sin(x))   # Euler's formula"
+  ],
+  seealso: ["expm", "expm1", "pow", "log"]
+};
+
+// src/embeddedDocs/function/arithmetic/expm.ts
+var expmDocs = {
+  name: "expm",
+  category: "Arithmetic",
+  syntax: ["exp(x)"],
+  description: "Compute the matrix exponential, expm(A) = e^A. The matrix must be square. Not to be confused with exp(a), which performs element-wise exponentiation.",
+  examples: ["expm([[0,2],[0,0]])"],
+  seealso: ["exp"]
+};
+
+// src/embeddedDocs/function/arithmetic/expm1.ts
+var expm1Docs = {
+  name: "expm1",
+  category: "Arithmetic",
+  syntax: ["expm1(x)"],
+  description: "Calculate the value of subtracting 1 from the exponential value.",
+  examples: ["expm1(2)", "pow(e, 2) - 1", "log(expm1(2) + 1)"],
+  seealso: ["exp", "pow", "log"]
+};
+
+// src/embeddedDocs/function/arithmetic/fix.ts
+var fixDocs = {
+  name: "fix",
+  category: "Arithmetic",
+  syntax: ["fix(x)", "fix(x, n)", "fix(unit, valuelessUnit)", "fix(unit, n, valuelessUnit)"],
+  description: "Round a value towards zero. If x is complex, both real and imaginary part are rounded towards zero.",
+  examples: [
+    "fix(3.2)",
+    "fix(3.8)",
+    "fix(-4.2)",
+    "fix(-4.8)",
+    "fix(3.241cm, cm)",
+    "fix(3.241cm, 2, cm)"
+  ],
+  seealso: ["ceil", "floor", "round"]
+};
+
+// src/embeddedDocs/function/arithmetic/floor.ts
+var floorDocs = {
+  name: "floor",
+  category: "Arithmetic",
+  syntax: [
+    "floor(x)",
+    "floor(x, n)",
+    "floor(unit, valuelessUnit)",
+    "floor(unit, n, valuelessUnit)"
+  ],
+  description: "Round a value towards minus infinity.If x is complex, both real and imaginary part are rounded towards minus infinity.",
+  examples: [
+    "floor(3.2)",
+    "floor(3.8)",
+    "floor(-4.2)",
+    "floor(3.241cm, cm)",
+    "floor(3.241cm, 2, cm)"
+  ],
+  seealso: ["ceil", "fix", "round"]
+};
+
+// src/embeddedDocs/function/arithmetic/gcd.ts
+var gcdDocs = {
+  name: "gcd",
+  category: "Arithmetic",
+  syntax: ["gcd(a, b)", "gcd(a, b, c, ...)"],
+  description: "Compute the greatest common divisor.",
+  examples: ["gcd(8, 12)", "gcd(-4, 6)", "gcd(25, 15, -10)"],
+  seealso: ["lcm", "xgcd"]
+};
+
+// src/embeddedDocs/function/arithmetic/hypot.ts
+var hypotDocs = {
+  name: "hypot",
+  category: "Arithmetic",
+  syntax: ["hypot(a, b, c, ...)", "hypot([a, b, c, ...])"],
+  description: "Calculate the hypotenuse of a list with values.",
+  examples: ["hypot(3, 4)", "sqrt(3^2 + 4^2)", "hypot(-2)", "hypot([3, 4, 5])"],
+  seealso: ["abs", "norm"]
+};
+
+// src/embeddedDocs/function/arithmetic/invmod.ts
+var invmodDocs = {
+  name: "invmod",
+  category: "Arithmetic",
+  syntax: ["invmod(a, b)"],
+  description: "Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation ax \u2263 1 (mod b)",
+  examples: ["invmod(8, 12)", "invmod(7, 13)", "invmod(15151, 15122)"],
+  seealso: ["gcd", "xgcd"]
+};
+
+// src/embeddedDocs/function/arithmetic/lcm.ts
+var lcmDocs = {
+  name: "lcm",
+  category: "Arithmetic",
+  syntax: ["lcm(x, y)"],
+  description: "Compute the least common multiple.",
+  examples: ["lcm(4, 6)", "lcm(6, 21)", "lcm(6, 21, 5)"],
+  seealso: ["gcd"]
+};
+
+// src/embeddedDocs/function/arithmetic/log.ts
+var logDocs = {
+  name: "log",
+  category: "Arithmetic",
+  syntax: ["log(x)", "log(x, base)"],
+  description: "Compute the logarithm of a value. If no base is provided, the natural logarithm of x is calculated. If base if provided, the logarithm is calculated for the specified base. log(x, base) is defined as log(x) / log(base).",
+  examples: [
+    "log(3.5)",
+    "a = log(2.4)",
+    "exp(a)",
+    "10 ^ 4",
+    "log(10000, 10)",
+    "log(10000) / log(10)",
+    "b = log(1024, 2)",
+    "2 ^ b"
+  ],
+  seealso: ["exp", "log1p", "log2", "log10"]
+};
+
+// src/embeddedDocs/function/arithmetic/log10.ts
+var log10Docs = {
+  name: "log10",
+  category: "Arithmetic",
+  syntax: ["log10(x)"],
+  description: "Compute the 10-base logarithm of a value.",
+  examples: ["log10(0.00001)", "log10(10000)", "10 ^ 4", "log(10000) / log(10)", "log(10000, 10)"],
+  seealso: ["exp", "log"]
+};
+
+// src/embeddedDocs/function/arithmetic/log1p.ts
+var log1pDocs = {
+  name: "log1p",
+  category: "Arithmetic",
+  syntax: ["log1p(x)", "log1p(x, base)"],
+  description: "Calculate the logarithm of a `value+1`",
+  examples: [
+    "log1p(2.5)",
+    "exp(log1p(1.4))",
+    "pow(10, 4)",
+    "log1p(9999, 10)",
+    "log1p(9999) / log(10)"
+  ],
+  seealso: ["exp", "log", "log2", "log10"]
+};
+
+// src/embeddedDocs/function/arithmetic/log2.ts
+var log2Docs = {
+  name: "log2",
+  category: "Arithmetic",
+  syntax: ["log2(x)"],
+  description: "Calculate the 2-base of a value. This is the same as calculating `log(x, 2)`.",
+  examples: ["log2(0.03125)", "log2(16)", "log2(16) / log2(2)", "pow(2, 4)"],
+  seealso: ["exp", "log1p", "log", "log10"]
+};
+
+// src/embeddedDocs/function/arithmetic/mod.ts
+var modDocs = {
+  name: "mod",
+  category: "Operators",
+  syntax: ["x % y", "x mod y", "mod(x, y)"],
+  description: "Calculates the modulus, the remainder of an integer division.",
+  examples: ["7 % 3", "11 % 2", "10 mod 4", "isOdd(x) = x % 2", "isOdd(2)", "isOdd(3)"],
+  seealso: ["divide"]
+};
+
+// src/embeddedDocs/function/arithmetic/multiply.ts
+var multiplyDocs = {
+  name: "multiply",
+  category: "Operators",
+  syntax: ["x * y", "multiply(x, y)"],
+  description: "multiply two values.",
+  examples: ["a = 2.1 * 3.4", "a / 3.4", "2 * 3 + 4", "2 * (3 + 4)", "3 * 2.1 km"],
+  seealso: ["divide"]
+};
+
+// src/embeddedDocs/function/arithmetic/norm.ts
+var normDocs = {
+  name: "norm",
+  category: "Arithmetic",
+  syntax: ["norm(x)", "norm(x, p)"],
+  description: "Calculate the norm of a number, vector or matrix.",
+  examples: [
+    "abs(-3.5)",
+    "norm(-3.5)",
+    "norm(3 - 4i)",
+    "norm([1, 2, -3], Infinity)",
+    "norm([1, 2, -3], -Infinity)",
+    "norm([3, 4], 2)",
+    "norm([[1, 2], [3, 4]], 1)",
+    'norm([[1, 2], [3, 4]], "inf")',
+    'norm([[1, 2], [3, 4]], "fro")'
+  ]
+};
+
+// src/embeddedDocs/function/arithmetic/nthRoot.ts
+var nthRootDocs = {
+  name: "nthRoot",
+  category: "Arithmetic",
+  syntax: ["nthRoot(a)", "nthRoot(a, root)"],
+  description: 'Calculate the nth root of a value. The principal nth root of a positive real number A, is the positive real solution of the equation "x^root = A".',
+  examples: ["4 ^ 3", "nthRoot(64, 3)", "nthRoot(9, 2)", "sqrt(9)"],
+  seealso: ["nthRoots", "pow", "sqrt"]
+};
+
+// src/embeddedDocs/function/arithmetic/nthRoots.ts
+var nthRootsDocs = {
+  name: "nthRoots",
+  category: "Arithmetic",
+  syntax: ["nthRoots(A)", "nthRoots(A, root)"],
+  description: 'Calculate the nth roots of a value. An nth root of a positive real number A, is a positive real solution of the equation "x^root = A". This function returns an array of complex values.',
+  examples: ["nthRoots(1)", "nthRoots(1, 3)"],
+  seealso: ["sqrt", "pow", "nthRoot"]
+};
+
+// src/embeddedDocs/function/arithmetic/pow.ts
+var powDocs = {
+  name: "pow",
+  category: "Operators",
+  syntax: ["x ^ y", "pow(x, y)"],
+  description: "Calculates the power of x to y, x^y.",
+  examples: [
+    "2^3",
+    "2*2*2",
+    "1 + e ^ (pi * i)",
+    "pow([[1, 2], [4, 3]], 2)",
+    "pow([[1, 2], [4, 3]], -1)"
+  ],
+  seealso: ["multiply", "nthRoot", "nthRoots", "sqrt"]
+};
+
+// src/embeddedDocs/function/arithmetic/round.ts
+var roundDocs = {
+  name: "round",
+  category: "Arithmetic",
+  syntax: [
+    "round(x)",
+    "round(x, n)",
+    "round(unit, valuelessUnit)",
+    "round(unit, n, valuelessUnit)"
+  ],
+  description: "round a value towards the nearest integer.If x is complex, both real and imaginary part are rounded towards the nearest integer. When n is specified, the value is rounded to n decimals.",
+  examples: [
+    "round(3.2)",
+    "round(3.8)",
+    "round(-4.2)",
+    "round(-4.8)",
+    "round(pi, 3)",
+    "round(123.45678, 2)",
+    "round(3.241cm, 2, cm)",
+    "round([3.2, 3.8, -4.7])"
+  ],
+  seealso: ["ceil", "floor", "fix"]
+};
+
+// src/embeddedDocs/function/arithmetic/sign.ts
+var signDocs = {
+  name: "sign",
+  category: "Arithmetic",
+  syntax: ["sign(x)"],
+  description: "Compute the sign of a value. The sign of a value x is 1 when x>0, -1 when x<0, and 0 when x=0.",
+  examples: ["sign(3.5)", "sign(-4.2)", "sign(0)"],
+  seealso: ["abs"]
+};
+
+// src/embeddedDocs/function/arithmetic/sqrt.ts
+var sqrtDocs = {
+  name: "sqrt",
+  category: "Arithmetic",
+  syntax: ["sqrt(x)"],
+  description: "Compute the square root value. If x = y * y, then y is the square root of x.",
+  examples: ["sqrt(25)", "5 * 5", "sqrt(-1)"],
+  seealso: ["square", "sqrtm", "multiply", "nthRoot", "nthRoots", "pow"]
+};
+
+// src/embeddedDocs/function/arithmetic/sqrtm.ts
+var sqrtmDocs = {
+  name: "sqrtm",
+  category: "Arithmetic",
+  syntax: ["sqrtm(x)"],
+  description: "Calculate the principal square root of a square matrix. The principal square root matrix `X` of another matrix `A` is such that `X * X = A`.",
+  examples: ["sqrtm([[33, 24], [48, 57]])"],
+  seealso: ["sqrt", "abs", "square", "multiply"]
+};
+
+// src/embeddedDocs/function/algebra/sylvester.ts
+var sylvesterDocs = {
+  name: "sylvester",
+  category: "Algebra",
+  syntax: ["sylvester(A,B,C)"],
+  description: "Solves the real-valued Sylvester equation AX+XB=C for X",
+  examples: [
+    "sylvester([[-1, -2], [1, 1]], [[-2, 1], [-1, 2]], [[-3, 2], [3, 0]])",
+    "A = [[-1, -2], [1, 1]]; B = [[2, -1], [1, -2]]; C = [[-3, 2], [3, 0]]",
+    "sylvester(A, B, C)"
+  ],
+  seealso: ["schur", "lyap"]
+};
+
+// src/embeddedDocs/function/algebra/schur.ts
+var schurDocs = {
+  name: "schur",
+  category: "Algebra",
+  syntax: ["schur(A)"],
+  description: "Performs a real Schur decomposition of the real matrix A = UTU'",
+  examples: ["schur([[1, 0], [-4, 3]])", "A = [[1, 0], [-4, 3]]", "schur(A)"],
+  seealso: ["lyap", "sylvester"]
+};
+
+// src/embeddedDocs/function/algebra/lyap.ts
+var lyapDocs = {
+  name: "lyap",
+  category: "Algebra",
+  syntax: ["lyap(A,Q)"],
+  description: "Solves the Continuous-time Lyapunov equation AP+PA'+Q=0 for P",
+  examples: [
+    "lyap([[-2, 0], [1, -4]], [[3, 1], [1, 3]])",
+    "A = [[-2, 0], [1, -4]]",
+    "Q = [[3, 1], [1, 3]]",
+    "lyap(A,Q)"
+  ],
+  seealso: ["schur", "sylvester"]
+};
+
+// src/embeddedDocs/function/arithmetic/square.ts
+var squareDocs = {
+  name: "square",
+  category: "Arithmetic",
+  syntax: ["square(x)"],
+  description: "Compute the square of a value. The square of x is x * x.",
+  examples: ["square(3)", "sqrt(9)", "3^2", "3 * 3"],
+  seealso: ["multiply", "pow", "sqrt", "cube"]
+};
+
+// src/embeddedDocs/function/arithmetic/subtract.ts
+var subtractDocs = {
+  name: "subtract",
+  category: "Operators",
+  syntax: ["x - y", "subtract(x, y)"],
+  description: "subtract two values.",
+  examples: ["a = 5.3 - 2", "a + 2", "2/3 - 1/6", "2 * 3 - 3", "2.1 km - 500m"],
+  seealso: ["add"]
+};
+
+// src/embeddedDocs/function/arithmetic/unaryMinus.ts
+var unaryMinusDocs = {
+  name: "unaryMinus",
+  category: "Operators",
+  syntax: ["-x", "unaryMinus(x)"],
+  description: "Inverse the sign of a value. Converts booleans and strings to numbers.",
+  examples: ["-4.5", "-(-5.6)", '-"22"'],
+  seealso: ["add", "subtract", "unaryPlus"]
+};
+
+// src/embeddedDocs/function/arithmetic/unaryPlus.ts
+var unaryPlusDocs = {
+  name: "unaryPlus",
+  category: "Operators",
+  syntax: ["+x", "unaryPlus(x)"],
+  description: "Converts booleans and strings to numbers.",
+  examples: ["+true", '+"2"'],
+  seealso: ["add", "subtract", "unaryMinus"]
+};
+
+// src/embeddedDocs/function/arithmetic/xgcd.ts
+var xgcdDocs = {
+  name: "xgcd",
+  category: "Arithmetic",
+  syntax: ["xgcd(a, b)"],
+  description: "Calculate the extended greatest common divisor for two values. The result is an array [d, x, y] with 3 entries, where d is the greatest common divisor, and d = x * a + y * b.",
+  examples: ["xgcd(8, 12)", "gcd(8, 12)", "xgcd(36163, 21199)"],
+  seealso: ["gcd", "lcm"]
+};
+
+// src/embeddedDocs/function/bitwise/bitAnd.ts
+var bitAndDocs = {
+  name: "bitAnd",
+  category: "Bitwise",
+  syntax: ["x & y", "bitAnd(x, y)"],
+  description: "Bitwise AND operation. Performs the logical AND operation on each pair of the corresponding bits of the two given values by multiplying them. If both bits in the compared position are 1, the bit in the resulting binary representation is 1, otherwise, the result is 0",
+  examples: ["5 & 3", "bitAnd(53, 131)", "[1, 12, 31] & 42"],
+  seealso: ["bitNot", "bitOr", "bitXor", "leftShift", "rightArithShift", "rightLogShift"]
+};
+
+// src/embeddedDocs/function/bitwise/bitNot.ts
+var bitNotDocs = {
+  name: "bitNot",
+  category: "Bitwise",
+  syntax: ["~x", "bitNot(x)"],
+  description: "Bitwise NOT operation. Performs a logical negation on each bit of the given value. Bits that are 0 become 1, and those that are 1 become 0.",
+  examples: ["~1", "~2", "bitNot([2, -3, 4])"],
+  seealso: ["bitAnd", "bitOr", "bitXor", "leftShift", "rightArithShift", "rightLogShift"]
+};
+
+// src/embeddedDocs/function/bitwise/bitOr.ts
+var bitOrDocs = {
+  name: "bitOr",
+  category: "Bitwise",
+  syntax: ["x | y", "bitOr(x, y)"],
+  description: "Bitwise OR operation. Performs the logical inclusive OR operation on each pair of corresponding bits of the two given values. The result in each position is 1 if the first bit is 1 or the second bit is 1 or both bits are 1, otherwise, the result is 0.",
+  examples: ["5 | 3", "bitOr([1, 2, 3], 4)"],
+  seealso: ["bitAnd", "bitNot", "bitXor", "leftShift", "rightArithShift", "rightLogShift"]
+};
+
+// src/embeddedDocs/function/bitwise/bitXor.ts
+var bitXorDocs = {
+  name: "bitXor",
+  category: "Bitwise",
+  syntax: ["bitXor(x, y)"],
+  description: "Bitwise XOR operation, exclusive OR. Performs the logical exclusive OR operation on each pair of corresponding bits of the two given values. The result in each position is 1 if only the first bit is 1 or only the second bit is 1, but will be 0 if both are 0 or both are 1.",
+  examples: ["bitOr(1, 2)", "bitXor([2, 3, 4], 4)"],
+  seealso: ["bitAnd", "bitNot", "bitOr", "leftShift", "rightArithShift", "rightLogShift"]
+};
+
+// src/embeddedDocs/function/bitwise/leftShift.ts
+var leftShiftDocs = {
+  name: "leftShift",
+  category: "Bitwise",
+  syntax: ["x << y", "leftShift(x, y)"],
+  description: "Bitwise left logical shift of a value x by y number of bits.",
+  examples: ["4 << 1", "8 >> 1"],
+  seealso: ["bitAnd", "bitNot", "bitOr", "bitXor", "rightArithShift", "rightLogShift"]
+};
+
+// src/embeddedDocs/function/bitwise/rightArithShift.ts
+var rightArithShiftDocs = {
+  name: "rightArithShift",
+  category: "Bitwise",
+  syntax: ["x >> y", "rightArithShift(x, y)"],
+  description: "Bitwise right arithmetic shift of a value x by y number of bits.",
+  examples: ["8 >> 1", "4 << 1", "-12 >> 2"],
+  seealso: ["bitAnd", "bitNot", "bitOr", "bitXor", "leftShift", "rightLogShift"]
+};
+
+// src/embeddedDocs/function/bitwise/rightLogShift.ts
+var rightLogShiftDocs = {
+  name: "rightLogShift",
+  category: "Bitwise",
+  syntax: ["x >>> y", "rightLogShift(x, y)"],
+  description: "Bitwise right logical shift of a value x by y number of bits.",
+  examples: ["8 >>> 1", "4 << 1", "-12 >>> 2"],
+  seealso: ["bitAnd", "bitNot", "bitOr", "bitXor", "leftShift", "rightArithShift"]
+};
+
+// src/embeddedDocs/function/combinatorics/bellNumbers.ts
+var bellNumbersDocs = {
+  name: "bellNumbers",
+  category: "Combinatorics",
+  syntax: ["bellNumbers(n)"],
+  description: "The Bell Numbers count the number of partitions of a set. A partition is a pairwise disjoint subset of S whose union is S. `bellNumbers` only takes integer arguments. The following condition must be enforced: n >= 0.",
+  examples: ["bellNumbers(3)", "bellNumbers(8)"],
+  seealso: ["stirlingS2"]
+};
+
+// src/embeddedDocs/function/combinatorics/catalan.ts
+var catalanDocs = {
+  name: "catalan",
+  category: "Combinatorics",
+  syntax: ["catalan(n)"],
+  description: "The Catalan Numbers enumerate combinatorial structures of many different types. catalan only takes integer arguments. The following condition must be enforced: n >= 0.",
+  examples: ["catalan(3)", "catalan(8)"],
+  seealso: ["bellNumbers"]
+};
+
+// src/embeddedDocs/function/combinatorics/composition.ts
+var compositionDocs = {
+  name: "composition",
+  category: "Combinatorics",
+  syntax: ["composition(n, k)"],
+  description: "The composition counts of n into k parts. composition only takes integer arguments. The following condition must be enforced: k <= n.",
+  examples: ["composition(5, 3)"],
+  seealso: ["combinations"]
+};
+
+// src/embeddedDocs/function/combinatorics/stirlingS2.ts
+var stirlingS2Docs = {
+  name: "stirlingS2",
+  category: "Combinatorics",
+  syntax: ["stirlingS2(n, k)"],
+  description: "The Stirling numbers of the second kind, counts the number of ways to partition a set of n labelled objects into k nonempty unlabelled subsets. `stirlingS2` only takes integer arguments. The following condition must be enforced: k <= n. If n = k or k = 1, then s(n,k) = 1.",
+  examples: ["stirlingS2(5, 3)"],
+  seealso: ["bellNumbers", "bernoulli"]
+};
+
+// src/embeddedDocs/function/complex/arg.ts
+var argDocs = {
+  name: "arg",
+  category: "Complex",
+  syntax: ["arg(x)"],
+  description: "Compute the argument of a complex value. If x = a+bi, the argument is computed as atan2(b, a).",
+  examples: ["arg(2 + 2i)", "atan2(3, 2)", "arg(2 + 3i)"],
+  seealso: ["re", "im", "conj", "abs"]
+};
+
+// src/embeddedDocs/function/complex/conj.ts
+var conjDocs = {
+  name: "conj",
+  category: "Complex",
+  syntax: ["conj(x)"],
+  description: "Compute the complex conjugate of a complex value. If x = a+bi, the complex conjugate is a-bi.",
+  examples: ["conj(2 + 3i)", "conj(2 - 3i)", "conj(-5.2i)"],
+  seealso: ["re", "im", "abs", "arg"]
+};
+
+// src/embeddedDocs/function/complex/im.ts
+var imDocs = {
+  name: "im",
+  category: "Complex",
+  syntax: ["im(x)"],
+  description: "Get the imaginary part of a complex number.",
+  examples: ["im(2 + 3i)", "re(2 + 3i)", "im(-5.2i)", "im(2.4)"],
+  seealso: ["re", "conj", "abs", "arg"]
+};
+
+// src/embeddedDocs/function/complex/re.ts
+var reDocs = {
+  name: "re",
+  category: "Complex",
+  syntax: ["re(x)"],
+  description: "Get the real part of a complex number.",
+  examples: ["re(2 + 3i)", "im(2 + 3i)", "re(-5.2i)", "re(2.4)"],
+  seealso: ["im", "conj", "abs", "arg"]
+};
+
+// src/embeddedDocs/function/expression/evaluate.ts
+var evaluateDocs = {
+  name: "evaluate",
+  category: "Expression",
+  syntax: [
+    "evaluate(expression)",
+    "evaluate(expression, scope)",
+    "evaluate([expr1, expr2, expr3, ...])",
+    "evaluate([expr1, expr2, expr3, ...], scope)"
+  ],
+  description: "Evaluate an expression or an array with expressions.",
+  examples: [
+    'evaluate("2 + 3")',
+    'evaluate("sqrt(16)")',
+    'evaluate("2 inch to cm")',
+    'evaluate("sin(x * pi)", { "x": 1/2 })',
+    'evaluate(["width=2", "height=4","width*height"])'
+  ],
+  seealso: ["parser", "parse", "compile"]
+};
+
+// src/embeddedDocs/function/expression/parser.ts
+var parserDocs = {
+  name: "parser",
+  category: "Expression",
+  syntax: ["parser()"],
+  description: "Create a parser object that keeps a context of variables and their values, allowing the evaluation of expressions in that context.",
+  examples: [
+    "myParser = parser()",
+    'myParser.evaluate("sqrt(3^2 + 4^2)")',
+    'myParser.set("x", 3)',
+    'myParser.evaluate("y = x + 3")',
+    'myParser.evaluate(["y = x + 3", "y = y + 1"])',
+    'myParser.get("y")'
+  ],
+  seealso: ["evaluate", "parse", "compile"]
+};
+
+// src/embeddedDocs/function/expression/parse.ts
+var parseDocs = {
+  name: "parse",
+  category: "Expression",
+  syntax: [
+    "parse(expr)",
+    "parse(expr, options)",
+    "parse([expr1, expr2, expr3, ...])",
+    "parse([expr1, expr2, expr3, ...], options)"
+  ],
+  description: "Parse an expression. Returns a node tree, which can be evaluated by invoking node.evaluate() or transformed into a functional object via node.compile().",
+  examples: [
+    'node1 = parse("sqrt(3^2 + 4^2)")',
+    "node1.evaluate()",
+    "code1 = node1.compile()",
+    "code1.evaluate()",
+    "scope = {a: 3, b: 4}",
+    'node2 = parse("a * b")',
+    "node2.evaluate(scope)",
+    "code2 = node2.compile()",
+    "code2.evaluate(scope)"
+  ],
+  seealso: ["parser", "evaluate", "compile"]
+};
+
+// src/embeddedDocs/function/expression/compile.ts
+var compileDocs = {
+  name: "compile",
+  category: "Expression",
+  syntax: ["compile(expr) ", "compile([expr1, expr2, expr3, ...])"],
+  description: "Parse and compile an expression. Returns a an object with a function evaluate([scope]) to evaluate the compiled expression.",
+  examples: [
+    'code1 = compile("sqrt(3^2 + 4^2)")',
+    "code1.evaluate() ",
+    'code2 = compile("a * b")',
+    "code2.evaluate({a: 3, b: 4})"
+  ],
+  seealso: ["parser", "parse", "evaluate"]
+};
+
+// src/embeddedDocs/function/expression/help.ts
+var helpDocs = {
+  name: "help",
+  category: "Expression",
+  syntax: ["help(object)", "help(string)"],
+  description: "Display documentation on a function or data type.",
+  examples: ["help(sqrt)", 'help("complex")'],
+  seealso: []
+};
+
+// src/embeddedDocs/function/geometry/distance.ts
+var distanceDocs = {
+  name: "distance",
+  category: "Geometry",
+  syntax: ["distance([x1, y1], [x2, y2])", "distance([[x1, y1], [x2, y2]])"],
+  description: "Calculates the Euclidean distance between two points.",
+  examples: ["distance([0,0], [4,4])", "distance([[0,0], [4,4]])"],
+  seealso: []
+};
+
+// src/embeddedDocs/function/geometry/intersect.ts
+var intersectDocs = {
+  name: "intersect",
+  category: "Geometry",
+  syntax: ["intersect(expr1, expr2, expr3, expr4)", "intersect(expr1, expr2, expr3)"],
+  description: "Computes the intersection point of lines and/or planes.",
+  examples: [
+    "intersect([0, 0], [10, 10], [10, 0], [0, 10])",
+    "intersect([1, 0, 1],  [4, -2, 2], [1, 1, 1, 6])"
+  ],
+  seealso: []
+};
+
+// src/embeddedDocs/function/logical/and.ts
+var andDocs = {
+  name: "and",
+  category: "Logical",
+  syntax: ["x and y", "and(x, y)"],
+  description: "Logical and. Test whether two values are both defined with a nonzero/nonempty value.",
+  examples: ["true and false", "true and true", "2 and 4"],
+  seealso: ["not", "or", "xor"]
+};
+
+// src/embeddedDocs/function/logical/not.ts
+var notDocs = {
+  name: "not",
+  category: "Logical",
+  syntax: ["not x", "not(x)"],
+  description: "Logical not. Flips the boolean value of given argument.",
+  examples: ["not true", "not false", "not 2", "not 0"],
+  seealso: ["and", "or", "xor"]
+};
+
+// src/embeddedDocs/function/logical/nullish.ts
+var nullishDocs = {
+  name: "nullish",
+  category: "Logical",
+  syntax: ["x ?? y", "nullish(x, y)"],
+  description: "Nullish coalescing operator. Returns the right-hand operand when the left-hand operand is null or undefined, and otherwise returns the left-hand operand.",
+  examples: ["null ?? 42", "undefined ?? 42", "0 ?? 42", "false ?? 42", "null ?? undefined ?? 42"],
+  seealso: ["and", "or", "not"]
+};
+
+// src/embeddedDocs/function/logical/or.ts
+var orDocs = {
+  name: "or",
+  category: "Logical",
+  syntax: ["x or y", "or(x, y)"],
+  description: "Logical or. Test if at least one value is defined with a nonzero/nonempty value.",
+  examples: ["true or false", "false or false", "0 or 4"],
+  seealso: ["not", "and", "xor"]
+};
+
+// src/embeddedDocs/function/logical/xor.ts
+var xorDocs = {
+  name: "xor",
+  category: "Logical",
+  syntax: ["x xor y", "xor(x, y)"],
+  description: "Logical exclusive or, xor. Test whether one and only one value is defined with a nonzero/nonempty value.",
+  examples: ["true xor false", "false xor false", "true xor true", "0 xor 4"],
+  seealso: ["not", "and", "or"]
+};
+
+// src/embeddedDocs/function/matrix/mapSlices.ts
+var mapSlicesDocs = {
+  name: "mapSlices",
+  category: "Matrix",
+  syntax: ["mapSlices(A, dim, callback)"],
+  description: "Generate a matrix one dimension less than A by applying callback to each slice of A along dimension dim.",
+  examples: [
+    "A = [[1, 2], [3, 4]]",
+    "mapSlices(A, 1, sum)",
+    // returns [4, 6]
+    "mapSlices(A, 2, prod)"
+    // returns [2, 12]
+  ],
+  seealso: ["map", "forEach"]
+};
+
+// src/embeddedDocs/function/matrix/column.ts
+var columnDocs = {
+  name: "column",
+  category: "Matrix",
+  syntax: ["column(x, index)"],
+  description: "Return a column from a matrix or array.",
+  examples: ["A = [[1, 2], [3, 4]]", "column(A, 1)", "column(A, 2)"],
+  seealso: ["row", "matrixFromColumns"]
+};
+
+// src/embeddedDocs/function/matrix/concat.ts
+var concatDocs = {
+  name: "concat",
+  category: "Matrix",
+  syntax: ["concat(A, B, C, ...)", "concat(A, B, C, ..., dim)"],
+  description: "Concatenate matrices. By default, the matrices are concatenated by the last dimension. The dimension on which to concatenate can be provided as last argument.",
+  examples: [
+    "A = [1, 2; 5, 6]",
+    "B = [3, 4; 7, 8]",
+    "concat(A, B)",
+    "concat(A, B, 1)",
+    "concat(A, B, 2)"
+  ],
+  seealso: [
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/count.ts
+var countDocs = {
+  name: "count",
+  category: "Matrix",
+  syntax: ["count(x)"],
+  description: "Count the number of elements of a matrix, array or string.",
+  examples: ["a = [1, 2; 3, 4; 5, 6]", "count(a)", "size(a)", 'count("hello world")'],
+  seealso: ["size"]
+};
+
+// src/embeddedDocs/function/matrix/cross.ts
+var crossDocs = {
+  name: "cross",
+  category: "Matrix",
+  syntax: ["cross(A, B)"],
+  description: "Calculate the cross product for two vectors in three dimensional space.",
+  examples: [
+    "cross([1, 1, 0],  [0, 1, 1])",
+    "cross([3, -3, 1], [4, 9, 2])",
+    "cross([2, 3, 4],  [5, 6, 7])"
+  ],
+  seealso: ["multiply", "dot"]
+};
+
+// src/embeddedDocs/function/matrix/ctranspose.ts
+var ctransposeDocs = {
+  name: "ctranspose",
+  category: "Matrix",
+  syntax: ["x'", "ctranspose(x)"],
+  description: "Complex Conjugate and Transpose a matrix",
+  examples: ["a = [1, 2, 3; 4, 5, 6]", "a'", "ctranspose(a)"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/det.ts
+var detDocs = {
+  name: "det",
+  category: "Matrix",
+  syntax: ["det(x)"],
+  description: "Calculate the determinant of a matrix",
+  examples: ["det([1, 2; 3, 4])", "det([-2, 2, 3; -1, 1, 3; 2, 0, -1])"],
+  seealso: [
+    "concat",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/diag.ts
+var diagDocs = {
+  name: "diag",
+  category: "Matrix",
+  syntax: ["diag(x)", "diag(x, k)"],
+  description: "Create a diagonal matrix or retrieve the diagonal of a matrix. When x is a vector, a matrix with the vector values on the diagonal will be returned. When x is a matrix, a vector with the diagonal values of the matrix is returned. When k is provided, the k-th diagonal will be filled in or retrieved, if k is positive, the values are placed on the super diagonal. When k is negative, the values are placed on the sub diagonal.",
+  examples: ["diag(1:3)", "diag(1:3, 1)", "a = [1, 2, 3; 4, 5, 6; 7, 8, 9]", "diag(a)"],
+  seealso: [
+    "concat",
+    "det",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/diff.ts
+var diffDocs = {
+  name: "diff",
+  category: "Matrix",
+  syntax: ["diff(arr)", "diff(arr, dim)"],
+  description: [
+    "Create a new matrix or array with the difference of the passed matrix or array.",
+    "Dim parameter is optional and used to indicate the dimension of the array/matrix to apply the difference",
+    "If no dimension parameter is passed it is assumed as dimension 0",
+    "Dimension is zero-based in javascript and one-based in the parser",
+    "Arrays must be 'rectangular' meaning arrays like [1, 2]",
+    "If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays"
+  ],
+  examples: [
+    "A = [1, 2, 4, 7, 0]",
+    "diff(A)",
+    "diff(A, 1)",
+    "B = [[1, 2], [3, 4]]",
+    "diff(B)",
+    "diff(B, 1)",
+    "diff(B, 2)",
+    "diff(B, bignumber(2))",
+    "diff([[1, 2], matrix([3, 4])], 2)"
+  ],
+  seealso: ["subtract", "partitionSelect"]
+};
+
+// src/embeddedDocs/function/matrix/dot.ts
+var dotDocs = {
+  name: "dot",
+  category: "Matrix",
+  syntax: ["dot(A, B)", "A * B"],
+  description: "Calculate the dot product of two vectors. The dot product of A = [a1, a2, a3, ..., an] and B = [b1, b2, b3, ..., bn] is defined as dot(A, B) = a1 * b1 + a2 * b2 + a3 * b3 + ... + an * bn",
+  examples: ["dot([2, 4, 1], [2, 2, 3])", "[2, 4, 1] * [2, 2, 3]"],
+  seealso: ["multiply", "cross"]
+};
+
+// src/embeddedDocs/function/matrix/eigs.ts
+var eigsDocs = {
+  name: "eigs",
+  category: "Matrix",
+  syntax: ["eigs(x)"],
+  description: "Calculate the eigenvalues and optionally eigenvectors of a square matrix",
+  examples: [
+    "eigs([[5, 2.3], [2.3, 1]])",
+    "eigs([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { precision: 1e-6, eigenvectors: false })"
+  ],
+  seealso: ["inv"]
+};
+
+// src/embeddedDocs/function/matrix/filter.ts
+var filterDocs = {
+  name: "filter",
+  category: "Matrix",
+  syntax: ["filter(x, test)"],
+  description: "Filter items in a matrix.",
+  examples: [
+    "isPositive(x) = x > 0",
+    "filter([6, -2, -1, 4, 3], isPositive)",
+    "filter([6, -2, 0, 1, 0], x != 0)"
+  ],
+  seealso: ["sort", "map", "forEach"]
+};
+
+// src/embeddedDocs/function/matrix/flatten.ts
+var flattenDocs = {
+  name: "flatten",
+  category: "Matrix",
+  syntax: ["flatten(x)"],
+  description: "Flatten a multi dimensional matrix into a single dimensional matrix.",
+  examples: ["a = [1, 2, 3; 4, 5, 6]", "size(a)", "b = flatten(a)", "size(b)"],
+  seealso: ["concat", "resize", "size", "squeeze"]
+};
+
+// src/embeddedDocs/function/matrix/forEach.ts
+var forEachDocs = {
+  name: "forEach",
+  category: "Matrix",
+  syntax: ["forEach(x, callback)"],
+  description: "Iterates over all elements of a matrix/array, and executes the given callback function.",
+  examples: [
+    "numberOfPets = {}",
+    "addPet(n) = numberOfPets[n] = (numberOfPets[n] ? numberOfPets[n]:0 ) + 1;",
+    'forEach(["Dog","Cat","Cat"], addPet)',
+    "numberOfPets"
+  ],
+  seealso: ["map", "sort", "filter"]
+};
+
+// src/embeddedDocs/function/matrix/getMatrixDataType.ts
+var getMatrixDataTypeDocs = {
+  name: "getMatrixDataType",
+  category: "Matrix",
+  syntax: ["getMatrixDataType(x)"],
+  description: 'Find the data type of all elements in a matrix or array, for example "number" if all items are a number and "Complex" if all values are complex numbers. If a matrix contains more than one data type, it will return "mixed".',
+  examples: [
+    "getMatrixDataType([1, 2, 3])",
+    "getMatrixDataType([[5 cm], [2 inch]])",
+    'getMatrixDataType([1, "text"])',
+    "getMatrixDataType([1, bignumber(4)])"
+  ],
+  seealso: ["matrix", "sparse", "typeOf"]
+};
+
+// src/embeddedDocs/function/matrix/identity.ts
+var identityDocs = {
+  name: "identity",
+  category: "Matrix",
+  syntax: ["identity(n)", "identity(m, n)", "identity([m, n])"],
+  description: "Returns the identity matrix with size m-by-n. The matrix has ones on the diagonal and zeros elsewhere.",
+  examples: ["identity(3)", "identity(3, 5)", "a = [1, 2, 3; 4, 5, 6]", "identity(size(a))"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/inv.ts
+var invDocs = {
+  name: "inv",
+  category: "Matrix",
+  syntax: ["inv(x)"],
+  description: "Calculate the inverse of a matrix",
+  examples: ["inv([1, 2; 3, 4])", "inv(4)", "1 / 4"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/pinv.ts
+var pinvDocs = {
+  name: "pinv",
+  category: "Matrix",
+  syntax: ["pinv(x)"],
+  description: "Calculate the Moore\u2013Penrose inverse of a matrix",
+  examples: ["pinv([1, 2; 3, 4])", "pinv([[1, 0], [0, 1], [0, 1]])", "pinv(4)"],
+  seealso: ["inv"]
+};
+
+// src/embeddedDocs/function/matrix/kron.ts
+var kronDocs = {
+  name: "kron",
+  category: "Matrix",
+  syntax: ["kron(x, y)"],
+  description: "Calculates the Kronecker product of 2 matrices or vectors.",
+  examples: ["kron([[1, 0], [0, 1]], [[1, 2], [3, 4]])", "kron([1,1], [2,3,4])"],
+  seealso: ["multiply", "dot", "cross"]
+};
+
+// src/embeddedDocs/function/matrix/map.ts
+var mapDocs = {
+  name: "map",
+  category: "Matrix",
+  syntax: ["map(x, callback)", "map(x, y, ..., callback)"],
+  description: "Create a new matrix or array with the results of the callback function executed on each entry of the matrix/array or the matrices/arrays.",
+  examples: ["map([1, 2, 3], square)", "map([1, 2], [3, 4], f(a,b) = a + b)"],
+  seealso: ["filter", "forEach"]
+};
+
+// src/embeddedDocs/function/matrix/matrixFromColumns.ts
+var matrixFromColumnsDocs = {
+  name: "matrixFromColumns",
+  category: "Matrix",
+  syntax: [
+    "matrixFromColumns(...arr)",
+    "matrixFromColumns(row1, row2)",
+    "matrixFromColumns(row1, row2, row3)"
+  ],
+  description: "Create a dense matrix from vectors as individual columns.",
+  examples: ["matrixFromColumns([1, 2, 3], [[4],[5],[6]])"],
+  seealso: ["matrix", "matrixFromRows", "matrixFromFunction", "zeros"]
+};
+
+// src/embeddedDocs/function/matrix/matrixFromFunction.ts
+var matrixFromFunctionDocs = {
+  name: "matrixFromFunction",
+  category: "Matrix",
+  syntax: [
+    "matrixFromFunction(size, fn)",
+    "matrixFromFunction(size, fn, format)",
+    "matrixFromFunction(size, fn, format, datatype)",
+    "matrixFromFunction(size, format, fn)",
+    "matrixFromFunction(size, format, datatype, fn)"
+  ],
+  description: "Create a matrix by evaluating a generating function at each index.",
+  examples: [
+    "f(I) = I[1] - I[2]",
+    "matrixFromFunction([3,3], f)",
+    "g(I) = I[1] - I[2] == 1 ? 4 : 0",
+    'matrixFromFunction([100, 100], "sparse", g)',
+    "matrixFromFunction([5], random)"
+  ],
+  seealso: ["matrix", "matrixFromRows", "matrixFromColumns", "zeros"]
+};
+
+// src/embeddedDocs/function/matrix/matrixFromRows.ts
+var matrixFromRowsDocs = {
+  name: "matrixFromRows",
+  category: "Matrix",
+  syntax: [
+    "matrixFromRows(...arr)",
+    "matrixFromRows(row1, row2)",
+    "matrixFromRows(row1, row2, row3)"
+  ],
+  description: "Create a dense matrix from vectors as individual rows.",
+  examples: ["matrixFromRows([1, 2, 3], [[4],[5],[6]])"],
+  seealso: ["matrix", "matrixFromColumns", "matrixFromFunction", "zeros"]
+};
+
+// src/embeddedDocs/function/matrix/ones.ts
+var onesDocs = {
+  name: "ones",
+  category: "Matrix",
+  syntax: [
+    "ones(m)",
+    "ones(m, n)",
+    "ones(m, n, p, ...)",
+    "ones([m])",
+    "ones([m, n])",
+    "ones([m, n, p, ...])"
+  ],
+  description: "Create a matrix containing ones.",
+  examples: [
+    "ones(3)",
+    "ones(3, 5)",
+    "ones([2,3]) * 4.5",
+    "a = [1, 2, 3; 4, 5, 6]",
+    "ones(size(a))"
+  ],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/partitionSelect.ts
+var partitionSelectDocs = {
+  name: "partitionSelect",
+  category: "Matrix",
+  syntax: ["partitionSelect(x, k)", "partitionSelect(x, k, compare)"],
+  description: "Partition-based selection of an array or 1D matrix. Will find the kth smallest value, and mutates the input array. Uses Quickselect.",
+  examples: [
+    "partitionSelect([5, 10, 1], 2)",
+    'partitionSelect(["C", "B", "A", "D"], 1, compareText)',
+    "arr = [5, 2, 1]",
+    "partitionSelect(arr, 0) # returns 1, arr is now: [1, 2, 5]",
+    "arr",
+    "partitionSelect(arr, 1, 'desc') # returns 2, arr is now: [5, 2, 1]",
+    "arr"
+  ],
+  seealso: ["sort"]
+};
+
+// src/embeddedDocs/function/matrix/range.ts
+var rangeDocs = {
+  name: "range",
+  category: "Type",
+  syntax: [
+    "start:end",
+    "start:step:end",
+    "range(start, end)",
+    "range(start, end, step)",
+    "range(string)"
+  ],
+  description: "Create a range. Lower bound of the range is included, upper bound is excluded.",
+  examples: [
+    "1:5",
+    "3:-1:-3",
+    "range(3, 7)",
+    "range(0, 12, 2)",
+    'range("4:10")',
+    "range(1m, 1m, 3m)",
+    "a = [1, 2, 3, 4; 5, 6, 7, 8]",
+    "a[1:2, 1:2]"
+  ],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/reshape.ts
+var reshapeDocs = {
+  name: "reshape",
+  category: "Matrix",
+  syntax: ["reshape(x, sizes)"],
+  description: "Reshape a multi dimensional array to fit the specified dimensions.",
+  examples: [
+    "reshape([1, 2, 3, 4, 5, 6], [2, 3])",
+    "reshape([[1, 2], [3, 4]], [1, 4])",
+    "reshape([[1, 2], [3, 4]], [4])",
+    "reshape([1, 2, 3, 4], [-1, 2])"
+  ],
+  seealso: ["size", "squeeze", "resize"]
+};
+
+// src/embeddedDocs/function/matrix/resize.ts
+var resizeDocs = {
+  name: "resize",
+  category: "Matrix",
+  syntax: ["resize(x, size)", "resize(x, size, defaultValue)"],
+  description: "Resize a matrix.",
+  examples: [
+    "resize([1,2,3,4,5], [3])",
+    "resize([1,2,3], [5])",
+    "resize([1,2,3], [5], -1)",
+    "resize(2, [2, 3])",
+    'resize("hello", [8], "!")'
+  ],
+  seealso: ["size", "subset", "squeeze", "reshape"]
+};
+
+// src/embeddedDocs/function/matrix/rotate.ts
+var rotateDocs = {
+  name: "rotate",
+  category: "Matrix",
+  syntax: ["rotate(w, theta)", "rotate(w, theta, v)"],
+  description: "Returns a 2-D rotation matrix (2x2) for a given angle (in radians). Returns a 2-D rotation matrix (3x3) of a given angle (in radians) around given axis.",
+  examples: [
+    "rotate([1, 0], pi / 2)",
+    'rotate(matrix([1, 0]), unit("35deg"))',
+    'rotate([1, 0, 0], unit("90deg"), [0, 0, 1])',
+    'rotate(matrix([1, 0, 0]), unit("90deg"), matrix([0, 0, 1]))'
+  ],
+  seealso: ["matrix", "rotationMatrix"]
+};
+
+// src/embeddedDocs/function/matrix/rotationMatrix.ts
+var rotationMatrixDocs = {
+  name: "rotationMatrix",
+  category: "Matrix",
+  syntax: ["rotationMatrix(theta)", "rotationMatrix(theta, v)", "rotationMatrix(theta, v, format)"],
+  description: "Returns a 2-D rotation matrix (2x2) for a given angle (in radians). Returns a 2-D rotation matrix (3x3) of a given angle (in radians) around given axis.",
+  examples: [
+    "rotationMatrix(pi / 2)",
+    'rotationMatrix(unit("45deg"), [0, 0, 1])',
+    'rotationMatrix(1, matrix([0, 0, 1]), "sparse")'
+  ],
+  seealso: ["cos", "sin"]
+};
+
+// src/embeddedDocs/function/matrix/row.ts
+var rowDocs = {
+  name: "row",
+  category: "Matrix",
+  syntax: ["row(x, index)"],
+  description: "Return a row from a matrix or array.",
+  examples: ["A = [[1, 2], [3, 4]]", "row(A, 1)", "row(A, 2)"],
+  seealso: ["column", "matrixFromRows"]
+};
+
+// src/embeddedDocs/function/matrix/size.ts
+var sizeDocs = {
+  name: "size",
+  category: "Matrix",
+  syntax: ["size(x)"],
+  description: "Calculate the size of a matrix.",
+  examples: ["size(2.3)", 'size("hello world")', "a = [1, 2; 3, 4; 5, 6]", "size(a)", "size(1:6)"],
+  seealso: [
+    "concat",
+    "count",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/sort.ts
+var sortDocs = {
+  name: "sort",
+  category: "Matrix",
+  syntax: ["sort(x)", "sort(x, compare)"],
+  description: 'Sort the items in a matrix. Compare can be a string "asc", "desc", "natural", or a custom sort function.',
+  examples: [
+    "sort([5, 10, 1])",
+    'sort(["C", "B", "A", "D"], "natural")',
+    "sortByLength(a, b) = size(a)[1] - size(b)[1]",
+    'sort(["Langdon", "Tom", "Sara"], sortByLength)',
+    'sort(["10", "1", "2"], "natural")'
+  ],
+  seealso: ["map", "filter", "forEach"]
+};
+
+// src/embeddedDocs/function/matrix/squeeze.ts
+var squeezeDocs = {
+  name: "squeeze",
+  category: "Matrix",
+  syntax: ["squeeze(x)"],
+  description: "Remove inner and outer singleton dimensions from a matrix.",
+  examples: ["a = zeros(3,2,1)", "size(squeeze(a))", "b = zeros(1,1,3)", "size(squeeze(b))"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "subset",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/subset.ts
+var subsetDocs = {
+  name: "subset",
+  category: "Matrix",
+  syntax: [
+    "value(index)",
+    "value(index) = replacement",
+    "subset(value, [index])",
+    "subset(value, [index], replacement)"
+  ],
+  description: "Get or set a subset of the entries of a matrix or characters of a string. Indexes are one-based. There should be one index specification for each dimension of the target. Each specification can be a single index, a list of indices, or a range in colon notation `l:u`. In a range, both the lower bound l and upper bound u are included; and if a bound is omitted it defaults to the most extreme valid value. The cartesian product of the indices specified in each dimension determines the target of the operation.",
+  examples: [
+    "d = [1, 2; 3, 4]",
+    "e = []",
+    "e[1, 1:2] = [5, 6]",
+    "e[2, :] = [7, 8]",
+    "f = d * e",
+    "f[2, 1]",
+    "f[:, 1]",
+    "f[[1,2], [1,3]] = [9, 10; 11, 12]",
+    "f"
+  ],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "trace",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/trace.ts
+var traceDocs = {
+  name: "trace",
+  category: "Matrix",
+  syntax: ["trace(A)"],
+  description: "Calculate the trace of a matrix: the sum of the elements on the main diagonal of a square matrix.",
+  examples: ["A = [1, 2, 3; -1, 2, 3; 2, 0, 3]", "trace(A)"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "transpose",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/transpose.ts
+var transposeDocs = {
+  name: "transpose",
+  category: "Matrix",
+  syntax: ["x'", "transpose(x)"],
+  description: "Transpose a matrix",
+  examples: ["a = [1, 2, 3; 4, 5, 6]", "a'", "transpose(a)"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "zeros"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/zeros.ts
+var zerosDocs = {
+  name: "zeros",
+  category: "Matrix",
+  syntax: [
+    "zeros(m)",
+    "zeros(m, n)",
+    "zeros(m, n, p, ...)",
+    "zeros([m])",
+    "zeros([m, n])",
+    "zeros([m, n, p, ...])"
+  ],
+  description: "Create a matrix containing zeros.",
+  examples: ["zeros(3)", "zeros(3, 5)", "a = [1, 2, 3; 4, 5, 6]", "zeros(size(a))"],
+  seealso: [
+    "concat",
+    "det",
+    "diag",
+    "identity",
+    "inv",
+    "ones",
+    "range",
+    "size",
+    "squeeze",
+    "subset",
+    "trace",
+    "transpose"
+  ]
+};
+
+// src/embeddedDocs/function/matrix/fft.ts
+var fftDocs = {
+  name: "fft",
+  category: "Matrix",
+  syntax: ["fft(x)"],
+  description: "Calculate N-dimensional Fourier transform",
+  examples: ["fft([[1, 0], [1, 0]])"],
+  seealso: ["ifft"]
+};
+
+// src/embeddedDocs/function/matrix/ifft.ts
+var ifftDocs = {
+  name: "ifft",
+  category: "Matrix",
+  syntax: ["ifft(x)"],
+  description: "Calculate N-dimensional inverse Fourier transform",
+  examples: ["ifft([[2, 2], [0, 0]])"],
+  seealso: ["fft"]
+};
+
+// src/embeddedDocs/function/probability/bernoulli.ts
+var bernoulliDocs = {
+  name: "bernoulli",
+  category: "Probability",
+  syntax: ["bernoulli(n)"],
+  description: "The nth Bernoulli number",
+  examples: ["bernoulli(4)", "bernoulli(fraction(12))"],
+  seealso: ["combinations", "gamma", "stirlingS2"]
+};
+
+// src/embeddedDocs/function/probability/combinations.ts
+var combinationsDocs = {
+  name: "combinations",
+  category: "Probability",
+  syntax: ["combinations(n, k)"],
+  description: "Compute the number of combinations of n items taken k at a time",
+  examples: ["combinations(7, 5)"],
+  seealso: ["combinationsWithRep", "permutations", "factorial"]
+};
+
+// src/embeddedDocs/function/probability/combinationsWithRep.ts
+var combinationsWithRepDocs = {
+  name: "combinationsWithRep",
+  category: "Probability",
+  syntax: ["combinationsWithRep(n, k)"],
+  description: "Compute the number of combinations of n items taken k at a time with replacements.",
+  examples: ["combinationsWithRep(7, 5)"],
+  seealso: ["combinations", "permutations", "factorial"]
+};
+
+// src/embeddedDocs/function/probability/factorial.ts
+var factorialDocs = {
+  name: "factorial",
+  category: "Probability",
+  syntax: ["n!", "factorial(n)"],
+  description: "Compute the factorial of a value",
+  examples: ["5!", "5 * 4 * 3 * 2 * 1", "3!"],
+  seealso: ["combinations", "combinationsWithRep", "permutations", "gamma"]
+};
+
+// src/embeddedDocs/function/probability/gamma.ts
+var gammaDocs = {
+  name: "gamma",
+  category: "Probability",
+  syntax: ["gamma(n)"],
+  description: "Compute the gamma function. For small values, the Lanczos approximation is used, and for large values the extended Stirling approximation.",
+  examples: ["gamma(4)", "3!", "gamma(1/2)", "sqrt(pi)"],
+  seealso: ["factorial"]
+};
+
+// src/embeddedDocs/function/probability/lgamma.ts
+var lgammaDocs = {
+  name: "lgamma",
+  category: "Probability",
+  syntax: ["lgamma(n)"],
+  description: "Logarithm of the gamma function for real, positive numbers and complex numbers, using Lanczos approximation for numbers and Stirling series for complex numbers.",
+  examples: ["lgamma(4)", "lgamma(1/2)", "lgamma(i)", "lgamma(complex(1.1, 2))"],
+  seealso: ["gamma"]
+};
+
+// src/embeddedDocs/function/probability/kldivergence.ts
+var kldivergenceDocs = {
+  name: "kldivergence",
+  category: "Probability",
+  syntax: ["kldivergence(x, y)"],
+  description: "Calculate the Kullback-Leibler (KL) divergence  between two distributions.",
+  examples: ["kldivergence([0.7,0.5,0.4], [0.2,0.9,0.5])"],
+  seealso: []
+};
+
+// src/embeddedDocs/function/probability/multinomial.ts
+var multinomialDocs = {
+  name: "multinomial",
+  category: "Probability",
+  syntax: ["multinomial(A)"],
+  description: "Multinomial Coefficients compute the number of ways of picking a1, a2, ..., ai unordered outcomes from `n` possibilities. multinomial takes one array of integers as an argument. The following condition must be enforced: every ai > 0.",
+  examples: ["multinomial([1, 2, 1])"],
+  seealso: ["combinations", "factorial"]
+};
+
+// src/embeddedDocs/function/probability/permutations.ts
+var permutationsDocs = {
+  name: "permutations",
+  category: "Probability",
+  syntax: ["permutations(n)", "permutations(n, k)"],
+  description: "Compute the number of permutations of n items taken k at a time",
+  examples: ["permutations(5)", "permutations(5, 3)"],
+  seealso: ["combinations", "combinationsWithRep", "factorial"]
+};
+
+// src/embeddedDocs/function/probability/pickRandom.ts
+var pickRandomDocs = {
+  name: "pickRandom",
+  category: "Probability",
+  syntax: [
+    "pickRandom(array)",
+    "pickRandom(array, number)",
+    "pickRandom(array, weights)",
+    "pickRandom(array, number, weights)",
+    "pickRandom(array, weights, number)"
+  ],
+  description: "Pick a random entry from a given array.",
+  examples: [
+    "pickRandom(0:10)",
+    "pickRandom([1, 3, 1, 6])",
+    "pickRandom([1, 3, 1, 6], 2)",
+    "pickRandom([1, 3, 1, 6], [2, 3, 2, 1])",
+    "pickRandom([1, 3, 1, 6], 2, [2, 3, 2, 1])",
+    "pickRandom([1, 3, 1, 6], [2, 3, 2, 1], 2)"
+  ],
+  seealso: ["random", "randomInt"]
+};
+
+// src/embeddedDocs/function/probability/random.ts
+var randomDocs = {
+  name: "random",
+  category: "Probability",
+  syntax: [
+    "random()",
+    "random(max)",
+    "random(min, max)",
+    "random(size)",
+    "random(size, max)",
+    "random(size, min, max)"
+  ],
+  description: "Return a random number.",
+  examples: ["random()", "random(10, 20)", "random([2, 3])"],
+  seealso: ["pickRandom", "randomInt"]
+};
+
+// src/embeddedDocs/function/probability/randomInt.ts
+var randomIntDocs = {
+  name: "randomInt",
+  category: "Probability",
+  syntax: [
+    "randomInt(max)",
+    "randomInt(min, max)",
+    "randomInt(size)",
+    "randomInt(size, max)",
+    "randomInt(size, min, max)"
+  ],
+  description: "Return a random integer number",
+  examples: ["randomInt(10, 20)", "randomInt([2, 3], 10)"],
+  seealso: ["pickRandom", "random"]
+};
+
+// src/embeddedDocs/function/relational/compare.ts
+var compareDocs = {
+  name: "compare",
+  category: "Relational",
+  syntax: ["compare(x, y)"],
+  description: "Compare two values. Returns 1 when x > y, -1 when x < y, and 0 when x == y.",
+  examples: [
+    "compare(2, 3)",
+    "compare(3, 2)",
+    "compare(2, 2)",
+    "compare(5cm, 40mm)",
+    "compare(2, [1, 2, 3])"
+  ],
+  seealso: [
+    "equal",
+    "unequal",
+    "smaller",
+    "smallerEq",
+    "largerEq",
+    "compareNatural",
+    "compareText"
+  ]
+};
+
+// src/embeddedDocs/function/relational/compareNatural.ts
+var compareNaturalDocs = {
+  name: "compareNatural",
+  category: "Relational",
+  syntax: ["compareNatural(x, y)"],
+  description: "Compare two values of any type in a deterministic, natural way. Returns 1 when x > y, -1 when x < y, and 0 when x == y.",
+  examples: [
+    "compareNatural(2, 3)",
+    "compareNatural(3, 2)",
+    "compareNatural(2, 2)",
+    "compareNatural(5cm, 40mm)",
+    'compareNatural("2", "10")',
+    "compareNatural(2 + 3i, 2 + 4i)",
+    "compareNatural([1, 2, 4], [1, 2, 3])",
+    "compareNatural([1, 5], [1, 2, 3])",
+    "compareNatural([1, 2], [1, 2])",
+    "compareNatural({a: 2}, {a: 4})"
+  ],
+  seealso: ["equal", "unequal", "smaller", "smallerEq", "largerEq", "compare", "compareText"]
+};
+
+// src/embeddedDocs/function/relational/compareText.ts
+var compareTextDocs = {
+  name: "compareText",
+  category: "Relational",
+  syntax: ["compareText(x, y)"],
+  description: "Compare two strings lexically. Comparison is case sensitive. Returns 1 when x > y, -1 when x < y, and 0 when x == y.",
+  examples: [
+    'compareText("B", "A")',
+    'compareText("A", "B")',
+    'compareText("A", "A")',
+    'compareText("2", "10")',
+    'compare("2", "10")',
+    "compare(2, 10)",
+    'compareNatural("2", "10")',
+    'compareText("B", ["A", "B", "C"])'
+  ],
+  seealso: ["compare", "compareNatural"]
+};
+
+// src/embeddedDocs/function/relational/deepEqual.ts
+var deepEqualDocs = {
+  name: "deepEqual",
+  category: "Relational",
+  syntax: ["deepEqual(x, y)"],
+  description: "Check equality of two matrices element wise. Returns true if the size of both matrices is equal and when and each of the elements are equal.",
+  examples: ["deepEqual([1,3,4], [1,3,4])", "deepEqual([1,3,4], [1,3])"],
+  seealso: ["equal", "unequal", "smaller", "larger", "smallerEq", "largerEq", "compare"]
+};
+
+// src/embeddedDocs/function/relational/equal.ts
+var equalDocs = {
+  name: "equal",
+  category: "Relational",
+  syntax: ["x == y", "equal(x, y)"],
+  description: "Check equality of two values. Returns true if the values are equal, and false if not.",
+  examples: ["2+2 == 3", "2+2 == 4", "a = 3.2", "b = 6-2.8", "a == b", "50cm == 0.5m"],
+  seealso: [
+    "unequal",
+    "smaller",
+    "larger",
+    "smallerEq",
+    "largerEq",
+    "compare",
+    "deepEqual",
+    "equalText"
+  ]
+};
+
+// src/embeddedDocs/function/relational/equalText.ts
+var equalTextDocs = {
+  name: "equalText",
+  category: "Relational",
+  syntax: ["equalText(x, y)"],
+  description: "Check equality of two strings. Comparison is case sensitive. Returns true if the values are equal, and false if not.",
+  examples: [
+    'equalText("Hello", "Hello")',
+    'equalText("a", "A")',
+    'equal("2e3", "2000")',
+    'equalText("2e3", "2000")',
+    'equalText("B", ["A", "B", "C"])'
+  ],
+  seealso: ["compare", "compareNatural", "compareText", "equal"]
+};
+
+// src/embeddedDocs/function/relational/larger.ts
+var largerDocs = {
+  name: "larger",
+  category: "Relational",
+  syntax: ["x > y", "larger(x, y)"],
+  description: "Check if value x is larger than y. Returns true if x is larger than y, and false if not. Comparing a value with NaN returns false.",
+  examples: ["2 > 3", "5 > 2*2", "a = 3.3", "b = 6-2.8", "(a > b)", "(b < a)", "5 cm > 2 inch"],
+  seealso: ["equal", "unequal", "smaller", "smallerEq", "largerEq", "compare"]
+};
+
+// src/embeddedDocs/function/relational/largerEq.ts
+var largerEqDocs = {
+  name: "largerEq",
+  category: "Relational",
+  syntax: ["x >= y", "largerEq(x, y)"],
+  description: "Check if value x is larger or equal to y. Returns true if x is larger or equal to y, and false if not.",
+  examples: ["2 >= 1+1", "2 > 1+1", "a = 3.2", "b = 6-2.8", "(a >= b)"],
+  seealso: ["equal", "unequal", "smallerEq", "smaller", "compare"]
+};
+
+// src/embeddedDocs/function/relational/smaller.ts
+var smallerDocs = {
+  name: "smaller",
+  category: "Relational",
+  syntax: ["x < y", "smaller(x, y)"],
+  description: "Check if value x is smaller than value y. Returns true if x is smaller than y, and false if not. Comparing a value with NaN returns false.",
+  examples: ["2 < 3", "5 < 2*2", "a = 3.3", "b = 6-2.8", "(a < b)", "5 cm < 2 inch"],
+  seealso: ["equal", "unequal", "larger", "smallerEq", "largerEq", "compare"]
+};
+
+// src/embeddedDocs/function/relational/smallerEq.ts
+var smallerEqDocs = {
+  name: "smallerEq",
+  category: "Relational",
+  syntax: ["x <= y", "smallerEq(x, y)"],
+  description: "Check if value x is smaller or equal to value y. Returns true if x is smaller than y, and false if not.",
+  examples: ["2 <= 1+1", "2 < 1+1", "a = 3.2", "b = 6-2.8", "(a <= b)"],
+  seealso: ["equal", "unequal", "larger", "smaller", "largerEq", "compare"]
+};
+
+// src/embeddedDocs/function/relational/unequal.ts
+var unequalDocs = {
+  name: "unequal",
+  category: "Relational",
+  syntax: ["x != y", "unequal(x, y)"],
+  description: "Check unequality of two values. Returns true if the values are unequal, and false if they are equal.",
+  examples: [
+    "2+2 != 3",
+    "2+2 != 4",
+    "a = 3.2",
+    "b = 6-2.8",
+    "a != b",
+    "50cm != 0.5m",
+    "5 cm != 2 inch"
+  ],
+  seealso: ["equal", "smaller", "larger", "smallerEq", "largerEq", "compare", "deepEqual"]
+};
+
+// src/embeddedDocs/function/set/setCartesian.ts
+var setCartesianDocs = {
+  name: "setCartesian",
+  category: "Set",
+  syntax: ["setCartesian(set1, set2)"],
+  description: "Create the cartesian product of two (multi)sets. Multi-dimension arrays will be converted to single-dimension arrays and the values will be sorted in ascending order before the operation.",
+  examples: ["setCartesian([1, 2], [3, 4])"],
+  seealso: ["setUnion", "setIntersect", "setDifference", "setPowerset"]
+};
+
+// src/embeddedDocs/function/set/setDifference.ts
+var setDifferenceDocs = {
+  name: "setDifference",
+  category: "Set",
+  syntax: ["setDifference(set1, set2)"],
+  description: "Create the difference of two (multi)sets: every element of set1, that is not the element of set2. Multi-dimension arrays will be converted to single-dimension arrays before the operation.",
+  examples: [
+    "setDifference([1, 2, 3, 4], [3, 4, 5, 6])",
+    "setDifference([[1, 2], [3, 4]], [[3, 4], [5, 6]])"
+  ],
+  seealso: ["setUnion", "setIntersect", "setSymDifference"]
+};
+
+// src/embeddedDocs/function/set/setDistinct.ts
+var setDistinctDocs = {
+  name: "setDistinct",
+  category: "Set",
+  syntax: ["setDistinct(set)"],
+  description: "Collect the distinct elements of a multiset. A multi-dimension array will be converted to a single-dimension array before the operation.",
+  examples: ["setDistinct([1, 1, 1, 2, 2, 3])"],
+  seealso: ["setMultiplicity"]
+};
+
+// src/embeddedDocs/function/set/setIntersect.ts
+var setIntersectDocs = {
+  name: "setIntersect",
+  category: "Set",
+  syntax: ["setIntersect(set1, set2)"],
+  description: "Create the intersection of two (multi)sets. Multi-dimension arrays will be converted to single-dimension arrays before the operation.",
+  examples: [
+    "setIntersect([1, 2, 3, 4], [3, 4, 5, 6])",
+    "setIntersect([[1, 2], [3, 4]], [[3, 4], [5, 6]])"
+  ],
+  seealso: ["setUnion", "setDifference"]
+};
+
+// src/embeddedDocs/function/set/setIsSubset.ts
+var setIsSubsetDocs = {
+  name: "setIsSubset",
+  category: "Set",
+  syntax: ["setIsSubset(set1, set2)"],
+  description: "Check whether a (multi)set is a subset of another (multi)set: every element of set1 is the element of set2. Multi-dimension arrays will be converted to single-dimension arrays before the operation.",
+  examples: ["setIsSubset([1, 2], [3, 4, 5, 6])", "setIsSubset([3, 4], [3, 4, 5, 6])"],
+  seealso: ["setUnion", "setIntersect", "setDifference"]
+};
+
+// src/embeddedDocs/function/set/setMultiplicity.ts
+var setMultiplicityDocs = {
+  name: "setMultiplicity",
+  category: "Set",
+  syntax: ["setMultiplicity(element, set)"],
+  description: "Count the multiplicity of an element in a multiset. A multi-dimension array will be converted to a single-dimension array before the operation.",
+  examples: ["setMultiplicity(1, [1, 2, 2, 4])", "setMultiplicity(2, [1, 2, 2, 4])"],
+  seealso: ["setDistinct", "setSize"]
+};
+
+// src/embeddedDocs/function/set/setPowerset.ts
+var setPowersetDocs = {
+  name: "setPowerset",
+  category: "Set",
+  syntax: ["setPowerset(set)"],
+  description: "Create the powerset of a (multi)set: the powerset contains very possible subsets of a (multi)set. A multi-dimension array will be converted to a single-dimension array before the operation.",
+  examples: ["setPowerset([1, 2, 3])"],
+  seealso: ["setCartesian"]
+};
+
+// src/embeddedDocs/function/set/setSize.ts
+var setSizeDocs = {
+  name: "setSize",
+  category: "Set",
+  syntax: ["setSize(set)", "setSize(set, unique)"],
+  description: 'Count the number of elements of a (multi)set. When the second parameter "unique" is true, count only the unique values. A multi-dimension array will be converted to a single-dimension array before the operation.',
+  examples: ["setSize([1, 2, 2, 4])", "setSize([1, 2, 2, 4], true)"],
+  seealso: ["setUnion", "setIntersect", "setDifference"]
+};
+
+// src/embeddedDocs/function/set/setSymDifference.ts
+var setSymDifferenceDocs = {
+  name: "setSymDifference",
+  category: "Set",
+  syntax: ["setSymDifference(set1, set2)"],
+  description: "Create the symmetric difference of two (multi)sets. Multi-dimension arrays will be converted to single-dimension arrays before the operation.",
+  examples: [
+    "setSymDifference([1, 2, 3, 4], [3, 4, 5, 6])",
+    "setSymDifference([[1, 2], [3, 4]], [[3, 4], [5, 6]])"
+  ],
+  seealso: ["setUnion", "setIntersect", "setDifference"]
+};
+
+// src/embeddedDocs/function/set/setUnion.ts
+var setUnionDocs = {
+  name: "setUnion",
+  category: "Set",
+  syntax: ["setUnion(set1, set2)"],
+  description: "Create the union of two (multi)sets. Multi-dimension arrays will be converted to single-dimension arrays before the operation.",
+  examples: [
+    "setUnion([1, 2, 3, 4], [3, 4, 5, 6])",
+    "setUnion([[1, 2], [3, 4]], [[3, 4], [5, 6]])"
+  ],
+  seealso: ["setIntersect", "setDifference"]
+};
+
+// src/embeddedDocs/function/signal/zpk2tf.ts
+var zpk2tfDocs = {
+  name: "zpk2tf",
+  category: "Signal",
+  syntax: ["zpk2tf(z, p, k)"],
+  description: "Compute the transfer function of a zero-pole-gain model.",
+  examples: [
+    "zpk2tf([1, 2], [-1, -2], 1)",
+    "zpk2tf([1, 2], [-1, -2])",
+    "zpk2tf([1 - 3i, 2 + 2i], [-1, -2])"
+  ],
+  seealso: []
+};
+
+// src/embeddedDocs/function/signal/freqz.ts
+var freqzDocs = {
+  name: "freqz",
+  category: "Signal",
+  syntax: ["freqz(b, a)", "freqz(b, a, w)"],
+  description: "Calculates the frequency response of a filter given its numerator and denominator coefficients.",
+  examples: [
+    "freqz([1, 2], [1, 2, 3])",
+    "freqz([1, 2], [1, 2, 3], [0, 1])",
+    "freqz([1, 2], [1, 2, 3], 512)"
+  ],
+  seealso: []
+};
+
+// src/embeddedDocs/function/special/erf.ts
+var erfDocs = {
+  name: "erf",
+  category: "Special",
+  syntax: ["erf(x)"],
+  description: "Compute the erf function of a value using a rational Chebyshev approximations for different intervals of x",
+  examples: ["erf(0.2)", "erf(-0.5)", "erf(4)"],
+  seealso: []
+};
+
+// src/embeddedDocs/function/special/zeta.ts
+var zetaDocs = {
+  name: "zeta",
+  category: "Special",
+  syntax: ["zeta(s)"],
+  description: "Compute the Riemann Zeta Function using an infinite series and Riemann's Functional Equation for the entire complex plane",
+  examples: ["zeta(0.2)", "zeta(-0.5)", "zeta(4)"],
+  seealso: []
+};
+
+// src/embeddedDocs/function/statistics/mad.ts
+var madDocs = {
+  name: "mad",
+  category: "Statistics",
+  syntax: ["mad(a, b, c, ...)", "mad(A)"],
+  description: "Compute the median absolute deviation of a matrix or a list with values. The median absolute deviation is defined as the median of the absolute deviations from the median.",
+  examples: ["mad(10, 20, 30)", "mad([1, 2, 3])"],
+  seealso: ["mean", "median", "std", "abs"]
+};
+
+// src/embeddedDocs/function/statistics/max.ts
+var maxDocs = {
+  name: "max",
+  category: "Statistics",
+  syntax: ["max(a, b, c, ...)", "max(A)", "max(A, dimension)"],
+  description: "Compute the maximum value of a list of values. If any NaN values are found, the function yields the last NaN in the input.",
+  examples: [
+    "max(2, 3, 4, 1)",
+    "max([2, 3, 4, 1])",
+    "max([2, 5; 4, 3])",
+    "max([2, 5; 4, 3], 1)",
+    "max([2, 5; 4, 3], 2)",
+    "max(2.7, 7.1, -4.5, 2.0, 4.1)",
+    "min(2.7, 7.1, -4.5, 2.0, 4.1)"
+  ],
+  seealso: ["mean", "median", "min", "prod", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/mean.ts
+var meanDocs = {
+  name: "mean",
+  category: "Statistics",
+  syntax: ["mean(a, b, c, ...)", "mean(A)", "mean(A, dimension)"],
+  description: "Compute the arithmetic mean of a list of values.",
+  examples: [
+    "mean(2, 3, 4, 1)",
+    "mean([2, 3, 4, 1])",
+    "mean([2, 5; 4, 3])",
+    "mean([2, 5; 4, 3], 1)",
+    "mean([2, 5; 4, 3], 2)",
+    "mean([1.0, 2.7, 3.2, 4.0])"
+  ],
+  seealso: ["max", "median", "min", "prod", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/median.ts
+var medianDocs = {
+  name: "median",
+  category: "Statistics",
+  syntax: ["median(a, b, c, ...)", "median(A)"],
+  description: "Compute the median of all values. The values are sorted and the middle value is returned. In case of an even number of values, the average of the two middle values is returned.",
+  examples: ["median(5, 2, 7)", "median([3, -1, 5, 7])"],
+  seealso: ["max", "mean", "min", "prod", "std", "sum", "variance", "quantileSeq"]
+};
+
+// src/embeddedDocs/function/statistics/min.ts
+var minDocs = {
+  name: "min",
+  category: "Statistics",
+  syntax: ["min(a, b, c, ...)", "min(A)", "min(A, dimension)"],
+  description: "Compute the minimum value of a list of values. If any NaN values are found, the function yields the last NaN in the input.",
+  examples: [
+    "min(2, 3, 4, 1)",
+    "min([2, 3, 4, 1])",
+    "min([2, 5; 4, 3])",
+    "min([2, 5; 4, 3], 1)",
+    "min([2, 5; 4, 3], 2)",
+    "min(2.7, 7.1, -4.5, 2.0, 4.1)",
+    "max(2.7, 7.1, -4.5, 2.0, 4.1)"
+  ],
+  seealso: ["max", "mean", "median", "prod", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/mode.ts
+var modeDocs = {
+  name: "mode",
+  category: "Statistics",
+  syntax: ["mode(a, b, c, ...)", "mode(A)", "mode(A, a, b, B, c, ...)"],
+  description: "Computes the mode of all values as an array. In case mode being more than one, multiple values are returned in an array.",
+  examples: ["mode(2, 1, 4, 3, 1)", "mode([1, 2.7, 3.2, 4, 2.7])", "mode(1, 4, 6, 1, 6)"],
+  seealso: ["max", "mean", "min", "median", "prod", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/prod.ts
+var prodDocs = {
+  name: "prod",
+  category: "Statistics",
+  syntax: ["prod(a, b, c, ...)", "prod(A)"],
+  description: "Compute the product of all values.",
+  examples: ["prod(2, 3, 4)", "prod([2, 3, 4])", "prod([2, 5; 4, 3])"],
+  seealso: ["max", "mean", "min", "median", "min", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/quantileSeq.ts
+var quantileSeqDocs = {
+  name: "quantileSeq",
+  category: "Statistics",
+  syntax: [
+    "quantileSeq(A, prob[, sorted])",
+    "quantileSeq(A, [prob1, prob2, ...][, sorted])",
+    "quantileSeq(A, N[, sorted])"
+  ],
+  description: "Compute the prob order quantile of a matrix or a list with values. The sequence is sorted and the middle value is returned. Supported types of sequence values are: Number, BigNumber, Unit Supported types of probability are: Number, BigNumber. \n\nIn case of a (multi dimensional) array or matrix, the prob order quantile of all elements will be calculated.",
+  examples: [
+    "quantileSeq([3, -1, 5, 7], 0.5)",
+    "quantileSeq([3, -1, 5, 7], [1/3, 2/3])",
+    "quantileSeq([3, -1, 5, 7], 2)",
+    "quantileSeq([-1, 3, 5, 7], 0.5, true)"
+  ],
+  seealso: ["mean", "median", "min", "max", "prod", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/std.ts
+var stdDocs = {
+  name: "std",
+  category: "Statistics",
+  syntax: [
+    "std(a, b, c, ...)",
+    "std(A)",
+    "std(A, dimension)",
+    "std(A, normalization)",
+    "std(A, dimension, normalization)"
+  ],
+  description: 'Compute the standard deviation of all values, defined as std(A) = sqrt(variance(A)). Optional parameter normalization can be "unbiased" (default), "uncorrected", or "biased".',
+  examples: [
+    "std(2, 4, 6)",
+    "std([2, 4, 6, 8])",
+    'std([2, 4, 6, 8], "uncorrected")',
+    'std([2, 4, 6, 8], "biased")',
+    "std([1, 2, 3; 4, 5, 6])"
+  ],
+  seealso: ["max", "mean", "min", "median", "prod", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/cumsum.ts
+var cumSumDocs = {
+  name: "cumsum",
+  category: "Statistics",
+  syntax: ["cumsum(a, b, c, ...)", "cumsum(A)"],
+  description: "Compute the cumulative sum of all values.",
+  examples: [
+    "cumsum(2, 3, 4, 1)",
+    "cumsum([2, 3, 4, 1])",
+    "cumsum([1, 2; 3, 4])",
+    "cumsum([1, 2; 3, 4], 1)",
+    "cumsum([1, 2; 3, 4], 2)"
+  ],
+  seealso: ["max", "mean", "median", "min", "prod", "std", "sum", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/sum.ts
+var sumDocs = {
+  name: "sum",
+  category: "Statistics",
+  syntax: ["sum(a, b, c, ...)", "sum(A)", "sum(A, dimension)"],
+  description: "Compute the sum of all values.",
+  examples: ["sum(2, 3, 4, 1)", "sum([2, 3, 4, 1])", "sum([2, 5; 4, 3])"],
+  seealso: ["max", "mean", "median", "min", "prod", "std", "variance"]
+};
+
+// src/embeddedDocs/function/statistics/variance.ts
+var varianceDocs = {
+  name: "variance",
+  category: "Statistics",
+  syntax: [
+    "variance(a, b, c, ...)",
+    "variance(A)",
+    "variance(A, dimension)",
+    "variance(A, normalization)",
+    "variance(A, dimension, normalization)"
+  ],
+  description: 'Compute the variance of all values. Optional parameter normalization can be "unbiased" (default), "uncorrected", or "biased".',
+  examples: [
+    "variance(2, 4, 6)",
+    "variance([2, 4, 6, 8])",
+    'variance([2, 4, 6, 8], "uncorrected")',
+    'variance([2, 4, 6, 8], "biased")',
+    "variance([1, 2, 3; 4, 5, 6])"
+  ],
+  seealso: ["max", "mean", "min", "median", "min", "prod", "std", "sum"]
+};
+
+// src/embeddedDocs/function/statistics/corr.ts
+var corrDocs = {
+  name: "corr",
+  category: "Statistics",
+  syntax: ["corr(A,B)"],
+  description: "Compute the correlation coefficient of a two list with values, For matrices, the matrix correlation coefficient is calculated.",
+  examples: [
+    "corr([2, 4, 6, 8],[1, 2, 3, 6])",
+    "corr(matrix([[1, 2.2, 3, 4.8, 5], [1, 2, 3, 4, 5]]), matrix([[4, 5.3, 6.6, 7, 8], [1, 2, 3, 4, 5]]))"
+  ],
+  seealso: ["max", "mean", "min", "median", "min", "prod", "std", "sum"]
+};
+
+// src/embeddedDocs/function/trigonometry/acos.ts
+var acosDocs = {
+  name: "acos",
+  category: "Trigonometry",
+  syntax: ["acos(x)"],
+  description: "Compute the inverse cosine of a value in radians.",
+  examples: ["acos(0.5)", "acos(cos(2.3))"],
+  seealso: ["cos", "atan", "asin"]
+};
+
+// src/embeddedDocs/function/trigonometry/acosh.ts
+var acoshDocs = {
+  name: "acosh",
+  category: "Trigonometry",
+  syntax: ["acosh(x)"],
+  description: "Calculate the hyperbolic arccos of a value, defined as `acosh(x) = ln(sqrt(x^2 - 1) + x)`.",
+  examples: ["acosh(1.5)"],
+  seealso: ["cosh", "asinh", "atanh"]
+};
+
+// src/embeddedDocs/function/trigonometry/acot.ts
+var acotDocs = {
+  name: "acot",
+  category: "Trigonometry",
+  syntax: ["acot(x)"],
+  description: "Calculate the inverse cotangent of a value.",
+  examples: ["acot(0.5)", "acot(cot(0.5))", "acot(2)"],
+  seealso: ["cot", "atan"]
+};
+
+// src/embeddedDocs/function/trigonometry/acoth.ts
+var acothDocs = {
+  name: "acoth",
+  category: "Trigonometry",
+  syntax: ["acoth(x)"],
+  description: "Calculate the inverse hyperbolic tangent of a value, defined as `acoth(x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.",
+  examples: ["acoth(2)", "acoth(0.5)"],
+  seealso: ["acsch", "asech"]
+};
+
+// src/embeddedDocs/function/trigonometry/acsc.ts
+var acscDocs = {
+  name: "acsc",
+  category: "Trigonometry",
+  syntax: ["acsc(x)"],
+  description: "Calculate the inverse cotangent of a value.",
+  examples: ["acsc(2)", "acsc(csc(0.5))", "acsc(0.5)"],
+  seealso: ["csc", "asin", "asec"]
+};
+
+// src/embeddedDocs/function/trigonometry/acsch.ts
+var acschDocs = {
+  name: "acsch",
+  category: "Trigonometry",
+  syntax: ["acsch(x)"],
+  description: "Calculate the inverse hyperbolic cosecant of a value, defined as `acsch(x) = ln(1/x + sqrt(1/x^2 + 1))`.",
+  examples: ["acsch(0.5)"],
+  seealso: ["asech", "acoth"]
+};
+
+// src/embeddedDocs/function/trigonometry/asec.ts
+var asecDocs = {
+  name: "asec",
+  category: "Trigonometry",
+  syntax: ["asec(x)"],
+  description: "Calculate the inverse secant of a value.",
+  examples: ["asec(0.5)", "asec(sec(0.5))", "asec(2)"],
+  seealso: ["acos", "acot", "acsc"]
+};
+
+// src/embeddedDocs/function/trigonometry/asech.ts
+var asechDocs = {
+  name: "asech",
+  category: "Trigonometry",
+  syntax: ["asech(x)"],
+  description: "Calculate the inverse secant of a value.",
+  examples: ["asech(0.5)"],
+  seealso: ["acsch", "acoth"]
+};
+
+// src/embeddedDocs/function/trigonometry/asin.ts
+var asinDocs = {
+  name: "asin",
+  category: "Trigonometry",
+  syntax: ["asin(x)"],
+  description: "Compute the inverse sine of a value in radians.",
+  examples: ["asin(0.5)", "asin(sin(0.5))"],
+  seealso: ["sin", "acos", "atan"]
+};
+
+// src/embeddedDocs/function/trigonometry/asinh.ts
+var asinhDocs = {
+  name: "asinh",
+  category: "Trigonometry",
+  syntax: ["asinh(x)"],
+  description: "Calculate the hyperbolic arcsine of a value, defined as `asinh(x) = ln(x + sqrt(x^2 + 1))`.",
+  examples: ["asinh(0.5)"],
+  seealso: ["acosh", "atanh"]
+};
+
+// src/embeddedDocs/function/trigonometry/atan.ts
+var atanDocs = {
+  name: "atan",
+  category: "Trigonometry",
+  syntax: ["atan(x)"],
+  description: "Compute the inverse tangent of a value in radians.",
+  examples: ["atan(0.5)", "atan(tan(0.5))"],
+  seealso: ["tan", "acos", "asin"]
+};
+
+// src/embeddedDocs/function/trigonometry/atan2.ts
+var atan2Docs = {
+  name: "atan2",
+  category: "Trigonometry",
+  syntax: ["atan2(y, x)"],
+  description: "Computes the principal value of the arc tangent of y/x in radians.",
+  examples: [
+    "atan2(2, 2) / pi",
+    "angle = 60 deg in rad",
+    "x = cos(angle)",
+    "y = sin(angle)",
+    "atan2(y, x)"
+  ],
+  seealso: ["sin", "cos", "tan"]
+};
+
+// src/embeddedDocs/function/trigonometry/atanh.ts
+var atanhDocs = {
+  name: "atanh",
+  category: "Trigonometry",
+  syntax: ["atanh(x)"],
+  description: "Calculate the hyperbolic arctangent of a value, defined as `atanh(x) = ln((1 + x)/(1 - x)) / 2`.",
+  examples: ["atanh(0.5)"],
+  seealso: ["acosh", "asinh"]
+};
+
+// src/embeddedDocs/function/trigonometry/cos.ts
+var cosDocs = {
+  name: "cos",
+  category: "Trigonometry",
+  syntax: ["cos(x)"],
+  description: "Compute the cosine of x in radians.",
+  examples: ["cos(2)", "cos(pi / 4) ^ 2", "cos(180 deg)", "cos(60 deg)", "sin(0.2)^2 + cos(0.2)^2"],
+  seealso: ["acos", "sin", "tan"]
+};
+
+// src/embeddedDocs/function/trigonometry/cosh.ts
+var coshDocs = {
+  name: "cosh",
+  category: "Trigonometry",
+  syntax: ["cosh(x)"],
+  description: "Compute the hyperbolic cosine of x in radians.",
+  examples: ["cosh(0.5)"],
+  seealso: ["sinh", "tanh", "coth"]
+};
+
+// src/embeddedDocs/function/trigonometry/cot.ts
+var cotDocs = {
+  name: "cot",
+  category: "Trigonometry",
+  syntax: ["cot(x)"],
+  description: "Compute the cotangent of x in radians. Defined as 1/tan(x)",
+  examples: ["cot(2)", "1 / tan(2)"],
+  seealso: ["sec", "csc", "tan"]
+};
+
+// src/embeddedDocs/function/trigonometry/coth.ts
+var cothDocs = {
+  name: "coth",
+  category: "Trigonometry",
+  syntax: ["coth(x)"],
+  description: "Compute the hyperbolic cotangent of x in radians.",
+  examples: ["coth(2)", "1 / tanh(2)"],
+  seealso: ["sech", "csch", "tanh"]
+};
+
+// src/embeddedDocs/function/trigonometry/csc.ts
+var cscDocs = {
+  name: "csc",
+  category: "Trigonometry",
+  syntax: ["csc(x)"],
+  description: "Compute the cosecant of x in radians. Defined as 1/sin(x)",
+  examples: ["csc(2)", "1 / sin(2)"],
+  seealso: ["sec", "cot", "sin"]
+};
+
+// src/embeddedDocs/function/trigonometry/csch.ts
+var cschDocs = {
+  name: "csch",
+  category: "Trigonometry",
+  syntax: ["csch(x)"],
+  description: "Compute the hyperbolic cosecant of x in radians. Defined as 1/sinh(x)",
+  examples: ["csch(2)", "1 / sinh(2)"],
+  seealso: ["sech", "coth", "sinh"]
+};
+
+// src/embeddedDocs/function/trigonometry/sec.ts
+var secDocs = {
+  name: "sec",
+  category: "Trigonometry",
+  syntax: ["sec(x)"],
+  description: "Compute the secant of x in radians. Defined as 1/cos(x)",
+  examples: ["sec(2)", "1 / cos(2)"],
+  seealso: ["cot", "csc", "cos"]
+};
+
+// src/embeddedDocs/function/trigonometry/sech.ts
+var sechDocs = {
+  name: "sech",
+  category: "Trigonometry",
+  syntax: ["sech(x)"],
+  description: "Compute the hyperbolic secant of x in radians. Defined as 1/cosh(x)",
+  examples: ["sech(2)", "1 / cosh(2)"],
+  seealso: ["coth", "csch", "cosh"]
+};
+
+// src/embeddedDocs/function/trigonometry/sin.ts
+var sinDocs = {
+  name: "sin",
+  category: "Trigonometry",
+  syntax: ["sin(x)"],
+  description: "Compute the sine of x in radians.",
+  examples: ["sin(2)", "sin(pi / 4) ^ 2", "sin(90 deg)", "sin(30 deg)", "sin(0.2)^2 + cos(0.2)^2"],
+  seealso: ["asin", "cos", "tan"]
+};
+
+// src/embeddedDocs/function/trigonometry/sinh.ts
+var sinhDocs = {
+  name: "sinh",
+  category: "Trigonometry",
+  syntax: ["sinh(x)"],
+  description: "Compute the hyperbolic sine of x in radians.",
+  examples: ["sinh(0.5)"],
+  seealso: ["cosh", "tanh"]
+};
+
+// src/embeddedDocs/function/trigonometry/tan.ts
+var tanDocs = {
+  name: "tan",
+  category: "Trigonometry",
+  syntax: ["tan(x)"],
+  description: "Compute the tangent of x in radians.",
+  examples: ["tan(0.5)", "sin(0.5) / cos(0.5)", "tan(pi / 4)", "tan(45 deg)"],
+  seealso: ["atan", "sin", "cos"]
+};
+
+// src/embeddedDocs/function/trigonometry/tanh.ts
+var tanhDocs = {
+  name: "tanh",
+  category: "Trigonometry",
+  syntax: ["tanh(x)"],
+  description: "Compute the hyperbolic tangent of x in radians.",
+  examples: ["tanh(0.5)", "sinh(0.5) / cosh(0.5)"],
+  seealso: ["sinh", "cosh"]
+};
+
+// src/embeddedDocs/function/units/to.ts
+var toDocs = {
+  name: "to",
+  category: "Units",
+  syntax: ["x to unit", "to(x, unit)"],
+  description: "Change the unit of a value.",
+  examples: ["5 inch to cm", "3.2kg to g", "16 bytes in bits"],
+  seealso: []
+};
+
+// src/embeddedDocs/function/units/toBest.ts
+var toBestDocs = {
+  name: "toBest",
+  category: "Units",
+  syntax: ["toBest(x)", "toBest(x, unitList)", "toBest(x, unitList, options)"],
+  description: "Converts to the most appropriate display unit.",
+  examples: [
+    'toBest(unit(5000, "m"))',
+    'toBest(unit(3500000, "W"))',
+    'toBest(unit(0.000000123, "A"))',
+    'toBest(unit(10, "m"), "cm")',
+    'toBest(unit(10, "m"), "mm,km", {offset: 1.5})'
+  ],
+  seealso: []
+};
+
+// src/embeddedDocs/function/utils/bin.ts
+var binDocs = {
+  name: "bin",
+  category: "Utils",
+  syntax: ["bin(value)"],
+  description: "Format a number as binary",
+  examples: ["bin(2)"],
+  seealso: ["oct", "hex"]
+};
+
+// src/embeddedDocs/function/utils/clone.ts
+var cloneDocs = {
+  name: "clone",
+  category: "Utils",
+  syntax: ["clone(x)"],
+  description: "Clone a variable. Creates a copy of primitive variables, and a deep copy of matrices",
+  examples: [
+    "clone(3.5)",
+    "clone(2 - 4i)",
+    "clone(45 deg)",
+    "clone([1, 2; 3, 4])",
+    'clone("hello world")'
+  ],
+  seealso: []
+};
+
+// src/embeddedDocs/function/utils/format.ts
+var formatDocs = {
+  name: "format",
+  category: "Utils",
+  syntax: ["format(value)", "format(value, precision)"],
+  description: "Format a value of any type as string.",
+  examples: ["format(2.3)", "format(3 - 4i)", "format([])", "format(pi, 3)"],
+  seealso: ["print"]
+};
+
+// src/embeddedDocs/function/utils/hasNumericValue.ts
+var hasNumericValueDocs = {
+  name: "hasNumericValue",
+  category: "Utils",
+  syntax: ["hasNumericValue(x)"],
+  description: "Test whether a value is an numeric value. In case of a string, true is returned if the string contains a numeric value.",
+  examples: [
+    "hasNumericValue(2)",
+    'hasNumericValue("2")',
+    'isNumeric("2")',
+    "hasNumericValue(0)",
+    "hasNumericValue(bignumber(500))",
+    "hasNumericValue(fraction(0.125))",
+    "hasNumericValue(2 + 3i)",
+    'hasNumericValue([2.3, "foo", false])'
+  ],
+  seealso: ["isInteger", "isZero", "isNegative", "isPositive", "isNaN", "isNumeric"]
+};
+
+// src/embeddedDocs/function/utils/hex.ts
+var hexDocs = {
+  name: "hex",
+  category: "Utils",
+  syntax: ["hex(value)"],
+  description: "Format a number as hexadecimal",
+  examples: ["hex(240)"],
+  seealso: ["bin", "oct"]
+};
+
+// src/embeddedDocs/function/utils/isInteger.ts
+var isIntegerDocs = {
+  name: "isInteger",
+  category: "Utils",
+  syntax: ["isInteger(x)"],
+  description: "Test whether a value is an integer number.",
+  examples: ["isInteger(2)", "isInteger(3.5)", "isInteger([3, 0.5, -2])"],
+  seealso: ["isNegative", "isNumeric", "isPositive", "isZero"]
+};
+
+// src/embeddedDocs/function/utils/isNaN.ts
+var isNaNDocs = {
+  name: "isNaN",
+  category: "Utils",
+  syntax: ["isNaN(x)"],
+  description: "Test whether a value is NaN (not a number)",
+  examples: ["isNaN(2)", "isNaN(0 / 0)", "isNaN(NaN)", "isNaN(Infinity)"],
+  seealso: ["isNegative", "isNumeric", "isPositive", "isZero", "isFinite", "isBounded"]
+};
+
+// src/embeddedDocs/function/utils/isBounded.ts
+var isBoundedDocs = {
+  name: "isBounded",
+  category: "Utils",
+  syntax: ["isBounded(x)"],
+  description: "Test whether a value or its entries are bounded.",
+  examples: ["isBounded(Infinity)", "isBounded(bigint(3))", "isBounded([3, -Infinity, -3])"],
+  seealso: ["isFinite", "isNumeric", "isNaN", "isNegative", "isPositive"]
+};
+
+// src/embeddedDocs/function/utils/isFinite.ts
+var isFiniteDocs = {
+  name: "isFinite",
+  category: "Utils",
+  syntax: ["isFinite(x)"],
+  description: "Test whether a value is finite, elementwise on collections.",
+  examples: ["isFinite(Infinity)", "isFinite(bigint(3))", "isFinite([3, -Infinity, -3])"],
+  seealso: ["isBounded", "isNumeric", "isNaN", "isNegative", "isPositive"]
+};
+
+// src/embeddedDocs/function/utils/isNegative.ts
+var isNegativeDocs = {
+  name: "isNegative",
+  category: "Utils",
+  syntax: ["isNegative(x)"],
+  description: "Test whether a value is negative: smaller than zero.",
+  examples: ["isNegative(2)", "isNegative(0)", "isNegative(-4)", "isNegative([3, 0.5, -2])"],
+  seealso: ["isInteger", "isNumeric", "isPositive", "isZero"]
+};
+
+// src/embeddedDocs/function/utils/isNumeric.ts
+var isNumericDocs = {
+  name: "isNumeric",
+  category: "Utils",
+  syntax: ["isNumeric(x)"],
+  description: "Test whether a value is a numeric value. Returns true when the input is a number, BigNumber, Fraction, or boolean.",
+  examples: [
+    "isNumeric(2)",
+    'isNumeric("2")',
+    'hasNumericValue("2")',
+    "isNumeric(0)",
+    "isNumeric(bignumber(500))",
+    "isNumeric(fraction(0.125))",
+    "isNumeric(2 + 3i)",
+    'isNumeric([2.3, "foo", false])'
+  ],
+  seealso: [
+    "isInteger",
+    "isZero",
+    "isNegative",
+    "isPositive",
+    "isNaN",
+    "hasNumericValue",
+    "isFinite",
+    "isBounded"
+  ]
+};
+
+// src/embeddedDocs/function/utils/isPositive.ts
+var isPositiveDocs = {
+  name: "isPositive",
+  category: "Utils",
+  syntax: ["isPositive(x)"],
+  description: "Test whether a value is positive: larger than zero.",
+  examples: ["isPositive(2)", "isPositive(0)", "isPositive(-4)", "isPositive([3, 0.5, -2])"],
+  seealso: ["isInteger", "isNumeric", "isNegative", "isZero"]
+};
+
+// src/embeddedDocs/function/utils/isPrime.ts
+var isPrimeDocs = {
+  name: "isPrime",
+  category: "Utils",
+  syntax: ["isPrime(x)"],
+  description: "Test whether a value is prime: has no divisors other than itself and one.",
+  examples: ["isPrime(3)", "isPrime(-2)", "isPrime([2, 17, 100])"],
+  seealso: ["isInteger", "isNumeric", "isNegative", "isZero"]
+};
+
+// src/embeddedDocs/function/utils/isZero.ts
+var isZeroDocs = {
+  name: "isZero",
+  category: "Utils",
+  syntax: ["isZero(x)"],
+  description: "Test whether a value is zero.",
+  examples: ["isZero(2)", "isZero(0)", "isZero(-4)", "isZero([3, 0, -2, 0])"],
+  seealso: ["isInteger", "isNumeric", "isNegative", "isPositive"]
+};
+
+// src/embeddedDocs/function/utils/numeric.ts
+var numericDocs = {
+  name: "numeric",
+  category: "Utils",
+  syntax: ["numeric(x)"],
+  description: "Convert a numeric input to a specific numeric type: number, BigNumber, bigint, or Fraction.",
+  examples: [
+    'numeric("4")',
+    'numeric("4", "number")',
+    'numeric("4", "bigint")',
+    'numeric("4", "BigNumber")',
+    'numeric("4", "Fraction")',
+    'numeric(4, "Fraction")',
+    'numeric(fraction(2, 5), "number")'
+  ],
+  seealso: ["number", "bigint", "fraction", "bignumber", "string", "format"]
+};
+
+// src/embeddedDocs/function/utils/oct.ts
+var octDocs = {
+  name: "oct",
+  category: "Utils",
+  syntax: ["oct(value)"],
+  description: "Format a number as octal",
+  examples: ["oct(56)"],
+  seealso: ["bin", "hex"]
+};
+
+// src/embeddedDocs/function/utils/print.ts
+var printDocs = {
+  name: "print",
+  category: "Utils",
+  syntax: ["print(template, values)", "print(template, values, precision)"],
+  description: "Interpolate values into a string template.",
+  examples: [
+    'print("Lucy is $age years old", {age: 5})',
+    'print("The value of pi is $pi", {pi: pi}, 3)',
+    'print("Hello, $user.name!", {user: {name: "John"}})',
+    'print("Values: $1, $2, $3", [6, 9, 4])'
+  ],
+  seealso: ["format"]
+};
+
+// src/embeddedDocs/function/utils/typeOf.ts
+var typeOfDocs = {
+  name: "typeOf",
+  category: "Utils",
+  syntax: ["typeOf(x)"],
+  description: "Get the type of a variable.",
+  examples: ["typeOf(3.5)", "typeOf(2 - 4i)", "typeOf(45 deg)", 'typeOf("hello world")'],
+  seealso: ["getMatrixDataType"]
+};
+
+// src/embeddedDocs/function/numeric/solveODE.ts
+var solveODEDocs = {
+  name: "solveODE",
+  category: "Numeric",
+  syntax: ["solveODE(func, tspan, y0)", "solveODE(func, tspan, y0, options)"],
+  description: "Numerical Integration of Ordinary Differential Equations.",
+  examples: [
+    "f(t,y) = y",
+    "tspan = [0, 4]",
+    "solveODE(f, tspan, 1)",
+    "solveODE(f, tspan, [1, 2])",
+    'solveODE(f, tspan, 1, { method:"RK23", maxStep:0.1 })'
+  ],
+  seealso: ["derivative", "simplifyCore"]
+};
+
+// src/embeddedDocs/embeddedDocs.ts
+var embeddedDocs = {
+  // construction functions
+  bignumber: bignumberDocs,
+  bigint: bigintDocs,
+  boolean: booleanDocs,
+  complex: complexDocs,
+  createUnit: createUnitDocs,
+  fraction: fractionDocs,
+  index: indexDocs,
+  matrix: matrixDocs,
+  number: numberDocs,
+  sparse: sparseDocs,
+  splitUnit: splitUnitDocs,
+  string: stringDocs,
+  unit: unitDocs,
+  // constants
+  e: eDocs,
+  E: eDocs,
+  false: falseDocs,
+  i: iDocs,
+  Infinity: InfinityDocs,
+  LN2: LN2Docs,
+  LN10: LN10Docs,
+  LOG2E: LOG2EDocs,
+  LOG10E: LOG10EDocs,
+  NaN: NaNDocs,
+  null: nullDocs,
+  pi: piDocs,
+  PI: piDocs,
+  phi: phiDocs,
+  SQRT1_2: SQRT12Docs,
+  SQRT2: SQRT2Docs,
+  tau: tauDocs,
+  true: trueDocs,
+  version: versionDocs,
+  // physical constants
+  // TODO: more detailed docs for physical constants
+  speedOfLight: { description: "Speed of light in vacuum", examples: ["speedOfLight"] },
+  gravitationConstant: {
+    description: "Newtonian constant of gravitation",
+    examples: ["gravitationConstant"]
+  },
+  planckConstant: { description: "Planck constant", examples: ["planckConstant"] },
+  reducedPlanckConstant: {
+    description: "Reduced Planck constant",
+    examples: ["reducedPlanckConstant"]
+  },
+  magneticConstant: {
+    description: "Magnetic constant (vacuum permeability)",
+    examples: ["magneticConstant"]
+  },
+  electricConstant: {
+    description: "Electric constant (vacuum permeability)",
+    examples: ["electricConstant"]
+  },
+  vacuumImpedance: {
+    description: "Characteristic impedance of vacuum",
+    examples: ["vacuumImpedance"]
+  },
+  coulomb: {
+    description: "Coulomb's constant. Deprecated in favor of coulombConstant",
+    examples: ["coulombConstant"]
+  },
+  coulombConstant: { description: "Coulomb's constant", examples: ["coulombConstant"] },
+  elementaryCharge: { description: "Elementary charge", examples: ["elementaryCharge"] },
+  bohrMagneton: { description: "Bohr magneton", examples: ["bohrMagneton"] },
+  conductanceQuantum: { description: "Conductance quantum", examples: ["conductanceQuantum"] },
+  inverseConductanceQuantum: {
+    description: "Inverse conductance quantum",
+    examples: ["inverseConductanceQuantum"]
+  },
+  // josephson: {description: 'Josephson constant', examples: ['josephson']},
+  magneticFluxQuantum: { description: "Magnetic flux quantum", examples: ["magneticFluxQuantum"] },
+  nuclearMagneton: { description: "Nuclear magneton", examples: ["nuclearMagneton"] },
+  klitzing: { description: "Von Klitzing constant", examples: ["klitzing"] },
+  bohrRadius: { description: "Bohr radius", examples: ["bohrRadius"] },
+  classicalElectronRadius: {
+    description: "Classical electron radius",
+    examples: ["classicalElectronRadius"]
+  },
+  electronMass: { description: "Electron mass", examples: ["electronMass"] },
+  fermiCoupling: { description: "Fermi coupling constant", examples: ["fermiCoupling"] },
+  fineStructure: { description: "Fine-structure constant", examples: ["fineStructure"] },
+  hartreeEnergy: { description: "Hartree energy", examples: ["hartreeEnergy"] },
+  protonMass: { description: "Proton mass", examples: ["protonMass"] },
+  deuteronMass: { description: "Deuteron Mass", examples: ["deuteronMass"] },
+  neutronMass: { description: "Neutron mass", examples: ["neutronMass"] },
+  quantumOfCirculation: {
+    description: "Quantum of circulation",
+    examples: ["quantumOfCirculation"]
+  },
+  rydberg: { description: "Rydberg constant", examples: ["rydberg"] },
+  thomsonCrossSection: { description: "Thomson cross section", examples: ["thomsonCrossSection"] },
+  weakMixingAngle: { description: "Weak mixing angle", examples: ["weakMixingAngle"] },
+  efimovFactor: { description: "Efimov factor", examples: ["efimovFactor"] },
+  atomicMass: { description: "Atomic mass constant", examples: ["atomicMass"] },
+  avogadro: { description: "Avogadro's number", examples: ["avogadro"] },
+  boltzmann: { description: "Boltzmann constant", examples: ["boltzmann"] },
+  faraday: { description: "Faraday constant", examples: ["faraday"] },
+  firstRadiation: { description: "First radiation constant", examples: ["firstRadiation"] },
+  loschmidt: {
+    description: "Loschmidt constant at T=273.15 K and p=101.325 kPa",
+    examples: ["loschmidt"]
+  },
+  gasConstant: { description: "Gas constant", examples: ["gasConstant"] },
+  molarPlanckConstant: { description: "Molar Planck constant", examples: ["molarPlanckConstant"] },
+  molarVolume: {
+    description: "Molar volume of an ideal gas at T=273.15 K and p=101.325 kPa",
+    examples: ["molarVolume"]
+  },
+  sackurTetrode: {
+    description: "Sackur-Tetrode constant at T=1 K and p=101.325 kPa",
+    examples: ["sackurTetrode"]
+  },
+  secondRadiation: { description: "Second radiation constant", examples: ["secondRadiation"] },
+  stefanBoltzmann: { description: "Stefan-Boltzmann constant", examples: ["stefanBoltzmann"] },
+  wienDisplacement: {
+    description: "Wien displacement law constant",
+    examples: ["wienDisplacement"]
+  },
+  // spectralRadiance: {description: 'First radiation constant for spectral radiance', examples: ['spectralRadiance']},
+  molarMass: { description: "Molar mass constant", examples: ["molarMass"] },
+  molarMassC12: { description: "Molar mass constant of carbon-12", examples: ["molarMassC12"] },
+  gravity: {
+    description: "Standard acceleration of gravity (standard acceleration of free-fall on Earth)",
+    examples: ["gravity"]
+  },
+  planckLength: { description: "Planck length", examples: ["planckLength"] },
+  planckMass: { description: "Planck mass", examples: ["planckMass"] },
+  planckTime: { description: "Planck time", examples: ["planckTime"] },
+  planckCharge: { description: "Planck charge", examples: ["planckCharge"] },
+  planckTemperature: { description: "Planck temperature", examples: ["planckTemperature"] },
+  // functions - algebra
+  derivative: derivativeDocs,
+  lsolve: lsolveDocs,
+  lsolveAll: lsolveAllDocs,
+  lup: lupDocs,
+  lusolve: lusolveDocs,
+  leafCount: leafCountDocs,
+  polynomialRoot: polynomialRootDocs,
+  resolve: resolveDocs,
+  simplify: simplifyDocs,
+  simplifyConstant: simplifyConstantDocs,
+  simplifyCore: simplifyCoreDocs,
+  symbolicEqual: symbolicEqualDocs,
+  rationalize: rationalizeDocs,
+  slu: sluDocs,
+  usolve: usolveDocs,
+  usolveAll: usolveAllDocs,
+  qr: qrDocs,
+  // functions - arithmetic
+  abs: absDocs,
+  add: addDocs,
+  cbrt: cbrtDocs,
+  ceil: ceilDocs,
+  cube: cubeDocs,
+  divide: divideDocs,
+  dotDivide: dotDivideDocs,
+  dotMultiply: dotMultiplyDocs,
+  dotPow: dotPowDocs,
+  exp: expDocs,
+  expm: expmDocs,
+  expm1: expm1Docs,
+  fix: fixDocs,
+  floor: floorDocs,
+  gcd: gcdDocs,
+  hypot: hypotDocs,
+  lcm: lcmDocs,
+  log: logDocs,
+  log2: log2Docs,
+  log1p: log1pDocs,
+  log10: log10Docs,
+  mod: modDocs,
+  multiply: multiplyDocs,
+  norm: normDocs,
+  nthRoot: nthRootDocs,
+  nthRoots: nthRootsDocs,
+  pow: powDocs,
+  round: roundDocs,
+  sign: signDocs,
+  sqrt: sqrtDocs,
+  sqrtm: sqrtmDocs,
+  square: squareDocs,
+  subtract: subtractDocs,
+  unaryMinus: unaryMinusDocs,
+  unaryPlus: unaryPlusDocs,
+  xgcd: xgcdDocs,
+  invmod: invmodDocs,
+  // functions - bitwise
+  bitAnd: bitAndDocs,
+  bitNot: bitNotDocs,
+  bitOr: bitOrDocs,
+  bitXor: bitXorDocs,
+  leftShift: leftShiftDocs,
+  rightArithShift: rightArithShiftDocs,
+  rightLogShift: rightLogShiftDocs,
+  // functions - combinatorics
+  bellNumbers: bellNumbersDocs,
+  catalan: catalanDocs,
+  composition: compositionDocs,
+  stirlingS2: stirlingS2Docs,
+  // functions - core
+  config: configDocs,
+  import: importDocs,
+  typed: typedDocs,
+  // functions - complex
+  arg: argDocs,
+  conj: conjDocs,
+  re: reDocs,
+  im: imDocs,
+  // functions - expression
+  evaluate: evaluateDocs,
+  help: helpDocs,
+  parse: parseDocs,
+  parser: parserDocs,
+  compile: compileDocs,
+  // functions - geometry
+  distance: distanceDocs,
+  intersect: intersectDocs,
+  // functions - logical
+  and: andDocs,
+  not: notDocs,
+  nullish: nullishDocs,
+  or: orDocs,
+  xor: xorDocs,
+  // functions - matrix
+  mapSlices: mapSlicesDocs,
+  concat: concatDocs,
+  count: countDocs,
+  cross: crossDocs,
+  column: columnDocs,
+  ctranspose: ctransposeDocs,
+  det: detDocs,
+  diag: diagDocs,
+  diff: diffDocs,
+  dot: dotDocs,
+  getMatrixDataType: getMatrixDataTypeDocs,
+  identity: identityDocs,
+  filter: filterDocs,
+  flatten: flattenDocs,
+  forEach: forEachDocs,
+  inv: invDocs,
+  pinv: pinvDocs,
+  eigs: eigsDocs,
+  kron: kronDocs,
+  matrixFromFunction: matrixFromFunctionDocs,
+  matrixFromRows: matrixFromRowsDocs,
+  matrixFromColumns: matrixFromColumnsDocs,
+  map: mapDocs,
+  ones: onesDocs,
+  partitionSelect: partitionSelectDocs,
+  range: rangeDocs,
+  resize: resizeDocs,
+  reshape: reshapeDocs,
+  rotate: rotateDocs,
+  rotationMatrix: rotationMatrixDocs,
+  row: rowDocs,
+  size: sizeDocs,
+  sort: sortDocs,
+  squeeze: squeezeDocs,
+  subset: subsetDocs,
+  trace: traceDocs,
+  transpose: transposeDocs,
+  zeros: zerosDocs,
+  fft: fftDocs,
+  ifft: ifftDocs,
+  sylvester: sylvesterDocs,
+  schur: schurDocs,
+  lyap: lyapDocs,
+  // functions - numeric
+  solveODE: solveODEDocs,
+  // functions - probability
+  bernoulli: bernoulliDocs,
+  combinations: combinationsDocs,
+  combinationsWithRep: combinationsWithRepDocs,
+  // distribution: distributionDocs,
+  factorial: factorialDocs,
+  gamma: gammaDocs,
+  kldivergence: kldivergenceDocs,
+  lgamma: lgammaDocs,
+  multinomial: multinomialDocs,
+  permutations: permutationsDocs,
+  pickRandom: pickRandomDocs,
+  random: randomDocs,
+  randomInt: randomIntDocs,
+  // functions - relational
+  compare: compareDocs,
+  compareNatural: compareNaturalDocs,
+  compareText: compareTextDocs,
+  deepEqual: deepEqualDocs,
+  equal: equalDocs,
+  equalText: equalTextDocs,
+  larger: largerDocs,
+  largerEq: largerEqDocs,
+  smaller: smallerDocs,
+  smallerEq: smallerEqDocs,
+  unequal: unequalDocs,
+  // functions - set
+  setCartesian: setCartesianDocs,
+  setDifference: setDifferenceDocs,
+  setDistinct: setDistinctDocs,
+  setIntersect: setIntersectDocs,
+  setIsSubset: setIsSubsetDocs,
+  setMultiplicity: setMultiplicityDocs,
+  setPowerset: setPowersetDocs,
+  setSize: setSizeDocs,
+  setSymDifference: setSymDifferenceDocs,
+  setUnion: setUnionDocs,
+  // functions - signal
+  zpk2tf: zpk2tfDocs,
+  freqz: freqzDocs,
+  // functions - special
+  erf: erfDocs,
+  zeta: zetaDocs,
+  // functions - statistics
+  cumsum: cumSumDocs,
+  mad: madDocs,
+  max: maxDocs,
+  mean: meanDocs,
+  median: medianDocs,
+  min: minDocs,
+  mode: modeDocs,
+  prod: prodDocs,
+  quantileSeq: quantileSeqDocs,
+  std: stdDocs,
+  sum: sumDocs,
+  variance: varianceDocs,
+  corr: corrDocs,
+  // functions - trigonometry
+  acos: acosDocs,
+  acosh: acoshDocs,
+  acot: acotDocs,
+  acoth: acothDocs,
+  acsc: acscDocs,
+  acsch: acschDocs,
+  asec: asecDocs,
+  asech: asechDocs,
+  asin: asinDocs,
+  asinh: asinhDocs,
+  atan: atanDocs,
+  atanh: atanhDocs,
+  atan2: atan2Docs,
+  cos: cosDocs,
+  cosh: coshDocs,
+  cot: cotDocs,
+  coth: cothDocs,
+  csc: cscDocs,
+  csch: cschDocs,
+  sec: secDocs,
+  sech: sechDocs,
+  sin: sinDocs,
+  sinh: sinhDocs,
+  tan: tanDocs,
+  tanh: tanhDocs,
+  // functions - units
+  to: toDocs,
+  toBest: toBestDocs,
+  // functions - utils
+  clone: cloneDocs,
+  format: formatDocs,
+  bin: binDocs,
+  oct: octDocs,
+  hex: hexDocs,
+  isNaN: isNaNDocs,
+  isBounded: isBoundedDocs,
+  isFinite: isFiniteDocs,
+  isInteger: isIntegerDocs,
+  isNegative: isNegativeDocs,
+  isNumeric: isNumericDocs,
+  hasNumericValue: hasNumericValueDocs,
+  isPositive: isPositiveDocs,
+  isPrime: isPrimeDocs,
+  isZero: isZeroDocs,
+  print: printDocs,
+  typeOf: typeOfDocs,
+  numeric: numericDocs
+};
+
 // src/compiler/compile.ts
 function compile(node, mathScope) {
   const evalFn = compileNode(node, mathScope, {});
@@ -7861,6 +11585,7 @@ export {
   createRangeNode,
   createRelationalNode,
   createSymbolNode,
+  embeddedDocs,
   escapeMathML,
   getAssociativity,
   getOperator,