skittles 0.1.0 → 0.1.3

package/README.md

@@ -2,9 +2,10 @@ Make it a cli app
 Create and deploy package
 save artifacts/build
 Remove tabs in yul, surely this can be automated or somethign
-Use the `FoxOperator` strings for the assemby stuff
+Use the `SkittlesOperator` strings for the assemby stuff
 Try changing balance to 1 in the contract and run tests
 add prepublish
+tsconfig error
 
 Add more support
 remove Token.yul

package/lib/compiler.js

@@ -14,11 +14,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileTypeScriptToBytecode = void 0;
 const get_bytecode_1 = __importDefault(require("./get-bytecode"));
-const get_fox_class_1 = __importDefault(require("./get-fox-class"));
+const get_skittles_class_1 = __importDefault(require("./get-skittles-class"));
 const get_yul_1 = __importDefault(require("./get-yul"));
 const compileTypeScriptToBytecode = (fileName) => __awaiter(void 0, void 0, void 0, function* () {
-    const foxClass = (0, get_fox_class_1.default)(fileName);
+    const skittlesClass = (0, get_skittles_class_1.default)(fileName);
     const yul = (0, get_yul_1.default)(fileName);
-    return (0, get_bytecode_1.default)(foxClass.name, yul);
+    return (0, get_bytecode_1.default)(skittlesClass.name, yul);
 });
 exports.compileTypeScriptToBytecode = compileTypeScriptToBytecode;

package/lib/get-abi.js

@@ -21,10 +21,10 @@ const getMethodAbi = (method) => {
         stateMutability: method.view ? "view" : "payable",
     };
 };
-const getAbi = (foxClass) => {
+const getAbi = (skittlesClass) => {
     return [
-        ...foxClass.properties.filter((p) => !p.private).map(getPropertyAbi),
-        ...foxClass.methods.filter((p) => !p.private).map(getMethodAbi),
+        ...skittlesClass.properties.filter((p) => !p.private).map(getPropertyAbi),
+        ...skittlesClass.methods.filter((p) => !p.private).map(getMethodAbi),
     ];
 };
 exports.default = getAbi;

package/lib/{get-fox-class.js → get-skittles-class.js}

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFoxParameters = void 0;
+exports.getSkittlesParameters = void 0;
 const typescript_1 = require("typescript");
 const get_ast_1 = __importDefault(require("./get-ast"));
 const ast_helper_1 = require("./helpers/ast-helper");
-const fox_class_1 = require("./types/fox-class");
-const getFoxType = (syntaxKind) => {
+const skittles_class_1 = require("./types/skittles-class");
+const getSkittlesType = (syntaxKind) => {
     if (!syntaxKind)
         return "void";
     switch (syntaxKind) {
@@ -26,63 +26,63 @@ const getFoxType = (syntaxKind) => {
             throw new Error(`Unknown syntax kind: ${syntaxKind}`);
     }
 };
-const getFoxOperator = (syntaxKind) => {
+const getSkittlesOperator = (syntaxKind) => {
     switch (syntaxKind) {
         case typescript_1.SyntaxKind.PlusToken:
-            return fox_class_1.FoxOperator.Plus;
+            return skittles_class_1.SkittlesOperator.Plus;
         case typescript_1.SyntaxKind.MinusToken:
-            return fox_class_1.FoxOperator.Minus;
+            return skittles_class_1.SkittlesOperator.Minus;
         case typescript_1.SyntaxKind.AsteriskToken:
-            return fox_class_1.FoxOperator.Multiply;
+            return skittles_class_1.SkittlesOperator.Multiply;
         case typescript_1.SyntaxKind.SlashToken:
-            return fox_class_1.FoxOperator.Divide;
+            return skittles_class_1.SkittlesOperator.Divide;
         case typescript_1.SyntaxKind.PercentToken:
-            return fox_class_1.FoxOperator.Modulo;
+            return skittles_class_1.SkittlesOperator.Modulo;
         case typescript_1.SyntaxKind.AmpersandAmpersandToken:
-            return fox_class_1.FoxOperator.And;
+            return skittles_class_1.SkittlesOperator.And;
         case typescript_1.SyntaxKind.BarBarToken:
-            return fox_class_1.FoxOperator.Or;
+            return skittles_class_1.SkittlesOperator.Or;
         case typescript_1.SyntaxKind.EqualsEqualsToken:
-            return fox_class_1.FoxOperator.Equals;
+            return skittles_class_1.SkittlesOperator.Equals;
         case typescript_1.SyntaxKind.ExclamationEqualsToken:
-            return fox_class_1.FoxOperator.NotEquals;
+            return skittles_class_1.SkittlesOperator.NotEquals;
         case typescript_1.SyntaxKind.LessThanToken:
-            return fox_class_1.FoxOperator.LessThan;
+            return skittles_class_1.SkittlesOperator.LessThan;
         case typescript_1.SyntaxKind.LessThanEqualsToken:
-            return fox_class_1.FoxOperator.LessThanOrEqual;
+            return skittles_class_1.SkittlesOperator.LessThanOrEqual;
         case typescript_1.SyntaxKind.GreaterThanToken:
-            return fox_class_1.FoxOperator.GreaterThan;
+            return skittles_class_1.SkittlesOperator.GreaterThan;
         case typescript_1.SyntaxKind.GreaterThanEqualsToken:
-            return fox_class_1.FoxOperator.GreaterThanOrEqual;
+            return skittles_class_1.SkittlesOperator.GreaterThanOrEqual;
         default:
             throw new Error(`Unknown syntax kind: ${syntaxKind}`);
     }
 };
-const getFoxExpression = (expression) => {
+const getSkittlesExpression = (expression) => {
     if ((0, typescript_1.isLiteralExpression)(expression)) {
         return {
-            expressionType: fox_class_1.FoxExpressionType.Value,
+            expressionType: skittles_class_1.SkittlesExpressionType.Value,
             value: expression.text,
         };
     }
     if ((0, typescript_1.isIdentifier)(expression)) {
         return {
-            expressionType: fox_class_1.FoxExpressionType.Value,
+            expressionType: skittles_class_1.SkittlesExpressionType.Value,
             value: expression.escapedText,
         };
     }
     if ((0, typescript_1.isPropertyAccessExpression)(expression)) {
         return {
-            expressionType: fox_class_1.FoxExpressionType.Storage,
+            expressionType: skittles_class_1.SkittlesExpressionType.Storage,
             variable: (0, ast_helper_1.getNodeName)(expression),
         };
     }
     if ((0, typescript_1.isBinaryExpression)(expression)) {
         return {
-            expressionType: fox_class_1.FoxExpressionType.Binary,
-            left: getFoxExpression(expression.left),
-            right: getFoxExpression(expression.right),
-            operator: getFoxOperator(expression.operatorToken.kind),
+            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+            left: getSkittlesExpression(expression.left),
+            right: getSkittlesExpression(expression.right),
+            operator: getSkittlesOperator(expression.operatorToken.kind),
         };
     }
     throw new Error(`Unknown expression type: ${expression.kind}`);
@@ -96,14 +96,14 @@ const isNodePrivate = (node) => {
     });
     return isPrivate;
 };
-const getFoxProperty = (astProperty) => {
+const getSkittlesProperty = (astProperty) => {
     if (!astProperty.type)
         throw new Error("Could not get property type");
     const initializer = astProperty.initializer;
     return {
         name: (0, ast_helper_1.getNodeName)(astProperty),
-        type: getFoxType(astProperty.type.kind),
-        value: initializer ? getFoxExpression(initializer) : undefined,
+        type: getSkittlesType(astProperty.type.kind),
+        value: initializer ? getSkittlesExpression(initializer) : undefined,
         private: isNodePrivate(astProperty),
     };
 };
@@ -123,53 +123,53 @@ const isNodeView = (node) => {
     });
     return isView;
 };
-const getFoxParameters = (node) => {
+const getSkittlesParameters = (node) => {
     const inputs = [];
     (0, typescript_1.forEachChild)(node, (node) => {
         var _a;
         if ((0, typescript_1.isParameter)(node)) {
             inputs.push({
                 name: (0, ast_helper_1.getNodeName)(node),
-                type: getFoxType((_a = node.type) === null || _a === void 0 ? void 0 : _a.kind),
+                type: getSkittlesType((_a = node.type) === null || _a === void 0 ? void 0 : _a.kind),
             });
         }
     });
     return inputs;
 };
-exports.getFoxParameters = getFoxParameters;
-const getFoxStatement = (node, returnType) => {
+exports.getSkittlesParameters = getSkittlesParameters;
+const getSkittlesStatement = (node, returnType) => {
     if ((0, typescript_1.isExpressionStatement)(node)) {
         const expression = node.expression;
         if ((0, typescript_1.isBinaryExpression)(expression)) {
             if ((0, typescript_1.isPropertyAccessExpression)(expression.left)) {
                 if ((0, ast_helper_1.isEquals)(expression)) {
                     return {
-                        statementType: fox_class_1.FoxStatementType.StorageUpdate,
+                        statementType: skittles_class_1.SkittlesStatementType.StorageUpdate,
                         variable: (0, ast_helper_1.getNodeName)(expression.left),
-                        value: getFoxExpression(expression.right),
+                        value: getSkittlesExpression(expression.right),
                     };
                 }
                 if ((0, ast_helper_1.isPlusEquals)(expression)) {
                     return {
-                        statementType: fox_class_1.FoxStatementType.StorageUpdate,
+                        statementType: skittles_class_1.SkittlesStatementType.StorageUpdate,
                         variable: (0, ast_helper_1.getNodeName)(expression.left),
                         value: {
-                            expressionType: fox_class_1.FoxExpressionType.Binary,
-                            operator: fox_class_1.FoxOperator.Plus,
-                            left: getFoxExpression(expression.left),
-                            right: getFoxExpression(expression.right),
+                            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+                            operator: skittles_class_1.SkittlesOperator.Plus,
+                            left: getSkittlesExpression(expression.left),
+                            right: getSkittlesExpression(expression.right),
                         },
                     };
                 }
                 if ((0, ast_helper_1.isMinusEquals)(expression)) {
                     return {
-                        statementType: fox_class_1.FoxStatementType.StorageUpdate,
+                        statementType: skittles_class_1.SkittlesStatementType.StorageUpdate,
                         variable: (0, ast_helper_1.getNodeName)(expression.left),
                         value: {
-                            expressionType: fox_class_1.FoxExpressionType.Binary,
-                            operator: fox_class_1.FoxOperator.Minus,
-                            left: getFoxExpression(expression.left),
-                            right: getFoxExpression(expression.right),
+                            expressionType: skittles_class_1.SkittlesExpressionType.Binary,
+                            operator: skittles_class_1.SkittlesOperator.Minus,
+                            left: getSkittlesExpression(expression.left),
+                            right: getSkittlesExpression(expression.right),
                         },
                     };
                 }
@@ -185,34 +185,34 @@ const getFoxStatement = (node, returnType) => {
             throw new Error("Return statement has no expression");
         if ((0, typescript_1.isBinaryExpression)(expression)) {
             return {
-                statementType: fox_class_1.FoxStatementType.Return,
+                statementType: skittles_class_1.SkittlesStatementType.Return,
                 type: returnType,
-                value: getFoxExpression(node.expression),
+                value: getSkittlesExpression(node.expression),
             };
         }
     }
     throw new Error(`Unknown statement type: ${node.kind}`);
 };
-const getFoxMethod = (astMethod) => {
+const getSkittlesMethod = (astMethod) => {
     var _a, _b;
     return {
         name: (0, ast_helper_1.getNodeName)(astMethod),
-        returns: getFoxType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind),
+        returns: getSkittlesType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind),
         private: isNodePrivate(astMethod),
         view: isNodeView(astMethod),
-        parameters: (0, exports.getFoxParameters)(astMethod),
-        statements: ((_b = astMethod.body) === null || _b === void 0 ? void 0 : _b.statements.map((statement) => { var _a; return getFoxStatement(statement, getFoxType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind)); })) || [],
+        parameters: (0, exports.getSkittlesParameters)(astMethod),
+        statements: ((_b = astMethod.body) === null || _b === void 0 ? void 0 : _b.statements.map((statement) => { var _a; return getSkittlesStatement(statement, getSkittlesType((_a = astMethod.type) === null || _a === void 0 ? void 0 : _a.kind)); })) || [],
     };
 };
-const getFoxClass = (file) => {
+const getSkittlesClass = (file) => {
     const ast = (0, get_ast_1.default)(file);
     const classNode = (0, ast_helper_1.getClassNode)(ast);
     const astProperties = classNode.members.filter(typescript_1.isPropertyDeclaration);
     const astMethods = classNode.members.filter(typescript_1.isMethodDeclaration);
     return {
         name: (0, ast_helper_1.getNodeName)(classNode),
-        properties: astProperties.map(getFoxProperty),
-        methods: astMethods.map(getFoxMethod),
+        properties: astProperties.map(getSkittlesProperty),
+        methods: astMethods.map(getSkittlesMethod),
     };
 };
-exports.default = getFoxClass;
+exports.default = getSkittlesClass;

package/lib/get-yul.js

@@ -29,8 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const yul_template_1 = __importStar(require("./data/yul-template"));
 const get_abi_1 = __importDefault(require("./get-abi"));
 const get_selector_1 = __importDefault(require("./get-selector"));
-const get_fox_class_1 = __importDefault(require("./get-fox-class"));
-const fox_class_1 = require("./types/fox-class");
+const get_skittles_class_1 = __importDefault(require("./get-skittles-class"));
+const skittles_class_1 = require("./types/skittles-class");
 const addToSection = (yul, section, lines) => {
     const sectionIndex = yul.findIndex((line) => line.includes(`- ${section} -`));
     if (sectionIndex === -1) {
@@ -82,33 +82,33 @@ const addMethodDispatcher = (yul, abi, method) => {
 const getBinaryYul = (expression) => {
     const { left, right, operator } = expression;
     switch (operator) {
-        case fox_class_1.FoxOperator.Plus:
+        case skittles_class_1.SkittlesOperator.Plus:
             return `safeAdd(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Minus:
+        case skittles_class_1.SkittlesOperator.Minus:
             return `sub(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Multiply:
+        case skittles_class_1.SkittlesOperator.Multiply:
             return `mul(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Divide:
+        case skittles_class_1.SkittlesOperator.Divide:
             return `div(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Modulo:
+        case skittles_class_1.SkittlesOperator.Modulo:
             return `mod(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Equals:
+        case skittles_class_1.SkittlesOperator.Equals:
             return `eq(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.NotEquals:
+        case skittles_class_1.SkittlesOperator.NotEquals:
             return `not(eq(${getExpressionYul(left)}, ${getExpressionYul(right)}))`;
-        case fox_class_1.FoxOperator.GreaterThan:
+        case skittles_class_1.SkittlesOperator.GreaterThan:
             return `gt(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.LessThan:
+        case skittles_class_1.SkittlesOperator.LessThan:
             return `lt(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.GreaterThanOrEqual:
+        case skittles_class_1.SkittlesOperator.GreaterThanOrEqual:
             return `gte(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.LessThanOrEqual:
+        case skittles_class_1.SkittlesOperator.LessThanOrEqual:
             return `lte(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.And:
+        case skittles_class_1.SkittlesOperator.And:
             return `and(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Or:
+        case skittles_class_1.SkittlesOperator.Or:
             return `or(${getExpressionYul(left)}, ${getExpressionYul(right)})`;
-        case fox_class_1.FoxOperator.Not:
+        case skittles_class_1.SkittlesOperator.Not:
             return `not(${getExpressionYul(left)})`;
         default:
             throw new Error(`Unsupported binary operator ${operator}`);
@@ -116,11 +116,11 @@ const getBinaryYul = (expression) => {
 };
 const getExpressionYul = (expression) => {
     switch (expression.expressionType) {
-        case fox_class_1.FoxExpressionType.Binary:
+        case skittles_class_1.SkittlesExpressionType.Binary:
             return getBinaryYul(expression);
-        case fox_class_1.FoxExpressionType.Value:
+        case skittles_class_1.SkittlesExpressionType.Value:
             return expression.value;
-        case fox_class_1.FoxExpressionType.Storage:
+        case skittles_class_1.SkittlesExpressionType.Storage:
             return `${expression.variable}Storage()`;
         default:
             throw new Error("Unsupported expression");
@@ -136,9 +136,9 @@ const getReturnYul = (statement) => {
 };
 const getStatementYul = (statement) => {
     switch (statement.statementType) {
-        case fox_class_1.FoxStatementType.StorageUpdate:
+        case skittles_class_1.SkittlesStatementType.StorageUpdate:
             return getStorageUpdateYul(statement);
-        case fox_class_1.FoxStatementType.Return:
+        case skittles_class_1.SkittlesStatementType.Return:
             return getReturnYul(statement);
         default:
             throw new Error("Unsupported statement");
@@ -178,18 +178,18 @@ const addStorageAccess = (yul, property) => {
 };
 const getYul = (file) => {
     // Getting base data
-    const foxClass = (0, get_fox_class_1.default)(file);
-    const abi = (0, get_abi_1.default)(foxClass);
-    let yul = getBaseYul(foxClass.name);
+    const skittlesClass = (0, get_skittles_class_1.default)(file);
+    const abi = (0, get_abi_1.default)(skittlesClass);
+    let yul = getBaseYul(skittlesClass.name);
     // Adding properties
-    foxClass.properties.forEach((property, index) => {
+    skittlesClass.properties.forEach((property, index) => {
         yul = addPropertyDispatcher(yul, abi, property);
         yul = addStorageLayout(yul, property, index);
         yul = addStorageAccess(yul, property);
         // TODO Handle private properties
     });
     // Adding methods
-    foxClass.methods.forEach((method) => {
+    skittlesClass.methods.forEach((method) => {
         yul = addMethodDispatcher(yul, abi, method);
         yul = addMethodFunction(yul, method);
         // TODO Handle private methods

package/lib/index.js

@@ -15,9 +15,12 @@ const compiler_1 = require("./compiler");
 const file_helper_1 = require("./helpers/file-helper");
 // clear();
 // console.log(
-//   chalk.red(figlet.textSync("fox-cli", { horizontalLayout: "full" }))
+//   chalk.red(figlet.textSync("skittles-cli", { horizontalLayout: "full" }))
 // );
-commander_1.program.name("fox").description("CLI for the Fox compiler").version("0.1.0");
+commander_1.program
+    .name("skittles")
+    .description("CLI for the Skittles compiler")
+    .version("0.1.0");
 // program
 //   .command("compile")
 //   .description("Compile TypeScript file")

package/lib/types/skittles-class.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkittlesStatementType = exports.SkittlesOperator = exports.SkittlesExpressionType = void 0;
+var SkittlesExpressionType;
+(function (SkittlesExpressionType) {
+    SkittlesExpressionType["Binary"] = "Binary";
+    SkittlesExpressionType["Value"] = "Value";
+    SkittlesExpressionType["Storage"] = "Storage";
+})(SkittlesExpressionType = exports.SkittlesExpressionType || (exports.SkittlesExpressionType = {}));
+var SkittlesOperator;
+(function (SkittlesOperator) {
+    SkittlesOperator["Plus"] = "+";
+    SkittlesOperator["Minus"] = "-";
+    SkittlesOperator["Multiply"] = "*";
+    SkittlesOperator["Divide"] = "/";
+    SkittlesOperator["Modulo"] = "%";
+    SkittlesOperator["Equals"] = "==";
+    SkittlesOperator["NotEquals"] = "!=";
+    SkittlesOperator["GreaterThan"] = ">";
+    SkittlesOperator["LessThan"] = "<";
+    SkittlesOperator["GreaterThanOrEqual"] = ">=";
+    SkittlesOperator["LessThanOrEqual"] = "<=";
+    SkittlesOperator["And"] = "&&";
+    SkittlesOperator["Or"] = "||";
+    SkittlesOperator["Not"] = "!";
+})(SkittlesOperator = exports.SkittlesOperator || (exports.SkittlesOperator = {}));
+var SkittlesStatementType;
+(function (SkittlesStatementType) {
+    SkittlesStatementType["StorageUpdate"] = "StorageUpdate";
+    SkittlesStatementType["Return"] = "Return";
+})(SkittlesStatementType = exports.SkittlesStatementType || (exports.SkittlesStatementType = {}));

package/package.json

@@ -1,33 +1,34 @@
 {
   "name": "skittles",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "TypeScript Smart Contract Language for the EVM",
   "main": "./lib/index.js",
   "bin": {
-    "fox": "./lib/index.js"
+    "skittles": "./lib/index.js"
   },
   "scripts": {
     "start": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts",
     "create": "yarn run build && yarn run test",
     "build": "tsc -p .",
     "refresh": "rm -rf ./node_modules ./package-lock.json && yarn",
-    "local": "sudo yarn global add && fox",
+    "local": "sudo yarn global add && skittles",
     "test": "hardhat test"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/chase-manning/fox.git"
+    "url": "git+https://github.com/chase-manning/skittles.git"
   },
   "author": "Chase Manning",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/chase-manning/fox/issues"
+    "url": "https://github.com/chase-manning/skittles/issues"
   },
-  "homepage": "https://github.com/chase-manning/fox#readme",
+  "homepage": "https://github.com/chase-manning/skittles#readme",
   "dependencies": {
     "chalk": "4.1.2",
     "clear": "^0.1.0",
     "commander": "^9.4.0",
+    "ethers": "^5.6.9",
     "figlet": "^1.5.2",
     "path": "^0.12.7",
     "solc": "^0.8.16",
@@ -56,7 +57,6 @@
     "eslint-plugin-prettier": "^3.4.1",
     "eslint-plugin-promise": "^5.2.0",
     "ethereum-waffle": "^3.4.4",
-    "ethers": "^5.6.9",
     "hardhat": "^2.10.1",
     "hardhat-gas-reporter": "^1.0.8",
     "nodemon": "^2.0.19",

package/lib/types/fox-class.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FoxStatementType = exports.FoxOperator = exports.FoxExpressionType = void 0;
-var FoxExpressionType;
-(function (FoxExpressionType) {
-    FoxExpressionType["Binary"] = "Binary";
-    FoxExpressionType["Value"] = "Value";
-    FoxExpressionType["Storage"] = "Storage";
-})(FoxExpressionType = exports.FoxExpressionType || (exports.FoxExpressionType = {}));
-var FoxOperator;
-(function (FoxOperator) {
-    FoxOperator["Plus"] = "+";
-    FoxOperator["Minus"] = "-";
-    FoxOperator["Multiply"] = "*";
-    FoxOperator["Divide"] = "/";
-    FoxOperator["Modulo"] = "%";
-    FoxOperator["Equals"] = "==";
-    FoxOperator["NotEquals"] = "!=";
-    FoxOperator["GreaterThan"] = ">";
-    FoxOperator["LessThan"] = "<";
-    FoxOperator["GreaterThanOrEqual"] = ">=";
-    FoxOperator["LessThanOrEqual"] = "<=";
-    FoxOperator["And"] = "&&";
-    FoxOperator["Or"] = "||";
-    FoxOperator["Not"] = "!";
-})(FoxOperator = exports.FoxOperator || (exports.FoxOperator = {}));
-var FoxStatementType;
-(function (FoxStatementType) {
-    FoxStatementType["StorageUpdate"] = "StorageUpdate";
-    FoxStatementType["Return"] = "Return";
-})(FoxStatementType = exports.FoxStatementType || (exports.FoxStatementType = {}));