@danielsimonjr/mathts-core 0.3.1 → 0.4.0

package/dist/internal.d.ts

@@ -0,0 +1,510 @@
+import { b as UnitConstructor, c as UnitDependencies } from './index-qMNYDTSO.js';
+export { A as AccessorNode, d as ArrayNode, e as AssignmentNode, B as BaseUnitDef, f as BigNumber, g as BigNumberConstructor, h as BigNumberValue, j as BlockNode, C as Chain, k as Complex, l as ComplexConstructor, m as ComplexValue, n as ConditionalNode, o as ConstantNode, p as ConverterFn, U as CoreUnit, q as CreateUnitDefObject, r as CreateUnitOptions, D as DenseMatrix, F as Fraction, s as FractionConstructor, t as FractionValue, u as FunctionAssignmentNode, v as FunctionNode, H as Help, I as Index, w as IndexDimension, x as IndexNode, M as Matrix, N as Node, y as Numeric, O as ObjectNode, z as OperatorNode, P as ParenthesisNode, E as ParseOptions, G as PartitionedMap, J as PrefixDef, K as PrefixTable, R as Range, L as RangeNode, Q as RelationalNode, S as ResultSet, T as ScalarBinaryOp, V as ScalarUnaryOp, W as SparseMatrix, X as SubtractScalar, Y as SymbolNode, Z as TypeConverters, _ as Unit, $ as UnitComponent, a0 as UnitConfig, a1 as UnitDef, a2 as UnitFormatOptions, a as UnitInstance, a3 as UnitJSON, a4 as UnitSystem, a5 as UnitSystemEntry, a6 as isAccessorNode, a7 as isArray, a8 as isArrayNode, a9 as isAssignmentNode, aa as isBigInt, ab as isBigNumber, ac as isBlockNode, ad as isBoolean, ae as isChain, af as isCollection, ag as isComplex, ah as isConditionalNode, ai as isConstantNode, aj as isDate, ak as isDenseMatrix, al as isFraction, am as isFunction, an as isFunctionAssignmentNode, ao as isFunctionNode, ap as isHelp, aq as isIndex, ar as isIndexNode, as as isMap, at as isMatrix, au as isNode, av as isNull, aw as isNumber, ax as isObject, ay as isObjectNode, az as isObjectWrappingMap, aA as isOperatorNode, aB as isParenthesisNode, aC as isPartitionedMap, aD as isRange, aE as isRangeNode, aF as isRegExp, aG as isRelationalNode, aH as isResultSet, aI as isSparseMatrix, aJ as isString, aK as isSymbolNode, aL as isUndefined, i as isUnit, aM as rule2Node, aN as typeOf } from './index-qMNYDTSO.js';
+
+/**
+ * Type for a factory function that creates instances
+ */
+interface FactoryFunction<TResult = unknown> {
+    (scope: Record<string, unknown>): TResult;
+    isFactory: true;
+    fn: string;
+    dependencies: string[];
+    meta?: FactoryMeta;
+}
+/**
+ * Meta information that can be attached to a factory
+ */
+interface FactoryMeta {
+    /**
+     * If true, the factory will be recreated when config changes
+     */
+    recreateOnConfigChange?: boolean;
+    /**
+     * If true, this is a lazy factory that should only be created when needed
+     */
+    lazy?: boolean;
+    /**
+     * Additional custom metadata
+     */
+    [key: string]: unknown;
+}
+
+declare const createUnitClass: FactoryFunction<UnitConstructor>;
+
+/** The full dependency bundle for `createUnitClass`. */
+declare const unitDependencies: UnitDependencies;
+
+/**
+ * Split value representation with sign, coefficients, and exponent
+ */
+interface SplitValue {
+    sign: '+' | '-' | '';
+    coefficients: number[];
+    exponent: number;
+}
+/**
+ * Configuration for number type handling
+ */
+interface NumberTypeConfig {
+    number: 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+    numberFallback: 'number' | 'BigNumber';
+}
+/**
+ * Format options for number formatting
+ */
+interface FormatOptions {
+    notation?: 'auto' | 'exponential' | 'fixed' | 'engineering' | 'bin' | 'oct' | 'hex';
+    precision?: number;
+    wordSize?: number;
+    lowerExp?: number;
+    upperExp?: number;
+}
+/**
+ * Normalized format options
+ */
+interface NormalizedFormatOptions {
+    notation: 'auto' | 'exponential' | 'fixed' | 'engineering' | 'bin' | 'oct' | 'hex';
+    precision: number | undefined;
+    wordSize: number | undefined;
+}
+/**
+ * Check if a number is integer
+ * @param value The value to check
+ * @return true if value is an integer
+ */
+declare function isInteger(value: number | boolean): boolean;
+/**
+ * Ensure the number type is compatible with the provided value.
+ * If not, return 'number' instead.
+ *
+ * For example:
+ *
+ *     safeNumberType('2.3', { number: 'bigint', numberFallback: 'number' })
+ *
+ * will return 'number' and not 'bigint' because trying to create a bigint with
+ * value 2.3 would throw an exception.
+ *
+ * @param numberStr The number as a string
+ * @param config    Configuration with number type preferences
+ * @returns The safe number type to use
+ */
+declare function safeNumberType(numberStr: string, config: NumberTypeConfig): 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+/**
+ * Calculate the sign of a number
+ * @param x The number
+ * @returns 1 for positive, -1 for negative, 0 for zero
+ */
+declare const sign: (x: number) => number;
+/**
+ * Calculate the base-2 logarithm of a number
+ * @param x The number
+ * @returns The base-2 logarithm
+ */
+declare const log2: (x: number) => number;
+/**
+ * Calculate the base-10 logarithm of a number
+ * @param x The number
+ * @returns The base-10 logarithm
+ */
+declare const log10: (x: number) => number;
+/**
+ * Calculate the natural logarithm of a number + 1
+ * @param x The number
+ * @returns ln(x + 1)
+ */
+declare const log1p: (x: number) => number;
+/**
+ * Calculate cubic root for a number
+ *
+ * Code from es6-shim.js:
+ *   https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1564-L1577
+ *
+ * @param x The number
+ * @returns The cubic root of x
+ */
+declare const cbrt: (x: number) => number;
+/**
+ * Calculates exponentiation minus 1
+ * @param x The exponent
+ * @return exp(x) - 1
+ */
+declare const expm1: (x: number) => number;
+/**
+ * Convert a number to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'engineering'    Always use engineering notation.
+ *                                          For example '123.4e+0' and '14.0e+6'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lowerExp` and `upperExp` bounds, and
+ *                                          uses exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default,
+ *                                          not rounding any digits.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12.071, {notation: 'fixed'})                // '12'
+ *    format(2.3,    {notation: 'fixed', precision: 2})  // '2.30'
+ *    format(52.8,   {notation: 'exponential'})          // '5.28e+1'
+ *    format(12345678, {notation: 'engineering'})        // '12.345678e+6'
+ *
+ * @param value   The number to format
+ * @param options Optional formatting options or custom formatter function or precision
+ * @return The formatted value
+ */
+declare function format(value: number, options?: FormatOptions | ((value: number) => string) | number): string;
+/**
+ * Normalize format options into an object:
+ *   {
+ *     notation: string,
+ *     precision: number | undefined,
+ *     wordSize: number | undefined
+ *   }
+ * @param options The input options
+ * @returns Normalized format options
+ */
+declare function normalizeFormatOptions(options?: FormatOptions | number): NormalizedFormatOptions;
+/**
+ * Split a number into sign, coefficients, and exponent
+ * @param value The number or string to split
+ * @return Object containing sign, coefficients, and exponent
+ */
+declare function splitNumber(value: number | string): SplitValue;
+/**
+ * Format a number in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param value     The number or string to format
+ * @param precision Optional number of significant figures to return
+ * @returns The formatted string
+ */
+declare function toEngineering(value: number | string, precision?: number): string;
+/**
+ * Format a number with fixed notation.
+ * @param value     The number or string to format
+ * @param precision Optional number of decimals after the decimal point
+ * @returns The formatted string
+ */
+declare function toFixed(value: number | string, precision?: number): string;
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param value     The number or string to format
+ * @param precision Number of digits in formatted output
+ * @returns The formatted string
+ */
+declare function toExponential(value: number | string, precision?: number): string;
+/**
+ * Format a number with a certain precision
+ * @param value     The number or string to format
+ * @param precision Optional number of digits
+ * @param options   Optional formatting options (lowerExp, upperExp)
+ * @return The formatted string
+ */
+declare function toPrecision(value: number | string, precision?: number, options?: FormatOptions): string;
+/**
+ * Round the number of digits of a number
+ * @param split     A value split with .splitNumber(value)
+ * @param precision A positive integer
+ * @return Object containing sign, coefficients, and exponent with rounded digits
+ */
+declare function roundDigits(split: SplitValue, precision?: number): SplitValue;
+/**
+ * Count the number of significant digits of a number.
+ *
+ * For example:
+ *   2.34 returns 3
+ *   0.0034 returns 2
+ *   120.5e+30 returns 4
+ *
+ * @param value The number
+ * @return Number of significant digits
+ */
+declare function digits(value: number): number;
+/**
+ * Compares two floating point numbers.
+ * @param a      First value to compare
+ * @param b      Second value to compare
+ * @param relTol The relative tolerance, indicating the maximum allowed difference relative to the larger absolute value. Must be greater than 0.
+ * @param absTol The minimum absolute tolerance, useful for comparisons near zero. Must be at least 0.
+ * @return whether the two numbers are nearly equal
+ *
+ * @throws Error If `relTol` is less than or equal to 0.
+ * @throws Error If `absTol` is less than 0.
+ *
+ * @example
+ * nearlyEqual(1.000000001, 1.0, 1e-8);            // true
+ * nearlyEqual(1.000000002, 1.0, 0);               // false
+ * nearlyEqual(1.0, 1.009, undefined, 0.01);       // true
+ * nearlyEqual(0.000000001, 0.0, undefined, 1e-8); // true
+ */
+declare function nearlyEqual(a: number, b: number, relTol?: number, absTol?: number): boolean;
+/**
+ * Calculate the hyperbolic arccos of a number
+ * @param x The number
+ * @return The hyperbolic arccosine
+ */
+declare const acosh: (x: number) => number;
+/**
+ * Calculate the hyperbolic arcsine of a number
+ * @param x The number
+ * @return The hyperbolic arcsine
+ */
+declare const asinh: (x: number) => number;
+/**
+ * Calculate the hyperbolic arctangent of a number
+ * @param x The number
+ * @return The hyperbolic arctangent
+ */
+declare const atanh: (x: number) => number;
+/**
+ * Calculate the hyperbolic cosine of a number
+ * @param x The number
+ * @returns The hyperbolic cosine
+ */
+declare const cosh: (x: number) => number;
+/**
+ * Calculate the hyperbolic sine of a number
+ * @param x The number
+ * @returns The hyperbolic sine
+ */
+declare const sinh: (x: number) => number;
+/**
+ * Calculate the hyperbolic tangent of a number
+ * @param x The number
+ * @returns The hyperbolic tangent
+ */
+declare const tanh: (x: number) => number;
+/**
+ * Returns a value with the magnitude of x and the sign of y.
+ * @param x The value providing the magnitude
+ * @param y The value providing the sign
+ * @returns Value with magnitude of x and sign of y
+ */
+declare function copysign(x: number, y: number): number;
+/**
+ * Check if x^y is 0 due to infinity
+ * @param x The base
+ * @param y The exponent
+ * @returns true if x^y is 0 due to infinity
+ */
+declare function isPowZeroAtInfinity(x: number, y: number): boolean;
+
+/**
+ * Shared utility functions used across core utility modules.
+ * This file must have ZERO imports from other core utility files
+ * to serve as the base of the dependency graph and break circular imports.
+ */
+/**
+ * A safe hasOwnProperty
+ * @param {Object} object
+ * @param {string} property
+ */
+declare function hasOwnProperty(object: unknown, property: string): boolean;
+/**
+ * True when `text` ends with `search`. (Equivalent to `String.prototype.endsWith`;
+ * kept as a named helper so relocated modules read the same as their mathjs origin.)
+ */
+declare function endsWith(text: string, search: string): boolean;
+/**
+ * Warn to the console at most once per distinct message, deduped for the process
+ * lifetime. Used for deprecation notices (e.g. `Unit.toNumber`).
+ */
+declare const warnOnce: (...args: unknown[]) => void;
+/** A function whose results are cached; clear the cache with `delete fn.cache`. */
+interface MemoizedFunction {
+    (...args: unknown[]): unknown;
+    cache?: Map<string, unknown>;
+}
+/**
+ * Memoize a pure function, caching results in a `Map` keyed by a string hash of the
+ * arguments (default `JSON.stringify`; override via `hasher`). Pass `limit` to bound
+ * the cache to N most-recently-used entries (LRU eviction via `Map` insertion order —
+ * on a hit the key is moved to the most-recent end; on overflow the oldest key is
+ * dropped); omit for an unbounded cache. The cache is exposed as `fn.cache` and can be
+ * reset with `delete fn.cache` — the next call lazily recreates it. (The relocated
+ * `Unit` relies on that reset when `createUnit`/`deleteUnit` invalidate the unit-name
+ * lookup cache, and passes `limit: 100` to bound the parse cache.)
+ */
+declare function memoize(fn: (...args: unknown[]) => unknown, { hasher, limit }?: {
+    hasher?: (args: unknown[]) => string;
+    limit?: number;
+}): MemoizedFunction;
+
+/**
+ * Clone an object
+ *
+ *     clone(x)
+ *
+ * Can clone any primitive type, array, and object.
+ * If x has a function clone, this function will be invoked to clone the object.
+ *
+ * @param {*} x
+ * @return {*} clone
+ */
+declare function clone<T>(x: T): T;
+/**
+ * Apply map to all properties of an object
+ * @param {Object} object
+ * @param {function} callback
+ * @return {Object} Returns a copy of the object with mapped properties
+ */
+declare function mapObject<T, U>(object: Record<string, T>, callback: (value: T) => U): Record<string, U>;
+/**
+ * Extend object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ */
+declare function extend<T extends Record<string, unknown>, U extends Record<string, unknown>>(a: T, b: U): T & U;
+/**
+ * Deep extend an object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @returns {Object}
+ */
+declare function deepExtend<T>(a: T, b: unknown): T;
+/**
+ * Deep test equality of all fields in two pairs of arrays or objects.
+ * Compares values and functions strictly (ie. 2 is not the same as '2').
+ * @param {Array | Object} a
+ * @param {Array | Object} b
+ * @returns {boolean}
+ */
+declare function deepStrictEqual(a: unknown, b: unknown): boolean;
+/**
+ * Recursively flatten a nested object.
+ * @param {Object} nestedObject
+ * @return {Object} Returns the flattened object
+ */
+declare function deepFlatten(nestedObject: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Test whether the current JavaScript engine supports Object.defineProperty
+ * @returns {boolean} returns true if supported
+ */
+declare function canDefineProperty(): boolean;
+/**
+ * Attach a lazy loading property to a constant.
+ * The given function `fn` is called once when the property is first requested.
+ *
+ * @param {Object} object         Object where to add the property
+ * @param {string} prop           Property name
+ * @param {Function} valueResolver Function returning the property value. Called
+ *                                without arguments.
+ */
+declare function lazy<T>(object: Record<string, unknown>, prop: string, valueResolver: () => T): void;
+/**
+ * Traverse a path into an object.
+ * When a namespace is missing, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path   A dot separated string like 'name.space'
+ * @return {Object} Returns the object at the end of the path
+ */
+declare function traverse(object: Record<string, unknown>, path: string | string[]): Record<string, unknown>;
+
+/**
+ * Test whether an object is a factory. a factory has fields:
+ *
+ * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object])   (required)
+ * - name: string (optional)
+ * - path: string    A dot separated path (optional)
+ * - math: boolean   If true (false by default), the math namespace is passed
+ *                   as fifth argument of the factory function
+ *
+ * @param {*} object
+ * @returns {boolean}
+ */
+declare function isLegacyFactory(object: unknown): boolean;
+/**
+ * Get a nested property from an object
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @returns {Object}
+ */
+declare function get(object: Record<string, unknown>, path: string | string[]): unknown;
+/**
+ * Set a nested property in an object
+ * Mutates the object itself
+ * If the path doesn't exist, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @param {*} value
+ * @returns {Object}
+ */
+declare function set<T extends Record<string, unknown>>(object: T, path: string | string[], value: unknown): T;
+/**
+ * Create an object composed of the picked object properties
+ * @param {Object} object
+ * @param {string[]} properties
+ * @param {function} [transform] Optional value to transform a value when picking it
+ * @return {Object}
+ */
+declare function pick(object: Record<string, unknown>, properties: string[], transform?: (value: unknown, key: string) => unknown): Record<string, unknown>;
+/**
+ * Shallow version of pick, creating an object composed of the picked object properties
+ * but not for nested properties
+ * @param {Object} object
+ * @param {string[]} properties
+ * @return {Object}
+ */
+declare function pickShallow(object: Record<string, unknown>, properties: string[]): Record<string, unknown>;
+
+export { type FormatOptions, type MemoizedFunction, type NormalizedFormatOptions, type NumberTypeConfig, type SplitValue, UnitConstructor, UnitDependencies, acosh, asinh, atanh, canDefineProperty, cbrt, clone, copysign, cosh, createUnitClass, deepExtend, deepFlatten, deepStrictEqual, digits, endsWith, expm1, extend, format, get, hasOwnProperty, isInteger, isLegacyFactory, isPowZeroAtInfinity, lazy, log10, log1p, log2, mapObject, memoize, nearlyEqual, normalizeFormatOptions, pick, pickShallow, roundDigits, safeNumberType, set, sign, sinh, splitNumber, tanh, toEngineering, toExponential, toFixed, toPrecision, traverse, unitDependencies, warnOnce };

package/dist/internal.js

@@ -0,0 +1,188 @@
+import {
+  Unit,
+  acosh,
+  asinh,
+  atanh,
+  canDefineProperty,
+  cbrt,
+  clone,
+  copysign,
+  cosh,
+  createUnitClass,
+  deepExtend,
+  deepFlatten,
+  deepStrictEqual,
+  digits,
+  endsWith,
+  expm1,
+  extend,
+  format,
+  get,
+  hasOwnProperty,
+  isAccessorNode,
+  isArray,
+  isArrayNode,
+  isAssignmentNode,
+  isBigInt,
+  isBigNumber2 as isBigNumber,
+  isBlockNode,
+  isBoolean,
+  isChain,
+  isCollection,
+  isComplex2 as isComplex,
+  isConditionalNode,
+  isConstantNode,
+  isDate,
+  isDenseMatrix,
+  isFraction2 as isFraction,
+  isFunction,
+  isFunctionAssignmentNode,
+  isFunctionNode,
+  isHelp,
+  isIndex,
+  isIndexNode,
+  isInteger,
+  isLegacyFactory,
+  isMap,
+  isMatrix,
+  isNode,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectNode,
+  isObjectWrappingMap,
+  isOperatorNode,
+  isParenthesisNode,
+  isPartitionedMap,
+  isPowZeroAtInfinity,
+  isRange,
+  isRangeNode,
+  isRegExp,
+  isRelationalNode,
+  isResultSet,
+  isSparseMatrix,
+  isString,
+  isSymbolNode,
+  isUndefined,
+  isUnit,
+  lazy,
+  log10,
+  log1p,
+  log2,
+  mapObject,
+  memoize,
+  nearlyEqual,
+  normalizeFormatOptions,
+  pick,
+  pickShallow,
+  roundDigits,
+  rule2Node,
+  safeNumberType,
+  set,
+  sign,
+  sinh,
+  splitNumber,
+  tanh,
+  toEngineering,
+  toExponential,
+  toFixed,
+  toPrecision,
+  traverse,
+  typeOf,
+  unitDependencies,
+  warnOnce
+} from "./chunk-JB4VPWK4.js";
+export {
+  Unit as CoreUnit,
+  acosh,
+  asinh,
+  atanh,
+  canDefineProperty,
+  cbrt,
+  clone,
+  copysign,
+  cosh,
+  createUnitClass,
+  deepExtend,
+  deepFlatten,
+  deepStrictEqual,
+  digits,
+  endsWith,
+  expm1,
+  extend,
+  format,
+  get,
+  hasOwnProperty,
+  isAccessorNode,
+  isArray,
+  isArrayNode,
+  isAssignmentNode,
+  isBigInt,
+  isBigNumber,
+  isBlockNode,
+  isBoolean,
+  isChain,
+  isCollection,
+  isComplex,
+  isConditionalNode,
+  isConstantNode,
+  isDate,
+  isDenseMatrix,
+  isFraction,
+  isFunction,
+  isFunctionAssignmentNode,
+  isFunctionNode,
+  isHelp,
+  isIndex,
+  isIndexNode,
+  isInteger,
+  isLegacyFactory,
+  isMap,
+  isMatrix,
+  isNode,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectNode,
+  isObjectWrappingMap,
+  isOperatorNode,
+  isParenthesisNode,
+  isPartitionedMap,
+  isPowZeroAtInfinity,
+  isRange,
+  isRangeNode,
+  isRegExp,
+  isRelationalNode,
+  isResultSet,
+  isSparseMatrix,
+  isString,
+  isSymbolNode,
+  isUndefined,
+  isUnit,
+  lazy,
+  log10,
+  log1p,
+  log2,
+  mapObject,
+  memoize,
+  nearlyEqual,
+  normalizeFormatOptions,
+  pick,
+  pickShallow,
+  roundDigits,
+  rule2Node,
+  safeNumberType,
+  set,
+  sign,
+  sinh,
+  splitNumber,
+  tanh,
+  toEngineering,
+  toExponential,
+  toFixed,
+  toPrecision,
+  traverse,
+  typeOf,
+  unitDependencies,
+  warnOnce
+};