mathjs 11.0.0 → 11.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "11.0.0",
+  "version": "11.2.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,42 +25,42 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.18.9",
+    "@babel/runtime": "^7.19.0",
     "complex.js": "^2.1.1",
-    "decimal.js": "^10.3.1",
+    "decimal.js": "^10.4.0",
     "escape-latex": "^1.2.0",
     "fraction.js": "^4.2.0",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
-    "typed-function": "^3.0.0"
+    "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.18.9",
+    "@babel/core": "7.19.0",
     "@babel/plugin-transform-object-assign": "7.18.6",
-    "@babel/plugin-transform-runtime": "7.18.9",
-    "@babel/preset-env": "7.18.9",
+    "@babel/plugin-transform-runtime": "7.18.10",
+    "@babel/preset-env": "7.19.0",
     "@babel/register": "7.18.9",
     "@types/assert": "1.5.6",
     "@types/mocha": "9.1.1",
-    "@typescript-eslint/eslint-plugin": "5.30.7",
-    "@typescript-eslint/parser": "5.30.7",
+    "@typescript-eslint/eslint-plugin": "5.36.2",
+    "@typescript-eslint/parser": "5.36.2",
     "assert": "2.0.0",
     "babel-loader": "8.2.5",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.23.5",
+    "core-js": "3.25.1",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.20.0",
+    "eslint": "8.23.1",
     "eslint-config-prettier": "8.5.0",
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.26.0",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "15.2.4",
+    "eslint-plugin-n": "15.2.5",
     "eslint-plugin-prettier": "4.2.1",
-    "eslint-plugin-promise": "6.0.0",
-    "expect-type": "0.13.0",
+    "eslint-plugin-promise": "6.0.1",
+    "expect-type": "0.14.2",
     "expr-eval": "2.0.2",
     "fancy-log": "2.0.0",
     "glob": "8.0.3",
@@ -90,8 +90,8 @@
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "4.7.4",
-    "webpack": "5.73.0",
+    "typescript": "4.8.3",
+    "webpack": "5.74.0",
     "zeros": "1.0.0"
   },
   "type": "module",
@@ -161,10 +161,9 @@
     "test:all": "npm run test:src && npm run test:generated && npm run test:node && npm run test:types",
     "test:browser": "karma start test/browser-test-config/local-karma.js",
     "test:browserstack": "karma start test/browser-test-config/browserstack-karma.js",
-    "test:types": "cd types && node --loader ts-node/esm ./index.ts",
+    "test:types": "cd types && tsc -p ./tsconfig.json && node --loader ts-node/esm ./index.ts",
     "coverage": "nyc --reporter=lcov --reporter=text-summary mocha test/unit-tests && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"",
     "prepublishOnly": "npm run test:all && npm run lint",
-    "prepare": "npm run build",
     "update-authors": "node ./tools/update-authors.js"
   },
   "bin": {

package/types/index.d.ts

@@ -283,6 +283,7 @@ declare namespace math {
   type OperatorNodeMap = {
     xor: 'xor'
     and: 'and'
+    or: 'or'
     bitOr: '|'
     bitXor: '^|'
     bitAnd: '&'
@@ -291,6 +292,7 @@ declare namespace math {
     smaller: '<'
     larger: '>'
     smallerEq: '<='
+    largerEq: '>='
     leftShift: '<<'
     rightArithShift: '>>'
     rightLogShift: '>>>'
@@ -478,6 +480,12 @@ declare namespace math {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     reviver(): (key: any, value: any) => any
 
+    /**
+     * Returns replacer function that can be used as replacer in JSON.stringify function.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer(): (key: any, value: any) => any
+
     /*************************************************************************
      * Core functions
      ************************************************************************/
@@ -890,8 +898,11 @@ declare namespace math {
      */
     simplify: Simplify
 
-    simplifyConstant(expr: MathNode | string, options?: SimplifyOptions)
-    simplifyCore(expr: MathNode | string, options?: SimplifyOptions)
+    simplifyConstant(
+      expr: MathNode | string,
+      options?: SimplifyOptions
+    ): MathNode
+    simplifyCore(expr: MathNode | string, options?: SimplifyOptions): MathNode
 
     /**
      *  Replaces variable nodes with their scoped values
@@ -2192,11 +2203,9 @@ declare namespace math {
      * undefined. Returns an array with the configured number of elements
      * when number is > 1.
      */
-    pickRandom(
-      array: number[],
-      number?: number,
-      weights?: number[]
-    ): number | number[]
+    pickRandom<T>(array: T[]): T
+    pickRandom<T>(array: T[], number: number): T[]
+    pickRandom<T>(array: T[], number: number, weights: number[]): T[]
 
     /**
      * Return a random number larger or equal to min and smaller than max
@@ -2567,9 +2576,9 @@ declare namespace math {
     median(...args: MathType[]): any
 
     /**
-     * Compute the maximum value of a matrix or a list of values. In case of
-     * a multi dimensional array, the maximum of the flattened array will be
-     * calculated. When dim is provided, the maximum over the selected
+     * Compute the minimum value of a matrix or a list of values. In case of
+     * a multi dimensional array, the minimun of the flattened array will be
+     * calculated. When dim is provided, the minimun over the selected
      * dimension will be calculated. Parameter dim is zero-based.
      * @param args A single matrix or or multiple scalar values
      * @returns The minimum value
@@ -3149,6 +3158,8 @@ declare namespace math {
 
     isRangeNode(x: unknown): x is RangeNode
 
+    isRelationalNode(x: unknown): x is RelationalNode
+
     isSymbolNode(x: unknown): x is SymbolNode
 
     isChain(x: unknown): x is MathJsChain<unknown>
@@ -4407,11 +4418,12 @@ declare namespace math {
      * pass a custom set of rules to the function as second argument. A rule
      * can be specified as an object, string, or function.
      * @param scope Scope to variables
+     * @param options Options to configure the behavior of simplify
      */
     simplify(
       this: MathJsChain<MathNode | string>,
       rules?: SimplifyRule[],
-      scope?: Map | object,
+      scope?: Map<string, MathType> | object,
       options?: SimplifyOptions
     ): MathJsChain<MathNode>
 
@@ -5511,11 +5523,13 @@ declare namespace math {
      * @param number An int or float
      * @param weights An array of ints or floats
      */
-    pickRandom(
-      array: MathJsChain<number[]>,
-      number?: number,
-      weights?: number[]
-    ): MathJsChain<number | number[]>
+    pickRandom<T>(this: MathJsChain<T[]>): MathJsChain<T>
+    pickRandom<T>(this: MathJsChain<T[]>, number: number): MathJsChain<T[]>
+    pickRandom<T>(
+      this: MathJsChain<T[]>,
+      number: number,
+      weights: number[]
+    ): MathJsChain<T[]>
 
     /**
      * Return a random number larger or equal to min and smaller than max
@@ -5863,9 +5877,9 @@ declare namespace math {
     median(this: MathJsChain<MathCollection>, dim?: number): MathJsChain<any>
 
     /**
-     * Compute the maximum value of a matrix or a list of values. In case of
-     * a multi dimensional array, the maximum of the flattened array will be
-     * calculated. When dim is provided, the maximum over the selected
+     * Compute the minimum value of a matrix or a list of values. In case of
+     * a multi dimensional array, the minimum of the flattened array will be
+     * calculated. When dim is provided, the minimum over the selected
      * dimension will be calculated. Parameter dim is zero-based.
      * @param dim The minimum over the selected dimension
      */

package/types/index.ts

@@ -1,35 +1,48 @@
 import {
-  create,
-  factory,
-  all,
-  MathJsFunctionName,
-  fractionDependencies,
+  AccessorNode,
   addDependencies,
-  divideDependencies,
-  formatDependencies,
-  MathNode,
-  MathJsChain,
+  all,
+  ArrayNode,
+  AssignmentNode,
   BigNumber,
-  MathCollection,
+  BlockNode,
   Complex,
-  Unit,
+  ConditionalNode,
+  ConstantNode,
+  create,
+  divideDependencies,
+  EvalFunction,
+  factory,
+  formatDependencies,
   Fraction,
-  MathArray,
+  fractionDependencies,
+  FunctionAssignmentNode,
+  FunctionNode,
+  Help,
   Index,
-  Matrix,
-  EvalFunction,
+  IndexNode,
   LUDecomposition,
-  QRDecomposition,
-  SLUDecomposition,
-  MathType,
+  MathArray,
+  MathCollection,
+  MathJsChain,
+  MathJsFunctionName,
+  MathNode,
+  MathNodeCommon,
   MathNumericType,
-  ConstantNode,
+  MathType,
+  Matrix,
+  ObjectNode,
   OperatorNode,
   OperatorNodeFn,
   OperatorNodeOp,
-  SymbolNode,
   ParenthesisNode,
+  PolarCoordinates,
+  QRDecomposition,
+  RangeNode,
   SimplifyRule,
+  SLUDecomposition,
+  SymbolNode,
+  Unit,
 } from 'mathjs'
 import * as assert from 'assert'
 import { expectTypeOf } from 'expect-type'
@@ -125,8 +138,8 @@ Basic usage examples
   ) // Matrix + Array
 
   // narrowed type inference
-  const _b: math.Matrix = math.add(math.matrix([2]), math.matrix([3]))
-  const _c: math.Matrix = math.subtract(math.matrix([4]), math.matrix([5]))
+  const _b: Matrix = math.add(math.matrix([2]), math.matrix([3]))
+  const _c: Matrix = math.subtract(math.matrix([4]), math.matrix([5]))
 }
 
 /*
@@ -944,18 +957,18 @@ Complex numbers examples
 
   // create a complex number from polar coordinates
   {
-    const p: math.PolarCoordinates = {
+    const p: PolarCoordinates = {
       r: math.sqrt(2) as number, // must be real but a sqrt could be Complex
       phi: math.pi / 4,
     }
-    const c: math.Complex = math.complex(p)
+    const c: Complex = math.complex(p)
     assert.strictEqual(c.im, 1)
     assert.ok(Math.abs(c.re - 1) < 1e-12)
   }
 
   // get polar coordinates of a complex number
   {
-    const _p: math.PolarCoordinates = math.complex(3, 4).toPolar()
+    const _p: PolarCoordinates = math.complex(3, 4).toPolar()
   }
 }
 
@@ -1014,7 +1027,7 @@ Expressions examples
 
   {
     const node2 = math.parse('x^a')
-    const _code2: math.EvalFunction = node2.compile()
+    const _code2: EvalFunction = node2.compile()
     node2.toString()
   }
 
@@ -1117,8 +1130,8 @@ Matrices examples
 
   // create matrices and arrays. a matrix is just a wrapper around an Array,
   // providing some handy utilities.
-  const a: math.Matrix = math.matrix([1, 4, 9, 16, 25])
-  const b: math.Matrix = math.matrix(math.ones([2, 3]))
+  const a: Matrix = math.matrix([1, 4, 9, 16, 25])
+  const b: Matrix = math.matrix(math.ones([2, 3]))
   b.size()
 
   // @ts-expect-error ... ones() in a chain cannot take more dimensions
@@ -1130,7 +1143,7 @@ Matrices examples
   const _array = a.valueOf()
 
   // Matrices can be cloned
-  const _clone: math.Matrix = a.clone()
+  const _clone: Matrix = a.clone()
 
   // perform operations with matrices
   math.map(a, math.sqrt)
@@ -1142,22 +1155,22 @@ Matrices examples
       [1, 2],
       [3, 4],
     ]
-    const b: math.Matrix = math.matrix([
+    const b: Matrix = math.matrix([
       [5, 6],
       [1, 1],
     ])
 
     b.subset(math.index(1, [0, 1]), [[7, 8]])
     const _c = math.multiply(a, b)
-    const f: math.Matrix = math.matrix([1, 0])
-    const _d: math.Matrix = f.subset(math.index(1))
+    const f: Matrix = math.matrix([1, 0])
+    const _d: Matrix = f.subset(math.index(1))
   }
 
   // get a sub matrix
   {
-    const a: math.Matrix = math.diag(math.range(1, 4))
+    const a: Matrix = math.diag(math.range(1, 4))
     a.subset(math.index([1, 2], [1, 2]))
-    const b: math.Matrix = math.range(1, 6)
+    const b: Matrix = math.range(1, 6)
     b.subset(math.index(math.range(1, 4)))
   }
 
@@ -1203,7 +1216,7 @@ Matrices examples
       [6, 4, 3]
     )
     assert.deepStrictEqual(
-      math.filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/),
+      math.filter(['23', 'foo', '100', '55', 'bar'], /\d+/),
       ['23', '100', '55']
     )
   }
@@ -1308,7 +1321,7 @@ Math types examples: Type results after multiplying  'MathTypes' with matrices
 
   // 1D JS Array
   const r3 = math.multiply(abc, bcd)
-  r3[1] // By default least promised valid syntax
+  const _r31 = r3[1] // By default least promised valid syntax
 
   // 2D JS Array
   const r12 = math.multiply(bcd, bcd)
@@ -1316,9 +1329,9 @@ Math types examples: Type results after multiplying  'MathTypes' with matrices
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const multiDimensional = (x: any): x is any[][] => x.length && x[0].length
   if (multiDimensional(r12)) {
-    r12[1][1]
+    const _r1211 = r12[1][1]
   }
-  r12[1] // Valid syntax
+  const _r121 = r12[1] // Valid syntax
 
   // Matrix: matrix * vector
   const r7 = math.multiply(Mabc, bcd)
@@ -1450,29 +1463,27 @@ Expression tree examples
   const math = create(all, {})
 
   // Filter an expression tree
-  const node: math.MathNode = math.parse('x^2 + x/4 + 3*y')
-  const filtered: math.MathNode[] = node.filter(
-    (node: math.MathNode) => node.type === 'SymbolNode' && node.name === 'x'
+  const node: MathNode = math.parse('x^2 + x/4 + 3*y')
+  const filtered: MathNode[] = node.filter(
+    (node: MathNode) => node.type === 'SymbolNode' && node.name === 'x'
   )
 
-  const _arr: string[] = filtered.map((node: math.MathNode) => node.toString())
+  const _arr: string[] = filtered.map((node: MathNode) => node.toString())
 
   // Traverse an expression tree
-  const node1: math.MathNode = math.parse('3 * x + 2')
-  node1.traverse(
-    (node: math.MathNode, _path: string, _parent: math.MathNode) => {
-      switch (node.type) {
-        case 'OperatorNode':
-          return node.type === 'OperatorNode'
-        case 'ConstantNode':
-          return node.type === 'ConstantNode'
-        case 'SymbolNode':
-          return node.type === 'SymbolNode'
-        default:
-          return
-      }
+  const node1: MathNode = math.parse('3 * x + 2')
+  node1.traverse((node: MathNode, _path: string, _parent: MathNode) => {
+    switch (node.type) {
+      case 'OperatorNode':
+        return node.type === 'OperatorNode'
+      case 'ConstantNode':
+        return node.type === 'ConstantNode'
+      case 'SymbolNode':
+        return node.type === 'SymbolNode'
+      default:
+        return
     }
-  )
+  })
 }
 
 /*
@@ -1535,9 +1546,9 @@ Function ceil examples
   )
 
   // numeric input, array or matrix of decimals
-  const numCeiled: math.MathArray = math.ceil(math.tau, [2, 3])
+  const numCeiled: MathArray = math.ceil(math.tau, [2, 3])
   assert.deepStrictEqual(numCeiled, [6.29, 6.284])
-  const bigCeiled: math.Matrix = math.ceil(
+  const bigCeiled: Matrix = math.ceil(
     math.bignumber(6.28318),
     math.matrix([2, 3])
   )
@@ -1611,9 +1622,9 @@ Function fix examples
   )
 
   // numeric input, array or matrix of decimals
-  const numFixed: math.MathArray = math.fix(math.tau, [2, 3])
+  const numFixed: MathArray = math.fix(math.tau, [2, 3])
   assert.deepStrictEqual(numFixed, [6.28, 6.283])
-  const bigFixed: math.Matrix = math.fix(
+  const bigFixed: Matrix = math.fix(
     math.bignumber(6.28318),
     math.matrix([2, 3])
   )
@@ -1687,9 +1698,9 @@ Function floor examples
   )
 
   // numeric input, array or matrix of decimals
-  const numFloored: math.MathArray = math.floor(math.tau, [2, 3])
+  const numFloored: MathArray = math.floor(math.tau, [2, 3])
   assert.deepStrictEqual(numFloored, [6.28, 6.283])
-  const bigFloored: math.Matrix = math.floor(
+  const bigFloored: Matrix = math.floor(
     math.bignumber(6.28318),
     math.matrix([2, 3])
   )
@@ -1763,9 +1774,9 @@ Function round examples
   )
 
   // numeric input, array or matrix of decimals
-  const numRounded: math.MathArray = math.round(math.tau, [2, 3])
+  const numRounded: MathArray = math.round(math.tau, [2, 3])
   assert.deepStrictEqual(numRounded, [6.28, 6.283])
-  const bigRounded: math.Matrix = math.round(
+  const bigRounded: Matrix = math.round(
     math.bignumber(6.28318),
     math.matrix([2, 3])
   )
@@ -2065,6 +2076,7 @@ Factory Test
     math.isOperatorNode,
     math.isParenthesisNode,
     math.isRangeNode,
+    math.isRelationalNode,
     math.isSymbolNode,
     math.isChain,
   ]
@@ -2077,22 +2089,22 @@ Factory Test
 
   // Check guards do type refinement
 
-  let x: unknown
+  const x: unknown = undefined
 
   if (math.isNumber(x)) {
     expectTypeOf(x).toMatchTypeOf<number>()
   }
   if (math.isBigNumber(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.BigNumber>()
+    expectTypeOf(x).toMatchTypeOf<BigNumber>()
   }
   if (math.isComplex(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Complex>()
+    expectTypeOf(x).toMatchTypeOf<Complex>()
   }
   if (math.isFraction(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Fraction>()
+    expectTypeOf(x).toMatchTypeOf<Fraction>()
   }
   if (math.isUnit(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Unit>()
+    expectTypeOf(x).toMatchTypeOf<Unit>()
   }
   if (math.isString(x)) {
     expectTypeOf(x).toMatchTypeOf<string>()
@@ -2101,22 +2113,22 @@ Factory Test
     expectTypeOf(x).toMatchTypeOf<unknown[]>()
   }
   if (math.isMatrix(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Matrix>()
+    expectTypeOf(x).toMatchTypeOf<Matrix>()
   }
   if (math.isDenseMatrix(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Matrix>()
+    expectTypeOf(x).toMatchTypeOf<Matrix>()
   }
   if (math.isSparseMatrix(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Matrix>()
+    expectTypeOf(x).toMatchTypeOf<Matrix>()
   }
   if (math.isIndex(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Index>()
+    expectTypeOf(x).toMatchTypeOf<Index>()
   }
   if (math.isBoolean(x)) {
     expectTypeOf(x).toMatchTypeOf<boolean>()
   }
   if (math.isHelp(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.Help>()
+    expectTypeOf(x).toMatchTypeOf<Help>()
   }
   if (math.isDate(x)) {
     expectTypeOf(x).toMatchTypeOf<Date>()
@@ -2132,40 +2144,40 @@ Factory Test
   }
 
   if (math.isAccessorNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.AccessorNode>()
+    expectTypeOf(x).toMatchTypeOf<AccessorNode>()
   }
   if (math.isArrayNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.ArrayNode>()
+    expectTypeOf(x).toMatchTypeOf<ArrayNode>()
   }
   if (math.isAssignmentNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.AssignmentNode>()
+    expectTypeOf(x).toMatchTypeOf<AssignmentNode>()
   }
   if (math.isBlockNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.BlockNode>()
+    expectTypeOf(x).toMatchTypeOf<BlockNode>()
   }
   if (math.isConditionalNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.ConditionalNode>()
+    expectTypeOf(x).toMatchTypeOf<ConditionalNode>()
   }
   if (math.isConstantNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.ConstantNode>()
+    expectTypeOf(x).toMatchTypeOf<ConstantNode>()
   }
   if (math.isFunctionAssignmentNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.FunctionAssignmentNode>()
+    expectTypeOf(x).toMatchTypeOf<FunctionAssignmentNode>()
   }
   if (math.isFunctionNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.FunctionNode>()
+    expectTypeOf(x).toMatchTypeOf<FunctionNode>()
   }
   if (math.isIndexNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.IndexNode>()
+    expectTypeOf(x).toMatchTypeOf<IndexNode>()
   }
   if (math.isNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.MathNodeCommon>()
+    expectTypeOf(x).toMatchTypeOf<MathNodeCommon>()
   }
   if (math.isNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.MathNodeCommon>()
+    expectTypeOf(x).toMatchTypeOf<MathNodeCommon>()
   }
   if (math.isObjectNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.ObjectNode>()
+    expectTypeOf(x).toMatchTypeOf<ObjectNode>()
   }
   if (math.isOperatorNode(x)) {
     expectTypeOf(x).toMatchTypeOf<
@@ -2173,17 +2185,20 @@ Factory Test
     >()
   }
   if (math.isParenthesisNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.ParenthesisNode>()
+    expectTypeOf(x).toMatchTypeOf<ParenthesisNode>()
   }
   if (math.isRangeNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.RangeNode>()
+    expectTypeOf(x).toMatchTypeOf<RangeNode>()
+  }
+  if (math.isRelationalNode(x)) {
+    expectTypeOf(x).toMatchTypeOf<math.RelationalNode>()
   }
   if (math.isSymbolNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.SymbolNode>()
+    expectTypeOf(x).toMatchTypeOf<SymbolNode>()
   }
   if (math.isChain(x)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expectTypeOf(x).toMatchTypeOf<math.MathJsChain<any>>()
+    expectTypeOf(x).toMatchTypeOf<MathJsChain<any>>()
   }
 }
 
@@ -2194,9 +2209,7 @@ Probability function examples
   const math = create(all, {})
 
   expectTypeOf(math.lgamma(1.5)).toMatchTypeOf<number>()
-  expectTypeOf(
-    math.lgamma(math.complex(1.5, -1.5))
-  ).toMatchTypeOf<math.Complex>()
+  expectTypeOf(math.lgamma(math.complex(1.5, -1.5))).toMatchTypeOf<Complex>()
 }
 
 /*
@@ -2231,7 +2244,22 @@ Resolve examples
   expectTypeOf(
     math.resolve([math.parse('x + y'), 'x*x'], { x: 0 })
   ).toMatchTypeOf<MathNode[]>()
-  expectTypeOf(
-    math.resolve(math.matrix(['x', 'y']))
-  ).toMatchTypeOf<math.Matrix>()
+  expectTypeOf(math.resolve(math.matrix(['x', 'y']))).toMatchTypeOf<Matrix>()
+}
+
+/*
+Random examples
+*/
+{
+  const math = create(all, {})
+  expectTypeOf(math.pickRandom([1, 2, 3])).toMatchTypeOf<number>()
+  expectTypeOf(math.pickRandom(['a', { b: 10 }, 42])).toMatchTypeOf<
+    string | number | { b: number }
+  >()
+  expectTypeOf(math.pickRandom([1, 2, 3])).toMatchTypeOf<number>()
+  expectTypeOf(math.pickRandom([1, 2, 3], 2)).toMatchTypeOf<number[]>()
+
+  expectTypeOf(math.chain([1, 2, 3]).pickRandom(2)).toMatchTypeOf<
+    MathJsChain<number[]>
+  >()
 }

package/types/tsconfig.json

@@ -15,5 +15,8 @@
     "strictNullChecks": false,
     "strictFunctionTypes": true,
     "forceConsistentCasingInFileNames": true
-  }
+  },
+  "files": [
+    "./index.ts"
+  ],
 }