Add Exponentiation support

Author: thinknathan

README.md

@@ -4,9 +4,10 @@ TypeScriptToLua plugin that performs [constant folding](https://en.wikipedia.org
 
 - Addition (+)
 - Subtraction (-)
-- Multiplication (*)
+- Multiplication (\*)
 - Division (/)
 - Modulo (%)
+- Exponentiation (\*\*)
 
 ## Example
 

dist/tstl-unroller.cjs

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ts = require("typescript");
-const tstl = require("typescript-to-lua");
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const ts = require('typescript');
+const tstl = require('typescript-to-lua');
 const constantUnroller = {
-    visitors: {
-        [ts.SyntaxKind.BinaryExpression]: (node, context) => {
-            const operator = node.operatorToken.kind;
-            const left = context.transformExpression(node.left);
-            const right = context.transformExpression(node.right);
-            if (tstl.isNumericLiteral(left) && tstl.isNumericLiteral(right)) {
-                switch (operator) {
-                    case ts.SyntaxKind.AsteriskToken:
-                        return tstl.createNumericLiteral(left.value * right.value);
-                    case ts.SyntaxKind.PlusToken:
-                        return tstl.createNumericLiteral(left.value + right.value);
-                    case ts.SyntaxKind.MinusToken:
-                        return tstl.createNumericLiteral(left.value - right.value);
-                    case ts.SyntaxKind.SlashToken:
-                        return tstl.createNumericLiteral(left.value / right.value);
-                    case ts.SyntaxKind.PercentToken:
-                        return tstl.createNumericLiteral(left.value % right.value);
-                }
-            }
-            return context.superTransformExpression(node);
-        },
-    },
+	visitors: {
+		[ts.SyntaxKind.BinaryExpression]: (node, context) => {
+			const operator = node.operatorToken.kind;
+			const left = context.transformExpression(node.left);
+			const right = context.transformExpression(node.right);
+			if (tstl.isNumericLiteral(left) && tstl.isNumericLiteral(right)) {
+				switch (operator) {
+					case ts.SyntaxKind.AsteriskToken:
+						return tstl.createNumericLiteral(left.value * right.value);
+					case ts.SyntaxKind.PlusToken:
+						return tstl.createNumericLiteral(left.value + right.value);
+					case ts.SyntaxKind.MinusToken:
+						return tstl.createNumericLiteral(left.value - right.value);
+					case ts.SyntaxKind.SlashToken:
+						return tstl.createNumericLiteral(left.value / right.value);
+					case ts.SyntaxKind.PercentToken:
+						return tstl.createNumericLiteral(left.value % right.value);
+				}
+			}
+			return context.superTransformExpression(node);
+		},
+	},
 };
 exports.default = constantUnroller;

tstl-unroller.ts

@@ -1,29 +1,33 @@
-import * as ts from "typescript";
-import * as tstl from "typescript-to-lua";
+import * as ts from 'typescript';
+import * as tstl from 'typescript-to-lua';
 
 const constantUnroller: tstl.Plugin = {
-  visitors: {
-    [ts.SyntaxKind.BinaryExpression]: (node, context) => {
-      const operator = node.operatorToken.kind;
-      const left = context.transformExpression(node.left);
-      const right = context.transformExpression(node.right);
-      if (tstl.isNumericLiteral(left) && tstl.isNumericLiteral(right)) {
-        switch (operator) {
-          case ts.SyntaxKind.AsteriskToken:
-            return tstl.createNumericLiteral(left.value * right.value);
-          case ts.SyntaxKind.PlusToken:
-            return tstl.createNumericLiteral(left.value + right.value);
-          case ts.SyntaxKind.MinusToken:
-            return tstl.createNumericLiteral(left.value - right.value);
-          case ts.SyntaxKind.SlashToken:
-            return tstl.createNumericLiteral(left.value / right.value);
+	visitors: {
+		[ts.SyntaxKind.BinaryExpression]: (node, context) => {
+			const operator = node.operatorToken.kind;
+			const left = context.transformExpression(node.left);
+			const right = context.transformExpression(node.right);
+
+			if (tstl.isNumericLiteral(left) && tstl.isNumericLiteral(right)) {
+				switch (operator) {
+					case ts.SyntaxKind.AsteriskToken:
+						return tstl.createNumericLiteral(left.value * right.value);
+					case ts.SyntaxKind.PlusToken:
+						return tstl.createNumericLiteral(left.value + right.value);
+					case ts.SyntaxKind.MinusToken:
+						return tstl.createNumericLiteral(left.value - right.value);
+					case ts.SyntaxKind.SlashToken:
+						return tstl.createNumericLiteral(left.value / right.value);
 					case ts.SyntaxKind.PercentToken:
-            return tstl.createNumericLiteral(left.value % right.value);
-        }
-      }
-      return context.superTransformExpression(node);
-    },
-  },
+						return tstl.createNumericLiteral(left.value % right.value);
+					case ts.SyntaxKind.AsteriskAsteriskToken:
+						return tstl.createNumericLiteral(Math.pow(left.value, right.value));
+				}
+			}
+
+			return context.superTransformExpression(node);
+		},
+	},
 };
 
 export default constantUnroller;