mathjs 10.2.0 → 10.4.1

package/lib/esm/expression/node/FunctionNode.js

@@ -77,76 +77,93 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
     var evalArgs = this.args.map(arg => arg._compile(math, argNames));
 
     if (isSymbolNode(this.fn)) {
-      // we can statically determine whether the function has an rawArgs property
       var _name = this.fn.name;
-      var fn = _name in math ? getSafeProperty(math, _name) : undefined;
-      var isRaw = typeof fn === 'function' && fn.rawArgs === true;
 
-      var resolveFn = scope => {
-        if (scope.has(_name)) {
-          return scope.get(_name);
-        }
+      if (!argNames[_name]) {
+        // we can statically determine whether the function has an rawArgs property
+        var fn = _name in math ? getSafeProperty(math, _name) : undefined;
+        var isRaw = typeof fn === 'function' && fn.rawArgs === true;
 
-        if (_name in math) {
-          return getSafeProperty(math, _name);
-        }
+        var resolveFn = scope => {
+          if (scope.has(_name)) {
+            return scope.get(_name);
+          }
 
-        return FunctionNode.onUndefinedFunction(_name);
-      };
+          if (_name in math) {
+            return getSafeProperty(math, _name);
+          }
 
-      if (isRaw) {
-        // pass unevaluated parameters (nodes) to the function
-        // "raw" evaluation
-        var rawArgs = this.args;
-        return function evalFunctionNode(scope, args, context) {
-          var fn = resolveFn(scope);
-          return fn(rawArgs, math, createSubScope(scope, args), scope);
+          return FunctionNode.onUndefinedFunction(_name);
         };
-      } else {
-        // "regular" evaluation
-        switch (evalArgs.length) {
-          case 0:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              return fn();
-            };
-
-          case 1:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              var evalArg0 = evalArgs[0];
-              return fn(evalArg0(scope, args, context));
-            };
-
-          case 2:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              var evalArg0 = evalArgs[0];
-              var evalArg1 = evalArgs[1];
-              return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
-            };
-
-          default:
-            return function evalFunctionNode(scope, args, context) {
-              var fn = resolveFn(scope);
-              var values = evalArgs.map(evalArg => evalArg(scope, args, context));
-              return fn(...values);
-            };
+
+        if (isRaw) {
+          // pass unevaluated parameters (nodes) to the function
+          // "raw" evaluation
+          var rawArgs = this.args;
+          return function evalFunctionNode(scope, args, context) {
+            var fn = resolveFn(scope);
+            return fn(rawArgs, math, createSubScope(scope, args), scope);
+          };
+        } else {
+          // "regular" evaluation
+          switch (evalArgs.length) {
+            case 0:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                return fn();
+              };
+
+            case 1:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                var evalArg0 = evalArgs[0];
+                return fn(evalArg0(scope, args, context));
+              };
+
+            case 2:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                var evalArg0 = evalArgs[0];
+                var evalArg1 = evalArgs[1];
+                return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
+              };
+
+            default:
+              return function evalFunctionNode(scope, args, context) {
+                var fn = resolveFn(scope);
+                var values = evalArgs.map(evalArg => evalArg(scope, args, context));
+                return fn(...values);
+              };
+          }
         }
+      } else {
+        // the function symbol is an argName
+        var _rawArgs = this.args;
+        return function evalFunctionNode(scope, args, context) {
+          var fn = args[_name];
+          var isRaw = fn && fn.rawArgs;
+
+          if (isRaw) {
+            return fn(_rawArgs, math, createSubScope(scope, args), scope); // "raw" evaluation
+          } else {
+            var values = evalArgs.map(evalArg => evalArg(scope, args, context));
+            return fn.apply(fn, values);
+          }
+        };
       }
     } else if (isAccessorNode(this.fn) && isIndexNode(this.fn.index) && this.fn.index.isObjectProperty()) {
       // execute the function with the right context: the object of the AccessorNode
       var evalObject = this.fn.object._compile(math, argNames);
 
       var prop = this.fn.index.getObjectProperty();
-      var _rawArgs = this.args;
+      var _rawArgs2 = this.args;
       return function evalFunctionNode(scope, args, context) {
         var object = evalObject(scope, args, context);
         validateSafeMethod(object, prop);
         var isRaw = object[prop] && object[prop].rawArgs;
 
         if (isRaw) {
-          return object[prop](_rawArgs, math, createSubScope(scope, args), scope); // "raw" evaluation
+          return object[prop](_rawArgs2, math, createSubScope(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(evalArg => evalArg(scope, args, context));
@@ -158,13 +175,13 @@ export var createFunctionNode = /* #__PURE__ */factory(name, dependencies, _ref
       // we have to dynamically determine whether the function has a rawArgs property
       var evalFn = this.fn._compile(math, argNames);
 
-      var _rawArgs2 = this.args;
+      var _rawArgs3 = this.args;
       return function evalFunctionNode(scope, args, context) {
         var fn = evalFn(scope, args, context);
         var isRaw = fn && fn.rawArgs;
 
         if (isRaw) {
-          return fn(_rawArgs2, math, createSubScope(scope, args), scope); // "raw" evaluation
+          return fn(_rawArgs3, math, createSubScope(scope, args), scope); // "raw" evaluation
         } else {
           // "regular" evaluation
           var values = evalArgs.map(evalArg => evalArg(scope, args, context));

package/lib/esm/expression/parse.js

@@ -241,18 +241,22 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   function getToken(state) {
     state.tokenType = TOKENTYPE.NULL;
     state.token = '';
-    state.comment = ''; // skip over whitespaces
-    // space, tab, and newline when inside parameters
+    state.comment = ''; // skip over ignored characters:
 
-    while (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) {
-      next(state);
-    } // skip comment
+    while (true) {
+      // comments:
+      if (currentCharacter(state) === '#') {
+        while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') {
+          state.comment += currentCharacter(state);
+          next(state);
+        }
+      } // whitespace: space, tab, and newline when inside parameters
 
 
-    if (currentCharacter(state) === '#') {
-      while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') {
-        state.comment += currentCharacter(state);
+      if (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) {
         next(state);
+      } else {
+        break;
       }
     } // check for end of expression
 

package/lib/esm/expression/transform/cumsum.transform.js

@@ -0,0 +1,48 @@
+import { isBigNumber, isCollection, isNumber } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createCumSum } from '../../function/statistics/cumsum.js';
+/**
+ * Attach a transform function to math.sum
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function sum
+ * from one-based to zero based
+ */
+
+var name = 'cumsum';
+var dependencies = ['typed', 'add', 'unaryPlus'];
+export var createCumSumTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    unaryPlus
+  } = _ref;
+  var cumsum = createCumSum({
+    typed,
+    add,
+    unaryPlus
+  });
+  return typed(name, {
+    '...any': function any(args) {
+      // change last argument dim from one-based to zero-based
+      if (args.length === 2 && isCollection(args[0])) {
+        var dim = args[1];
+
+        if (isNumber(dim)) {
+          args[1] = dim - 1;
+        } else if (isBigNumber(dim)) {
+          args[1] = dim.minus(1);
+        }
+      }
+
+      try {
+        return cumsum.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/lib/esm/expression/transform/sum.transform.js

@@ -6,7 +6,7 @@ import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
  * Attach a transform function to math.sum
  * Adds a property transform containing the transform function.
  *
- * This transform changed the last `dim` parameter of function mean
+ * This transform changed the last `dim` parameter of function sum
  * from one-based to zero based
  */
 

package/lib/esm/factoriesAny.js

@@ -221,6 +221,7 @@ export { createDivide } from './function/arithmetic/divide.js';
 export { createDistance } from './function/geometry/distance.js';
 export { createIntersect } from './function/geometry/intersect.js';
 export { createSum } from './function/statistics/sum.js';
+export { createCumSum } from './function/statistics/cumsum.js';
 export { createMean } from './function/statistics/mean.js';
 export { createMedian } from './function/statistics/median.js';
 export { createMad } from './function/statistics/mad.js';
@@ -245,6 +246,7 @@ export { createLeafCount } from './function/algebra/leafCount.js';
 export { createSimplify } from './function/algebra/simplify.js';
 export { createSimplifyCore } from './function/algebra/simplifyCore.js';
 export { createResolve } from './function/algebra/resolve.js';
+export { createSymbolicEqual } from './function/algebra/symbolicEqual.js';
 export { createDerivative } from './function/algebra/derivative.js';
 export { createRationalize } from './function/algebra/rationalize.js';
 export { createReviver } from './json/reviver.js';
@@ -268,4 +270,5 @@ export { createConcatTransform } from './expression/transform/concat.transform.j
 export { createDiffTransform } from './expression/transform/diff.transform.js';
 export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
+export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
 export { createVarianceTransform } from './expression/transform/variance.transform.js';

package/lib/esm/factoriesNumber.js

@@ -146,6 +146,7 @@ export { createProd } from './function/statistics/prod.js';
 export { createMax } from './function/statistics/max.js';
 export { createMin } from './function/statistics/min.js';
 export { createSum } from './function/statistics/sum.js';
+export { createCumSum } from './function/statistics/cumsum.js';
 export { createMean } from './function/statistics/mean.js';
 export { createMedian } from './function/statistics/median.js';
 export { createMad } from './function/statistics/mad.js';
@@ -195,6 +196,7 @@ export var createSubsetTransform = /* #__PURE__ */factory('subset', [], () => no
 });
 export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
+export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
 export { createVarianceTransform } from './expression/transform/variance.transform.js'; // utils
 
 export { createClone } from './function/utils/clone.js';

package/lib/esm/function/algebra/simplify.js

@@ -327,6 +327,14 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
         total: true
       }
     }
+  }, {
+    s: 'n-n -> 0',
+    // partial alternative when we can't always subtract
+    assuming: {
+      subtract: {
+        total: false
+      }
+    }
   }, {
     s: '-(c*v) -> v * (-c)',
     // make non-constant terms positive

package/lib/esm/function/algebra/simplifyCore.js

@@ -206,9 +206,9 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             }
           }
         }
-
-        return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
+
+      return new OperatorNode(node.op, node.fn, [_a, a1]);
     } else if (isFunctionNode(node)) {
       return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
     } else if (isArrayNode(node)) {

package/lib/esm/function/algebra/symbolicEqual.js

@@ -0,0 +1,80 @@
+import { isConstantNode } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'symbolicEqual';
+var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    simplify,
+    typed,
+    OperatorNode
+  } = _ref;
+
+  /**
+   * Attempts to determine if two expressions are symbolically equal, i.e.
+   * one is the result of valid algebraic manipulations on the other.
+   * Currently, this simply checks if the difference of the two expressions
+   * simplifies down to 0. So there are two important caveats:
+   * 1. whether two expressions are symbolically equal depends on the
+   *     manipulations allowed. Therefore, this function takes an optional
+   *     third argument, which are the options that control the behavior
+   *     as documented for the `simplify()` function.
+   * 2. it is in general intractable to find the minimal simplification of
+   *     an arbitrarily complicated expression. So while a `true` value
+   *     of `symbolicEqual` ensures that the two expressions can be manipulated
+   *     to match each other, a `false` value does not absolutely rule this out.
+   *
+   * Syntax:
+   *
+   *    symbolicEqual(expr1, expr2)
+   *    symbolicEqual(expr1, expr2, options)
+   *
+   * Examples:
+   *
+   *    symbolicEqual('x*y', 'y*x') // true
+   *    symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}})
+   *        //false
+   *    symbolicEqual('x/y', '(y*x^(-1))^(-1)') // true
+   *    symbolicEqual('abs(x)','x') // false
+   *    symbolicEqual('abs(x)','x', simplify.positiveContext) // true
+   *
+   * See also:
+   *
+   *    simplify, evaluate
+   *
+   * @param {Node|string} expr1  The first expression to compare
+   * @param {Node|string} expr2  The second expression to compare
+   * @param {Object} [options] Optional option object, passed to simplify
+   * @returns {boolean}
+   *     Returns true if a valid manipulation making the expressions equal
+   *     is found.
+   */
+  return typed(name, {
+    'string, string': function stringString(s1, s2) {
+      return this(parse(s1), parse(s2), {});
+    },
+    'string, string, Object': function stringStringObject(s1, s2, options) {
+      return this(parse(s1), parse(s2), options);
+    },
+    'Node, string': function NodeString(e1, s2) {
+      return this(e1, parse(s2), {});
+    },
+    'Node, string, Object': function NodeStringObject(e1, s2, options) {
+      return this(e1, parse(s2), options);
+    },
+    'string, Node': function stringNode(s1, e2) {
+      return this(parse(s1), e2, {});
+    },
+    'string, Node, Object': function stringNodeObject(s1, e2, options) {
+      return this(parse(s1), e2, options);
+    },
+    'Node, Node': function NodeNode(e1, e2) {
+      return this(e1, e2, {});
+    },
+    'Node, Node, Object': function NodeNodeObject(e1, e2, options) {
+      var diff = new OperatorNode('-', 'subtract', [e1, e2]);
+      var simplified = simplify(diff, {}, options);
+      return isConstantNode(simplified) && !simplified.value;
+    }
+  });
+});

package/lib/esm/function/matrix/eigs/complexEigs.js

@@ -38,32 +38,36 @@ export function createComplexEigs(_ref) {
     } // TODO check if any row/col are zero except the diagonal
     // make sure corresponding rows and columns have similar magnitude
     // important because of numerical stability
+    // MODIFIES arr by side effect!
 
 
     var R = balance(arr, N, prec, type, findVectors); // R is the row transformation matrix
-    // A' = R A R⁻¹, A is the original matrix
+    // arr = A' = R A R⁻¹, A is the original matrix
     // (if findVectors is false, R is undefined)
+    // (And so to return to original matrix: A = R⁻¹ arr R)
     // TODO if magnitudes of elements vary over many orders,
     // move greatest elements to the top left corner
     // using similarity transformations, reduce the matrix
     // to Hessenberg form (upper triangular plus one subdiagonal row)
     // updates the transformation matrix R with new row operationsq
+    // MODIFIES arr by side effect!
 
-    reduceToHessenberg(arr, N, prec, type, findVectors, R); // find eigenvalues
+    reduceToHessenberg(arr, N, prec, type, findVectors, R); // still true that original A = R⁻¹ arr R)
+    // find eigenvalues
 
     var {
       values,
       C
     } = iterateUntilTriangular(arr, N, prec, type, findVectors); // values is the list of eigenvalues, C is the column
-    // transformation matrix that transforms the hessenberg
-    // matrix to upper triangular
-    // compose transformations A → hess. and hess. → triang.
+    // transformation matrix that transforms arr, the hessenberg
+    // matrix, to upper triangular
+    // (So U = C⁻¹ arr C and the relationship between current arr
+    // and original A is unchanged.)
 
-    C = multiply(inv(R), C);
     var vectors;
 
     if (findVectors) {
-      vectors = findEigenvectors(arr, N, C, values, prec, type);
+      vectors = findEigenvectors(arr, N, C, R, values, prec, type);
       vectors = matrixFromColumns(...vectors);
     }
 
@@ -84,8 +88,9 @@ export function createComplexEigs(_ref) {
   function balance(arr, N, prec, type, findVectors) {
     var big = type === 'BigNumber';
     var cplx = type === 'Complex';
-    var zero = big ? bignumber(0) : cplx ? complex(0) : 0;
-    var one = big ? bignumber(1) : cplx ? complex(1) : 1; // base of the floating-point arithmetic
+    var realzero = big ? bignumber(0) : 0;
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1;
+    var realone = big ? bignumber(1) : 1; // base of the floating-point arithmetic
 
     var radix = big ? bignumber(10) : 2;
     var radixSq = multiplyScalar(radix, radix); // the diagonal transformation matrix R
@@ -106,12 +111,13 @@ export function createComplexEigs(_ref) {
       for (var i = 0; i < N; i++) {
         // compute the taxicab norm of i-th column and row
         // TODO optimize for complex numbers
-        var colNorm = zero;
-        var rowNorm = zero;
+        var colNorm = realzero;
+        var rowNorm = realzero;
 
         for (var j = 0; j < N; j++) {
           if (i === j) continue;
-          var c = abs(arr[i][j]);
+          var c = abs(arr[i][j]); // should be real
+
           colNorm = addScalar(colNorm, c);
           rowNorm = addScalar(rowNorm, c);
         }
@@ -120,7 +126,7 @@ export function createComplexEigs(_ref) {
           // find integer power closest to balancing the matrix
           // (we want to scale only by integer powers of radix,
           // so that we don't lose any precision due to round-off)
-          var f = one;
+          var f = realone;
           var _c = colNorm;
           var rowDivRadix = divideScalar(rowNorm, radix);
           var rowMulRadix = multiplyScalar(rowNorm, radix);
@@ -392,16 +398,17 @@ export function createComplexEigs(_ref) {
     };
   }
   /**
-   * @param {Matrix} A original matrix
+   * @param {Matrix} A hessenberg-form matrix
    * @param {number} N size of A
    * @param {Matrix} C column transformation matrix that turns A into upper triangular
+   * @param {Matrix} R similarity that turns original matrix into A
    * @param {number[]} values array of eigenvalues of A
    * @param {'number'|'BigNumber'|'Complex'} type
    * @returns {number[][]} eigenvalues
    */
 
 
-  function findEigenvectors(A, N, C, values, prec, type) {
+  function findEigenvectors(A, N, C, R, values, prec, type) {
     var Cinv = inv(C);
     var U = multiply(Cinv, A, C);
     var big = type === 'BigNumber';
@@ -434,30 +441,34 @@ export function createComplexEigs(_ref) {
 
     var failedLambdas = [];
 
-    for (var _i4 = 0; _i4 < len; _i4++) {
-      var _λ = uniqueValues[_i4];
-
-      var _A = subtract(U, multiply(_λ, E)); // the characteristic matrix
-
+    var _loop = function _loop(_i4) {
+      var λ = uniqueValues[_i4];
+      var S = subtract(U, multiply(λ, E)); // the characteristic matrix
 
-      var solutions = usolveAll(_A, b);
-      solutions = solutions.map(v => multiply(C, v));
+      var solutions = usolveAll(S, b);
       solutions.shift(); // ignore the null vector
       // looks like we missed something, try inverse iteration
 
       while (solutions.length < multiplicities[_i4]) {
-        var approxVec = inverseIterate(_A, N, solutions, prec, type);
+        var approxVec = inverseIterate(S, N, solutions, prec, type);
 
         if (approxVec == null) {
           // no more vectors were found
-          failedLambdas.push(_λ);
+          failedLambdas.push(λ);
           break;
         }
 
         solutions.push(approxVec);
-      }
+      } // Transform back into original array coordinates
+
 
+      var correction = multiply(inv(R), C);
+      solutions = solutions.map(v => multiply(correction, v));
       vectors.push(...solutions.map(v => flatten(v)));
+    };
+
+    for (var _i4 = 0; _i4 < len; _i4++) {
+      _loop(_i4);
     }
 
     if (failedLambdas.length !== 0) {

package/lib/esm/function/matrix/map.js

@@ -8,8 +8,15 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * Create a new matrix or array with the results of the callback function executed on
-   * each entry of the matrix/array.
+   * Create a new matrix or array with the results of a callback function executed on
+   * each entry of a given matrix/array.
+   *
+   * For each entry of the input, the callback is invoked with three arguments:
+   * the value of the entry, the index at which that entry occurs, and the full
+   * matrix/array being traversed. Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
    *
    * Syntax:
    *
@@ -21,15 +28,25 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      return value * value
    *    })  // returns [1, 4, 9]
    *
+   *    // The calling convention for the callback can cause subtleties:
+   *    math.map([1, 2, 3], math.format)
+   *    // throws TypeError: map attempted to call 'format(1,[0])' but argument 2 of type Array does not match expected type number or function or Object or string or boolean
+   *    // [This happens because `format` _can_ take a second argument,
+   *    // but its semantics don't match that of the 2nd argument `map` provides]
+   *
+   *    // To avoid this error, use a function that takes exactly the
+   *    // desired arguments:
+   *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
+   *
    * See also:
    *
    *    filter, forEach, sort
    *
-   * @param {Matrix | Array} x    The matrix to iterate on.
-   * @param {Function} callback   The callback method is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the matrix being traversed.
-   * @return {Matrix | array}     Transformed map of x
+   * @param {Matrix | Array} x    The input to iterate on.
+   * @param {Function} callback
+   *     The function to call (as described above) on each entry of the input
+   * @return {Matrix | array}
+   *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
     'Array, function': _map,
@@ -57,14 +74,35 @@ function _map(array, callback) {
         return recurse(child, index.concat(i));
       });
     } else {
-      // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        return callback(value);
-      } else if (args === 2) {
-        return callback(value, index);
-      } else {
-        // 3 or -1
-        return callback(value, index, array);
+      try {
+        // invoke the callback function with the right number of arguments
+        if (args === 1) {
+          return callback(value);
+        } else if (args === 2) {
+          return callback(value, index);
+        } else {
+          // 3 or -1
+          return callback(value, index, array);
+        }
+      } catch (err) {
+        // But maybe the arguments still weren't right
+        if (err instanceof TypeError && 'data' in err && err.data.category === 'wrongType') {
+          var newmsg = "map attempted to call '".concat(err.data.fn, "(").concat(value);
+          var indexString = JSON.stringify(index);
+
+          if (args === 2) {
+            newmsg += ',' + indexString;
+          } else if (args !== 1) {
+            newmsg += ",".concat(indexString, ",").concat(array);
+          }
+
+          newmsg += ")' but argument ".concat(err.data.index + 1, " of type ");
+          newmsg += "".concat(err.data.actual, " does not match expected type ");
+          newmsg += err.data.expected.join(' or ');
+          throw new TypeError(newmsg);
+        }
+
+        throw err;
       }
     }
   };