| 1 | var syntax = module.exports;
|
| 2 |
|
| 3 | syntax.ArrayExpression = require('./ArrayExpression');
|
| 4 | syntax.AssignmentExpression = require('./AssignmentExpression');
|
| 5 | syntax.BinaryExpression = require('./BinaryExpression');
|
| 6 | syntax.BlockStatement = require('./BlockStatement');
|
| 7 | syntax.BreakStatement = require('./BreakStatement');
|
| 8 | syntax.CallExpression = require('./CallExpression');
|
| 9 | syntax.CatchClause = require('./CatchClause');
|
| 10 | syntax.ConditionalExpression = require('./ConditionalExpression');
|
| 11 | syntax.ContinueStatement = require('./ContinueStatement');
|
| 12 | syntax.EmptyStatement = require('./EmptyStatement');
|
| 13 | syntax.ExpressionStatement = require('./ExpressionStatement');
|
| 14 | syntax.ForInStatement = require('./ForInStatement');
|
| 15 | syntax.ForStatement = require('./ForStatement');
|
| 16 | syntax.FunctionDeclaration = require('./FunctionDeclaration');
|
| 17 | syntax.FunctionExpression = require('./FunctionExpression');
|
| 18 | syntax.Identifier = require('./Identifier');
|
| 19 | syntax.IfStatement = require('./IfStatement');
|
| 20 | syntax.Literal = require('./Literal');
|
| 21 | syntax.LogicalExpression = require('./LogicalExpression');
|
| 22 | syntax.MemberExpression = require('./MemberExpression');
|
| 23 | syntax.NewExpression = require('./NewExpression');
|
| 24 | syntax.ObjectExpression = require('./ObjectExpression');
|
| 25 | syntax.Program = require('./Program');
|
| 26 | syntax.Property = require('./Property');
|
| 27 | syntax.ReturnStatement = require('./ReturnStatement');
|
| 28 | syntax.SequenceExpression = require('./SequenceExpression');
|
| 29 | syntax.SwitchStatement = require('./SwitchStatement');
|
| 30 | syntax.ThisExpression = require('./ThisExpression');
|
| 31 | syntax.ThrowStatement = require('./ThrowStatement');
|
| 32 | syntax.TryStatement = require('./TryStatement');
|
| 33 | syntax.UnaryExpression = require('./UnaryExpression');
|
| 34 | syntax.UpdateExpression = require('./UpdateExpression');
|
| 35 | syntax.VariableDeclaration = require('./VariableDeclaration');
|
| 36 | syntax.VariableDeclarator = require('./VariableDeclarator');
|
| 37 | syntax.WhileStatement = require('./WhileStatement');
|
| 38 |
|
| 39 | syntax.factory = function (node) {
|
| 40 | switch (node.type) {
|
| 41 | case 'ArrayExpression':
|
| 42 | return new syntax.ArrayExpression(node.elements);
|
| 43 | case 'AssignmentExpression':
|
| 44 | return new syntax.AssignmentExpression(node.operator, node.left, node.right);
|
| 45 | case 'BinaryExpression':
|
| 46 | return new syntax.BinaryExpression(node.operator, node.left, node.right);
|
| 47 | case 'BlockStatement':
|
| 48 | return new syntax.BlockStatement(node.body);
|
| 49 | case 'BreakStatement':
|
| 50 | return new syntax.BreakStatement(node.label);
|
| 51 | case 'CallExpression':
|
| 52 | return new syntax.CallExpression(node.callee, node.arguments);
|
| 53 | case 'CatchClause':
|
| 54 | return new syntax.CatchClause(node.param, node.guard, node.body);
|
| 55 | case 'ConditionalExpression':
|
| 56 | return new syntax.ConditionalExpression(node.test, node.consequent, node.alternate);
|
| 57 | case 'ContinueStatement':
|
| 58 | return new syntax.ContinueStatement(node.label);
|
| 59 | case 'EmptyStatement':
|
| 60 | return new syntax.EmptyStatement();
|
| 61 | case 'ExpressionStatement':
|
| 62 | return new syntax.ExpressionStatement(node.expression);
|
| 63 | case 'ForInStatement':
|
| 64 | return new syntax.ForInStatement(node.left, node.right, node.body, node.each);
|
| 65 | case 'ForStatement':
|
| 66 | return new syntax.ForStatement(node.init, node.test, node.update, node.body);
|
| 67 | case 'FunctionDeclaration':
|
| 68 | return new syntax.FunctionDeclaration(node.id, node.params, node.body);
|
| 69 | case 'FunctionExpression':
|
| 70 | return new syntax.FunctionExpression(node.id, node.params, node.body);
|
| 71 | case 'Identifier':
|
| 72 | return new syntax.Identifier(node.name);
|
| 73 | case 'IfStatement':
|
| 74 | return new syntax.IfStatement(node.test, node.consequent, node.alternate);
|
| 75 | case 'Literal':
|
| 76 | return new syntax.Literal(node.value);
|
| 77 | case 'LogicalExpression':
|
| 78 | return new syntax.LogicalExpression(node.operator, node.left, node.right);
|
| 79 | case 'MemberExpression':
|
| 80 | return new syntax.MemberExpression(node.object, node.property, node.computed);
|
| 81 | case 'NewExpression':
|
| 82 | return new syntax.NewExpression(node.callee, node.arguments);
|
| 83 | case 'ObjectExpression':
|
| 84 | return new syntax.ObjectExpression(node.properties);
|
| 85 | case 'Property':
|
| 86 | return new syntax.Property(node.key, node.value, node.kind);
|
| 87 | case 'ReturnStatement':
|
| 88 | return new syntax.ReturnStatement(node.argument);
|
| 89 | case 'SwitchStatement':
|
| 90 | return new syntax.SwitchStatement(node.discriminant, node.cases);
|
| 91 | case 'SequenceExpression':
|
| 92 | return new syntax.SequenceExpression(node.expressions);
|
| 93 | case 'ThisExpression':
|
| 94 | return new syntax.ThisExpression(node);
|
| 95 | case 'ThrowStatement':
|
| 96 | return new syntax.ThrowStatement(node.argument);
|
| 97 | case 'TryStatement':
|
| 98 | return new syntax.TryStatement(node.block, node.handlers, node.finalizer);
|
| 99 | case 'UnaryExpression':
|
| 100 | return new syntax.UnaryExpression(node.operator, node.argument);
|
| 101 | case 'UpdateExpression':
|
| 102 | return new syntax.UpdateExpression(node.operator, node.argument, node.prefix);
|
| 103 | case 'VariableDeclaration':
|
| 104 | return new syntax.VariableDeclaration(node.declarations, node.kind);
|
| 105 | case 'VariableDeclarator':
|
| 106 | return new syntax.VariableDeclarator(node.id, node.init);
|
| 107 | case 'WhileStatement':
|
| 108 | return new syntax.WhileStatement(node.test, node.body);
|
| 109 | default:
|
| 110 | return node;
|
| 111 | }
|
| 112 | };
|