@needle-tools/needle-component-compiler 1.9.2-exp → 1.9.2

package/test/csharp/codegen/static method/input.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.MyComponent = void 0;
+var MyComponent = /** @class */ (function (_super) {
+    __extends(MyComponent, _super);
+    function MyComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MyComponent.myMethod = function () { };
+    return MyComponent;
+}(Behaviour));
+exports.MyComponent = MyComponent;

package/test/csharp/codegen/static method/input.ts

@@ -0,0 +1,3 @@
+export class MyComponent extends Behaviour {
+    public static myMethod(): void {}
+}

package/test/csharp/codegen/static method/output.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+// auto generated code - do not edit directly
+
+#pragma warning disable
+
+namespace Needle.Typescript.GeneratedComponents
+{
+	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+		public void myMethod(){}
+	}
+}
+
+// NEEDLE_CODEGEN_END

package/test/csharp/codegen/string/expected.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+    // auto generated code - do not edit directly
+    
+    #pragma warning disable
+    
+    namespace Needle.Typescript.GeneratedComponents
+    {
+    	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+    public string @myField;
+	}
+    }
+    
+    // NEEDLE_CODEGEN_END

package/test/csharp/codegen/string/input.js

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.MyComponent = void 0;
+var MyComponent = /** @class */ (function (_super) {
+    __extends(MyComponent, _super);
+    function MyComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MyComponent;
+}(Behaviour));
+exports.MyComponent = MyComponent;

package/test/csharp/codegen/string/input.ts

@@ -0,0 +1,3 @@
+export class MyComponent extends Behaviour {
+    public myField: string;
+}

package/test/csharp/codegen/string/output.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+// auto generated code - do not edit directly
+
+#pragma warning disable
+
+namespace Needle.Typescript.GeneratedComponents
+{
+	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+		public string @myField;
+	}
+}
+
+// NEEDLE_CODEGEN_END

package/test/csharp/codegen/stringArray/expected.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+    // auto generated code - do not edit directly
+    
+    #pragma warning disable
+    
+    namespace Needle.Typescript.GeneratedComponents
+    {
+    	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+    public string[] @myField;
+	}
+    }
+    
+    // NEEDLE_CODEGEN_END

package/test/csharp/codegen/stringArray/input.js

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.MyComponent = void 0;
+var MyComponent = /** @class */ (function (_super) {
+    __extends(MyComponent, _super);
+    function MyComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MyComponent;
+}(Behaviour));
+exports.MyComponent = MyComponent;

package/test/csharp/codegen/stringArray/input.ts

@@ -0,0 +1,3 @@
+export class MyComponent extends Behaviour {
+    public myField: string[];
+}

package/test/csharp/codegen/stringArray/output.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+// auto generated code - do not edit directly
+
+#pragma warning disable
+
+namespace Needle.Typescript.GeneratedComponents
+{
+	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+		public string[] @myField;
+	}
+}
+
+// NEEDLE_CODEGEN_END

package/test/helpers.ts

@@ -0,0 +1,72 @@
+import { compile } from "../src/component-compiler";
+import { expect } from 'chai';
+import * as fs from "fs";
+import { debuglog } from "util";
+
+class TestOptions {
+    ignoreWhiteSpace: boolean = true;
+}
+
+export function testCompile(code: string): string | null {
+
+    const res = compile(code, "test", null, false);
+    const output = res?.length > 0 ? res[0] : "";
+
+    return output;
+
+}
+
+function compareByLine(output: string, expected: string) {
+    const splitCode = /\r?\n/;
+
+    if (output == null) {
+
+        expect(expected).to.equal(output);
+    }
+    else {
+
+        const outputLines = output.split(splitCode);
+        const expectedLines = expected.split(splitCode);
+        for (let i = 0; i < outputLines.length; i++) {
+            const outputLine = outputLines[i].trim();
+            const expectedLine = expectedLines[i].trim();
+            expect(outputLine).to.equal(expectedLine, `Line ${i} does not match`);
+        }
+    }
+
+}
+
+export function compareCodegen(id: string, input: string, expected: string) {
+    const baseDir = "test/codegen";
+    if (!fs.existsSync(baseDir))
+        fs.mkdirSync(baseDir);
+    const dir = `${baseDir}/${id}`;
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir);
+    fs.writeFileSync(`${dir}\\input.ts`, input);
+    const result = testCompile(input);
+    if (result !== null)
+        fs.writeFileSync(`${dir}\\output.cs`, result);
+    fs.writeFileSync(`${dir}\\expected.cs`, expected);
+
+    compareByLine(result, expected);
+
+    // expect(result).to.equal(expected);
+}
+
+export function compareCodegenWithDefaultContext(id: string, input: string, expected: string) {
+
+
+    expected = `// NEEDLE_CODEGEN_START
+    // auto generated code - do not edit directly
+    
+    #pragma warning disable
+    
+    namespace Needle.Typescript.GeneratedComponents
+    {
+    \t` + expected + `
+    }
+    
+    // NEEDLE_CODEGEN_END`;
+    return compareCodegen(id, input, expected);
+}

package/workspace.code-workspace

@@ -1,12 +1,12 @@
-{
-	"folders": [
-		{
-			"path": "."
-		}
-	],
-	"settings": {
-		"files.exclude": {
-		  "test/*.js": true
-		}
-	}
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {
+		"files.exclude": {
+		  "test/*.js": true
+		}
+	}
 }

package/src/base-compiler.js

@@ -1,404 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.Compiler = exports.runFromFile = exports.CodeTextWriter = exports.Visibility = void 0;
-var fs_1 = require("fs");
-var ts = require("typescript");
-var fs = require("fs");
-var Visibility;
-(function (Visibility) {
-    Visibility[Visibility["Public"] = 0] = "Public";
-    Visibility[Visibility["Protected"] = 1] = "Protected";
-    Visibility[Visibility["Private"] = 2] = "Private";
-})(Visibility = exports.Visibility || (exports.Visibility = {}));
-var CodeTextWriter = /** @class */ (function () {
-    function CodeTextWriter() {
-        this.indent = 0;
-        this.lines = [];
-    }
-    CodeTextWriter.prototype.beginBlock = function (line) {
-        this.writeLine(line);
-        this.indent++;
-    };
-    CodeTextWriter.prototype.endBlock = function (line) {
-        // remove the comma from the last line
-        if (this.lines.length > 0) {
-            var prevLine = this.lines[this.lines.length - 1];
-            if (prevLine.endsWith(",")) {
-                this.lines[this.lines.length - 1] = prevLine.substring(0, prevLine.length - 1);
-            }
-        }
-        this.indent--;
-        this.writeLine(line);
-    };
-    CodeTextWriter.prototype.writeLine = function (line) {
-        var indent = "";
-        for (var i = 0; i < this.indent; i++) {
-            indent += "    ";
-        }
-        // remove whitespace so we can ensure we correctly end with a comma
-        this.lines.push(indent + (line === null || line === void 0 ? void 0 : line.trim()));
-    };
-    CodeTextWriter.prototype.write = function (text) {
-        var lines = text.split("\r");
-        if (lines.length > 1) {
-            for (var i = 0; i < lines.length; i++) {
-                this.writeLine(lines[i]);
-            }
-        }
-        else {
-            if (this.lines.length == 0) {
-                this.writeLine(text);
-            }
-            else {
-                var lastLine = this.lines[this.lines.length - 1];
-                this.lines[this.lines.length - 1] = lastLine + text;
-            }
-        }
-    };
-    CodeTextWriter.prototype.beginArray = function () {
-        this.writeLine("[");
-        this.indent++;
-    };
-    CodeTextWriter.prototype.insertArrayItem = function (item) {
-        this.writeLine(item + ",");
-    };
-    CodeTextWriter.prototype.endArray = function () {
-    };
-    CodeTextWriter.prototype.flush = function (directory, filename) {
-        if (this.lines.length === 0)
-            return;
-        if (!fs.existsSync(directory)) {
-            fs.mkdirSync(directory, { recursive: true });
-        }
-        console.log("Writing " + filename + " to " + directory);
-        var content = this.lines.join("\r");
-        this.lines.length = 0;
-        var fullPath = directory + "/" + filename;
-        fs.writeFileSync(fullPath, content);
-        return fs.realpathSync(fullPath);
-    };
-    return CodeTextWriter;
-}());
-exports.CodeTextWriter = CodeTextWriter;
-function runFromFile(writer, path) {
-    if (!fs.existsSync(path)) {
-        console.error("File not found", path);
-        return;
-    }
-    var code = (0, fs_1.readFileSync)(path).toString();
-    var compiler = new Compiler();
-    compiler.compile(writer, code);
-    return compiler;
-}
-exports.runFromFile = runFromFile;
-var Compiler = /** @class */ (function () {
-    function Compiler() {
-    }
-    Compiler.prototype.compile = function (writer, code) {
-        var file = "needle_compiled.ts";
-        var sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.ES2015, true, /*setParentNodes */ ts.ScriptKind.TS);
-        var prog = ts.createProgram([file], {});
-        this.run(prog, writer, sourceFile);
-    };
-    Compiler.prototype.run = function (prog, writer, sourceFile) {
-        var _this = this;
-        writer.begin();
-        ts.forEachChild(sourceFile, function (node) {
-            _this.visit(node, writer);
-        });
-        writer.end();
-    };
-    Compiler.prototype.visit = function (node, writer) {
-        var _this = this;
-        if (ts.isClassDeclaration(node)) {
-            this.visitClassDeclaration(node, writer);
-        }
-        else if (ts.isPropertyDeclaration(node)) {
-            this.visitPropertyDeclaration(node, writer);
-        }
-        else if (ts.isMethodDeclaration(node)) {
-            this.visitMethodDeclaration(node, writer);
-        }
-        else {
-            ts.forEachChild(node, function (node) {
-                _this.visit(node, writer);
-            });
-        }
-    };
-    Compiler.prototype.visitClassDeclaration = function (node, writer) {
-        var _this = this;
-        var name = node.name.text;
-        var base = node.heritageClauses && node.heritageClauses[0].types[0].expression.getText();
-        this.debugLog("CLASS START", name, base);
-        var res = writer.startNewType(name, base, this.getComments(node));
-        if (res === false) {
-            this.debugLog("CLASS SKIPPED", name);
-            return;
-        }
-        ts.forEachChild(node, function (node) {
-            _this.visit(node, writer);
-        });
-        writer.endNewType(name);
-        this.debugLog("CLASS END", name, "\n");
-    };
-    Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
-        var name = node.name.getText();
-        var type = this.resolveType(node.type, writer);
-        var visibility = this.getVisibility(node);
-        var initialValue = node.initializer && this.resolveExpression(node.initializer, writer);
-        var isArray = this.isArrayType(node.type);
-        if (!type && node.initializer) {
-            type = this.tryResolveTypeFromExpression(node.initializer, writer);
-        }
-        this.debugLog("PROPERTY", Visibility[visibility], name, isArray, type, initialValue);
-        writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
-    };
-    Compiler.prototype.visitMethodDeclaration = function (node, writer) {
-        var _a;
-        var name = node.name.getText();
-        var visibility = this.getVisibility(node);
-        var returnType = this.resolveType(node.type, writer);
-        var args;
-        if ((_a = node.parameters) === null || _a === void 0 ? void 0 : _a.length) {
-            args = this.resolveParameters(node.parameters, writer);
-        }
-        this.debugLog("METHOD", Visibility[visibility], name, returnType, args);
-        writer.writeMethod(visibility, name, returnType, args, this.getComments(node));
-    };
-    Compiler.prototype.resolveParameters = function (parameters, writer) {
-        var result = [];
-        for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
-            var parameter = parameters_1[_i];
-            var name_1 = parameter.name.getText();
-            var type = this.resolveType(parameter.type, writer);
-            var defaultValue = parameter.initializer && this.resolveExpression(parameter.initializer, writer);
-            result.push({ name: name_1, type: type, defaultValue: defaultValue });
-        }
-        return result;
-    };
-    Compiler.prototype.debugLog = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        console.log.apply(console, args);
-    };
-    Compiler.prototype.getComments = function (node) {
-        var commentRanges = ts.getLeadingCommentRanges(node.getFullText(), 0);
-        if (commentRanges) {
-            var comments = [];
-            for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
-                var range = commentRanges_1[_i];
-                var text = node.getFullText().substring(range.pos, range.end).trimStart();
-                // match only lines that starts with //@ or // @
-                var match = text.match(/\/\/\s*@(.+)/);
-                if (match) {
-                    comments.push(text.substring(match.index + 2).trim());
-                }
-            }
-            return comments;
-        }
-    };
-    Compiler.prototype.getVisibility = function (node) {
-        if (node.modifiers) {
-            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
-                var modifier = _a[_i];
-                if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
-                    return Visibility.Public;
-                }
-                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
-                    return Visibility.Protected;
-                }
-                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
-                    return Visibility.Private;
-                }
-            }
-        }
-        return Visibility.Public;
-    };
-    Compiler.prototype.tryResolveTypeFromExpression = function (exp, write) {
-        var _a;
-        if (ts.isNewExpression(exp)) {
-            // try get generic type from expression
-            if ((_a = exp.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
-                for (var _i = 0, _b = exp.typeArguments; _i < _b.length; _i++) {
-                    var arg = _b[_i];
-                    var type = this.resolveType(arg, write);
-                    if (type) {
-                        return type;
-                    }
-                }
-            }
-            var typeName = exp.expression.getText();
-            // const typeName = exp.expression.getText();
-            // console.log("NEW EXPRESSION", typeName);
-            // const args = exp.arguments?.map(arg => this.resolveExpression(arg, write));
-            // write.writeNewTypeExpression(typeName, args);
-            return typeName;
-        }
-    };
-    Compiler.prototype.resolveType = function (typeNode, writer) {
-        if (!typeNode)
-            return undefined;
-        // check if its an array
-        if (this.isArrayType(typeNode)) {
-            if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-                var arrayType = typeNode;
-                return this.resolveType(arrayType.elementType, writer);
-            }
-            // check if its Array<> or Map
-            if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-                var typeReference = typeNode;
-                if (typeReference.typeName.getText() === "Array") {
-                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-                else if (typeReference.typeName.getText() === "Map") {
-                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-            }
-            // check if its dictionary
-            if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-                var typeLiteral = typeNode;
-                var members = typeLiteral.members;
-                if (members.length === 2) {
-                    var firstMember = members[0];
-                    var secondMember = members[1];
-                    if (firstMember.kind === ts.SyntaxKind.IndexSignature && secondMember.kind === ts.SyntaxKind.IndexSignature) {
-                        var firstIndexSignature = firstMember;
-                        var secondIndexSignature = secondMember;
-                        var firstIndexType = firstIndexSignature.parameters[0].type;
-                        var secondIndexType = secondIndexSignature.parameters[0].type;
-                        if (firstIndexType.kind === ts.SyntaxKind.StringKeyword && secondIndexType.kind === ts.SyntaxKind.NumberKeyword) {
-                            var valueType = firstIndexSignature.type;
-                            return this.resolveType(valueType, writer);
-                        }
-                    }
-                }
-            }
-            // is generic
-            // if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            //     const typeReference = typeNode as ts.TypeReferenceNode;
-            //     const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-            //     return this.resolveType(typeArgument, writer);
-            // }
-            console.error("!!!!! ----- Unknown array type", typeNode.getText());
-        }
-        var type = typeNode.getText();
-        return this.resolveTypeFromString(type, writer);
-    };
-    Compiler.prototype.resolveTypeFromString = function (type, writer) {
-        var resolved = writer.resolveTypeName(type);
-        return resolved || type;
-    };
-    Compiler.prototype.isArrayType = function (typeNode) {
-        if (!typeNode)
-            return false;
-        // check if its an array
-        if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-            return true;
-        }
-        // check if its Array<> or map
-        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            var typeReference = typeNode;
-            if (typeReference.typeName.getText() === "Array") {
-                return true;
-            }
-            else if (typeReference.typeName.getText() === "Map") {
-                return true;
-            }
-        }
-        // check if its array or dictionary
-        if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-            var typeLiteral = typeNode;
-            if (typeLiteral.members.length === 2) {
-                var first = typeLiteral.members[0];
-                var second = typeLiteral.members[1];
-                if (first.kind === ts.SyntaxKind.IndexSignature && second.kind === ts.SyntaxKind.IndexSignature) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    Compiler.prototype.resolveExpression = function (node, writer) {
-        var _this = this;
-        if (ts.isStringLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isNumericLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isIdentifier(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        // is true or false
-        else if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
-            return this.resolveTypeFromString(node.getText(), writer);
-        }
-        else if (ts.isPropertyAccessExpression(node)) {
-            var left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                return left + "." + this.resolveTypeFromString(node.name.text, writer);
-            }
-        }
-        else if (ts.isCallExpression(node)) {
-            var left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
-                return left + "(" + args.join(", ") + ")";
-            }
-        }
-        else if (ts.isBinaryExpression(node)) {
-            var left = this.resolveExpression(node.left, writer);
-            var right = this.resolveExpression(node.right, writer);
-            if (left && right) {
-                return left + " " + node.operatorToken.getText() + " " + right;
-            }
-        }
-        else if (ts.isPrefixUnaryExpression(node)) {
-            var operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return node.operator + operand;
-            }
-        }
-        else if (ts.isPostfixUnaryExpression(node)) {
-            var operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return operand + node.operator;
-            }
-        }
-        else if (ts.isParenthesizedExpression(node)) {
-            return this.resolveExpression(node.expression, writer);
-        }
-        else if (ts.isArrayLiteralExpression(node)) {
-            var elements = node.elements.map(function (e) { return _this.resolveExpression(e, writer); }).filter(function (e) { return e; });
-            return "[" + elements.join(", ") + "]";
-        }
-        else if (ts.isObjectLiteralExpression(node)) {
-            var properties = node.properties.map(function (p) {
-                if (ts.isPropertyAssignment(p)) {
-                    var name_2 = p.name.getText();
-                    var value = _this.resolveExpression(p.initializer, writer);
-                    if (value) {
-                        return name_2 + ": " + value;
-                    }
-                }
-            }).filter(function (p) { return p; });
-            return "{" + properties.join(", ") + "}";
-        }
-        else if (ts.isNewExpression(node)) {
-            var typeName = this.resolveTypeFromString(node.expression.getText(), writer);
-            if (typeName) {
-                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
-                // writer.writeNewTypeExpression(typeName, args);
-                // return;
-                return "new " + typeName + "(" + args.join(", ") + ")";
-            }
-        }
-        console.error("!!!!! ----- Unknown expression", ts.SyntaxKind[node.kind], node.getText());
-    };
-    return Compiler;
-}());
-exports.Compiler = Compiler;