• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4  value: true
5});
6exports.UnaryExpression = UnaryExpression;
7exports.DoExpression = DoExpression;
8exports.ParenthesizedExpression = ParenthesizedExpression;
9exports.UpdateExpression = UpdateExpression;
10exports.ConditionalExpression = ConditionalExpression;
11exports.NewExpression = NewExpression;
12exports.SequenceExpression = SequenceExpression;
13exports.ThisExpression = ThisExpression;
14exports.Super = Super;
15exports.Decorator = Decorator;
16exports.OptionalMemberExpression = OptionalMemberExpression;
17exports.OptionalCallExpression = OptionalCallExpression;
18exports.CallExpression = CallExpression;
19exports.Import = Import;
20exports.EmptyStatement = EmptyStatement;
21exports.ExpressionStatement = ExpressionStatement;
22exports.AssignmentPattern = AssignmentPattern;
23exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
24exports.BindExpression = BindExpression;
25exports.MemberExpression = MemberExpression;
26exports.MetaProperty = MetaProperty;
27exports.PrivateName = PrivateName;
28exports.AwaitExpression = exports.YieldExpression = void 0;
29
30function t() {
31  const data = _interopRequireWildcard(require("@babel/types"));
32
33  t = function () {
34    return data;
35  };
36
37  return data;
38}
39
40var n = _interopRequireWildcard(require("../node"));
41
42function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
43
44function UnaryExpression(node) {
45  if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") {
46    this.word(node.operator);
47    this.space();
48  } else {
49    this.token(node.operator);
50  }
51
52  this.print(node.argument, node);
53}
54
55function DoExpression(node) {
56  this.word("do");
57  this.space();
58  this.print(node.body, node);
59}
60
61function ParenthesizedExpression(node) {
62  this.token("(");
63  this.print(node.expression, node);
64  this.token(")");
65}
66
67function UpdateExpression(node) {
68  if (node.prefix) {
69    this.token(node.operator);
70    this.print(node.argument, node);
71  } else {
72    this.startTerminatorless(true);
73    this.print(node.argument, node);
74    this.endTerminatorless();
75    this.token(node.operator);
76  }
77}
78
79function ConditionalExpression(node) {
80  this.print(node.test, node);
81  this.space();
82  this.token("?");
83  this.space();
84  this.print(node.consequent, node);
85  this.space();
86  this.token(":");
87  this.space();
88  this.print(node.alternate, node);
89}
90
91function NewExpression(node, parent) {
92  this.word("new");
93  this.space();
94  this.print(node.callee, node);
95
96  if (this.format.minified && node.arguments.length === 0 && !node.optional && !t().isCallExpression(parent, {
97    callee: node
98  }) && !t().isMemberExpression(parent) && !t().isNewExpression(parent)) {
99    return;
100  }
101
102  this.print(node.typeArguments, node);
103  this.print(node.typeParameters, node);
104
105  if (node.optional) {
106    this.token("?.");
107  }
108
109  this.token("(");
110  this.printList(node.arguments, node);
111  this.token(")");
112}
113
114function SequenceExpression(node) {
115  this.printList(node.expressions, node);
116}
117
118function ThisExpression() {
119  this.word("this");
120}
121
122function Super() {
123  this.word("super");
124}
125
126function Decorator(node) {
127  this.token("@");
128  this.print(node.expression, node);
129  this.newline();
130}
131
132function OptionalMemberExpression(node) {
133  this.print(node.object, node);
134
135  if (!node.computed && t().isMemberExpression(node.property)) {
136    throw new TypeError("Got a MemberExpression for MemberExpression property");
137  }
138
139  let computed = node.computed;
140
141  if (t().isLiteral(node.property) && typeof node.property.value === "number") {
142    computed = true;
143  }
144
145  if (node.optional) {
146    this.token("?.");
147  }
148
149  if (computed) {
150    this.token("[");
151    this.print(node.property, node);
152    this.token("]");
153  } else {
154    if (!node.optional) {
155      this.token(".");
156    }
157
158    this.print(node.property, node);
159  }
160}
161
162function OptionalCallExpression(node) {
163  this.print(node.callee, node);
164  this.print(node.typeArguments, node);
165  this.print(node.typeParameters, node);
166
167  if (node.optional) {
168    this.token("?.");
169  }
170
171  this.token("(");
172  this.printList(node.arguments, node);
173  this.token(")");
174}
175
176function CallExpression(node) {
177  this.print(node.callee, node);
178  this.print(node.typeArguments, node);
179  this.print(node.typeParameters, node);
180  this.token("(");
181  this.printList(node.arguments, node);
182  this.token(")");
183}
184
185function Import() {
186  this.word("import");
187}
188
189function buildYieldAwait(keyword) {
190  return function (node) {
191    this.word(keyword);
192
193    if (node.delegate) {
194      this.token("*");
195    }
196
197    if (node.argument) {
198      this.space();
199      const terminatorState = this.startTerminatorless();
200      this.print(node.argument, node);
201      this.endTerminatorless(terminatorState);
202    }
203  };
204}
205
206const YieldExpression = buildYieldAwait("yield");
207exports.YieldExpression = YieldExpression;
208const AwaitExpression = buildYieldAwait("await");
209exports.AwaitExpression = AwaitExpression;
210
211function EmptyStatement() {
212  this.semicolon(true);
213}
214
215function ExpressionStatement(node) {
216  this.print(node.expression, node);
217  this.semicolon();
218}
219
220function AssignmentPattern(node) {
221  this.print(node.left, node);
222  if (node.left.optional) this.token("?");
223  this.print(node.left.typeAnnotation, node);
224  this.space();
225  this.token("=");
226  this.space();
227  this.print(node.right, node);
228}
229
230function AssignmentExpression(node, parent) {
231  const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);
232
233  if (parens) {
234    this.token("(");
235  }
236
237  this.print(node.left, node);
238  this.space();
239
240  if (node.operator === "in" || node.operator === "instanceof") {
241    this.word(node.operator);
242  } else {
243    this.token(node.operator);
244  }
245
246  this.space();
247  this.print(node.right, node);
248
249  if (parens) {
250    this.token(")");
251  }
252}
253
254function BindExpression(node) {
255  this.print(node.object, node);
256  this.token("::");
257  this.print(node.callee, node);
258}
259
260function MemberExpression(node) {
261  this.print(node.object, node);
262
263  if (!node.computed && t().isMemberExpression(node.property)) {
264    throw new TypeError("Got a MemberExpression for MemberExpression property");
265  }
266
267  let computed = node.computed;
268
269  if (t().isLiteral(node.property) && typeof node.property.value === "number") {
270    computed = true;
271  }
272
273  if (computed) {
274    this.token("[");
275    this.print(node.property, node);
276    this.token("]");
277  } else {
278    this.token(".");
279    this.print(node.property, node);
280  }
281}
282
283function MetaProperty(node) {
284  this.print(node.meta, node);
285  this.token(".");
286  this.print(node.property, node);
287}
288
289function PrivateName(node) {
290  this.token("#");
291  this.print(node.id, node);
292}