mathjs-min 11.7.2

package/lib/cjs/core/create.js

@@ -0,0 +1,207 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.create = create;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _typedFunction = _interopRequireDefault(require("typed-function"));
+var _object = require("../utils/object.js");
+var emitter = _interopRequireWildcard(require("./../utils/emitter.js"));
+var _import = require("./function/import.js");
+var _config = require("./function/config.js");
+var _factory = require("../utils/factory.js");
+var _is = require("../utils/is.js");
+var _ArgumentsError = require("../error/ArgumentsError.js");
+var _DimensionError = require("../error/DimensionError.js");
+var _IndexError = require("../error/IndexError.js");
+var _config2 = require("./config.js");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * Create a mathjs instance from given factory functions and optionally config
+ *
+ * Usage:
+ *
+ *     const mathjs1 = create({ createAdd, createMultiply, ...})
+ *     const config = { number: 'BigNumber' }
+ *     const mathjs2 = create(all, config)
+ *
+ * @param {Object} [factories] An object with factory functions
+ *                             The object can contain nested objects,
+ *                             all nested objects will be flattened.
+ * @param {Object} [config]    Available options:
+ *                            {number} epsilon
+ *                              Minimum relative difference between two
+ *                              compared values, used by all comparison functions.
+ *                            {string} matrix
+ *                              A string 'Matrix' (default) or 'Array'.
+ *                            {string} number
+ *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+ *                            {number} precision
+ *                              The number of significant digits for BigNumbers.
+ *                              Not applicable for Numbers.
+ *                            {boolean} predictable
+ *                              Predictable output type of functions. When true,
+ *                              output type depends only on the input types. When
+ *                              false (default), output type can vary depending
+ *                              on input values. For example `math.sqrt(-4)`
+ *                              returns `complex('2i')` when predictable is false, and
+ *                              returns `NaN` when true.
+ *                            {string} randomSeed
+ *                              Random seed for seeded pseudo random number generator.
+ *                              Set to null to randomly seed.
+ * @returns {Object} Returns a bare-bone math.js instance containing
+ *                   functions:
+ *                   - `import` to add new functions
+ *                   - `config` to change configuration
+ *                   - `on`, `off`, `once`, `emit` for events
+ */
+function create(factories, config) {
+  var configInternal = (0, _extends2["default"])({}, _config2.DEFAULT_CONFIG, config);
+
+  // simple test for ES5 support
+  if (typeof Object.create !== 'function') {
+    throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.');
+  }
+
+  // create the mathjs instance
+  var math = emitter.mixin({
+    // only here for backward compatibility for legacy factory functions
+    isNumber: _is.isNumber,
+    isComplex: _is.isComplex,
+    isBigNumber: _is.isBigNumber,
+    isFraction: _is.isFraction,
+    isUnit: _is.isUnit,
+    isString: _is.isString,
+    isArray: _is.isArray,
+    isMatrix: _is.isMatrix,
+    isCollection: _is.isCollection,
+    isDenseMatrix: _is.isDenseMatrix,
+    isSparseMatrix: _is.isSparseMatrix,
+    isRange: _is.isRange,
+    isIndex: _is.isIndex,
+    isBoolean: _is.isBoolean,
+    isResultSet: _is.isResultSet,
+    isHelp: _is.isHelp,
+    isFunction: _is.isFunction,
+    isDate: _is.isDate,
+    isRegExp: _is.isRegExp,
+    isObject: _is.isObject,
+    isNull: _is.isNull,
+    isUndefined: _is.isUndefined,
+    isAccessorNode: _is.isAccessorNode,
+    isArrayNode: _is.isArrayNode,
+    isAssignmentNode: _is.isAssignmentNode,
+    isBlockNode: _is.isBlockNode,
+    isConditionalNode: _is.isConditionalNode,
+    isConstantNode: _is.isConstantNode,
+    isFunctionAssignmentNode: _is.isFunctionAssignmentNode,
+    isFunctionNode: _is.isFunctionNode,
+    isIndexNode: _is.isIndexNode,
+    isNode: _is.isNode,
+    isObjectNode: _is.isObjectNode,
+    isOperatorNode: _is.isOperatorNode,
+    isParenthesisNode: _is.isParenthesisNode,
+    isRangeNode: _is.isRangeNode,
+    isRelationalNode: _is.isRelationalNode,
+    isSymbolNode: _is.isSymbolNode,
+    isChain: _is.isChain
+  });
+
+  // load config function and apply provided config
+  math.config = (0, _config.configFactory)(configInternal, math.emit);
+  math.expression = {
+    transform: {},
+    mathWithTransform: {
+      config: math.config
+    }
+  };
+
+  // cached factories and instances used by function load
+  var legacyFactories = [];
+  var legacyInstances = [];
+
+  /**
+   * Load a function or data type from a factory.
+   * If the function or data type already exists, the existing instance is
+   * returned.
+   * @param {Function} factory
+   * @returns {*}
+   */
+  function load(factory) {
+    if ((0, _factory.isFactory)(factory)) {
+      return factory(math);
+    }
+    var firstProperty = factory[Object.keys(factory)[0]];
+    if ((0, _factory.isFactory)(firstProperty)) {
+      return firstProperty(math);
+    }
+    if (!(0, _object.isLegacyFactory)(factory)) {
+      console.warn('Factory object with properties `type`, `name`, and `factory` expected', factory);
+      throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
+    }
+    var index = legacyFactories.indexOf(factory);
+    var instance;
+    if (index === -1) {
+      // doesn't yet exist
+      if (factory.math === true) {
+        // pass with math namespace
+        instance = factory.factory(math.type, configInternal, load, math.typed, math);
+      } else {
+        instance = factory.factory(math.type, configInternal, load, math.typed);
+      }
+
+      // append to the cache
+      legacyFactories.push(factory);
+      legacyInstances.push(instance);
+    } else {
+      // already existing function, return the cached instance
+      instance = legacyInstances[index];
+    }
+    return instance;
+  }
+  var importedFactories = {};
+
+  // load the import function
+  function lazyTyped() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return math.typed.apply(math.typed, args);
+  }
+  lazyTyped.isTypedFunction = _typedFunction["default"].isTypedFunction;
+  var internalImport = (0, _import.importFactory)(lazyTyped, load, math, importedFactories);
+  math["import"] = internalImport;
+
+  // listen for changes in config, import all functions again when changed
+  // TODO: move this listener into the import function?
+  math.on('config', function () {
+    (0, _object.values)(importedFactories).forEach(function (factory) {
+      if (factory && factory.meta && factory.meta.recreateOnConfigChange) {
+        // FIXME: only re-create when the current instance is the same as was initially created
+        // FIXME: delete the functions/constants before importing them again?
+        internalImport(factory, {
+          override: true
+        });
+      }
+    });
+  });
+
+  // the create function exposed on the mathjs instance is bound to
+  // the factory functions passed before
+  math.create = create.bind(null, factories);
+
+  // export factory function
+  math.factory = _factory.factory;
+
+  // import the factory functions like createAdd as an array instead of object,
+  // else they will get a different naming (`createAdd` instead of `add`).
+  math["import"]((0, _object.values)((0, _object.deepFlatten)(factories)));
+  math.ArgumentsError = _ArgumentsError.ArgumentsError;
+  math.DimensionError = _DimensionError.DimensionError;
+  math.IndexError = _IndexError.IndexError;
+  return math;
+}

package/lib/cjs/core/function/config.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NUMBER_OPTIONS = exports.MATRIX_OPTIONS = void 0;
+exports.configFactory = configFactory;
+var _object = require("../../utils/object.js");
+var _config2 = require("../config.js");
+var MATRIX_OPTIONS = ['Matrix', 'Array']; // valid values for option matrix
+exports.MATRIX_OPTIONS = MATRIX_OPTIONS;
+var NUMBER_OPTIONS = ['number', 'BigNumber', 'Fraction']; // valid values for option number
+exports.NUMBER_OPTIONS = NUMBER_OPTIONS;
+function configFactory(config, emit) {
+  /**
+   * Set configuration options for math.js, and get current options.
+   * Will emit a 'config' event, with arguments (curr, prev, changes).
+   *
+   * This function is only available on a mathjs instance created using `create`.
+   *
+   * Syntax:
+   *
+   *     math.config(config: Object): Object
+   *
+   * Examples:
+   *
+   *
+   *     import { create, all } from 'mathjs'
+   *
+   *     // create a mathjs instance
+   *     const math = create(all)
+   *
+   *     math.config().number                // outputs 'number'
+   *     math.evaluate('0.4')                // outputs number 0.4
+   *     math.config({number: 'Fraction'})
+   *     math.evaluate('0.4')                // outputs Fraction 2/5
+   *
+   * @param {Object} [options] Available options:
+   *                            {number} epsilon
+   *                              Minimum relative difference between two
+   *                              compared values, used by all comparison functions.
+   *                            {string} matrix
+   *                              A string 'Matrix' (default) or 'Array'.
+   *                            {string} number
+   *                              A string 'number' (default), 'BigNumber', or 'Fraction'
+   *                            {number} precision
+   *                              The number of significant digits for BigNumbers.
+   *                              Not applicable for Numbers.
+   *                            {string} parenthesis
+   *                              How to display parentheses in LaTeX and string
+   *                              output.
+   *                            {string} randomSeed
+   *                              Random seed for seeded pseudo random number generator.
+   *                              Set to null to randomly seed.
+   * @return {Object} Returns the current configuration
+   */
+  function _config(options) {
+    if (options) {
+      var prev = (0, _object.mapObject)(config, _object.clone);
+
+      // validate some of the options
+      validateOption(options, 'matrix', MATRIX_OPTIONS);
+      validateOption(options, 'number', NUMBER_OPTIONS);
+
+      // merge options
+      (0, _object.deepExtend)(config, options);
+      var curr = (0, _object.mapObject)(config, _object.clone);
+      var changes = (0, _object.mapObject)(options, _object.clone);
+
+      // emit 'config' event
+      emit('config', curr, prev, changes);
+      return curr;
+    } else {
+      return (0, _object.mapObject)(config, _object.clone);
+    }
+  }
+
+  // attach the valid options to the function so they can be extended
+  _config.MATRIX_OPTIONS = MATRIX_OPTIONS;
+  _config.NUMBER_OPTIONS = NUMBER_OPTIONS;
+
+  // attach the config properties as readonly properties to the config function
+  Object.keys(_config2.DEFAULT_CONFIG).forEach(function (key) {
+    Object.defineProperty(_config, key, {
+      get: function get() {
+        return config[key];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  });
+  return _config;
+}
+
+/**
+ * Test whether an Array contains a specific item.
+ * @param {Array.<string>} array
+ * @param {string} item
+ * @return {boolean}
+ */
+function contains(array, item) {
+  return array.indexOf(item) !== -1;
+}
+
+/**
+ * Validate an option
+ * @param {Object} options         Object with options
+ * @param {string} name            Name of the option to validate
+ * @param {Array.<string>} values  Array with valid values for this option
+ */
+function validateOption(options, name, values) {
+  if (options[name] !== undefined && !contains(values, options[name])) {
+    // unknown value
+    console.warn('Warning: Unknown value "' + options[name] + '" for configuration option "' + name + '". ' + 'Available options: ' + values.map(function (value) {
+      return JSON.stringify(value);
+    }).join(', ') + '.');
+  }
+}

package/lib/cjs/core/function/import.js

@@ -0,0 +1,340 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.importFactory = importFactory;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var _object = require("../../utils/object.js");
+var _array = require("../../utils/array.js");
+var _ArgumentsError = require("../../error/ArgumentsError.js");
+function importFactory(typed, load, math, importedFactories) {
+  /**
+   * Import functions from an object or a module.
+   *
+   * This function is only available on a mathjs instance created using `create`.
+   *
+   * Syntax:
+   *
+   *    math.import(functions)
+   *    math.import(functions, options)
+   *
+   * Where:
+   *
+   * - `functions: Object`
+   *   An object with functions or factories to be imported.
+   * - `options: Object` An object with import options. Available options:
+   *   - `override: boolean`
+   *     If true, existing functions will be overwritten. False by default.
+   *   - `silent: boolean`
+   *     If true, the function will not throw errors on duplicates or invalid
+   *     types. False by default.
+   *   - `wrap: boolean`
+   *     If true, the functions will be wrapped in a wrapper function
+   *     which converts data types like Matrix to primitive data types like Array.
+   *     The wrapper is needed when extending math.js with libraries which do not
+   *     support these data type. False by default.
+   *
+   * Examples:
+   *
+   *    import { create, all } from 'mathjs'
+   *    import * as numbers from 'numbers'
+   *
+   *    // create a mathjs instance
+   *    const math = create(all)
+   *
+   *    // define new functions and variables
+   *    math.import({
+   *      myvalue: 42,
+   *      hello: function (name) {
+   *        return 'hello, ' + name + '!'
+   *      }
+   *    })
+   *
+   *    // use the imported function and variable
+   *    math.myvalue * 2               // 84
+   *    math.hello('user')             // 'hello, user!'
+   *
+   *    // import the npm module 'numbers'
+   *    // (must be installed first with `npm install numbers`)
+   *    math.import(numbers, {wrap: true})
+   *
+   *    math.fibonacci(7) // returns 13
+   *
+   * @param {Object | Array} functions  Object with functions to be imported.
+   * @param {Object} [options]          Import options.
+   */
+  function mathImport(functions, options) {
+    var num = arguments.length;
+    if (num !== 1 && num !== 2) {
+      throw new _ArgumentsError.ArgumentsError('import', num, 1, 2);
+    }
+    if (!options) {
+      options = {};
+    }
+    function flattenImports(flatValues, value, name) {
+      if (Array.isArray(value)) {
+        value.forEach(function (item) {
+          return flattenImports(flatValues, item);
+        });
+      } else if ((0, _typeof2["default"])(value) === 'object') {
+        for (var _name in value) {
+          if ((0, _object.hasOwnProperty)(value, _name)) {
+            flattenImports(flatValues, value[_name], _name);
+          }
+        }
+      } else if ((0, _factory.isFactory)(value) || name !== undefined) {
+        var flatName = (0, _factory.isFactory)(value) ? isTransformFunctionFactory(value) ? value.fn + '.transform' // TODO: this is ugly
+        : value.fn : name;
+
+        // we allow importing the same function twice if it points to the same implementation
+        if ((0, _object.hasOwnProperty)(flatValues, flatName) && flatValues[flatName] !== value && !options.silent) {
+          throw new Error('Cannot import "' + flatName + '" twice');
+        }
+        flatValues[flatName] = value;
+      } else {
+        if (!options.silent) {
+          throw new TypeError('Factory, Object, or Array expected');
+        }
+      }
+    }
+    var flatValues = {};
+    flattenImports(flatValues, functions);
+    for (var name in flatValues) {
+      if ((0, _object.hasOwnProperty)(flatValues, name)) {
+        // console.log('import', name)
+        var value = flatValues[name];
+        if ((0, _factory.isFactory)(value)) {
+          // we ignore name here and enforce the name of the factory
+          // maybe at some point we do want to allow overriding it
+          // in that case we can implement an option overrideFactoryNames: true
+          _importFactory(value, options);
+        } else if (isSupportedType(value)) {
+          _import(name, value, options);
+        } else {
+          if (!options.silent) {
+            throw new TypeError('Factory, Object, or Array expected');
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Add a property to the math namespace
+   * @param {string} name
+   * @param {*} value
+   * @param {Object} options  See import for a description of the options
+   * @private
+   */
+  function _import(name, value, options) {
+    // TODO: refactor this function, it's to complicated and contains duplicate code
+    if (options.wrap && typeof value === 'function') {
+      // create a wrapper around the function
+      value = _wrap(value);
+    }
+
+    // turn a plain function with a typed-function signature into a typed-function
+    if (hasTypedFunctionSignature(value)) {
+      value = typed(name, (0, _defineProperty2["default"])({}, value.signature, value));
+    }
+    if (typed.isTypedFunction(math[name]) && typed.isTypedFunction(value)) {
+      if (options.override) {
+        // give the typed function the right name
+        value = typed(name, value.signatures);
+      } else {
+        // merge the existing and typed function
+        value = typed(math[name], value);
+      }
+      math[name] = value;
+      delete importedFactories[name];
+      _importTransform(name, value);
+      math.emit('import', name, function resolver() {
+        return value;
+      });
+      return;
+    }
+    if (math[name] === undefined || options.override) {
+      math[name] = value;
+      delete importedFactories[name];
+      _importTransform(name, value);
+      math.emit('import', name, function resolver() {
+        return value;
+      });
+      return;
+    }
+    if (!options.silent) {
+      throw new Error('Cannot import "' + name + '": already exists');
+    }
+  }
+  function _importTransform(name, value) {
+    if (value && typeof value.transform === 'function') {
+      math.expression.transform[name] = value.transform;
+      if (allowedInExpressions(name)) {
+        math.expression.mathWithTransform[name] = value.transform;
+      }
+    } else {
+      // remove existing transform
+      delete math.expression.transform[name];
+      if (allowedInExpressions(name)) {
+        math.expression.mathWithTransform[name] = value;
+      }
+    }
+  }
+  function _deleteTransform(name) {
+    delete math.expression.transform[name];
+    if (allowedInExpressions(name)) {
+      math.expression.mathWithTransform[name] = math[name];
+    } else {
+      delete math.expression.mathWithTransform[name];
+    }
+  }
+
+  /**
+   * Create a wrapper a round an function which converts the arguments
+   * to their primitive values (like convert a Matrix to Array)
+   * @param {Function} fn
+   * @return {Function} Returns the wrapped function
+   * @private
+   */
+  function _wrap(fn) {
+    var wrapper = function wrapper() {
+      var args = [];
+      for (var i = 0, len = arguments.length; i < len; i++) {
+        var arg = arguments[i];
+        args[i] = arg && arg.valueOf();
+      }
+      return fn.apply(math, args);
+    };
+    if (fn.transform) {
+      wrapper.transform = fn.transform;
+    }
+    return wrapper;
+  }
+
+  /**
+   * Import an instance of a factory into math.js
+   * @param {function(scope: object)} factory
+   * @param {Object} options  See import for a description of the options
+   * @param {string} [name=factory.name] Optional custom name
+   * @private
+   */
+  function _importFactory(factory, options) {
+    var name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : factory.fn;
+    if ((0, _array.contains)(name, '.')) {
+      throw new Error('Factory name should not contain a nested path. ' + 'Name: ' + JSON.stringify(name));
+    }
+    var namespace = isTransformFunctionFactory(factory) ? math.expression.transform : math;
+    var existingTransform = (name in math.expression.transform);
+    var existing = (0, _object.hasOwnProperty)(namespace, name) ? namespace[name] : undefined;
+    var resolver = function resolver() {
+      // collect all dependencies, handle finding both functions and classes and other special cases
+      var dependencies = {};
+      factory.dependencies.map(_factory.stripOptionalNotation).forEach(function (dependency) {
+        if ((0, _array.contains)(dependency, '.')) {
+          throw new Error('Factory dependency should not contain a nested path. ' + 'Name: ' + JSON.stringify(dependency));
+        }
+        if (dependency === 'math') {
+          dependencies.math = math;
+        } else if (dependency === 'mathWithTransform') {
+          dependencies.mathWithTransform = math.expression.mathWithTransform;
+        } else if (dependency === 'classes') {
+          // special case for json reviver
+          dependencies.classes = math;
+        } else {
+          dependencies[dependency] = math[dependency];
+        }
+      });
+      var instance = /* #__PURE__ */factory(dependencies);
+      if (instance && typeof instance.transform === 'function') {
+        throw new Error('Transforms cannot be attached to factory functions. ' + 'Please create a separate function for it with exports.path="expression.transform"');
+      }
+      if (existing === undefined || options.override) {
+        return instance;
+      }
+      if (typed.isTypedFunction(existing) && typed.isTypedFunction(instance)) {
+        // merge the existing and new typed function
+        return typed(existing, instance);
+      }
+      if (options.silent) {
+        // keep existing, ignore imported function
+        return existing;
+      } else {
+        throw new Error('Cannot import "' + name + '": already exists');
+      }
+    };
+
+    // TODO: add unit test with non-lazy factory
+    if (!factory.meta || factory.meta.lazy !== false) {
+      (0, _object.lazy)(namespace, name, resolver);
+
+      // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
+      if (existing && existingTransform) {
+        _deleteTransform(name);
+      } else {
+        if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
+          (0, _object.lazy)(math.expression.mathWithTransform, name, function () {
+            return namespace[name];
+          });
+        }
+      }
+    } else {
+      namespace[name] = resolver();
+
+      // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
+      if (existing && existingTransform) {
+        _deleteTransform(name);
+      } else {
+        if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
+          (0, _object.lazy)(math.expression.mathWithTransform, name, function () {
+            return namespace[name];
+          });
+        }
+      }
+    }
+
+    // TODO: improve factories, store a list with imports instead which can be re-played
+    importedFactories[name] = factory;
+    math.emit('import', name, resolver);
+  }
+
+  /**
+   * Check whether given object is a type which can be imported
+   * @param {Function | number | string | boolean | null | Unit | Complex} object
+   * @return {boolean}
+   * @private
+   */
+  function isSupportedType(object) {
+    return typeof object === 'function' || typeof object === 'number' || typeof object === 'string' || typeof object === 'boolean' || object === null || (0, _is.isUnit)(object) || (0, _is.isComplex)(object) || (0, _is.isBigNumber)(object) || (0, _is.isFraction)(object) || (0, _is.isMatrix)(object) || Array.isArray(object);
+  }
+  function hasTypedFunctionSignature(fn) {
+    return typeof fn === 'function' && typeof fn.signature === 'string';
+  }
+  function allowedInExpressions(name) {
+    return !(0, _object.hasOwnProperty)(unsafe, name);
+  }
+  function factoryAllowedInExpressions(factory) {
+    return factory.fn.indexOf('.') === -1 &&
+    // FIXME: make checking on path redundant, check on meta data instead
+    !(0, _object.hasOwnProperty)(unsafe, factory.fn) && (!factory.meta || !factory.meta.isClass);
+  }
+  function isTransformFunctionFactory(factory) {
+    return factory !== undefined && factory.meta !== undefined && factory.meta.isTransformFunction === true || false;
+  }
+
+  // namespaces and functions not available in the parser for safety reasons
+  var unsafe = {
+    expression: true,
+    type: true,
+    docs: true,
+    error: true,
+    json: true,
+    chain: true // chain method not supported. Note that there is a unit chain too.
+  };
+
+  return mathImport;
+}