@openrewrite/rewrite 0.18.0

package/dist/src/javascript/parser.js

@@ -0,0 +1,1137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaScriptParserVisitor = exports.JavaScriptParser = void 0;
+const ts = __importStar(require("typescript"));
+const J = __importStar(require("../java"));
+const java_1 = require("../java");
+const JS = __importStar(require("."));
+const core_1 = require("../core");
+const parserUtils_1 = require("./parserUtils");
+const typeMapping_1 = require("./typeMapping");
+class JavaScriptParser extends core_1.Parser {
+    constructor() {
+        super();
+        this.sourceFileCache = new Map();
+        this.compilerOptions = {
+            target: ts.ScriptTarget.Latest,
+            module: ts.ModuleKind.CommonJS,
+            allowJs: true,
+        };
+    }
+    reset() {
+        this.sourceFileCache.clear();
+        this.oldProgram = undefined;
+        return this;
+    }
+    parseProgramSources(program, relativeTo, ctx) {
+        const typeChecker = program.getTypeChecker();
+        const result = [];
+        for (const filePath of program.getRootFileNames()) {
+            const sourceFile = program.getSourceFile(filePath);
+            const input = new core_1.ParserInput(filePath, null, false, () => Buffer.from(ts.sys.readFile(filePath)));
+            try {
+                const parsed = new JavaScriptParserVisitor(this, sourceFile, typeChecker).visit(sourceFile);
+                result.push(parsed);
+            }
+            catch (error) {
+                result.push(core_1.ParseError.build(this, input, relativeTo, ctx, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error), null));
+            }
+        }
+        return result;
+    }
+    parseInputs(inputs, relativeTo, ctx) {
+        const inputFiles = new Map();
+        for (const input of inputs) {
+            inputFiles.set(input.path, input);
+            this.sourceFileCache.delete(input.path);
+        }
+        const host = ts.createCompilerHost(this.compilerOptions);
+        host.getSourceFile = (fileName, languageVersion, onError) => {
+            let sourceFile = this.sourceFileCache.get(fileName);
+            if (sourceFile) {
+                return sourceFile;
+            }
+            let sourceText;
+            const input = inputFiles.get(fileName);
+            if (input) {
+                sourceText = input.source().toString('utf8');
+            }
+            else {
+                sourceText = ts.sys.readFile(fileName);
+            }
+            if (sourceText !== undefined) {
+                sourceFile = ts.createSourceFile(fileName, sourceText, languageVersion, true);
+                if (!input) {
+                    this.sourceFileCache.set(fileName, sourceFile);
+                }
+                return sourceFile;
+            }
+            if (onError)
+                onError(`File not found: ${fileName}`);
+            return undefined;
+        };
+        host.fileExists = (fileName) => {
+            return inputFiles.has(fileName) || ts.sys.fileExists(fileName);
+        };
+        host.readFile = (fileName) => {
+            const input = inputFiles.get(fileName);
+            return input
+                ? input.source().toString('utf8')
+                : ts.sys.readFile(fileName);
+        };
+        const program = ts.createProgram([...inputFiles.keys()], this.compilerOptions, host, this.oldProgram);
+        this.oldProgram = program;
+        const typeChecker = program.getTypeChecker();
+        const result = [];
+        for (const input of inputFiles.values()) {
+            const filePath = input.path;
+            const sourceFile = program.getSourceFile(filePath);
+            if (sourceFile) {
+                try {
+                    const parsed = new JavaScriptParserVisitor(this, sourceFile, typeChecker).visit(sourceFile);
+                    result.push(parsed);
+                }
+                catch (error) {
+                    result.push(core_1.ParseError.build(this, input, relativeTo, ctx, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error), null));
+                }
+            }
+            else {
+                result.push(core_1.ParseError.build(this, input, relativeTo, ctx, new Error('Parser returned undefined'), null));
+            }
+        }
+        return result;
+    }
+    accept(path) {
+        return path.endsWith('.ts') || path.endsWith('.tsx') || path.endsWith('.js') || path.endsWith('.jsx');
+    }
+    sourcePathFromSourceText(prefix, sourceCode) {
+        return prefix + "/source.ts";
+    }
+    static builder() {
+        return new JavaScriptParser.Builder();
+    }
+}
+exports.JavaScriptParser = JavaScriptParser;
+(function (JavaScriptParser) {
+    class Builder extends core_1.Parser.Builder {
+        build() {
+            return new JavaScriptParser();
+        }
+    }
+    JavaScriptParser.Builder = Builder;
+})(JavaScriptParser || (exports.JavaScriptParser = JavaScriptParser = {}));
+const visitMethodMap = new Map();
+for (const [key, value] of Object.entries(ts.SyntaxKind)) {
+    if (typeof value === 'number' && !visitMethodMap.has(value)) {
+        visitMethodMap.set(value, 'visit' + key);
+    }
+}
+class JavaScriptParserVisitor {
+    constructor(parser, sourceFile, typeChecker) {
+        this.parser = parser;
+        this.sourceFile = sourceFile;
+        this.mapModifier = (node) => {
+            let kind;
+            switch (node.kind) {
+                case ts.SyntaxKind.PublicKeyword:
+                    kind = J.Modifier.Type.Public;
+                    break;
+                case ts.SyntaxKind.PrivateKeyword:
+                    kind = J.Modifier.Type.Private;
+                    break;
+                case ts.SyntaxKind.ProtectedKeyword:
+                    kind = J.Modifier.Type.Protected;
+                    break;
+                case ts.SyntaxKind.StaticKeyword:
+                    kind = J.Modifier.Type.Static;
+                    break;
+                case ts.SyntaxKind.AbstractKeyword:
+                    kind = J.Modifier.Type.Abstract;
+                    break;
+                default:
+                    kind = J.Modifier.Type.LanguageExtension;
+            }
+            return new J.Modifier((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, kind == J.Modifier.Type.LanguageExtension ? node.getText() : null, kind, []);
+        };
+        this.semicolonPrefix = (n) => {
+            const last = n.getLastToken();
+            return (last === null || last === void 0 ? void 0 : last.kind) == ts.SyntaxKind.SemicolonToken ? this.prefix(last) : java_1.Space.EMPTY;
+        };
+        this.keywordPrefix = (token) => (node) => {
+            const last = (0, parserUtils_1.getNextSibling)(node);
+            return (last === null || last === void 0 ? void 0 : last.kind) == token ? this.prefix(last) : java_1.Space.EMPTY;
+        };
+        this._seenTriviaSpans = [];
+        this.typeMapping = new typeMapping_1.JavaScriptTypeMapping(typeChecker);
+    }
+    visit(node) {
+        const member = this[visitMethodMap.get(node.kind)];
+        if (typeof member === 'function') {
+            return member.bind(this)(node);
+        }
+        else {
+            return this.visitUnknown(node);
+        }
+    }
+    convert(node) {
+        return this.visit(node);
+    }
+    visitSourceFile(node) {
+        return new JS.CompilationUnit((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.sourceFile.fileName, null, null, false, null, [], this.semicolonPaddedStatementList(node.statements), this.prefix(node.endOfFileToken));
+    }
+    semicolonPaddedStatementList(statements) {
+        return this.rightPaddedList([...statements], this.semicolonPrefix, n => {
+            const last = n.getLastToken();
+            return (last === null || last === void 0 ? void 0 : last.kind) == ts.SyntaxKind.SemicolonToken ? core_1.Markers.build([new java_1.Semicolon((0, core_1.randomId)())]) : core_1.Markers.EMPTY;
+        });
+    }
+    visitUnknown(node) {
+        return new J.Unknown((0, core_1.randomId)(), java_1.Space.EMPTY, core_1.Markers.EMPTY, new J.Unknown.Source((0, core_1.randomId)(), java_1.Space.EMPTY, core_1.Markers.build([
+            core_1.ParseExceptionResult.build(this.parser, new Error("Unsupported AST element: " + node)).withTreeType(visitMethodMap.get(node.kind).substring(5))
+        ]), node.getFullText()));
+    }
+    mapModifiers(node) {
+        var _a, _b;
+        if (ts.isVariableStatement(node)) {
+            return [new J.Modifier((0, core_1.randomId)(), java_1.Space.EMPTY, core_1.Markers.EMPTY, (_a = node.declarationList.getFirstToken()) === null || _a === void 0 ? void 0 : _a.getText(), J.Modifier.Type.LanguageExtension, [])];
+        }
+        else if (ts.isClassDeclaration(node)) {
+            return node.modifiers ? (_b = node.modifiers) === null || _b === void 0 ? void 0 : _b.filter(ts.isModifier).map(this.mapModifier) : [];
+        }
+        else if (ts.isPropertyDeclaration(node)) {
+            return [];
+        }
+        throw new Error(`Cannot get modifiers from ${node}`);
+    }
+    rightPadded(t, trailing, markers) {
+        return new java_1.JRightPadded(t, trailing, markers !== null && markers !== void 0 ? markers : core_1.Markers.EMPTY);
+    }
+    rightPaddedList(nodes, trailing, markers) {
+        return nodes.map(n => this.rightPadded(this.convert(n), trailing(n), markers === null || markers === void 0 ? void 0 : markers(n)));
+    }
+    rightPaddedSeparatedList(nodes, separator, markers) {
+        if (nodes.length === 0) {
+            return [];
+        }
+        const ts = [];
+        for (let i = 0; i < nodes.length - 1; i += 2) {
+            const last = i === nodes.length - 2;
+            ts.push(this.rightPadded(this.convert(nodes[i]), this.prefix(nodes[i + 1]), markers(nodes, i)));
+        }
+        if ((nodes.length & 1) === 1) {
+            ts.push(this.rightPadded(this.convert(nodes[nodes.length - 1]), java_1.Space.EMPTY, markers(nodes, nodes.length - 1)));
+        }
+        return ts;
+    }
+    leftPadded(before, t, markers) {
+        return new java_1.JLeftPadded(before, t, markers !== null && markers !== void 0 ? markers : core_1.Markers.EMPTY);
+    }
+    leftPaddedList(before, nodes, markers) {
+        return nodes.map(n => this.leftPadded(before(n), this.convert(n), markers === null || markers === void 0 ? void 0 : markers(n)));
+    }
+    visitClassDeclaration(node) {
+        return new J.ClassDeclaration((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.mapDecorators(node), this.mapModifiers(node), new J.ClassDeclaration.Kind((0, core_1.randomId)(), node.modifiers ? this.suffix(node.modifiers[node.modifiers.length - 1]) : this.prefix(node), core_1.Markers.EMPTY, [], J.ClassDeclaration.Kind.Type.Class), node.name ? this.convert(node.name) : this.mapIdentifier(node, ""), this.mapTypeParameters(node), null, this.mapExtends(node), this.mapImplements(node), null, this.convertBlock(node.getChildren().slice(-3)), this.mapType(node));
+    }
+    mapExtends(node) {
+        if (node.heritageClauses == undefined || node.heritageClauses.length == 0) {
+            return null;
+        }
+        for (let heritageClause of node.heritageClauses) {
+            if (heritageClause.token == ts.SyntaxKind.ExtendsKeyword) {
+                return this.leftPadded(this.prefix(heritageClause.getFirstToken()), this.visit(heritageClause.types[0]));
+            }
+        }
+        return null;
+    }
+    mapImplements(node) {
+        if (node.heritageClauses == undefined || node.heritageClauses.length == 0) {
+            return null;
+        }
+        for (let heritageClause of node.heritageClauses) {
+            if (heritageClause.token == ts.SyntaxKind.ImplementsKeyword) {
+                const _implements = [];
+                for (let type of heritageClause.types) {
+                    _implements.push(this.rightPadded(this.visit(type), this.suffix(type)));
+                }
+                return _implements.length > 0 ? new java_1.JContainer(this.prefix(heritageClause.getFirstToken()), _implements, core_1.Markers.EMPTY) : null;
+            }
+        }
+        return null;
+    }
+    visitNumericLiteral(node) {
+        return this.mapLiteral(node, node.text);
+    }
+    visitTrueKeyword(node) {
+        return this.mapLiteral(node, true);
+    }
+    visitNumberKeyword(node) {
+        return this.mapIdentifier(node, 'number');
+    }
+    visitStringKeyword(node) {
+        return this.mapIdentifier(node, 'string');
+    }
+    visitUndefinedKeyword(node) {
+        return this.mapIdentifier(node, 'undefined');
+    }
+    visitFalseKeyword(node) {
+        return this.mapLiteral(node, false);
+    }
+    visitNullKeyword(node) {
+        return this.mapLiteral(node, null);
+    }
+    mapLiteral(node, value) {
+        return new J.Literal((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, value, node.getText(), null, this.mapPrimitiveType(node));
+    }
+    visitBigIntLiteral(node) {
+        return this.mapLiteral(node, node.text);
+    }
+    visitStringLiteral(node) {
+        return this.mapLiteral(node, node.text);
+    }
+    visitJsxText(node) {
+        return this.visitUnknown(node);
+    }
+    visitRegularExpressionLiteral(node) {
+        return this.mapLiteral(node, node.text);
+    }
+    visitNoSubstitutionTemplateLiteral(node) {
+        return this.mapLiteral(node, node.text);
+    }
+    visitTemplateHead(node) {
+        return this.visitUnknown(node);
+    }
+    visitTemplateMiddle(node) {
+        return this.visitUnknown(node);
+    }
+    visitTemplateTail(node) {
+        return this.visitUnknown(node);
+    }
+    visitIdentifier(node) {
+        if (node.text === 'undefined') {
+            return this.mapLiteral(node, undefined);
+        }
+        return this.mapIdentifier(node, node.text);
+    }
+    mapIdentifier(node, name, withType = true) {
+        let type = withType ? this.mapType(node) : null;
+        return new J.Identifier((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, [], name, type instanceof java_1.JavaType.Variable ? type.type : type, type instanceof java_1.JavaType.Variable ? type : null);
+    }
+    visitThisKeyword(node) {
+        return this.mapIdentifier(node, 'this');
+    }
+    visitPrivateIdentifier(node) {
+        return this.mapIdentifier(node, node.text);
+    }
+    visitQualifiedName(node) {
+        return this.visitUnknown(node);
+    }
+    visitComputedPropertyName(node) {
+        return new J.NewArray((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, null, [], new java_1.JContainer(java_1.Space.EMPTY, [this.rightPadded(this.convert(node.expression), this.suffix(node.expression))], core_1.Markers.EMPTY), this.mapType(node));
+    }
+    visitTypeParameter(node) {
+        return this.visitUnknown(node);
+    }
+    visitParameter(node) {
+        return this.visitUnknown(node);
+    }
+    visitDecorator(node) {
+        return this.visitUnknown(node);
+    }
+    visitPropertySignature(node) {
+        return this.visitUnknown(node);
+    }
+    visitPropertyDeclaration(node) {
+        return new J.VariableDeclarations((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, [], this.mapModifiers(node), node.type ? this.visit(node.type) : null, null, [], [this.rightPadded(new J.VariableDeclarations.NamedVariable((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.visit(node.name), [], node.initializer ? this.leftPadded(this.prefix(node.getChildAt(node.getChildCount() - 2)), this.visit(node.initializer)) : null, this.mapVariableType(node)), java_1.Space.EMPTY)]);
+    }
+    visitMethodSignature(node) {
+        return this.visitUnknown(node);
+    }
+    visitMethodDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitClassStaticBlockDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitConstructor(node) {
+        return this.visitUnknown(node);
+    }
+    visitGetAccessor(node) {
+        return this.visitUnknown(node);
+    }
+    visitSetAccessor(node) {
+        return this.visitUnknown(node);
+    }
+    visitCallSignature(node) {
+        return this.visitUnknown(node);
+    }
+    visitConstructSignature(node) {
+        return this.visitUnknown(node);
+    }
+    visitIndexSignature(node) {
+        return this.visitUnknown(node);
+    }
+    visitTypePredicate(node) {
+        return this.visitUnknown(node);
+    }
+    visitTypeReference(node) {
+        return this.visitUnknown(node);
+    }
+    visitFunctionType(node) {
+        return this.visitUnknown(node);
+    }
+    visitConstructorType(node) {
+    }
+    visitTypeQuery(node) {
+        return this.visitUnknown(node);
+    }
+    visitTypeLiteral(node) {
+        return this.visitUnknown(node);
+    }
+    visitArrayType(node) {
+        return this.visitUnknown(node);
+    }
+    visitTupleType(node) {
+        return this.visitUnknown(node);
+    }
+    visitOptionalType(node) {
+        return this.visitUnknown(node);
+    }
+    visitRestType(node) {
+        return this.visitUnknown(node);
+    }
+    visitUnionType(node) {
+        return new JS.Union((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.rightPaddedList([...node.types], (n) => this.keywordPrefix(ts.SyntaxKind.BarToken)(n)), this.mapType(node));
+    }
+    visitIntersectionType(node) {
+        return this.visitUnknown(node);
+    }
+    visitConditionalType(node) {
+        return this.visitUnknown(node);
+    }
+    visitInferType(node) {
+        return this.visitUnknown(node);
+    }
+    visitParenthesizedType(node) {
+        return this.visitUnknown(node);
+    }
+    visitThisType(node) {
+        return this.visitUnknown(node);
+    }
+    visitTypeOperator(node) {
+        return this.visitUnknown(node);
+    }
+    visitIndexedAccessType(node) {
+        return this.visitUnknown(node);
+    }
+    visitMappedType(node) {
+        return this.visitUnknown(node);
+    }
+    visitLiteralType(node) {
+        return this.visit(node.literal);
+    }
+    visitNamedTupleMember(node) {
+        return this.visitUnknown(node);
+    }
+    visitTemplateLiteralType(node) {
+        return this.visitUnknown(node);
+    }
+    visitTemplateLiteralTypeSpan(node) {
+        return this.visitUnknown(node);
+    }
+    visitImportType(node) {
+        return this.visitUnknown(node);
+    }
+    visitObjectBindingPattern(node) {
+        return this.visitUnknown(node);
+    }
+    visitArrayBindingPattern(node) {
+        return this.visitUnknown(node);
+    }
+    visitBindingElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitArrayLiteralExpression(node) {
+        return new J.NewArray((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, null, [], this.mapArguments(node.getChildren()), this.mapType(node));
+    }
+    visitObjectLiteralExpression(node) {
+        return new J.NewClass((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, null, java_1.Space.EMPTY, null, java_1.JContainer.empty(), this.convertPropertyAssignments(node.getChildren().slice(-3)), this.mapMethodType(node));
+    }
+    convertPropertyAssignments(nodes) {
+        const prefix = this.prefix(nodes[0]);
+        let statementList = nodes[1];
+        const statements = this.rightPaddedSeparatedList([...statementList.getChildren()], ts.SyntaxKind.CommaToken, (nodes, i) => i == nodes.length - 2 && nodes[i + 1].kind == ts.SyntaxKind.CommaToken ? core_1.Markers.build([new java_1.TrailingComma((0, core_1.randomId)(), this.prefix(nodes[i + 1]))]) : core_1.Markers.EMPTY);
+        return new J.Block((0, core_1.randomId)(), prefix, core_1.Markers.EMPTY, this.rightPadded(false, java_1.Space.EMPTY), statements, this.prefix(nodes[nodes.length - 1]));
+    }
+    visitPropertyAccessExpression(node) {
+        return new J.FieldAccess((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.expression), this.leftPadded(this.prefix(node.getChildAt(1)), this.convert(node.name)), this.mapType(node));
+    }
+    visitElementAccessExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitCallExpression(node) {
+        const prefix = this.prefix(node);
+        let select;
+        let name;
+        if (ts.isPropertyAccessExpression(node.expression)) {
+            select = this.rightPadded(this.convert(node.expression.expression), this.prefix(node.expression.getChildAt(1)));
+            name = this.convert(node.expression.name);
+        }
+        else {
+            select = null;
+            name = this.convert(node.expression);
+        }
+        return new J.MethodInvocation((0, core_1.randomId)(), prefix, core_1.Markers.EMPTY, select, null, name, this.mapArguments(node.getChildren().slice(-3)), this.mapMethodType(node));
+    }
+    visitNewExpression(node) {
+        return new J.NewClass((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, null, java_1.Space.EMPTY, this.visit(node.expression), this.mapArguments(node.arguments ? node.getChildren().slice(2) : []), null, this.mapMethodType(node));
+    }
+    visitTaggedTemplateExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitTypeAssertionExpression(node) {
+        return new J.TypeCast((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, new J.ControlParentheses((0, core_1.randomId)(), this.prefix(node.getFirstToken()), core_1.Markers.EMPTY, this.rightPadded(this.convert(node.type), this.prefix(node.getChildAt(2)))), this.convert(node.expression));
+    }
+    visitParenthesizedExpression(node) {
+        return new J.Parentheses((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.rightPadded(this.convert(node.expression), this.prefix(node.getLastToken())));
+    }
+    visitFunctionExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitArrowFunction(node) {
+        return this.visitUnknown(node);
+    }
+    visitDeleteExpression(node) {
+        return new JS.Delete((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.expression), this.mapType(node));
+    }
+    visitTypeOfExpression(node) {
+        return new JS.TypeOf((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.expression), this.mapType(node));
+    }
+    visitVoidExpression(node) {
+        return new JS.Void((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.expression));
+    }
+    visitAwaitExpression(node) {
+        return new JS.Await((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.expression), this.mapType(node));
+    }
+    visitPrefixUnaryExpression(node) {
+        let unaryOperator;
+        switch (node.operator) {
+            case ts.SyntaxKind.PlusToken:
+                unaryOperator = J.Unary.Type.Positive;
+                break;
+            case ts.SyntaxKind.MinusToken:
+                unaryOperator = J.Unary.Type.Negative;
+                break;
+            case ts.SyntaxKind.ExclamationToken:
+                unaryOperator = J.Unary.Type.Not;
+                break;
+            case ts.SyntaxKind.PlusPlusToken:
+                unaryOperator = J.Unary.Type.PreIncrement;
+                break;
+            case ts.SyntaxKind.MinusMinusToken:
+                unaryOperator = J.Unary.Type.PreDecrement;
+                break;
+            case ts.SyntaxKind.TildeToken:
+                unaryOperator = J.Unary.Type.Complement;
+        }
+        if (unaryOperator === undefined) {
+            return this.visitUnknown(node);
+        }
+        return new J.Unary((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.leftPadded(this.prefix(node.getFirstToken()), unaryOperator), this.convert(node.operand), this.mapType(node));
+    }
+    visitPostfixUnaryExpression(node) {
+        let unaryOperator;
+        switch (node.operator) {
+            case ts.SyntaxKind.PlusPlusToken:
+                unaryOperator = J.Unary.Type.PostIncrement;
+                break;
+            case ts.SyntaxKind.MinusMinusToken:
+                unaryOperator = J.Unary.Type.PostDecrement;
+                break;
+        }
+        if (unaryOperator === undefined) {
+            return this.visitUnknown(node);
+        }
+        return new J.Unary((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.leftPadded(this.prefix(node.getFirstToken()), unaryOperator), this.convert(node.operand), this.mapType(node));
+    }
+    visitBinaryExpression(node) {
+        let binaryOperator;
+        switch (node.operatorToken.kind) {
+            case ts.SyntaxKind.EqualsEqualsEqualsToken:
+                binaryOperator = JS.JsBinary.Type.IdentityEquals;
+                break;
+            case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+                binaryOperator = JS.JsBinary.Type.IdentityNotEquals;
+                break;
+        }
+        if (binaryOperator !== undefined) {
+            return new JS.JsBinary((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.left), this.leftPadded(this.prefix(node.operatorToken), binaryOperator), this.convert(node.right), this.mapType(node));
+        }
+        if (node.operatorToken.kind == ts.SyntaxKind.InstanceOfKeyword) {
+            return new J.InstanceOf((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.rightPadded(this.convert(node.left), this.prefix(node.operatorToken)), this.convert(node.right), null, this.mapType(node));
+        }
+        binaryOperator = this.mapBinaryOperator(node);
+        if (binaryOperator === undefined) {
+            return this.visitUnknown(node);
+        }
+        return new J.Binary((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.left), this.leftPadded(this.prefix(node.operatorToken), binaryOperator), this.convert(node.right), this.mapType(node));
+    }
+    mapBinaryOperator(node) {
+        switch (node.operatorToken.kind) {
+            case ts.SyntaxKind.PlusToken:
+                return J.Binary.Type.Addition;
+            case ts.SyntaxKind.MinusToken:
+                return J.Binary.Type.Subtraction;
+            case ts.SyntaxKind.AsteriskToken:
+                return J.Binary.Type.Multiplication;
+            case ts.SyntaxKind.SlashToken:
+                return J.Binary.Type.Division;
+            case ts.SyntaxKind.PercentToken:
+                return J.Binary.Type.Modulo;
+            case ts.SyntaxKind.LessThanLessThanToken:
+                return J.Binary.Type.LeftShift;
+            case ts.SyntaxKind.GreaterThanGreaterThanToken:
+                return J.Binary.Type.RightShift;
+            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                return J.Binary.Type.UnsignedRightShift;
+            case ts.SyntaxKind.AmpersandToken:
+                return J.Binary.Type.BitAnd;
+            case ts.SyntaxKind.BarToken:
+                return J.Binary.Type.BitOr;
+            case ts.SyntaxKind.CaretToken:
+                return J.Binary.Type.BitXor;
+            case ts.SyntaxKind.EqualsEqualsToken:
+                return J.Binary.Type.Equal;
+            case ts.SyntaxKind.ExclamationEqualsToken:
+                return J.Binary.Type.NotEqual;
+            case ts.SyntaxKind.LessThanToken:
+                return J.Binary.Type.LessThan;
+            case ts.SyntaxKind.LessThanEqualsToken:
+                return J.Binary.Type.LessThanOrEqual;
+            case ts.SyntaxKind.GreaterThanToken:
+                return J.Binary.Type.GreaterThan;
+            case ts.SyntaxKind.GreaterThanEqualsToken:
+                return J.Binary.Type.GreaterThanOrEqual;
+            case ts.SyntaxKind.AmpersandAmpersandToken:
+                return J.Binary.Type.And;
+            case ts.SyntaxKind.BarBarToken:
+                return J.Binary.Type.Or;
+        }
+        return undefined;
+    }
+    visitConditionalExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitTemplateExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitYieldExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitSpreadElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitClassExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitOmittedExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitExpressionWithTypeArguments(node) {
+        if (node.typeArguments) {
+            return this.visitUnknown(node);
+        }
+        return this.visit(node.expression);
+    }
+    visitAsExpression(node) {
+        return new JS.JsBinary((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.convert(node.expression), this.leftPadded(this.prefix(node.getChildAt(1)), JS.JsBinary.Type.As), this.convert(node.type), this.mapType(node));
+    }
+    visitNonNullExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitMetaProperty(node) {
+        return this.visitUnknown(node);
+    }
+    visitSyntheticExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitSatisfiesExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitTemplateSpan(node) {
+        return this.visitUnknown(node);
+    }
+    visitSemicolonClassElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitBlock(node) {
+        return this.visitUnknown(node);
+    }
+    visitEmptyStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitVariableStatement(node) {
+        if (node.declarationList.declarations.length > 1) {
+            return this.visitUnknown(node);
+        }
+        return new J.VariableDeclarations((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, [], this.mapModifiers(node), node.declarationList.declarations[0].type ? this.visit(node.declarationList.declarations[0].type) : null, null, [], this.rightPaddedList([...node.declarationList.declarations], n => {
+            return java_1.Space.EMPTY;
+        }));
+    }
+    visitExpressionStatement(node) {
+        return new JS.ExpressionStatement((0, core_1.randomId)(), this.visit(node.expression));
+    }
+    visitIfStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitDoStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitWhileStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitForStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitForInStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitForOfStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitContinueStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitBreakStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitReturnStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitWithStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitSwitchStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitLabeledStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitThrowStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitTryStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitDebuggerStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitVariableDeclaration(node) {
+        return new J.VariableDeclarations.NamedVariable((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.visit(node.name), [], node.initializer ? this.leftPadded(this.prefix(node.getChildAt(node.getChildCount() - 2)), this.visit(node.initializer)) : null, this.mapVariableType(node));
+    }
+    visitVariableDeclarationList(node) {
+        return this.visitUnknown(node);
+    }
+    visitFunctionDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitInterfaceDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitTypeAliasDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitEnumDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitModuleDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitModuleBlock(node) {
+        return this.visitUnknown(node);
+    }
+    visitCaseBlock(node) {
+        return this.visitUnknown(node);
+    }
+    visitNamespaceExportDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitImportEqualsDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitImportKeyword(node) {
+        return this.mapIdentifier(node, 'import');
+    }
+    visitImportDeclaration(node) {
+        var _a, _b, _c;
+        const children = node.getChildren();
+        const _default = !!((_a = node.importClause) === null || _a === void 0 ? void 0 : _a.name);
+        const onlyDefault = _default && node.importClause.namedBindings == undefined;
+        return new JS.JsImport((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, _default ? this.rightPadded(this.visit((_b = node.importClause) === null || _b === void 0 ? void 0 : _b.name), this.suffix((_c = node.importClause) === null || _c === void 0 ? void 0 : _c.name)) : null, node.importClause && !onlyDefault ? this.visit(node.importClause) : null, children[children.indexOf(node.moduleSpecifier) - 1].kind == ts.SyntaxKind.FromKeyword ? this.prefix(children[children.indexOf(node.moduleSpecifier) - 1]) : null, this.convert(node.moduleSpecifier), null);
+    }
+    visitImportClause(node) {
+        var _a;
+        if (node.namedBindings && ts.isNamespaceImport(node.namedBindings)) {
+            return new java_1.JContainer(this.prefix(node), [this.rightPadded(new JS.Alias((0, core_1.randomId)(), java_1.Space.EMPTY, core_1.Markers.EMPTY, this.rightPadded(this.mapIdentifier(node.namedBindings, "*"), this.prefix(node.namedBindings.getChildAt(1))), this.convert(node.namedBindings.name)), java_1.Space.EMPTY)], core_1.Markers.EMPTY);
+        }
+        return this.mapArguments((_a = node.namedBindings) === null || _a === void 0 ? void 0 : _a.getChildren());
+    }
+    visitNamespaceImport(node) {
+        return this.visitUnknown(node);
+    }
+    visitNamedImports(node) {
+        return this.visitUnknown(node);
+    }
+    visitImportSpecifier(node) {
+        return this.mapIdentifier(node, node.name.text, false);
+    }
+    visitExportAssignment(node) {
+        return this.visitUnknown(node);
+    }
+    visitExportDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitNamedExports(node) {
+        return this.visitUnknown(node);
+    }
+    visitNamespaceExport(node) {
+        return this.visitUnknown(node);
+    }
+    visitExportSpecifier(node) {
+        return this.visitUnknown(node);
+    }
+    visitMissingDeclaration(node) {
+        return this.visitUnknown(node);
+    }
+    visitExternalModuleReference(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxSelfClosingElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxOpeningElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxClosingElement(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxFragment(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxOpeningFragment(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxClosingFragment(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxAttribute(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxAttributes(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxSpreadAttribute(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitJsxNamespacedName(node) {
+        return this.visitUnknown(node);
+    }
+    visitCaseClause(node) {
+        return this.visitUnknown(node);
+    }
+    visitDefaultClause(node) {
+        return this.visitUnknown(node);
+    }
+    visitHeritageClause(node) {
+        return this.convert(node.types[0]);
+    }
+    visitCatchClause(node) {
+        return this.visitUnknown(node);
+    }
+    visitImportAttributes(node) {
+        return this.visitUnknown(node);
+    }
+    visitImportAttribute(node) {
+        return this.visitUnknown(node);
+    }
+    visitPropertyAssignment(node) {
+        return new JS.PropertyAssignment((0, core_1.randomId)(), this.prefix(node), core_1.Markers.EMPTY, this.rightPadded(this.visit(node.name), this.suffix(node.name)), this.visit(node.initializer));
+    }
+    visitShorthandPropertyAssignment(node) {
+        return this.visitUnknown(node);
+    }
+    visitSpreadAssignment(node) {
+        return this.visitUnknown(node);
+    }
+    visitEnumMember(node) {
+        return this.visitUnknown(node);
+    }
+    visitBundle(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocTypeExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocNameReference(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocMemberName(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocAllType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocUnknownType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocNullableType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocNonNullableType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocOptionalType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocFunctionType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocVariadicType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocNamepathType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDoc(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocType(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocText(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocTypeLiteral(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocSignature(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocLink(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocLinkCode(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocLinkPlain(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocAugmentsTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocImplementsTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocAuthorTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocDeprecatedTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocClassTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocPublicTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocPrivateTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocProtectedTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocReadonlyTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocOverrideTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocCallbackTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocOverloadTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocEnumTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocParameterTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocReturnTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocThisTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocTypeTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocTemplateTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocTypedefTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocSeeTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocPropertyTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocThrowsTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocSatisfiesTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitJSDocImportTag(node) {
+        return this.visitUnknown(node);
+    }
+    visitSyntaxList(node) {
+        return this.visitUnknown(node);
+    }
+    visitNotEmittedStatement(node) {
+        return this.visitUnknown(node);
+    }
+    visitPartiallyEmittedExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitCommaListExpression(node) {
+        return this.visitUnknown(node);
+    }
+    visitSyntheticReferenceExpression(node) {
+        return this.visitUnknown(node);
+    }
+    prefix(node) {
+        if (node.getFullStart() == node.getStart()) {
+            return java_1.Space.EMPTY;
+        }
+        const nodeStart = node.getFullStart();
+        const span = [nodeStart, node.getStart()];
+        let idx = (0, parserUtils_1.binarySearch)(this._seenTriviaSpans, span, parserUtils_1.compareTextSpans);
+        if (idx >= 0)
+            return java_1.Space.EMPTY;
+        idx = ~idx;
+        if (idx > 0 && this._seenTriviaSpans[idx - 1][1] > span[0])
+            return java_1.Space.EMPTY;
+        this._seenTriviaSpans.splice(idx, 0, span);
+        return prefixFromNode(node, this.sourceFile);
+    }
+    suffix(node) {
+        return this.prefix((0, parserUtils_1.getNextSibling)(node));
+    }
+    mapType(node) {
+        return this.typeMapping.type(node);
+    }
+    mapPrimitiveType(node) {
+        return this.typeMapping.primitiveType(node);
+    }
+    mapVariableType(node) {
+        return this.typeMapping.variableType(node);
+    }
+    mapMethodType(node) {
+        return this.typeMapping.methodType(node);
+    }
+    mapArguments(nodes) {
+        if (nodes.length === 0) {
+            return java_1.JContainer.empty();
+        }
+        const prefix = this.prefix(nodes[0]);
+        let argList = nodes[1];
+        let childCount = argList.getChildCount();
+        const args = [];
+        if (childCount === 0) {
+            args.push(this.rightPadded(new J.Empty((0, core_1.randomId)(), java_1.Space.EMPTY, core_1.Markers.EMPTY), this.prefix(nodes[2]), core_1.Markers.EMPTY));
+        }
+        else {
+            for (let i = 0; i < childCount - 1; i += 2) {
+                const last = i === childCount - 2;
+                args.push(this.rightPadded(this.convert(argList.getChildAt(i)), this.prefix(argList.getChildAt(i + 1)), last ? core_1.Markers.build([new java_1.TrailingComma((0, core_1.randomId)(), this.prefix(nodes[2]))]) : core_1.Markers.EMPTY));
+            }
+            if ((childCount & 1) === 1) {
+                args.push(this.rightPadded(this.convert(argList.getChildAt(childCount - 1)), this.prefix(nodes[2])));
+            }
+        }
+        return new java_1.JContainer(prefix, args, core_1.Markers.EMPTY);
+    }
+    mapDecorators(node) {
+        return [];
+    }
+    mapTypeParameters(node) {
+        return null;
+    }
+    convertBlock(nodes) {
+        const prefix = this.prefix(nodes[0]);
+        let statementList = nodes[1];
+        const statements = this.rightPaddedSeparatedList([...statementList.getChildren()], ts.SyntaxKind.SemicolonToken, (nodes, i) => { var _a; return ((_a = nodes[i].getLastToken()) === null || _a === void 0 ? void 0 : _a.kind) == ts.SyntaxKind.SemicolonToken ? core_1.Markers.build([new java_1.Semicolon((0, core_1.randomId)())]) : core_1.Markers.EMPTY; });
+        return new J.Block((0, core_1.randomId)(), prefix, core_1.Markers.EMPTY, this.rightPadded(false, java_1.Space.EMPTY), statements, this.prefix(nodes[nodes.length - 1]));
+    }
+}
+exports.JavaScriptParserVisitor = JavaScriptParserVisitor;
+function prefixFromNode(node, sourceFile) {
+    const comments = [];
+    const text = sourceFile.getFullText();
+    const nodeStart = node.getFullStart();
+    let leadingWhitespacePos = node.getStart();
+    ts.forEachLeadingCommentRange(text, nodeStart, (pos, end, kind) => {
+        leadingWhitespacePos = Math.min(leadingWhitespacePos, pos);
+        const isMultiline = kind === ts.SyntaxKind.MultiLineCommentTrivia;
+        const commentStart = isMultiline ? pos + 2 : pos + 2;
+        const commentEnd = isMultiline ? end - 2 : end;
+        let suffixEnd = end;
+        while (suffixEnd < text.length && (text[suffixEnd] === ' ' || text[suffixEnd] === '\t' || text[suffixEnd] === '\n' || text[suffixEnd] === '\r')) {
+            suffixEnd++;
+        }
+        const commentBody = text.slice(commentStart, commentEnd);
+        const suffix = text.slice(end, suffixEnd);
+        comments.push(new J.TextComment(isMultiline, commentBody, suffix, core_1.Markers.EMPTY));
+    });
+    let whitespace = '';
+    if (leadingWhitespacePos > nodeStart) {
+        whitespace = text.slice(nodeStart, leadingWhitespacePos);
+    }
+    return new java_1.Space(comments, whitespace.length > 0 ? whitespace : null);
+}
+//# sourceMappingURL=parser.js.map