Class FunctionNode

src/expression/node/FunctionNode.js:88–528

  }

  class FunctionNode extends Node {
    /**
     * @constructor FunctionNode
     * @extends {./Node}
     * invoke a list with arguments on a node
     * @param {./Node | string} fn
     *     Item resolving to a function on which to invoke
     *     the arguments, typically a SymbolNode or AccessorNode
     * @param {./Node[]} args
     */
    constructor (fn, args, optional) {
      super()
      if (typeof fn === 'string') {
        fn = new SymbolNode(fn)
      }

      // validate input
      if (!isNode(fn)) throw new TypeError('Node expected as parameter "fn"')
      if (!Array.isArray(args) || !args.every(isNode)) {
        throw new TypeError(
          'Array containing Nodes expected for parameter "args"')
      }
      const optionalType = typeof optional
      if (!(optionalType === 'undefined' || optionalType === 'boolean')) {
        throw new TypeError('optional flag, if specified, must be boolean')
      }

      this.fn = fn
      this.args = args || []
      this.optional = !!optional
    }

    // readonly property name
    get name () {
      return this.fn.name || ''
    }

    static name = name
    get type () { return name }
    get isFunctionNode () { return true }

    /**
     * Compile a node into a JavaScript function.
     * This basically pre-calculates as much as possible and only leaves open
     * calculations which depend on a dynamic scope with variables.
     * @param {Object} math     Math.js namespace with functions and constants.
     * @param {Object} argNames An object with argument names as key and `true`
     *                          as value. Used in the SymbolNode to optimize
     *                          for arguments from user assigned functions
     *                          (see FunctionAssignmentNode) or special symbols
     *                          like `end` (see IndexNode).
     * @return {function} Returns a function which can be called like:
     *                        evalNode(scope: Object, args: Object, context: *)
     */
    _compile (math, argNames) {
      // compile arguments
      const evalArgs = this.args.map((arg) => arg._compile(math, argNames))
      const fromOptionalChaining = this.optional ||