Math.sqrt i.e sqrt is a part of Math namespace.

// 2 ways to get square root.
Math.sqrt(100); // 10, Method 1
100*(1/2); // 10, Method 2
8*(1/3); // 2, works for cubic root also

Math.max() & Math.min():

Math.max(23,54,12,6,32,98,87,34,11); // 98
// Does type coercion also
Math.min(23,54,12,'6',32,98,87,34,11); // 6
// Does not do parsing
Math.min(23,54,12,'6px',32,98,87,34,11); // NaN

Inbuilt constants on Math object:

Math.PI * (Number.parseFloat('10px')**(2)); // Getting area

Generate a no b/w 1-6:

Math.trunc(Math.random() * 6) + 1;

Generatate a random no b/w an upper-lower limit:

const randomInt = (min, max) => Math.floor(Math.random() * (max-min)) + 1 + min;
randomInt(10,20);

// All of these Math.method() do type coercion.
Math.trunc(25.4); // 25
Math.round(25.4); // 25
Math.floor(25.4); // 25
Math.ceil(25.4); // 26

Math.floor is a better choice for negative numbers.

Math.trunc(-25.4); // -25
Math.floor(-25.4); // -26

// Rounding decimals: .toFixed returns a string, not a number
(2.5).toFixed(0); // '3'
(2.5).toFixed(3); // '2.500'
(2.345).toFixed(2); // '2.35'

// Add a unary + sign to convert it to a no.
+(2.345).toFixed(2); // 2.35

// Number is a primitive, hence they don't have methods. SO behind the scene, JS will do boxing, i.e transform primitive into a no object, perform the operation and then when operation is finished, transform it back to primitive.

Modular or Remainder Operator:

5 % 2; // 1

8 % 3; // 2
8 / 3; // 2.6666666666666665

// Odd or Even
const isEven = n => n%2 === 0;
isEven(20);
isEven(21);
isEven(22);

Usecase: Used to work with all odd rows, even rows, nth time etc.

Numeric Separators: [ES2021]

Used for representing really large numbers
These are underscores which can be placed between numbers. The engine ignores these underscores, its reduces the confusion for devs.
Ex. const diameter = 287_460_000_000;
diameter; // 287460000000

const price = 342_25;
price; // 34225

const fee1 = 1_500;
const fee2 = 15_00;
fee1 === fee2; // true

Underscore can be placed ONLY between numbers.
It cannot be placed adjacent to a dot of decimal.
It also cannot be placed at the begining or the end of the no.

const PI = 3.14_15;
PI; // 3.1415

All are invalid example of numeric separators

const PI = 3.1415; // Cannot be placed in the begining.
const PI = 3.1415; // Cannot be placed in the end.
const PI = 3_.1415; // Cannot be placed adjacent to a decimal dot.
const PI = 3.1415; // Cannot be placed adjacent to a decimal dot.
const PI = 3._1415; // Two in a row cannot be placed.

Converting Strings to Numbers:

Number('2500'); // 2500
Number('25_00'); // NaN , Hence we can only use when directly numbers are assigned to a variable. Hence, if a no is stored in the string or getting a no from an API, then to avoid error don't use '_' numeric separator.
Similar goes for parseInt i.e anything after _ is discarded as shown below:
parseInt('25_00'); // 25

BigInt

Special type of integers, introduced in ES2020
Numbers are represented internally as 64 bits i.e 64 1s or 0s to represent any number. Only 53 are used to store the digits, remaining are used to store the position of decimal point and the sign. Hence, there is a limit on the size of the number i.e ((2*53) - 1). This is the biggest no which JS can safely represent. The base is 2, because we are working in binary form while storing.
2*53 - 1; // 9007199254740991
Number.MAX_SAFE_INTEGER; // 9007199254740991

Anything larger than this is not safe i.e it cannot be represented accurately. Precision will be lost for numbers larger than this as shown in last digit. Sometimes it might work, whereas sometimes it won't.
Number.MAX_SAFE_INTEGER + 1; // 9007199254740992
Number.MAX_SAFE_INTEGER + 2; // 9007199254740992
Number.MAX_SAFE_INTEGER + 3; // 9007199254740994
Number.MAX_SAFE_INTEGER + 4; // 9007199254740996

Incase we get a larger no from an API larger than this, then JS won't be able to deal with it. So to resolve the above issue, BigInt a new primitive data type was introduces in ES2020. This can store integers as large as we want.

An 'n' is added at the end of the no to make it a BigInt. Ex.
const num = 283891738917391283734234324223122313243249821n;
num; // 283891738917391283734234324223122313243249821n

BigInt is JS way of displaying such huge numbers.
Another way using Constructor Fn for creating BigInt number.
const x = BigInt(283891738917391283734234324223122313243249821);
x; // 283891738917391288062871194223849945790676992n

Operations: All arithmetic operators work the same with BigInt;
const x = 100n + 100n;
x; // 200n

const x = 10n * 10n;
x; // 100n

Avoid mixing BigInt numbers with regular numbers

const x = 100n;
const y = 10;
z = x*y; // Error

To make it work, use BigInt constructor Fn:
z = x * BigInt(y);
z; // 1000n

Exception to it are comparsion operators & unary + operator.

20n > 19; // true
20n === 20; // false, === prevents JS from doing type coercion. Both the LHS & RHS have different primitive types, hence results in 'false'.

typeof 20n; // 'bigint'
typeof 20; // 'number'

20n == 20; // true, as JS does type coercion to compare only the values and not the types by converting BigInt to a regular number.
Same goes for this also: 20n == '20'; // true

Exception:

BigInt number is not converted to string on using + operator.
const num = 248923874328974239473829n
"num is huge i.e. " + num; // 'num is huge i.e. 248923874328974239473829'

Note:
Math.sqrt doesn't work with BigInt.
During division of BigInts, it discards the decimal part.
10 / 3; // 3.3333333333333335
10n / 3n; // 3n
12n / 3n; // 4n

This new primitive type adds some new capabilities to JS language to make it work with huge no.