nerdamer 1.1.13 → 2.0.0-rc.1

package/output/index.js

@@ -0,0 +1,715 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_json_1 = __importDefault(require("../package.json"));
+const factor_1 = require("./algebra/factor/factor");
+const gcd_1 = require("./algebra/gcd/gcd");
+const groebner_1 = require("./algebra/groebner");
+const partfrac_1 = require("./algebra/partfrac");
+const simplify_1 = require("./algebra/simplify/simplify");
+const utils_1 = require("./algebra/utils");
+const diff_1 = require("./calculus/derivative/diff");
+const fresnel_1 = require("./calculus/fresnel");
+const integrate_1 = require("./calculus/integrate/integrate");
+const ilaplace_1 = require("./calculus/laplace/ilaplace");
+const laplace_1 = require("./calculus/laplace/laplace");
+const limit_1 = require("./calculus/limit/limit");
+const assume_1 = require("./core/classes/assumption/assume");
+const Assumption_1 = require("./core/classes/assumption/Assumption");
+const Collection_1 = require("./core/classes/collection/Collection");
+const Dictionary_1 = require("./core/classes/dictionary/Dictionary");
+const Equation_1 = require("./core/classes/equation/Equation");
+const Expression_1 = require("./core/classes/expression/Expression");
+const shortcuts_1 = require("./core/classes/expression/shortcuts");
+const functions_1 = require("./core/classes/matrix/functions");
+const Matrix_1 = require("./core/classes/matrix/Matrix");
+const utils_2 = require("./core/classes/matrix/utils");
+const constants_1 = require("./core/classes/parser/constants");
+const Parser_1 = require("./core/classes/parser/Parser");
+const scope_1 = require("./core/classes/parser/scripting/scope");
+const functions_2 = require("./core/classes/polynomial/functions");
+const Polynomial_1 = require("./core/classes/polynomial/Polynomial");
+const Rational_1 = require("./core/classes/rational/Rational");
+const ValuesSet_1 = require("./core/classes/valuesSet/ValuesSet");
+const functions_3 = require("./core/classes/vector/functions");
+const Vector_1 = require("./core/classes/vector/Vector");
+const Converter_1 = require("./core/converters/Converter");
+const dispatch_1 = require("./core/dispatch");
+const errors = __importStar(require("./core/errors"));
+const build_1 = require("./core/functions/build");
+const complex_1 = require("./core/functions/complex");
+const expand_1 = require("./core/functions/expand/expand");
+const setFunction_1 = require("./core/functions/setFunction");
+const subst_1 = require("./core/functions/subst");
+const geometry_1 = require("./math/geometry");
+const math_1 = require("./math/math");
+const trig_1 = require("./math/trig");
+const trunc_1 = require("./math/trunc");
+const utils_3 = require("./math/utils");
+const SolutionSet_1 = require("./solve/classes/SolutionSet");
+const solve_1 = require("./solve/solve");
+const solveSystem_1 = require("./solve/solveSystem");
+/**
+ * Adds selected root functions as instance methods without changing the source classes.
+ * Existing class methods win, so a class can keep a more specific implementation.
+ */
+function extendApi(classes, methods, scalarMethods = {}) {
+    for (const cls of classes) {
+        const prototype = cls.prototype;
+        for (const methodName in methods) {
+            // Keep native implementations such as Matrix.expand().
+            if (!(methodName in prototype)) {
+                const method = methods[methodName];
+                Object.defineProperty(prototype, methodName, {
+                    configurable: true,
+                    writable: true,
+                    value: function (...args) {
+                        const apply = (value) => {
+                            let retval;
+                            // Equations are not enumerable, but transformations apply to both sides.
+                            if (Equation_1.Equation.isEquation(value)) {
+                                retval = value.each(e => apply(e));
+                            }
+                            else if (value.isEnumerable) {
+                                // Structured values receive the operation element-wise on a copy.
+                                const enumerable = value;
+                                retval = enumerable.copy().each(e => apply(e));
+                            }
+                            else {
+                                // Scalar expressions can be passed directly to the root function.
+                                retval = method(value, ...args);
+                            }
+                            return retval;
+                        };
+                        return apply(this);
+                    },
+                });
+            }
+        }
+        for (const methodName in scalarMethods) {
+            if (!(methodName in prototype)) {
+                const method = scalarMethods[methodName];
+                Object.defineProperty(prototype, methodName, {
+                    configurable: true,
+                    writable: true,
+                    value: function (...args) {
+                        if (!Expression_1.Expression.isExpression(this)) {
+                            throw new errors.UnexpectedDataType(errors.message('expressionExpected', {
+                                type: constants_1.dataTypes[this.dataType] ?? this.dataType,
+                            }));
+                        }
+                        return method(this, ...args);
+                    },
+                });
+            }
+        }
+    }
+}
+// -----------------------------------------------------------------------------
+// Shared conversion helpers
+// -----------------------------------------------------------------------------
+const latexConverter = new Converter_1.Converter();
+const textConverter = new Converter_1.Converter('text');
+function normalizeTeXOptions(options) {
+    let retval;
+    if (typeof options === 'string') {
+        retval = { decimal: true };
+    }
+    else if (options?.decimals === true && !('decimal' in options)) {
+        retval = { ...options, decimal: true };
+    }
+    else {
+        retval = options;
+    }
+    return retval;
+}
+// -----------------------------------------------------------------------------
+// Main callable API
+// -----------------------------------------------------------------------------
+/**
+ * Parses Nerdamer notation into a supported parser entity.
+ *
+ * The returned runtime type depends on the notation and can be an
+ * {@link Expression}, equation, or structured parser value. Most type-specific methods
+ * still require the corresponding class guard. Full-package methods declared across all
+ * parser results can be called directly; scalar-only methods such as `buildFunction()`
+ * reject structured results at runtime.
+ *
+ * @remarks
+ * Entries in `values` are substituted while parsing and take precedence over
+ * known parser values, including otherwise restricted names. Parser and
+ * registration settings are shared by this module-level Nerdamer instance.
+ *
+ * @param e - Expression-compatible input to parse.
+ * @param values - Optional name-to-value substitutions for this parse.
+ * @returns The parsed {@link ParserEntity}; inspect its runtime type when the
+ * input can produce more than an Expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer('x+2*x+1').text(); 						// '1+3*x'
+ * nerdamer('2*[a, b, 3]').text(); 					// '[2*a, 2*b, 6]'
+ * nerdamer('x+6*y+a', {x: 1, y: 2, a:'t'}).text(); // '13+t'
+ *
+ * // Evaluation allows even restricted variables to be overridden
+ * nerdamer('e+pi', {π: 1, e: 2}).text(); // '2+pi'
+ * ```
+ */
+function nerdamer(e, values) {
+    return Parser_1.Parser.parse(e, values);
+}
+// -----------------------------------------------------------------------------
+// Full-package Expression and Equation methods
+// -----------------------------------------------------------------------------
+/**
+ * Solves this expression for the requested variable.
+ */
+Expression_1.Expression.prototype.solveFor = function (variable) {
+    return (0, solve_1.solve)(this, variable);
+};
+/**
+ * Solves this equation for the requested variable without modifying the equation.
+ *
+ * @param variable - Variable to solve for.
+ * @returns The solver's {@link SolutionSet}.
+ */
+Equation_1.Equation.prototype.solveFor = function (variable) {
+    return (0, solve_1.solve)(this, variable);
+};
+/**
+ * Converts the expression to TeX.
+ */
+Expression_1.Expression.prototype.toTeX = function (options) {
+    return latexConverter.convert(this, normalizeTeXOptions(options));
+};
+/**
+ * Converts the expression to formatted text.
+ */
+Expression_1.Expression.prototype.toText = function () {
+    return textConverter.convert(this);
+};
+/** Legacy TeX conversion alias. */
+Expression_1.Expression.prototype.latex = function (options) {
+    return latexConverter.convert(this, normalizeTeXOptions(options));
+};
+/** Legacy infinity check alias. */
+Expression_1.Expression.prototype.isInfinity = function () {
+    return this.isInf();
+};
+/** Legacy fractional-multiplier check. */
+Expression_1.Expression.prototype.isFraction = function () {
+    return !this.getMultiplier().isInteger();
+};
+/** Legacy integral-presence check. */
+Expression_1.Expression.prototype.hasIntegral = function () {
+    return this.hasFunction('integrate', true);
+};
+/** Legacy equation-building helper. */
+Expression_1.Expression.prototype.equals = function (value) {
+    return new Equation_1.Equation(this, Expression_1.Expression.create(value));
+};
+// -----------------------------------------------------------------------------
+// Parsing and conversion
+// -----------------------------------------------------------------------------
+/**
+ * Formats a parser entity or notation string as TeX or normalized text.
+ *
+ * @param e - Parser entity or notation string to format.
+ * @param type - Output format. Defaults to `'TeX'`.
+ * @returns Formatted text without modifying an entity input.
+ *
+ * @example
+ * ```ts
+ * const f = nerdamer('x^2+1+2*x');
+ * nerdamer.pretty(f, 'text'); 					// 'x^2+2*x+1'
+ * nerdamer.pretty(f, 'TeX'); 					// 'x^{2}+2 \\cdot x+1'
+ * nerdamer.pretty('a*x+b*x^2+cos(x)', 'text'); // 'cos(x)+a*x+b*x^2'
+ * ```
+ */
+nerdamer.pretty = function (e, type = 'TeX') {
+    const converter = type === 'TeX' ? latexConverter : textConverter;
+    return converter.convert(e);
+};
+/**
+ * Parses the supported TeX subset into a Nerdamer parser entity.
+ *
+ * @param TeX - TeX source accepted by {@link Converter.fromTeX}.
+ * @returns The parsed parser entity. Not every TeX construct is supported.
+ *
+ * @example
+ * ```ts
+ * nerdamer.convertFromLaTeX('x^{2}+2 \\cdot x+1').text(); // '1+2*x+x^2'
+ * ```
+ */
+nerdamer.convertFromLaTeX = function (TeX) {
+    return latexConverter.fromTeX(TeX);
+};
+/**
+ * Converts an expression to TeX math markup without requiring the caller to construct a converter.
+ * String input follows the legacy source-preserving path before symbolic normalization;
+ * entity input keeps ordinary structured Converter behavior.
+ *
+ * @param expression - Parser entity or notation string to format.
+ * @param options - Converter formatting options. The legacy `'decimal'`, `'decimals'`,
+ * and `decimals: true` spellings are normalized to the 2.0 `decimal: true` option.
+ * Decimal conversion uses the evaluated Converter path.
+ * @returns TeX math markup generated by the shared converter.
+ */
+nerdamer.convertToTeX = function (expression, options) {
+    let conversionOptions = normalizeTeXOptions(options);
+    if (typeof expression === 'string' && !conversionOptions?.decimal) {
+        conversionOptions = { ...(conversionOptions ?? {}), preserveSource: true };
+    }
+    return latexConverter.convert(expression, conversionOptions);
+};
+/**
+ * Legacy alias for {@link nerdamer.convertToTeX}.
+ *
+ * @deprecated Use {@link nerdamer.convertToTeX} for TeX math output.
+ */
+nerdamer.convertToLaTeX = nerdamer.convertToTeX;
+// -----------------------------------------------------------------------------
+// Configuration and parser state
+// -----------------------------------------------------------------------------
+/**
+ * Registers a symbolic function using the legacy public signature.
+ *
+ * Calls subsequently parsed with `name` substitute their arguments into `body`
+ * in the supplied order. Registration changes shared parser state.
+ *
+ * @param name - Function name.
+ * @param args - Argument names in call order.
+ * @param body - Symbolic function body.
+ * @returns The root `nerdamer` function for chaining.
+ */
+nerdamer.setFunction = function (name, args, body) {
+    (0, setFunction_1.setFunction)({
+        type: 'symbolic',
+        name,
+        argsOrder: args,
+        fn: body,
+    });
+    return nerdamer;
+};
+/**
+ * Registers or removes a parser constant using the legacy public entry point.
+ *
+ * Numeric values are converted to exact rational text before registration so
+ * they do not introduce decimal-formatting intent. The string `'delete'`
+ * removes the constant. Registration changes shared parser state.
+ *
+ * @param name - Constant name.
+ * @param value - Constant value, or `'delete'` to remove it.
+ * @returns The root `nerdamer` function for chaining.
+ */
+nerdamer.setConstant = function (name, value) {
+    let constantValue = value === 'delete' ? '' : String(value);
+    // Legacy setConstant treats numeric values as exact constants rather than
+    // carrying decimal formatting intent into expressions that use them.
+    if (typeof value === 'number') {
+        const rational = Rational_1.Rational.create(String(value));
+        constantValue =
+            rational.denominator === 1n
+                ? String(rational.numerator)
+                : `${rational.numerator}/${rational.denominator}`;
+    }
+    Parser_1.Parser.setConstants({ [name]: constantValue });
+    return nerdamer;
+};
+/**
+ * Returns the current text registered for a parser constant.
+ *
+ * Built-in constants are generated at the active precision before being returned.
+ * As in the legacy API, an unknown constant is reported as the string `'undefined'`.
+ *
+ * @param name - Constant name to read.
+ * @returns The registered constant text.
+ */
+nerdamer.getConstant = function (name) {
+    const constants = constants_1.PARSER_CONSTANTS;
+    const constant = constants[name];
+    return String(typeof constant === 'function' ? constant() : constant);
+};
+/**
+ * Changes one or more shared parser settings.
+ *
+ * The legacy `PRECISION` setting is routed through {@link Parser.setPrecision} so Decimal-backed
+ * calculations and the finite-precision `pi` and `e` constants remain synchronized.
+ *
+ * @param setting - Setting name or settings object accepted by {@link Parser.set}.
+ * @param value - Value used when `setting` is a single name.
+ * @returns The root `nerdamer` function for chaining.
+ */
+nerdamer.set = function (setting, value) {
+    if (setting === 'PRECISION') {
+        Parser_1.Parser.setPrecision(Number(value));
+    }
+    else if (typeof setting === 'object' && 'PRECISION' in setting) {
+        const { PRECISION, ...remainingSettings } = setting;
+        Parser_1.Parser.set(remainingSettings);
+        Parser_1.Parser.setPrecision(Number(PRECISION));
+    }
+    else {
+        Parser_1.Parser.set(setting, value);
+    }
+    return nerdamer;
+};
+/**
+ * Reads the current value of a shared parser setting.
+ *
+ * `PRECISION` mirrors the root setter's special handling and is read from the
+ * shared Rational/Decimal precision. Other settings delegate to the parser.
+ *
+ * @param setting - Parser setting to read.
+ * @returns The setting's current value.
+ */
+nerdamer.get = function (setting) {
+    let retval;
+    if (setting === 'PRECISION') {
+        retval = Parser_1.Parser.getPrecision();
+    }
+    else {
+        retval = Parser_1.Parser.get(setting);
+    }
+    return retval;
+};
+/** Returns a detached snapshot of a registered parser operator. */
+nerdamer.getOperator = function (symbol) {
+    return Parser_1.Parser.getOperator(symbol);
+};
+/** Registers or updates a parser operator and returns the root API for chaining. */
+nerdamer.setOperator = function (operator, action) {
+    Parser_1.Parser.setOperator(operator, action);
+    return nerdamer;
+};
+/** Aliases an existing parser operator and returns the root API for chaining. */
+nerdamer.aliasOperator = function (symbol, alias) {
+    Parser_1.Parser.aliasOperator(symbol, alias);
+    return nerdamer;
+};
+/**
+ * Sets a known parser value. Unlike a constant, a known value can be overridden
+ * by the values object supplied to a parse call.
+ *
+ * @param name - Known-value name.
+ * @param value - Value to assign, or `'delete'` to remove the assignment.
+ * @returns Nothing. This operation changes shared parser state.
+ */
+nerdamer.setVar = function (name, value) {
+    if (value === 'delete') {
+        (0, scope_1.unassign)(name);
+    }
+    else {
+        (0, scope_1.assign)(name, String(value));
+    }
+};
+/**
+ * Clears all known parser values.
+ *
+ * @returns The nerdamer function for chaining.
+ */
+nerdamer.clearVars = function () {
+    for (const name of Object.keys(Parser_1.Parser.KNOWN_VALUES)) {
+        (0, scope_1.unassign)(name);
+    }
+    return nerdamer;
+};
+/**
+ * Returns a snapshot of all known parser values in text or TeX form.
+ *
+ * @param option - Output format. Defaults to `'text'`.
+ * @returns A new record keyed by known-value name.
+ */
+nerdamer.getVars = function (option = 'text') {
+    const converter = option === 'LaTeX' ? latexConverter : textConverter;
+    const retval = {};
+    for (const name of Object.keys(Parser_1.Parser.KNOWN_VALUES)) {
+        retval[name] = converter.convert(Parser_1.Parser.KNOWN_VALUES[name]);
+    }
+    return retval;
+};
+/**
+ * Lists currently registered parser functions by registration level.
+ *
+ * @returns New `user` and `system` name arrays reflecting current shared state.
+ */
+nerdamer.functions = function () {
+    const retval = { user: [], system: [] };
+    for (const x in dispatch_1.mathFunctionRegistry) {
+        const f = dispatch_1.mathFunctionRegistry[x];
+        retval[f.level].push(x);
+    }
+    return retval;
+};
+// -----------------------------------------------------------------------------
+// Root utilities and compatibility namespaces
+// -----------------------------------------------------------------------------
+/** Creates frozen plain-variable Expressions keyed by their requested names. */
+nerdamer.symbols = shortcuts_1.symbols;
+/**
+ * Returns the package version declared by this Nerdamer build.
+ * @returns The semantic version string.
+ *
+ * @example
+ * ```ts
+ * nerdamer.version(); // '2.0.0'
+ * ```
+ */
+nerdamer.version = function () {
+    return package_json_1.default.version;
+};
+/**
+ * Runtime namespace containing Nerdamer's public error constructors.
+ *
+ * Use these constructors for reliable `instanceof` checks when calling the
+ * compatibility root API.
+ */
+nerdamer.errors = errors;
+/**
+ * Compiles an expression into a native JavaScript-number function.
+ *
+ * @remarks
+ * This uses dynamic JavaScript function construction and may be unavailable under
+ * a strict Content Security Policy. It favors native-number throughput over
+ * Nerdamer's exact or arbitrary-precision arithmetic. Scalar function calls are linked
+ * to explicit numerical implementations; symbolic-only or structured operations that
+ * survive to this stage are rejected rather than compiled incorrectly. When `argsArray`
+ * is omitted, variable names are sorted alphabetically.
+ *
+ * Values returned by `nerdamer(...)` also expose `buildFunction()` for convenient
+ * chaining. That form succeeds only when the parsed result is an Expression; structured
+ * results throw {@link core!UnexpectedDataType} instead of compiling their members.
+ *
+ * @param x - Expression to compile.
+ * @param argsArray - Optional argument names in call order.
+ * @returns A numeric function accepting and returning JavaScript numbers.
+ * @throws {@link core!UnsupportedOperationError} If a surviving function has no faithful
+ * JavaScript-number implementation.
+ *
+ * @example
+ * ```ts
+ * nerdamer.buildFunction('x-y')(9, 7);				// 2
+ * nerdamer.buildFunction('x-y', ['y', 'x'])(9, 7);	// -2
+ * nerdamer.buildFunction('erf(x)+2')(9)				// 3
+ * nerdamer('cos(x)').buildFunction(['x'])(0);			// 1
+ * ```
+ */
+nerdamer.buildFunction = build_1.build;
+/**
+ * Compatibility registry of selected Nerdamer constructors and the shared Parser instance.
+ *
+ * @remarks
+ * This registry is retained as a supported compatibility surface for 2.0. Typed code
+ * should prefer the documented package subpaths, which provide domain-specific and advanced
+ * import paths without relying on registry membership.
+ */
+nerdamer.classes = {
+    Expression: Expression_1.Expression,
+    Rational: Rational_1.Rational,
+    Polynomial: Polynomial_1.Polynomial,
+    Matrix: Matrix_1.Matrix,
+    Vector: Vector_1.Vector,
+    Collection: Collection_1.Collection,
+    Converter: Converter_1.Converter,
+    Dictionary: Dictionary_1.Dictionary,
+    ValuesSet: ValuesSet_1.ValuesSet,
+    SolutionSet: SolutionSet_1.SolutionSet,
+    Assumption: Assumption_1.Assumption,
+    Equation: Equation_1.Equation,
+    instance: {
+        Parser: Parser_1.Parser,
+    },
+};
+// -----------------------------------------------------------------------------
+// Mathematical root API
+// -----------------------------------------------------------------------------
+// Trigonometric functions
+nerdamer.cos = trig_1.cos;
+nerdamer.sin = trig_1.sin;
+nerdamer.tan = trig_1.tan;
+nerdamer.acos = trig_1.acos;
+nerdamer.asin = trig_1.asin;
+nerdamer.atan = trig_1.atan;
+nerdamer.arccos = trig_1.acos;
+nerdamer.arcsin = trig_1.asin;
+nerdamer.arctan = trig_1.atan;
+nerdamer.atan2 = trig_1.atan2;
+nerdamer.sec = trig_1.sec;
+nerdamer.csc = trig_1.csc;
+nerdamer.cot = trig_1.cot;
+nerdamer.asec = trig_1.asec;
+nerdamer.acsc = trig_1.acsc;
+nerdamer.acot = trig_1.acot;
+// Hyperbolic functions
+nerdamer.cosh = trig_1.cosh;
+nerdamer.sinh = trig_1.sinh;
+nerdamer.tanh = trig_1.tanh;
+nerdamer.acosh = trig_1.acosh;
+nerdamer.asinh = trig_1.asinh;
+nerdamer.atanh = trig_1.atanh;
+nerdamer.sech = trig_1.sech;
+nerdamer.csch = trig_1.csch;
+nerdamer.coth = trig_1.coth;
+nerdamer.asech = trig_1.asech;
+nerdamer.acsch = trig_1.acsch;
+nerdamer.acoth = trig_1.acoth;
+// Elementary and numeric functions
+nerdamer.log = math_1.log;
+nerdamer.exp = math_1.exp;
+nerdamer.sqrt = math_1.sqrt;
+nerdamer.cbrt = math_1.cbrt;
+nerdamer.nthroot = math_1.nthroot;
+nerdamer.numeric = math_1.numeric;
+nerdamer.abs = math_1.abs;
+nerdamer.sign = math_1.sign;
+nerdamer.min = math_1.min;
+nerdamer.max = math_1.max;
+nerdamer.round = math_1.round;
+nerdamer.floor = math_1.floor;
+nerdamer.ceil = math_1.ceiling;
+nerdamer.trunc = trunc_1.trunc;
+nerdamer.hypot = geometry_1.hypot;
+// Discrete and number-theoretic functions
+nerdamer.fact = math_1.factorial;
+nerdamer.factorial = math_1.factorial;
+nerdamer.dfact = math_1.doubleFactorial;
+nerdamer.dfactorial = math_1.doubleFactorial;
+nerdamer.fib = math_1.fibonacci;
+nerdamer.mod = math_1.mod;
+nerdamer.modInv = math_1.modInv;
+nerdamer.isPrime = utils_3.isprime;
+// Complex functions
+nerdamer.imagpart = complex_1.imagPart;
+nerdamer.realpart = complex_1.realPart;
+nerdamer.polarform = complex_1.polarForm;
+nerdamer.rectform = complex_1.rectForm;
+nerdamer.arg = complex_1.arg;
+nerdamer.conjugate = complex_1.conjugate;
+nerdamer.csgn = complex_1.csgn;
+// Special functions
+nerdamer.gamma = math_1.gamma;
+nerdamer.erf = math_1.erf;
+nerdamer.erfc = math_1.erfc;
+nerdamer.heaviside = math_1.heaviside;
+nerdamer.delta = math_1.dirac;
+nerdamer.Ci = math_1.Ci;
+nerdamer.Chi = math_1.Chi;
+nerdamer.Si = math_1.Si;
+nerdamer.Shi = math_1.Shi;
+nerdamer.Li = math_1.Li;
+nerdamer.Ei = math_1.Ei;
+nerdamer.sinc = math_1.sinc;
+// Symbolic utilities
+nerdamer.contains = math_1.contains;
+nerdamer.subst = subst_1.subst;
+nerdamer.uSub = subst_1.uSub;
+nerdamer.uUnSub = subst_1.uUnSub;
+// Algebra
+nerdamer.expand = expand_1.expand;
+nerdamer.factor = factor_1.factor;
+nerdamer.polyFactors = factor_1.polyFactors;
+nerdamer.completeSquare = utils_1.sqcomp;
+nerdamer.gcd = gcd_1.gcd;
+nerdamer.lcm = gcd_1.lcm;
+nerdamer.partfrac = partfrac_1.partfrac;
+nerdamer.div = functions_2.div;
+nerdamer.divide = functions_2.divide;
+nerdamer.simplify = simplify_1.simplify;
+nerdamer.groebner = groebner_1.groebner;
+// Solvers
+nerdamer.solve = solve_1.solve;
+nerdamer.solveSystem = solveSystem_1.solveSystem;
+nerdamer.solveeqs = solveSystem_1.solveSystem;
+// Calculus
+nerdamer.diff = diff_1.diff;
+nerdamer.integrate = integrate_1.integrate;
+nerdamer.laplace = laplace_1.laplace;
+nerdamer.ilaplace = ilaplace_1.ilaplace;
+nerdamer.ilt = ilaplace_1.ilaplace;
+nerdamer.sum = math_1.sum;
+nerdamer.product = math_1.product;
+nerdamer.limit = limit_1.limit;
+nerdamer.defint = math_1.defint;
+nerdamer.S = fresnel_1.S;
+nerdamer.C = fresnel_1.C;
+// Matrix operations
+nerdamer.matrix = math_1.matrix;
+nerdamer.imatrix = utils_2.imatrix;
+nerdamer.determinant = functions_1.determinant;
+nerdamer.nullspace = functions_1.nullspace;
+// Vector operations
+nerdamer.dot = functions_3.dot;
+nerdamer.cross = functions_3.cross;
+// Polynomial operations
+nerdamer.deg = functions_2.deg;
+nerdamer.content = functions_2.content;
+// Assumptions
+/**
+ * Registers a process-wide numeric interval assumption.
+ *
+ * @remarks
+ * Repeated constraints for a variable are intersected. Assumptions are consulted by
+ * symbolic comparisons and by algorithms that depend on those comparisons. The root
+ * compatibility API uses global state in 2.0; callers that need to clear or inspect it
+ * directly can use the documented assumption-domain functions.
+ */
+nerdamer.assume = assume_1.assume;
+// -----------------------------------------------------------------------------
+// Complete the full-package instance API
+// -----------------------------------------------------------------------------
+//
+// Root functions are exposed as chainable instance methods only after the complete
+// Nerdamer API has been assembled above. Native class methods are left untouched.
+nerdamer.updateAPI = function () {
+    const methods = {
+        diff: nerdamer.diff,
+        expand: nerdamer.expand,
+        factor: nerdamer.factor,
+        integrate: nerdamer.integrate,
+        numeric: nerdamer.numeric,
+        simplify: nerdamer.simplify,
+        subst: nerdamer.subst,
+    };
+    const scalarMethods = {
+        buildFunction: nerdamer.buildFunction,
+    };
+    extendApi([Expression_1.Expression, Matrix_1.Matrix, Vector_1.Vector, Collection_1.Collection, Dictionary_1.Dictionary, ValuesSet_1.ValuesSet, Equation_1.Equation], methods, scalarMethods);
+    return nerdamer;
+};
+nerdamer.updateAPI();
+exports.default = nerdamer;