mathjs 14.9.0 → 15.0.0

package/lib/esm/function/logical/nullish.js

@@ -62,8 +62,8 @@ export var createNullish = /* #__PURE__ */factory(name, dependencies, _ref => {
     'undefined, any': (_x, y) => y,
     // SparseMatrix-first with collection RHS: enforce exact shape match
     'SparseMatrix, Array | Matrix': (x, y) => {
-      var sx = flatten(size(x).valueOf()); // work around #3529/#3530
-      var sy = flatten(size(y).valueOf());
+      var sx = size(x);
+      var sy = size(y);
       if (deepEqual(sx, sy)) return x;
       throw new DimensionError(sx, sy);
     },

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

@@ -52,8 +52,9 @@ export var createColumn = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
     validateIndex(column, value.size()[1]);
     var rowRange = range(0, value.size()[0]);
-    var index = new Index(rowRange, column);
+    var index = new Index(rowRange, [column]);
     var result = value.subset(index);
+    // once config.legacySubset just return result
     return isMatrix(result) ? result : matrix([[result]]);
   }
 });

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

@@ -38,8 +38,8 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     'SparseMatrix, SparseMatrix': _sparseDot
   });
   function _validateDim(x, y) {
-    var xSize = _size(x);
-    var ySize = _size(y);
+    var xSize = size(x);
+    var ySize = size(y);
     var xLen, yLen;
     if (xSize.length === 1) {
       xLen = xSize[0];
@@ -67,8 +67,8 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     var bdt = isMatrix(b) ? b._datatype || b.getDataType() : undefined;
 
     // are these 2-dimensional column vectors? (as opposed to 1-dimensional vectors)
-    var aIsColumn = _size(a).length === 2;
-    var bIsColumn = _size(b).length === 2;
+    var aIsColumn = size(a).length === 2;
+    var bIsColumn = size(b).length === 2;
     var add = addScalar;
     var mul = multiplyScalar;
 
@@ -148,9 +148,4 @@ export var createDot = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
     return c;
   }
-
-  // TODO remove this once #1771 is fixed
-  function _size(x) {
-    return isMatrix(x) ? x.size() : size(x);
-  }
 });

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

@@ -22,17 +22,20 @@ export var createFlatten = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    concat, resize, size, squeeze
    *
-   * @param {Matrix | Array} x   Matrix to be flattened
-   * @return {Matrix | Array} Returns the flattened matrix
+   * @param {DenseMatrix | Array} x   Matrix to be flattened
+   * @return {DenseMatrix | Array} Returns the flattened matrix
    */
   return typed(name, {
     Array: function Array(x) {
       return flattenArray(x);
     },
-    Matrix: function Matrix(x) {
+    DenseMatrix: function DenseMatrix(x) {
       // Return the same matrix type as x (Dense or Sparse Matrix)
       // Return the same data type as x
       return x.create(flattenArray(x.valueOf(), true), x.datatype());
+    },
+    SparseMatrix: function SparseMatrix(_x) {
+      throw new TypeError('SparseMatrix is not supported by function flatten ' + 'because it does not support 1D vectors. ' + 'Convert to a DenseMatrix or Array first. Example: flatten(x.toArray())');
     }
   });
 });

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

@@ -25,7 +25,7 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
      *    // returns [ [ 1, 2, 0, 0 ], [ 3, 4, 0, 0 ], [ 0, 0, 1, 2 ], [ 0, 0, 3, 4 ] ]
      *
      *    math.kron([1,1], [2,3,4])
-     *    // returns [ [ 2, 3, 4, 2, 3, 4 ] ]
+     *    // returns [2, 3, 4, 2, 3, 4]
      *
      * See also:
      *
@@ -49,37 +49,38 @@ export var createKron = /* #__PURE__ */factory(name, dependencies, _ref => {
   });
 
   /**
-     * Calculate the Kronecker product of two matrices / vectors
-     * @param {Array} a  First vector
-     * @param {Array} b  Second vector
-     * @returns {Array} Returns the Kronecker product of x and y
-     * @private
+   * Calculate the Kronecker product of two (1-dimensional) vectors,
+   * with no dimension checking
+   * @param {Array} a  First vector
+   * @param {Array} b  Second vector
+   * @returns {Array}  the 1-dimensional Kronecker product of a and b
+   * @private
+   */
+  function _kron1d(a, b) {
+    // TODO in core overhaul: would be faster to see if we can choose a
+    // particular implementation of multiplyScalar at the beginning,
+    // rather than re-dispatch for _every_ ordered pair of entries.
+    return a.flatMap(x => b.map(y => multiplyScalar(x, y)));
+  }
+
+  /**
+   * Calculate the Kronecker product of two possibly multidimensional arrays
+   * @param {Array} a  First array
+   * @param {Array} b  Second array
+   * @param {number} [d]  common dimension; if missing, compute and match args
+   * @returns {Array} Returns the Kronecker product of x and y
+   * @private
      */
   function _kron(a, b) {
-    // Deal with the dimensions of the matricies.
-    if (size(a).length === 1) {
-      // Wrap it in a 2D Matrix
-      a = [a];
-    }
-    if (size(b).length === 1) {
-      // Wrap it in a 2D Matrix
-      b = [b];
-    }
-    if (size(a).length > 2 || size(b).length > 2) {
-      throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
+    var d = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    if (d < 0) {
+      var adim = size(a).length;
+      var bdim = size(b).length;
+      d = Math.max(adim, bdim);
+      while (adim++ < d) a = [a];
+      while (bdim++ < d) b = [b];
     }
-    var t = [];
-    var r = [];
-    return a.map(function (a) {
-      return b.map(function (b) {
-        r = [];
-        t.push(r);
-        return a.map(function (y) {
-          return b.map(function (x) {
-            return r.push(multiplyScalar(y, x));
-          });
-        });
-      });
-    }) && t;
+    if (d === 1) return _kron1d(a, b);
+    return a.flatMap(aSlice => b.map(bSlice => _kron(aSlice, bSlice, d - 1)));
   }
 });

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

@@ -52,8 +52,9 @@ export var createRow = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
     validateIndex(row, value.size()[0]);
     var columnRange = range(0, value.size()[1]);
-    var index = new Index(row, columnRange);
+    var index = new Index([row], columnRange);
     var result = value.subset(index);
+    // once config.legacySubset just return result
     return isMatrix(result) ? result : matrix([[result]]);
   }
 });

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

@@ -1,16 +1,16 @@
 import { arraySize } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
-import { noMatrix } from '../../utils/noop.js';
 var name = 'size';
-var dependencies = ['typed', 'config', '?matrix'];
+var dependencies = ['typed'];
 export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    typed,
-    config,
-    matrix
+    typed
   } = _ref;
   /**
-   * Calculate the size of a matrix or scalar.
+   * Calculate the size of a matrix or scalar. Always returns an Array containing numbers.
+   *
+   * Note that in mathjs v14 and older, function size could return a Matrix depending on
+   * the input type and configuration.
    *
    * Syntax:
    *
@@ -30,19 +30,13 @@ export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     count, resize, squeeze, subset
    *
    * @param {boolean | number | Complex | Unit | string | Array | Matrix} x  A matrix
-   * @return {Array | Matrix} A vector with size of `x`.
+   * @return {Array} A vector with size of `x`.
    */
   return typed(name, {
-    Matrix: function Matrix(x) {
-      return x.create(x.size(), 'number');
-    },
+    Matrix: x => x.size(),
     Array: arraySize,
-    string: function string(x) {
-      return config.matrix === 'Array' ? [x.length] : matrix([x.length], 'dense', 'number');
-    },
-    'number | Complex | BigNumber | Unit | boolean | null': function number__Complex__BigNumber__Unit__boolean__null(x) {
-      // scalar
-      return config.matrix === 'Array' ? [] : matrix ? matrix([], 'dense', 'number') : noMatrix();
-    }
+    string: x => [x.length],
+    // scalar
+    'number | Complex | BigNumber | Unit | boolean | null': _x => []
   });
 });

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

@@ -25,8 +25,8 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     // get a subset
    *     const d = [[1, 2], [3, 4]]
    *     math.subset(d, math.index(1, 0))             // returns 3
-   *     math.subset(d, math.index([0, 1], 1))        // returns [[2], [4]]
-   *     math.subset(d, math.index([false, true], 0)) // returns [[3]]
+   *     math.subset(d, math.index([0, 1], [1]))        // returns [[2], [4]]
+   *     math.subset(d, math.index([false, true], [0])) // returns [[3]]
    *
    *     // replace a subset
    *     const e = []
@@ -36,9 +36,9 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *     // get submatrix using ranges
    *     const M = [
-   *       [1,2,3],
-   *       [4,5,6],
-   *       [7,8,9]
+   *       [1, 2, 3],
+   *       [4, 5, 6],
+   *       [7, 8, 9]
    *     ]
    *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1, 2, 3], [4, 5, 6]]
    *
@@ -117,7 +117,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
     if (typeof replacement === 'string') {
       throw new Error('can\'t boradcast a string');
     }
-    if (index._isScalar) {
+    if (index.isScalar()) {
       return replacement;
     }
     var indexSize = index.size();
@@ -159,9 +159,14 @@ function _getSubstring(str, index) {
   validateIndex(index.max()[0], strLen);
   var range = index.dimension(0);
   var substr = '';
-  range.forEach(function (v) {
+  function callback(v) {
     substr += str.charAt(v);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range);
+  } else {
+    range.forEach(callback);
+  }
   return substr;
 }
 
@@ -195,7 +200,7 @@ function _setSubstring(str, index, replacement, defaultValue) {
     defaultValue = ' ';
   }
   var range = index.dimension(0);
-  var len = range.size()[0];
+  var len = Number.isInteger(range) ? 1 : range.size()[0];
   if (len !== replacement.length) {
     throw new DimensionError(range.size()[0], replacement.length);
   }
@@ -210,9 +215,14 @@ function _setSubstring(str, index, replacement, defaultValue) {
   for (var i = 0; i < strLen; i++) {
     chars[i] = str.charAt(i);
   }
-  range.forEach(function (v, i) {
+  function callback(v, i) {
     chars[v] = replacement.charAt(i[0]);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range, [0]);
+  } else {
+    range.forEach(callback);
+  }
 
   // initialize undefined characters with a space
   if (chars.length > strLen) {

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

@@ -8,10 +8,11 @@ import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
 import { optimizeCallback } from '../../utils/optimizeCallback.js';
 var name = 'DenseMatrix';
-var dependencies = ['Matrix'];
+var dependencies = ['Matrix', 'config'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    Matrix
+    Matrix,
+    config
   } = _ref;
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
@@ -221,7 +222,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     if (!isIndex(index)) {
       throw new TypeError('Invalid index');
     }
-    var isScalar = index.isScalar();
+    var isScalar = config.legacySubset ? index.size().every(idx => idx === 1) : index.isScalar();
     if (isScalar) {
       // return a scalar
       return matrix.get(index.min());
@@ -241,12 +242,12 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       }
 
       // retrieve submatrix
-      var returnMatrix = new DenseMatrix([]);
+      var returnMatrix = new DenseMatrix();
       var submatrix = _getSubmatrix(matrix._data, index);
       returnMatrix._size = submatrix.size;
       returnMatrix._datatype = matrix._datatype;
       returnMatrix._data = submatrix.data;
-      return returnMatrix;
+      return config.legacySubset ? returnMatrix.reshape(index.size()) : returnMatrix;
     }
   }
 
@@ -264,22 +265,30 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     var size = Array(maxDepth);
     return {
       data: getSubmatrixRecursive(data),
-      size
+      size: size.filter(x => x !== null)
     };
     function getSubmatrixRecursive(data) {
       var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var ranges = index.dimension(depth);
-      size[depth] = ranges.size()[0];
+      var dims = index.dimension(depth);
+      function _mapIndex(dim, callback) {
+        // applies a callback for when the index is a Number or a Matrix
+        if (isNumber(dim)) return callback(dim);else return dim.map(callback).valueOf();
+      }
+      if (isNumber(dims)) {
+        size[depth] = null;
+      } else {
+        size[depth] = dims.size()[0];
+      }
       if (depth < maxDepth) {
-        return ranges.map(rangeIndex => {
-          validateIndex(rangeIndex, data.length);
-          return getSubmatrixRecursive(data[rangeIndex], depth + 1);
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          validateIndex(dimIndex, data.length);
+          return getSubmatrixRecursive(data[dimIndex], depth + 1);
+        });
       } else {
-        return ranges.map(rangeIndex => {
-          validateIndex(rangeIndex, data.length);
-          return data[rangeIndex];
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          validateIndex(dimIndex, data.length);
+          return data[dimIndex];
+        });
       }
     }
   }
@@ -306,18 +315,18 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     var isScalar = index.isScalar();
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    var sSize;
+    var submatrixSize;
     if (isMatrix(submatrix)) {
-      sSize = submatrix.size();
+      submatrixSize = submatrix.size();
       submatrix = submatrix.valueOf();
     } else {
-      sSize = arraySize(submatrix);
+      submatrixSize = arraySize(submatrix);
     }
     if (isScalar) {
       // set a scalar
 
       // check whether submatrix is a scalar
-      if (sSize.length !== 0) {
+      if (submatrixSize.length !== 0) {
         throw new TypeError('Scalar expected');
       }
       matrix.set(index.min(), submatrix, defaultValue);
@@ -325,26 +334,26 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       // set a submatrix
 
       // broadcast submatrix
-      if (!deepStrictEqual(sSize, iSize)) {
-        try {
-          if (sSize.length === 0) {
-            submatrix = broadcastTo([submatrix], iSize);
-          } else {
+      if (!deepStrictEqual(submatrixSize, iSize)) {
+        if (submatrixSize.length === 0) {
+          submatrix = broadcastTo([submatrix], iSize);
+        } else {
+          try {
             submatrix = broadcastTo(submatrix, iSize);
-          }
-          sSize = arraySize(submatrix);
-        } catch (_unused) {}
+          } catch (error) {}
+        }
+        submatrixSize = arraySize(submatrix);
       }
 
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new DimensionError(iSize.length, matrix._size.length, '<');
       }
-      if (sSize.length < iSize.length) {
+      if (submatrixSize.length < iSize.length) {
         // calculate number of missing outer dimensions
         var i = 0;
         var outer = 0;
-        while (iSize[i] === 1 && sSize[i] === 1) {
+        while (iSize[i] === 1 && submatrixSize[i] === 1) {
           i++;
         }
         while (iSize[i] === 1) {
@@ -353,12 +362,12 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
         }
 
         // unsqueeze both outer and inner dimensions
-        submatrix = unsqueeze(submatrix, iSize.length, outer, sSize);
+        submatrix = unsqueeze(submatrix, iSize.length, outer, submatrixSize);
       }
 
       // check whether the size of the submatrix matches the index size
-      if (!deepStrictEqual(iSize, sSize)) {
-        throw new DimensionError(iSize, sSize, '>');
+      if (!deepStrictEqual(iSize, submatrixSize)) {
+        throw new DimensionError(iSize, submatrixSize, '>');
       }
 
       // enlarge matrix when needed
@@ -387,16 +396,18 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     function setSubmatrixRecursive(data, submatrix) {
       var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
       var range = index.dimension(depth);
+      var recursiveCallback = (rangeIndex, i) => {
+        validateIndex(rangeIndex, data.length);
+        setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
+      };
+      var finalCallback = (rangeIndex, i) => {
+        validateIndex(rangeIndex, data.length);
+        data[rangeIndex] = submatrix[i[0]];
+      };
       if (depth < maxDepth) {
-        range.forEach((rangeIndex, i) => {
-          validateIndex(rangeIndex, data.length);
-          setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
-        });
+        if (isNumber(range)) recursiveCallback(range, [0]);else range.forEach(recursiveCallback);
       } else {
-        range.forEach((rangeIndex, i) => {
-          validateIndex(rangeIndex, data.length);
-          data[rangeIndex] = submatrix[i[0]];
-        });
+        if (isNumber(range)) finalCallback(range, [0]);else range.forEach(finalCallback);
       }
     }
   }

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

@@ -1,4 +1,4 @@
-import { isArray, isMatrix, isRange } from '../../utils/is.js';
+import { isArray, isMatrix, isRange, isNumber, isString } from '../../utils/is.js';
 import { clone } from '../../utils/object.js';
 import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
@@ -31,7 +31,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @Constructor Index
    * @param {...*} ranges
    */
-  function Index(ranges) {
+  function Index() {
     if (!(this instanceof Index)) {
       throw new SyntaxError('Constructor must be called with the new operator');
     }
@@ -39,7 +39,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     this._sourceSize = [];
     this._isScalar = true;
     for (var i = 0, ii = arguments.length; i < ii; i++) {
-      var arg = arguments[i];
+      var arg = i < 0 || arguments.length <= i ? undefined : arguments[i];
       var argIsArray = isArray(arg);
       var argIsMatrix = isMatrix(arg);
       var argType = typeof arg;
@@ -50,6 +50,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       } else if (argIsArray || argIsMatrix) {
         // create matrix
         var m = void 0;
+        this._isScalar = false;
         if (getMatrixDataType(arg) === 'boolean') {
           if (argIsArray) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg).valueOf());
           if (argIsMatrix) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg._data).valueOf());
@@ -58,16 +59,10 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
           m = _createImmutableMatrix(arg.valueOf());
         }
         this._dimensions.push(m);
-        // size
-        var size = m.size();
-        // scalar
-        if (size.length !== 1 || size[0] !== 1 || sourceSize !== null) {
-          this._isScalar = false;
-        }
       } else if (argType === 'number') {
-        this._dimensions.push(_createImmutableMatrix([arg]));
+        this._dimensions.push(arg);
       } else if (argType === 'bigint') {
-        this._dimensions.push(_createImmutableMatrix([Number(arg)]));
+        this._dimensions.push(Number(arg));
       } else if (argType === 'string') {
         // object property (arguments.count should be 1)
         this._dimensions.push(arg);
@@ -87,12 +82,15 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
   function _createImmutableMatrix(arg) {
     // loop array elements
     for (var i = 0, l = arg.length; i < l; i++) {
-      if (typeof arg[i] !== 'number' || !isInteger(arg[i])) {
+      if (!isNumber(arg[i]) || !isInteger(arg[i])) {
         throw new TypeError('Index parameters must be positive integer numbers');
       }
     }
     // create matrix
-    return new ImmutableDenseMatrix(arg);
+    var matrix = new ImmutableDenseMatrix();
+    matrix._data = arg;
+    matrix._size = [arg.length];
+    return matrix;
   }
 
   /**
@@ -130,7 +128,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     var size = [];
     for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
       var d = this._dimensions[i];
-      size[i] = typeof d === 'string' ? 1 : d.size()[0];
+      size[i] = isString(d) || isNumber(d) ? 1 : d.size()[0];
     }
     return size;
   };
@@ -144,7 +142,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     var values = [];
     for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
       var range = this._dimensions[i];
-      values[i] = typeof range === 'string' ? range : range.max();
+      values[i] = isString(range) || isNumber(range) ? range : range.max();
     }
     return values;
   };
@@ -158,7 +156,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     var values = [];
     for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
       var range = this._dimensions[i];
-      values[i] = typeof range === 'string' ? range : range.min();
+      values[i] = isString(range) || isNumber(range) ? range : range.min();
     }
     return values;
   };
@@ -183,10 +181,11 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @returns {Range | null} range
    */
   Index.prototype.dimension = function (dim) {
-    if (typeof dim !== 'number') {
+    var _this$_dimensions$dim;
+    if (!isNumber(dim)) {
       return null;
     }
-    return this._dimensions[dim] || null;
+    return (_this$_dimensions$dim = this._dimensions[dim]) !== null && _this$_dimensions$dim !== void 0 ? _this$_dimensions$dim : null;
   };
 
   /**
@@ -194,7 +193,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @returns {boolean} Returns true if the index is an object property
    */
   Index.prototype.isObjectProperty = function () {
-    return this._dimensions.length === 1 && typeof this._dimensions[0] === 'string';
+    return this._dimensions.length === 1 && isString(this._dimensions[0]);
   };
 
   /**
@@ -228,7 +227,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     var array = [];
     for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
       var dimension = this._dimensions[i];
-      array.push(typeof dimension === 'string' ? dimension : dimension.toArray());
+      array.push(isString(dimension) || isNumber(dimension) ? dimension : dimension.toArray());
     }
     return array;
   };
@@ -250,7 +249,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     var strings = [];
     for (var i = 0, ii = this._dimensions.length; i < ii; i++) {
       var dimension = this._dimensions[i];
-      if (typeof dimension === 'string') {
+      if (isString(dimension)) {
         strings.push(JSON.stringify(dimension));
       } else {
         strings.push(dimension.toString());