> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript Exponentiation
The `**` operator is the exponentiation operator in TypeScript, evaluating to the result of raising the left operand (base) to the power of the right operand (exponent). While mathematically equivalent to `Math.pow()`, the `**` operator natively supports both `number` and `bigint` operands. In contrast, `Math.pow()` strictly accepts `number` types; passing a `bigint` to `Math.pow()` results in a TypeScript compile-time error (`Argument of type 'bigint' is not assignable to parameter of type 'number'`).
```typescript theme={"dark"}
base ** exponent
```
## Type Constraints and BigInt Behavior
TypeScript enforces strict type checking on the operands. Both the base and the exponent must be of type `number` or `bigint`, and both operands must be of the exact same type. Mixing types will result in a compiler error.
Furthermore, when using `bigint` operands, the exponent must be non-negative. Because the `bigint` type cannot represent fractional values, evaluating a `bigint` base with a negative `bigint` exponent throws a runtime `RangeError`.
```typescript theme={"dark"}
const num: number = 3 ** 4; // Valid: 81
const big: bigint = 2n ** 64n; // Valid: 18446744073709551616n
// @ts-expect-error: Operator '**' cannot be applied to types 'bigint' and 'number'.
const mixed = 2n ** 3;
// Compiles successfully, but throws a runtime RangeError: BigInt negative exponent
const negativeBigIntExponent = 2n ** -1n;
```
## Associativity
Unlike most binary operators in TypeScript (which are left-associative), the `**` operator is **right-associative**. Multiple exponentiation operations in a single expression are evaluated from right to left.
```typescript theme={"dark"}
const result = 2 ** 3 ** 2;
// Evaluates as: 2 ** (3 ** 2) -> 2 ** 9 -> 512
// NOT as: (2 ** 3) ** 2 -> 8 ** 2 -> 64
```
## Precedence and Unary Operators
The `**` operator has a higher precedence than standard arithmetic operators (`*`, `/`, `+`, `-`). However, TypeScript enforces a strict parsing rule: a unary operator (such as `-`, `+`, `~`, `!`) cannot immediately precede the base operand of an unparenthesized exponentiation expression. This prevents ambiguity regarding whether the unary operator applies to the base or the evaluated result.
```typescript theme={"dark"}
// TS SyntaxError: Unary operator used immediately before exponentiation expression.
// const invalid = -2 ** 2;
// Valid: Unary operator applied to the base
const negativeBase = (-2) ** 2; // Evaluates to 4
// Valid: Unary operator applied to the evaluated exponentiation expression
const negativeResult = -(2 ** 2); // Evaluates to -4
```
## Compound Assignment
The operator includes a compound assignment variant, `**=`, which applies the exponentiation operation to a variable and assigns the result back to that variable.
```typescript theme={"dark"}
let x: number = 5;
x **= 3; // Syntactic sugar for: x = x ** 3
// x is now 125
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
