mathjs 13.1.0 → 13.2.0

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

@@ -2,6 +2,7 @@ import { factory } from '../../utils/factory.js';
 import { isFunctionAssignmentNode, isSymbolNode } from '../../utils/is.js';
 import { createMap } from '../../function/matrix/map.js';
 import { compileInlineExpression } from './utils/compileInlineExpression.js';
+import { createTransformCallback } from './utils/transformCallback.js';
 var name = 'map';
 var dependencies = ['typed'];
 export var createMapTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -17,6 +18,9 @@ export var createMapTransform = /* #__PURE__ */factory(name, dependencies, _ref
   var map = createMap({
     typed
   });
+  var transformCallback = createTransformCallback({
+    typed
+  });
   function mapTransform(args, math, scope) {
     if (args.length === 0) {
       return map();
@@ -25,9 +29,8 @@ export var createMapTransform = /* #__PURE__ */factory(name, dependencies, _ref
       return map(args[0]);
     }
     var N = args.length - 1;
-    var X, callback;
-    callback = args[N];
-    X = args.slice(0, N);
+    var X = args.slice(0, N);
+    var callback = args[N];
     X = X.map(arg => _compileAndEvaluate(arg, scope));
     if (callback) {
       if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) {
@@ -38,101 +41,13 @@ export var createMapTransform = /* #__PURE__ */factory(name, dependencies, _ref
         callback = compileInlineExpression(callback, math, scope);
       }
     }
-    return map(...X, _transformCallback(callback, N));
+    return map(...X, transformCallback(callback, N));
     function _compileAndEvaluate(arg, scope) {
       return arg.compile().evaluate(scope);
     }
   }
   mapTransform.rawArgs = true;
   return mapTransform;
-
-  /**
-   * Transforms the given callback function based on its type and number of arrays.
-   *
-   * @param {Function} callback - The callback function to transform.
-   * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
-   * @returns {*} - The transformed callback function.
-   */
-  function _transformCallback(callback, numberOfArrays) {
-    if (typed.isTypedFunction(callback)) {
-      return _transformTypedCallbackFunction(callback, numberOfArrays);
-    } else {
-      return _transformCallbackFunction(callback, callback.length, numberOfArrays);
-    }
-  }
-
-  /**
-   * Transforms the given typed callback function based on the number of arrays.
-   *
-   * @param {Function} typedFunction - The typed callback function to transform.
-   * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
-   * @returns {*} - The transformed typed callback function.
-   */
-  function _transformTypedCallbackFunction(typedFunction, numberOfArrays) {
-    var signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
-      var [signature, callbackFunction] = _ref2;
-      var numberOfCallbackInputs = signature.split(',').length;
-      if (typed.isTypedFunction(callbackFunction)) {
-        return [signature, _transformTypedCallbackFunction(callbackFunction, numberOfArrays)];
-      } else {
-        return [signature, _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays)];
-      }
-    }));
-    if (typeof typedFunction.name === 'string') {
-      return typed(typedFunction.name, signatures);
-    } else {
-      return typed(signatures);
-    }
-  }
 }, {
   isTransformFunction: true
-});
-
-/**
- * Transforms the callback function based on the number of callback inputs and arrays.
- * There are three cases:
- * 1. The callback function has N arguments.
- * 2. The callback function has N+1 arguments.
- * 3. The callback function has 2N+1 arguments.
- *
- * @param {Function} callbackFunction - The callback function to transform.
- * @param {number} numberOfCallbackInputs - The number of callback inputs.
- * @param {number} numberOfArrays - The number of arrays.
- * @returns {Function} The transformed callback function.
- */
-function _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays) {
-  if (numberOfCallbackInputs === numberOfArrays) {
-    return callbackFunction;
-  } else if (numberOfCallbackInputs === numberOfArrays + 1) {
-    return function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      var vals = args.slice(0, numberOfArrays);
-      var idx = _transformDims(args[numberOfArrays]);
-      return callbackFunction(...vals, idx);
-    };
-  } else if (numberOfCallbackInputs > numberOfArrays + 1) {
-    return function () {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
-      var vals = args.slice(0, numberOfArrays);
-      var idx = _transformDims(args[numberOfArrays]);
-      var rest = args.slice(numberOfArrays + 1);
-      return callbackFunction(...vals, idx, ...rest);
-    };
-  } else {
-    return callbackFunction;
-  }
-}
-
-/**
- * Transforms the dimensions by adding 1 to each dimension.
- *
- * @param {Array} dims - The dimensions to transform.
- * @returns {Array} The transformed dimensions.
- */
-function _transformDims(dims) {
-  return dims.map(dim => dim.isBigNumber ? dim.plus(1) : dim + 1);
-}
+});

package/lib/esm/expression/transform/utils/transformCallback.js

@@ -0,0 +1,95 @@
+import { factory } from '../../../utils/factory.js';
+var name = 'transformCallback';
+var dependencies = ['typed'];
+export var createTransformCallback = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+         * Transforms the given callback function based on its type and number of arrays.
+         *
+         * @param {Function} callback - The callback function to transform.
+         * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+         * @returns {*} - The transformed callback function.
+         */
+  return function (callback, numberOfArrays) {
+    if (typed.isTypedFunction(callback)) {
+      return _transformTypedCallbackFunction(callback, numberOfArrays);
+    } else {
+      return _transformCallbackFunction(callback, callback.length, numberOfArrays);
+    }
+  };
+
+  /**
+       * Transforms the given typed callback function based on the number of arrays.
+       *
+       * @param {Function} typedFunction - The typed callback function to transform.
+       * @param {number} numberOfArrays - The number of arrays to pass to the callback function.
+       * @returns {*} - The transformed callback function.
+       */
+  function _transformTypedCallbackFunction(typedFunction, numberOfArrays) {
+    var signatures = Object.fromEntries(Object.entries(typedFunction.signatures).map(_ref2 => {
+      var [signature, callbackFunction] = _ref2;
+      var numberOfCallbackInputs = signature.split(',').length;
+      if (typed.isTypedFunction(callbackFunction)) {
+        return [signature, _transformTypedCallbackFunction(callbackFunction, numberOfArrays)];
+      } else {
+        return [signature, _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays)];
+      }
+    }));
+    if (typeof typedFunction.name === 'string') {
+      return typed(typedFunction.name, signatures);
+    } else {
+      return typed(signatures);
+    }
+  }
+});
+
+/**
+     * Transforms the callback function based on the number of callback inputs and arrays.
+     * There are three cases:
+     * 1. The callback function has N arguments.
+     * 2. The callback function has N+1 arguments.
+     * 3. The callback function has 2N+1 arguments.
+     *
+     * @param {Function} callbackFunction - The callback function to transform.
+     * @param {number} numberOfCallbackInputs - The number of callback inputs.
+     * @param {number} numberOfArrays - The number of arrays.
+     * @returns {Function} The transformed callback function.
+     */
+function _transformCallbackFunction(callbackFunction, numberOfCallbackInputs, numberOfArrays) {
+  if (numberOfCallbackInputs === numberOfArrays) {
+    return callbackFunction;
+  } else if (numberOfCallbackInputs === numberOfArrays + 1) {
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var idx = _transformDims(args[numberOfArrays]);
+      return callbackFunction(...vals, idx);
+    };
+  } else if (numberOfCallbackInputs > numberOfArrays + 1) {
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      var vals = args.slice(0, numberOfArrays);
+      var idx = _transformDims(args[numberOfArrays]);
+      var rest = args.slice(numberOfArrays + 1);
+      return callbackFunction(...vals, idx, ...rest);
+    };
+  } else {
+    return callbackFunction;
+  }
+}
+
+/**
+   * Transforms the dimensions by adding 1 to each dimension.
+   *
+   * @param {Array} dims - The dimensions to transform.
+   * @returns {Array} The transformed dimensions.
+   */
+function _transformDims(dims) {
+  return dims.map(dim => dim + 1);
+}

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

@@ -65,14 +65,18 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     var res = _derivative(expr, constNodes);
     return options.simplify ? simplify(res) : res;
   }
-  typed.addConversion({
-    from: 'identifier',
-    to: 'SymbolNode',
-    convert: parse
-  });
+  function parseIdentifier(string) {
+    var symbol = parse(string);
+    if (!symbol.isSymbolNode) {
+      throw new TypeError('Invalid variable. ' + "Cannot parse ".concat(JSON.stringify(string), " into a variable in function derivative"));
+    }
+    return symbol;
+  }
   var derivative = typed(name, {
     'Node, SymbolNode': plainDerivative,
-    'Node, SymbolNode, Object': plainDerivative
+    'Node, SymbolNode, Object': plainDerivative,
+    'Node, string': (node, symbol) => plainDerivative(node, parseIdentifier(symbol)),
+    'Node, string, Object': (node, symbol, options) => plainDerivative(node, parseIdentifier(symbol), options)
 
     /* TODO: implement and test syntax with order of derivatives -> implement as an option {order: number}
     'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
@@ -86,11 +90,6 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     }
     */
   });
-  typed.removeConversion({
-    from: 'identifier',
-    to: 'SymbolNode',
-    convert: parse
-  });
   derivative._simplify = true;
   derivative.toTex = function (deriv) {
     return _derivTex.apply(null, deriv.args);

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

@@ -1,4 +1,4 @@
-import { applyCallback } from '../../utils/applyCallback.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 import { filter, filterRegExp } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'filter';
@@ -56,8 +56,9 @@ export var createFilter = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @private
  */
 function _filterCallback(x, callback) {
+  var fastCallback = optimizeCallback(callback, x, 'filter');
   return filter(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    return applyCallback(callback, value, [index], array, 'filter');
+    return fastCallback(value, [index], array);
   });
 }

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

@@ -1,6 +1,6 @@
-import { applyCallback } from '../../utils/applyCallback.js';
-import { forEach as forEachArray } from '../../utils/array.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 import { factory } from '../../utils/factory.js';
+import { recurse } from '../../utils/array.js';
 var name = 'forEach';
 var dependencies = ['typed'];
 export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -45,16 +45,5 @@ export var createForEach = /* #__PURE__ */factory(name, dependencies, _ref => {
  * @private
  */
 function _forEach(array, callback) {
-  var _recurse = function recurse(value, index) {
-    if (Array.isArray(value)) {
-      forEachArray(value, function (child, i) {
-        // we create a copy of the index array and append the new index value
-        _recurse(child, index.concat(i));
-      });
-    } else {
-      // invoke the callback function with the right number of arguments
-      return applyCallback(callback, value, index, array, 'forEach');
-    }
-  };
-  _recurse(array, []);
+  recurse(array, [], array, optimizeCallback(callback, array, name));
 }

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

@@ -1,5 +1,5 @@
-import { applyCallback } from '../../utils/applyCallback.js';
-import { arraySize, broadcastSizes, broadcastTo, get } from '../../utils/array.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
+import { arraySize, broadcastSizes, broadcastTo, get, recurse } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 var name = 'map';
 var dependencies = ['typed'];
@@ -129,36 +129,14 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
       return 0;
     }
   }
-});
-
-/**
- * Map for a multi dimensional array
- * @param {Array} array
- * @param {Function} callback
- * @return {Array}
- * @private
- */
-function _mapArray(array, callback) {
-  return _recurse(array, [], array, callback);
-}
-
-/**
- * Recursive function to map a multi-dimensional array.
- *
- * @param {*} value - The current value being processed in the array.
- * @param {Array} index - The index of the current value being processed in the array.
- * @param {Array} array - The array being processed.
- * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
- * @returns {*} The new array with each element being the result of the callback function.
- */
-function _recurse(value, index, array, callback) {
-  if (Array.isArray(value)) {
-    return value.map(function (child, i) {
-      // we create a copy of the index array and append the new index value
-      return _recurse(child, index.concat(i), array, callback);
-    });
-  } else {
-    // invoke the callback function with the right number of arguments
-    return applyCallback(callback, value, index, array, 'map');
+  /**
+  * Map for a multi dimensional array
+  * @param {Array} array
+  * @param {Function} callback
+  * @return {Array}
+  * @private
+  */
+  function _mapArray(array, callback) {
+    return recurse(array, [], array, optimizeCallback(callback, array, name));
   }
-}
+});

package/lib/esm/type/matrix/DenseMatrix.js

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-this-alias
 import { isArray, isBigNumber, isCollection, isIndex, isMatrix, isNumber, isString, typeOf } from '../../utils/is.js';
 import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo, get } from '../../utils/array.js';
 import { format } from '../../utils/string.js';
@@ -5,7 +6,7 @@ import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
-import { applyCallback } from '../../utils/applyCallback.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -516,6 +517,66 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     return this._size.slice(0); // return a clone of _size
   };
 
+  /**
+   * Applies a callback function to a reference to each element of the matrix
+   * @memberof DenseMatrix
+   * @param {Function} callback   The callback function is invoked with three
+   *                              parameters: an array, an integer index to that
+   *                              array, and the Matrix being traversed.
+   */
+  DenseMatrix.prototype._forEach = function (callback) {
+    // matrix instance
+    var me = this;
+    var s = me.size();
+
+    // if there is only one dimension, just loop through it
+    if (s.length === 1) {
+      for (var i = 0; i < s[0]; i++) {
+        callback(me._data, i, [i]);
+      }
+      return;
+    }
+
+    // keep track of the current index permutation
+    var index = Array(s.length).fill(0);
+
+    // store a reference of each dimension of the matrix for faster access
+    var data = Array(s.length - 1);
+    var last = data.length - 1;
+    data[0] = me._data[0];
+    for (var _i = 0; _i < last; _i++) {
+      data[_i + 1] = data[_i][0];
+    }
+    index[last] = -1;
+    while (true) {
+      var _i2 = void 0;
+      for (_i2 = last; _i2 >= 0; _i2--) {
+        // march index to the next permutation
+        index[_i2]++;
+        if (index[_i2] === s[_i2]) {
+          index[_i2] = 0;
+          continue;
+        }
+
+        // update references to matrix dimensions
+        data[_i2] = _i2 === 0 ? me._data[index[_i2]] : data[_i2 - 1][index[_i2]];
+        for (var j = _i2; j < last; j++) {
+          data[j + 1] = data[j][0];
+        }
+
+        // loop through the last dimension and map each value
+        for (var _j = 0; _j < s[data.length]; _j++) {
+          index[data.length] = _j;
+          callback(data[last], _j, index.slice(0));
+        }
+        break;
+      }
+      if (_i2 === -1) {
+        break;
+      }
+    }
+  };
+
   /**
    * Create a new matrix with the results of the callback function executed on
    * each entry of the matrix.
@@ -527,24 +588,13 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {DenseMatrix} matrix
    */
   DenseMatrix.prototype.map = function (callback) {
-    // matrix instance
     var me = this;
-    var _recurse = function recurse(value, index) {
-      if (isArray(value)) {
-        return value.map(function (child, i) {
-          return _recurse(child, index.concat(i));
-        });
-      } else {
-        // invoke the callback function with the right number of arguments
-        return applyCallback(callback, value, index, me, 'map');
-      }
-    };
-
-    // determine the new datatype when the original matrix has datatype defined
-    // TODO: should be done in matrix constructor instead
-    var data = _recurse(this._data, []);
-    var datatype = this._datatype !== undefined ? getArrayDataType(data, typeOf) : undefined;
-    return new DenseMatrix(data, datatype);
+    var result = new DenseMatrix(me);
+    var fastCallback = optimizeCallback(callback, me._data, 'map');
+    result._forEach(function (arr, i, index) {
+      arr[i] = fastCallback(arr[i], index, me);
+    });
+    return result;
   };
 
   /**
@@ -555,18 +605,11 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    *                              of the element, and the Matrix being traversed.
    */
   DenseMatrix.prototype.forEach = function (callback) {
-    // matrix instance
     var me = this;
-    var _recurse2 = function recurse(value, index) {
-      if (isArray(value)) {
-        value.forEach(function (child, i) {
-          _recurse2(child, index.concat(i));
-        });
-      } else {
-        callback(value, index, me);
-      }
-    };
-    _recurse2(this._data, []);
+    var fastCallback = optimizeCallback(callback, me._data, 'map');
+    me._forEach(function (arr, i, index) {
+      fastCallback(arr[i], index, me);
+    });
   };
 
   /**
@@ -574,10 +617,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {Iterable<{ value, index: number[] }>}
    */
   DenseMatrix.prototype[Symbol.iterator] = function* () {
-    var _recurse3 = function* recurse(value, index) {
+    var _recurse = function* recurse(value, index) {
       if (isArray(value)) {
         for (var i = 0; i < value.length; i++) {
-          yield* _recurse3(value[i], index.concat(i));
+          yield* _recurse(value[i], index.concat(i));
         }
       } else {
         yield {
@@ -586,7 +629,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
         };
       }
     };
-    yield* _recurse3(this._data, []);
+    yield* _recurse(this._data, []);
   };
 
   /**

package/lib/esm/type/matrix/SparseMatrix.js

@@ -5,7 +5,7 @@ import { clone, deepStrictEqual } from '../../utils/object.js';
 import { arraySize, getArrayDataType, processSizesWildcard, unsqueeze, validateIndex } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { DimensionError } from '../../error/DimensionError.js';
-import { applyCallback } from '../../utils/applyCallback.js';
+import { optimizeCallback } from '../../utils/optimizeCallback.js';
 var name = 'SparseMatrix';
 var dependencies = ['typed', 'equalScalar', 'Matrix'];
 export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -872,10 +872,11 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // rows and columns
     var rows = this._size[0];
     var columns = this._size[1];
+    var fastCallback = optimizeCallback(callback, me, 'map');
     // invoke callback
     var invoke = function invoke(v, i, j) {
       // invoke callback
-      return applyCallback(callback, v, [i, j], me, 'map');
+      return fastCallback(v, [i, j], me);
     };
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
@@ -980,6 +981,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // rows and columns
     var rows = this._size[0];
     var columns = this._size[1];
+    var fastCallback = optimizeCallback(callback, me, 'forEach');
     // loop columns
     for (var j = 0; j < columns; j++) {
       // k0 <= k < k1 where k0 = _ptr[j] && k1 = _ptr[j+1]
@@ -992,7 +994,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
           var i = this._index[k];
 
           // value @ k
-          callback(this._values[k], [i, j], me);
+          fastCallback(this._values[k], [i, j], me);
         }
       } else {
         // create a cache holding all defined values
@@ -1006,7 +1008,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
         // and either read the value or zero
         for (var _i7 = 0; _i7 < rows; _i7++) {
           var value = _i7 in values ? values[_i7] : 0;
-          callback(value, [_i7, j], me);
+          fastCallback(value, [_i7, j], me);
         }
       }
     }
@@ -1405,6 +1407,7 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // indeces for column j
     var k0 = ptr[j];
     var k1 = ptr[j + 1];
+
     // loop
     for (var k = k0; k < k1; k++) {
       // invoke callback

package/lib/esm/utils/array.js

@@ -806,6 +806,27 @@ export function get(array, index) {
   return index.reduce((acc, curr) => acc[curr], array);
 }
 
+/**
+ * Recursive function to map a multi-dimensional array.
+ *
+ * @param {*} value - The current value being processed in the array.
+ * @param {Array} index - The index of the current value being processed in the array.
+ * @param {Array} array - The array being processed.
+ * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
+ * @returns {*} The new array with each element being the result of the callback function.
+ */
+export function recurse(value, index, array, callback) {
+  if (Array.isArray(value)) {
+    return value.map(function (child, i) {
+      // we create a copy of the index array and append the new index value
+      return recurse(child, index.concat(i), array, callback);
+    });
+  } else {
+    // invoke the callback function with the right number of arguments
+    return callback(value, index, array);
+  }
+}
+
 /**
  * Deep clones a multidimensional array
  * @param {Array} array

package/lib/esm/utils/customs.js

@@ -10,7 +10,7 @@ import { hasOwnProperty } from './object.js';
  */
 function getSafeProperty(object, prop) {
   // only allow getting safe properties of a plain object
-  if (isPlainObject(object) && isSafeProperty(object, prop)) {
+  if (isSafeProperty(object, prop)) {
     return object[prop];
   }
   if (typeof object[prop] === 'function' && isSafeMethod(object, prop)) {
@@ -31,27 +31,22 @@ function getSafeProperty(object, prop) {
 // TODO: merge this function into access.js?
 function setSafeProperty(object, prop, value) {
   // only allow setting safe properties of a plain object
-  if (isPlainObject(object) && isSafeProperty(object, prop)) {
+  if (isSafeProperty(object, prop)) {
     object[prop] = value;
     return value;
   }
   throw new Error('No access to property "' + prop + '"');
 }
-function getSafeProperties(object) {
-  return Object.keys(object).filter(prop => hasOwnProperty(object, prop));
-}
-function hasSafeProperty(object, prop) {
-  return prop in object;
-}
 
 /**
- * Test whether a property is safe to use for an object.
+ * Test whether a property is safe to use on an object or Array.
  * For example .toString and .constructor are not safe
+ * @param {Object | Array} object
  * @param {string} prop
  * @return {boolean} Returns true when safe
  */
 function isSafeProperty(object, prop) {
-  if (!object || typeof object !== 'object') {
+  if (!isPlainObject(object) && !Array.isArray(object)) {
     return false;
   }
   // SAFE: whitelisted
@@ -147,8 +142,6 @@ var safeNativeMethods = {
 export { getSafeProperty };
 export { setSafeProperty };
 export { isSafeProperty };
-export { hasSafeProperty };
-export { getSafeProperties };
 export { getSafeMethod };
 export { isSafeMethod };
 export { isPlainObject };