test: comprehensive tests for new features and minor bugfixes they revealed

gwhitney · gwhitney · commit 128411eae2ca · 2025-12-08T12:40:49.000-08:00
diff --git a/src/function/arithmetic/subtract.js b/src/function/arithmetic/subtract.js
@@ -66,7 +66,7 @@ export const createSubtract = /* #__PURE__ */ factory(name, dependencies, ({ typ
         return r.createRange({
           start: self(r.start, p.start),
           length: r.length,
-          step: self(r.ste, p.step)
+          step: self(r.step, p.step)
         })
       }),
       'Range, Matrix': typed.referToSelf(
diff --git a/src/type/matrix/Matrix.js b/src/type/matrix/Matrix.js
@@ -144,7 +144,7 @@ export const createMatrixClass = /* #__PURE__ */ factory(name, dependencies, ()
           fields[key] = val
         }
         if (fields.start === '') fields.start = index.shiftPosition
-        if (fields.end === '') fields.end = size[dim] + index.shiftPosition - 1
+        if (fields.end === '') fields.end = size[dim] + index.shiftPosition
         fields.start -= index.shiftPosition
         fields.end -= index.shiftPosition
         const attributes = index.includeEnd
diff --git a/src/type/matrix/Range.js b/src/type/matrix/Range.js
@@ -209,7 +209,8 @@ export const createRangeClass = /* #__PURE__ */ factory(name, dependencies, ({
           // if the span is computed in bigints, we want a bigint increment
           let bigi = isBigInt(span)
           bigi ||= isMatrix(span) && span.datatype() === 'bigint'
-          bigi ||= Array.isArray(span) && getArrayDataType(span) === 'bigint'
+          bigi ||= Array.isArray(span) &&
+            getArrayDataType(span, typeOf) === 'bigint'
           const denominator = bigi ? BigInt(segments) : segments
           attributes.step = divide(span, denominator)
         }
@@ -428,7 +429,7 @@ export const createRangeClass = /* #__PURE__ */ factory(name, dependencies, ({
    *
    * @return {string}           The storage format.
    */
-  Matrix.prototype.storage = function () {
+  Range.prototype.storage = function () {
     return 'range' // neither 'sparse' or 'dense' seemed fair
   }
 
diff --git a/src/type/matrix/function/matrix.js b/src/type/matrix/function/matrix.js
@@ -5,6 +5,7 @@ const name = 'matrix'
 const dependencies = ['typed', 'Matrix', 'DenseMatrix', 'SparseMatrix', 'Range']
 
 export const createMatrix = /* #__PURE__ */ factory(name, dependencies, ({ typed, Matrix, DenseMatrix, SparseMatrix, Range }) => {
+  const rangeCreator = new Range() // dummy to use to get access to .create()
   /**
    * Create a Matrix. The function creates a new `math.Matrix` object from
    * an `Array`. A Matrix has utility functions to manipulate the data in the
@@ -88,7 +89,7 @@ export const createMatrix = /* #__PURE__ */ factory(name, dependencies, ({ typed
           start: data.start, step: data.step, length: data.length
         })
       }
-      return new Range(data)
+      return rangeCreator.create(data)
     }
 
     throw new TypeError('Unknown matrix type ' + JSON.stringify(format) + '.')
diff --git a/test/unit-tests/function/arithmetic/add.test.js b/test/unit-tests/function/arithmetic/add.test.js
@@ -248,6 +248,19 @@ describe('add', function () {
     })
   })
 
+  describe('Range', function () {
+    it('should keep the result a Range when possible', function () {
+      assert.deepStrictEqual(add(math.range(2, 5), 7), new math.Range(9, 12))
+      assert.deepStrictEqual(
+        add(-3, math.range(6, 11, 2)), new math.Range(3, 8, 2))
+      assert.deepStrictEqual(
+        add(math.range(0.5, 4.5), math.range(0, 2.1, 0.5)),
+        new math.Range({ start: 0.5, step: 1.5, length: 4 }))
+      assert.deepStrictEqual(
+        add(math.range(2, 5), [1, 3, 6]), math.matrix([3, 6, 10]))
+    })
+  })
+
   describe('multiple arguments', function () {
     it('should add more than two arguments', function () {
       assert.deepStrictEqual(add(2, 3, 4), 9)
diff --git a/test/unit-tests/function/arithmetic/divide.test.js b/test/unit-tests/function/arithmetic/divide.test.js
@@ -210,6 +210,14 @@ describe('divide', function () {
     assert.throws(function () { divide(a, [[1]]) })
   })
 
+  describe('Range', function () {
+    it('should keep the result a Range when possible', function () {
+      assert.deepStrictEqual(
+        divide(math.range(2, 5), 7),
+        new math.Range({ start: 2 / 7, step: 1 / 7, length: 3 }))
+    })
+  })
+
   /*
   // These are supported now --ericman314
   it('should throw an error if dividing a number by a unit', function() {
diff --git a/test/unit-tests/function/arithmetic/multiply.test.js b/test/unit-tests/function/arithmetic/multiply.test.js
@@ -899,6 +899,18 @@ describe('multiply', function () {
     })
   })
 
+  describe('Range', function () {
+    it('should keep the result a Range when possible', function () {
+      assert.deepStrictEqual(
+        multiply(math.range(2, 5), 7),
+        new math.Range({ start: 14, step: 7, length: 3 }))
+      const frac = math.fraction
+      assert.deepStrictEqual(
+        multiply(frac(1, 3), math.range(2n, 5n)),
+        new math.Range(frac(2, 3), frac(5, 3), frac(1, 3)))
+    })
+  })
+
   describe('multiple arguments', function () {
     it('should multiply more than two arguments', function () {
       assert.deepStrictEqual(multiply(2, 3, 4), 24)
diff --git a/test/unit-tests/function/arithmetic/subtract.test.js b/test/unit-tests/function/arithmetic/subtract.test.js
@@ -245,6 +245,20 @@ describe('subtract', function () {
     })
   })
 
+  describe('Range', function () {
+    it('should keep the result a Range when possible', function () {
+      assert.deepStrictEqual(
+        subtract(math.range(2, 5), 7), new math.Range(-5, -2))
+      assert.deepStrictEqual(
+        subtract(-3, math.range(6, 11, 2)), new math.Range(-9, -14, -2))
+      assert.deepStrictEqual(
+        subtract(math.range(0.5, 4.5), math.range(0, 2.1, 0.5)),
+        new math.Range({ start: 0.5, step: 0.5, length: 4 }))
+      assert.deepStrictEqual(
+        subtract(math.range(2, 5), [1, 3, 6]), math.matrix([1, 0, -2]))
+    })
+  })
+
   it('should throw an error in case of invalid number of arguments', function () {
     assert.throws(function () { subtract(1) }, /TypeError: Too few arguments/)
     assert.throws(function () { subtract(1, 2, 3) }, /TypeError: Too many arguments/)
diff --git a/test/unit-tests/function/matrix/concat.test.js b/test/unit-tests/function/matrix/concat.test.js
@@ -79,6 +79,11 @@ describe('concat', function () {
     ])
   })
 
+  it('should keep Ranges if possible', function () {
+    assert.deepStrictEqual(
+      math.concat(math.range(2, 10), math.range(10, 20)), new math.Range(2, 20))
+  })
+
   it('should concatenate strings', function () {
     assert.strictEqual(math.concat('a', 'b'), 'ab')
     assert.strictEqual(math.concat('a', 'b', 'c'), 'abc')
diff --git a/test/unit-tests/function/matrix/range.test.js b/test/unit-tests/function/matrix/range.test.js
@@ -23,6 +23,7 @@ describe('range', function () {
   })
 
   it('should create a range start:1:end if called with 2 numbers', function () {
+    assert.deepStrictEqual(range(3, 6), new Range(3, 6))
     assert.deepStrictEqual(range(3, 6).valueOf(), [3, 4, 5])
     assert.deepStrictEqual(range(1, 6).valueOf(), [1, 2, 3, 4, 5])
     assert.deepStrictEqual(range(1, 6.1).valueOf(), [1, 2, 3, 4, 5, 6])
@@ -31,6 +32,7 @@ describe('range', function () {
   })
 
   it('should create a range start:step:end if called with 3 numbers', function () {
+    assert.deepStrictEqual(range(0, 10, 2), new Range(0, 10, 2))
     assert.deepStrictEqual(range(0, 10, 2).valueOf(), [0, 2, 4, 6, 8])
     assert.deepStrictEqual(range(5, 0, -1).valueOf(), [5, 4, 3, 2, 1])
     assert.deepStrictEqual(range(2, -4, -2).valueOf(), [2, 0, -2])
@@ -78,13 +80,15 @@ describe('range', function () {
   })
 
   it('should create a range with bigints', function () {
+    assert.deepStrictEqual(range(1n, 3n), new Range(1n, 3n))
     assert.deepStrictEqual(range(1n, 3n).valueOf(), [1n, 2n])
     assert.deepStrictEqual(range(3n, 1n, -1n).valueOf(), [3n, 2n])
     assert.deepStrictEqual(range(1n, 3n, true).valueOf(), [1n, 2n, 3n])
     assert.deepStrictEqual(range(3n, 1n, -1n, true).valueOf(), [3n, 2n, 1n])
   })
 
   it('should handle mixed numbers and bigints appropriately', function () {
+    assert.deepStrictEqual(range(1n, 3), new Range(1n, 3n))
     assert.deepStrictEqual(range(1n, 3).valueOf(), [1n, 2n])
     assert.deepStrictEqual(range(3, 1n, -1n).valueOf(), [3, 2])
     assert.deepStrictEqual(range(3n, 1, -1).valueOf(), [3, 2])
@@ -96,8 +100,9 @@ describe('range', function () {
   })
 
   it('should create a range with bignumbers', function () {
-    assert.deepStrictEqual(
-      range(bignumber(1), bignumber(3)).valueOf(), [bignumber(1), bignumber(2)])
+    const bigRange = range(bignumber(1), bignumber(3))
+    assert.deepStrictEqual(bigRange, new Range(bignumber(1), bignumber(3)))
+    assert.deepStrictEqual(bigRange.valueOf(), [bignumber(1), bignumber(2)])
     assert.deepStrictEqual(
       range(bignumber(3), bignumber(1), bignumber(-1)).valueOf(),
       [bignumber(3), bignumber(2)])
@@ -220,9 +225,10 @@ describe('range', function () {
 
     it('should handle Fractions', function () {
       const frac = math.fraction
+      const fRange = range(frac(1, 3), frac(10, 3))
+      assert.deepStrictEqual(fRange, new Range(frac(1, 3), frac(10, 3)))
       assert.deepStrictEqual(
-        range(frac(1, 3), frac(10, 3)).valueOf(),
-        [frac(1, 3), frac(4, 3), frac(7, 3)])
+        fRange.valueOf(), [frac(1, 3), frac(4, 3), frac(7, 3)])
       assert.deepStrictEqual(
         range(frac(1, 3), frac(7, 3), true).valueOf(),
         [frac(1, 3), frac(4, 3), frac(7, 3)])
diff --git a/test/unit-tests/function/matrix/subset.test.js b/test/unit-tests/function/matrix/subset.test.js
@@ -6,6 +6,7 @@ import sinon from 'sinon'
 const subset = math.subset
 const matrix = math.matrix
 const Range = math.Range
+const range = math.range
 const index = math.index
 
 describe('subset', function () {
@@ -16,10 +17,13 @@ describe('subset', function () {
     assert.deepStrictEqual(subset(a, index(new Range(0, 2), 1)), [2, 4])
     assert.deepStrictEqual(subset(a, index(1, 0)), 3)
     assert.deepStrictEqual(subset([math.bignumber(2)], index(0)), math.bignumber(2))
+    assert.deepStrictEqual(subset(a, 1), [3, 4])
+    assert.deepStrictEqual(subset(a, [range(0, 2), 1]), [2, 4])
   })
 
   it('should get the right subset of an array of booleans', function () {
     assert.deepStrictEqual(subset(a, index([true, true], [1])), [[2], [4]])
+    assert.deepStrictEqual(subset(a, [[true, true], [1]]), [[2], [4]])
     assert.deepStrictEqual(subset(a, index([false, true], [true, false])), [[3]])
     assert.deepStrictEqual(subset([math.bignumber(2)], index([true])), [math.bignumber(2)])
   })
@@ -29,6 +33,7 @@ describe('subset', function () {
     assert.deepStrictEqual(subset(a, index(new math.Range(0, 0), 1)), [])
     assert.deepStrictEqual(subset(b, index([], 1)), math.matrix())
     assert.deepStrictEqual(subset(b, index(new math.Range(0, 0), 1)), math.matrix())
+    assert.deepStrictEqual(subset(b, [range(0, 0), 1]), math.matrix())
     assert.deepStrictEqual(subset({ a: 1 }, index('')), undefined)
     assert.deepStrictEqual(subset('hello', index('')), '')
   })
@@ -66,6 +71,7 @@ describe('subset', function () {
   it('should get the right subset of an object', function () {
     const obj = { foo: 'bar' }
     assert.deepStrictEqual(subset(obj, index('foo')), 'bar')
+    assert.deepStrictEqual(subset(obj, ['foo']), 'bar')
     assert.deepStrictEqual(subset(obj, index('bla')), undefined)
   })
 
@@ -78,6 +84,8 @@ describe('subset', function () {
 
   it('should get the right subset of a matrix', function () {
     assert.deepStrictEqual(subset(b, index(new Range(0, 2), 1)), matrix([2, 4]))
+    assert.deepStrictEqual(subset(b, [range(0, 2), 1]), matrix([2, 4]))
+    assert.deepStrictEqual(subset(b, 0), matrix([1, 2]))
     assert.deepStrictEqual(subset(b, index(1, 0)), 3)
   })
 
diff --git a/test/unit-tests/function/statistics/prod.test.js b/test/unit-tests/function/statistics/prod.test.js
@@ -59,6 +59,13 @@ describe('prod', function () {
     assert.strictEqual(prod(new DenseMatrix([1, 3, 5, 2])), 30)
   })
 
+  it('should return the prod of a Range', function () {
+    assert.strictEqual(prod(math.range(8, 1, -2)), 8 * 6 * 4 * 2) // 8!!
+    // and 2.5 rising 4:
+    assert.strictEqual(
+      prod(math.range({ start: 2.5, length: 4 })), 2.5 * 3.5 * 4.5 * 5.5)
+  })
+
   it('should return the prod element from a 2d array', function () {
     assert.deepStrictEqual(prod([
       [1, 7, 2],
diff --git a/test/unit-tests/type/matrix/DenseMatrix.test.js b/test/unit-tests/type/matrix/DenseMatrix.test.js
@@ -488,6 +488,8 @@ describe('DenseMatrix', function () {
       m = new DenseMatrix(math.range(0, 10))
       assert.deepStrictEqual(m.size(), [10])
       assert.deepStrictEqual(m.subset(index(new Range(2, 5))).valueOf(), [2, 3, 4])
+      assert.deepStrictEqual(
+        m.subset(index('6:')), new DenseMatrix([6, 7, 8, 9], 'number'))
 
       // get 2-dimensional
       m = new DenseMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
@@ -499,6 +501,7 @@ describe('DenseMatrix', function () {
       assert.deepStrictEqual(m.subset(index(new Range(1, 3), 1)).valueOf(), [5, 8])
       assert.deepStrictEqual(m.subset(index(new Range(1, 3), 2)).valueOf(), [6, 9])
       assert.deepStrictEqual(m.subset(index([0, 1, 2], [1])).valueOf(), [[2], [5], [8]])
+      assert.deepStrictEqual(m.layer(1), new DenseMatrix([4, 5, 6]))
 
       // get n-dimensional
       m = new DenseMatrix([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
diff --git a/test/unit-tests/type/matrix/Range.test.js b/test/unit-tests/type/matrix/Range.test.js
@@ -42,6 +42,92 @@ describe('range', function () {
       assert.deepStrictEqual(r.size(), [0])
     })
 
+    it('should create ranges from attributes', function () {
+      const frac = math.fraction
+      assert.deepStrictEqual(new Range({}).toArray(), [])
+
+      assert.deepStrictEqual(new Range({ start: 3 }).toArray(), [])
+      assert.deepStrictEqual(new Range({ end: 3 }).toArray(), [0, 1, 2])
+      assert.deepStrictEqual(new Range({ step: 3 }).toArray(), [])
+      assert.deepStrictEqual(new Range({ last: 3 }).toArray(), [0, 1, 2, 3])
+      assert.deepStrictEqual(new Range({ length: 3 }).toArray(), [0, 1, 2])
+
+      assert.deepStrictEqual(
+        new Range({ start: 3, end: 7 }).toArray(), [3, 4, 5, 6])
+      assert.deepStrictEqual(
+        new Range({ start: 3, step: 3 }).toArray(), [])
+      assert.deepStrictEqual(
+        new Range({ start: 3, last: 7 }).toArray(), [3, 4, 5, 6, 7])
+      assert.deepStrictEqual(
+        new Range({ start: 3, length: 3 }).toArray(), [3, 4, 5])
+      assert.deepStrictEqual(
+        new Range({ end: 7, step: 3 }).toArray(), [0, 3, 6])
+      assert.deepStrictEqual(
+        new Range({ end: 7, last: 6 }).toArray(), [0, 1, 2, 3, 4, 5, 6])
+      assert.deepStrictEqual( // last takes precedence:
+        new Range({ end: 7, last: 3 }).toArray(), [0, 1, 2, 3])
+      assert.deepStrictEqual(
+        new Range({ end: 7, length: 3 }).toArray(), [4, 5, 6])
+      assert.deepStrictEqual(
+        new Range({ step: 3, last: 7 }).toArray(), [0, 3, 6])
+      assert.deepStrictEqual(
+        new Range({ step: 3, length: 3 }).toArray(), [0, 3, 6])
+      assert.deepStrictEqual(
+        new Range({ length: 3, last: 7 }).toArray(), [5, 6, 7])
+
+      assert.deepStrictEqual(
+        new Range({ step: 3, last: 7, length: 3 }).toArray(), [1, 4, 7])
+      assert.deepStrictEqual(
+        new Range({ end: 3, last: 7, length: 3 }).toArray(), [5, 6, 7])
+      assert.deepStrictEqual(
+        new Range({ step: 3, end: 12, length: 3 }).toArray(), [3, 6, 9])
+      assert.deepStrictEqual(
+        new Range({ step: 3, end: 3, last: 10 }).toArray(), [0, 3, 6, 9])
+      assert.deepStrictEqual(
+        new Range({ start: 7, last: 3, length: 3 }).toArray(), [7, 5, 3])
+      assert.deepStrictEqual(
+        new Range({ step: 7, start: 6, length: 3 }).toArray(), [6, 13, 20])
+      assert.deepStrictEqual(
+        new Range({ step: 7, start: 3, last: 12 }).toArray(), [3, 10])
+      assert.deepStrictEqual(
+        new Range({ start: frac(3), end: frac(7), length: 3 }).toArray(),
+        [frac(3), frac(13, 3), frac(17, 3)])
+      assert.deepStrictEqual(
+        new Range({ start: 3, end: 3, last: 4 }).toArray(), [3, 4])
+      assert.deepStrictEqual(
+        new Range({ start: 3, step: 2, end: 7 }).toArray(), [3, 5])
+
+      assert.deepStrictEqual(
+        new Range({ end: -3, step: -1, last: 3, length: 4 }).toArray(),
+        [6, 5, 4, 3])
+      assert.deepStrictEqual( // last overridden when start, step, length given
+        new Range({ start: 5, step: -1, last: 3, length: 4 }).toArray(),
+        [5, 4, 3, 2])
+      assert.deepStrictEqual(
+        new Range({ start: 5, end: 3, last: 3.5, length: 4 }).toArray(),
+        [5, 4.5, 4, 3.5])
+      assert.deepStrictEqual( // end overridden similarly
+        new Range({ start: 5, end: 3, step: 2, length: 3 }).toArray(),
+        [5, 7, 9])
+      assert.deepStrictEqual(
+        new Range({ start: 5, end: 3, step: 3, last: 10 }).toArray(),
+        [5, 8])
+
+      assert.deepStrictEqual(
+        new Range({ start: 2, end: 20, step: -0.25, last: 10, length: 3 })
+          .toArray(),
+        [2, 1.75, 1.5])
+    })
+
+    it('can make 2D ranges', function () {
+      assert.deepStrictEqual(
+        new Range({ start: [1, 3], step: [1, -1], length: 3 }).toArray(),
+        [[1, 3], [2, 2], [3, 1]])
+      assert.deepStrictEqual(
+        new Range({ start: [1, 3, 5], last: [0, 0, 0], length: 3 }).toArray(),
+        [[1, 3, 5], [0.5, 1.5, 2.5], [0, 0, 0]])
+    })
+
     it('should throw an error when created without new keyword', function () {
       assert.throws(function () { Range(0, 10) }, /Constructor must be called with the new operator/)
     })
diff --git a/test/unit-tests/type/matrix/function/matrix.test.js b/test/unit-tests/type/matrix/function/matrix.test.js
@@ -76,6 +76,14 @@ describe('matrix', function () {
     assert.deepStrictEqual(math.size(d), [5])
   })
 
+  it('should create Ranges', function () {
+    const r1 = math.range(1, 6)
+    const r2 = matrix(r1, 'range')
+    assert.ok(r1 !== r2)
+    assert.deepStrictEqual(r1, r2)
+    assert.deepStrictEqual(matrix([1, 2, 3, 4, 5], 'range'), r1)
+  })
+
   it('should throw an error if called with an invalid argument', function () {
     assert.throws(function () { matrix(new Date()) }, TypeError)
   })
diff --git a/test/unit-tests/type/unit/Unit.test.js b/test/unit-tests/type/unit/Unit.test.js
@@ -80,6 +80,7 @@ describe('Unit', function () {
     it('should create a unitless Unit if second parameter is undefined', function () {
       const a = new Unit(6)
       assert(a.dimensions.every(d => d === 0))
+      assert.strictEqual(a.unitless(), true)
     })
 
     it('should ignore properties on Object.prototype', function () {

Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ export const createMatrixClass = /* #__PURE__ */ factory(name, dependencies, ()`
`144`	`144`	`fields[key] = val`
`145`	`145`	`}`
`146`	`146`	`if (fields.start === '') fields.start = index.shiftPosition`
`147`		`- if (fields.end === '') fields.end = size[dim] + index.shiftPosition - 1`
	`147`	`+ if (fields.end === '') fields.end = size[dim] + index.shiftPosition`
`148`	`148`	`fields.start -= index.shiftPosition`
`149`	`149`	`fields.end -= index.shiftPosition`
`150`	`150`	`const attributes = index.includeEnd`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,8 @@ export const createRangeClass = /* #__PURE__ */ factory(name, dependencies, ({`
`209`	`209`	`// if the span is computed in bigints, we want a bigint increment`
`210`	`210`	`let bigi = isBigInt(span)`
`211`	`211`	`bigi \|\|= isMatrix(span) && span.datatype() === 'bigint'`
`212`		`- bigi \|\|= Array.isArray(span) && getArrayDataType(span) === 'bigint'`
	`212`	`+ bigi \|\|= Array.isArray(span) &&`
	`213`	`+ getArrayDataType(span, typeOf) === 'bigint'`
`213`	`214`	`const denominator = bigi ? BigInt(segments) : segments`
`214`	`215`	`attributes.step = divide(span, denominator)`
`215`	`216`	`}`
`@@ -428,7 +429,7 @@ export const createRangeClass = /* #__PURE__ */ factory(name, dependencies, ({`
`428`	`429`	`*`
`429`	`430`	`* @return {string} The storage format.`
`430`	`431`	`*/`
`431`		`- Matrix.prototype.storage = function () {`
	`432`	`+ Range.prototype.storage = function () {`
`432`	`433`	`return 'range' // neither 'sparse' or 'dense' seemed fair`
`433`	`434`	`}`
`434`	`435`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@ const name = 'matrix'`
`5`	`5`	`const dependencies = ['typed', 'Matrix', 'DenseMatrix', 'SparseMatrix', 'Range']`
`6`	`6`
`7`	`7`	`export const createMatrix = /* #__PURE__ */ factory(name, dependencies, ({ typed, Matrix, DenseMatrix, SparseMatrix, Range }) => {`
	`8`	`+ const rangeCreator = new Range() // dummy to use to get access to .create()`
`8`	`9`	`/**`
`9`	`10`	* Create a Matrix. The function creates a new `math.Matrix` object from
`10`	`11`	* an `Array`. A Matrix has utility functions to manipulate the data in the
`@@ -88,7 +89,7 @@ export const createMatrix = /* #__PURE__ */ factory(name, dependencies, ({ typed`
`88`	`89`	`start: data.start, step: data.step, length: data.length`
`89`	`90`	`})`
`90`	`91`	`}`
`91`		`- return new Range(data)`
	`92`	`+ return rangeCreator.create(data)`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`throw new TypeError('Unknown matrix type ' + JSON.stringify(format) + '.')`