├── .editorconfig
├── .gitattributes
├── .gitignore
├── .npmignore
├── .travis.yml
├── LICENSE
├── README.md
├── index.d.ts
├── index.js
├── package.json
├── test
    ├── driver.js
    ├── run.js
    ├── tests-jsx.js
    └── tests-misc.js
└── xhtml.js


/.editorconfig:
--------------------------------------------------------------------------------
1 | root = true
2 | 
3 | [*]
4 | indent_style = space
5 | indent_size = 2
6 | end_of_line = lf
7 | insert_final_newline = true
8 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | * text eol=lf
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /node_modules
2 | /package-lock.json
3 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | test
2 | .*
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: node_js
 2 | node_js:
 3 |   - '4'
 4 |   - '6'
 5 |   - '8'
 6 |   - '10'
 7 |   - '12'
 8 |   - '14'
 9 | env:
10 |   - ACORN_VERSION=6
11 |   - ACORN_VERSION=7
12 |   - ACORN_VERSION=8
13 | 
14 | install:
15 |   - npm install -D acorn@$ACORN_VERSION
16 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2012-2017 by Ingvar Stepanyan
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Acorn-JSX
 2 | 
 3 | [![Build Status](https://travis-ci.org/acornjs/acorn-jsx.svg?branch=master)](https://travis-ci.org/acornjs/acorn-jsx)
 4 | [![NPM version](https://img.shields.io/npm/v/acorn-jsx.svg)](https://www.npmjs.org/package/acorn-jsx)
 5 | 
 6 | <a href="https://stand-with-ukraine.pp.ua/"><img src="https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner-direct.svg" width="800"></a>
 7 | 
 8 | This is plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.
 9 | 
10 | It was created as an experimental alternative, faster [React.js JSX](http://facebook.github.io/react/docs/jsx-in-depth.html) parser. Later, it replaced the [official parser](https://github.com/facebookarchive/esprima) and these days is used by many prominent development tools.
11 | 
12 | ## Transpiler
13 | 
14 | Please note that this tool only parses source code to JSX AST, which is useful for various language tools and services. If you want to transpile your code to regular ES5-compliant JavaScript with source map, check out [Babel](https://babeljs.io/) and [Buble](https://buble.surge.sh/) transpilers which use `acorn-jsx` under the hood.
15 | 
16 | ## Usage
17 | 
18 | Requiring this module provides you with an Acorn plugin that you can use like this:
19 | 
20 | ```javascript
21 | var acorn = require("acorn");
22 | var jsx = require("acorn-jsx");
23 | acorn.Parser.extend(jsx()).parse("my(<jsx/>, 'code');");
24 | ```
25 | 
26 | Note that official spec doesn't support mix of XML namespaces and object-style access in tag names (#27) like in `<namespace:Object.Property />`, so it was deprecated in `acorn-jsx@3.0`. If you still want to opt-in to support of such constructions, you can pass the following option:
27 | 
28 | ```javascript
29 | acorn.Parser.extend(jsx({ allowNamespacedObjects: true }))
30 | ```
31 | 
32 | Also, since most apps use pure React transformer, a new option was introduced that allows to prohibit namespaces completely:
33 | 
34 | ```javascript
35 | acorn.Parser.extend(jsx({ allowNamespaces: false }))
36 | ```
37 | 
38 | Note that by default `allowNamespaces` is enabled for spec compliancy.
39 | 
40 | ## License
41 | 
42 | This plugin is issued under the [MIT license](./LICENSE).
43 | 


--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
 1 | import * as acorn from 'acorn';
 2 | 
 3 | interface JsxTokTypes extends AcornTokTypes {
 4 |   jsxName: acorn.TokenType,
 5 |   jsxText: acorn.TokenType,
 6 |   jsxTagEnd: acorn.TokenType,
 7 |   jsxTagStart: acorn.TokenType
 8 | }
 9 | 
10 | declare const jsx: {
11 |   tokTypes: JsxTokTypes;
12 |   (options?: jsx.Options): (BaseParser: typeof acorn.Parser) => jsx.AcornJsxParserCtor
13 | }
14 | 
15 | type AcornTokTypes = typeof acorn.tokTypes;
16 | 
17 | declare namespace jsx {
18 | 
19 |   type TokTypes = JsxTokTypes
20 | 
21 |   interface Options {
22 |     allowNamespacedObjects?: boolean;
23 |     allowNamespaces?: boolean;
24 |   }
25 | 
26 |   interface TokContexts {
27 |     tc_oTag: acorn.TokContext,
28 |     tc_cTag: acorn.TokContext,
29 |     tc_expr: acorn.TokContext
30 |   }
31 | 
32 |   // We pick (statics) from acorn rather than plain extending to avoid complaint
33 |   //   about base constructors needing the same return type (i.e., we return
34 |   //   `AcornJsxParser` here)
35 |   interface AcornJsxParserCtor extends Pick<typeof acorn.Parser, keyof typeof acorn.Parser> {
36 |     readonly acornJsx: {
37 |       tokTypes: TokTypes;
38 |       tokContexts: TokContexts
39 |     };
40 | 
41 |     new (options: acorn.Options, input: string, startPos?: number): AcornJsxParser;
42 |   }
43 | 
44 |   interface AcornJsxParser extends acorn.Parser {
45 |     jsx_readToken(): string;
46 |     jsx_readNewLine(normalizeCRLF: boolean): void;
47 |     jsx_readString(quote: number): void;
48 |     jsx_readEntity(): string;
49 |     jsx_readWord(): void;
50 |     jsx_parseIdentifier(): acorn.Node;
51 |     jsx_parseNamespacedName(): acorn.Node;
52 |     jsx_parseElementName(): acorn.Node | string;
53 |     jsx_parseAttributeValue(): acorn.Node;
54 |     jsx_parseEmptyExpression(): acorn.Node;
55 |     jsx_parseExpressionContainer(): acorn.Node;
56 |     jsx_parseAttribute(): acorn.Node;
57 |     jsx_parseOpeningElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
58 |     jsx_parseClosingElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
59 |     jsx_parseElementAt(startPos: number, startLoc?: acorn.SourceLocation): acorn.Node;
60 |     jsx_parseText(): acorn.Node;
61 |     jsx_parseElement(): acorn.Node;
62 |   }
63 | }
64 | 
65 | export = jsx;
66 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const XHTMLEntities = require('./xhtml');
  4 | 
  5 | const hexNumber = /^[\da-fA-F]+$/;
  6 | const decimalNumber = /^\d+$/;
  7 | 
  8 | // The map to `acorn-jsx` tokens from `acorn` namespace objects.
  9 | const acornJsxMap = new WeakMap();
 10 | 
 11 | // Get the original tokens for the given `acorn` namespace object.
 12 | function getJsxTokens(acorn) {
 13 |   acorn = acorn.Parser.acorn || acorn;
 14 |   let acornJsx = acornJsxMap.get(acorn);
 15 |   if (!acornJsx) {
 16 |     const tt = acorn.tokTypes;
 17 |     const TokContext = acorn.TokContext;
 18 |     const TokenType = acorn.TokenType;
 19 |     const tc_oTag = new TokContext('<tag', false);
 20 |     const tc_cTag = new TokContext('</tag', false);
 21 |     const tc_expr = new TokContext('<tag>...</tag>', true, true);
 22 |     const tokContexts = {
 23 |       tc_oTag: tc_oTag,
 24 |       tc_cTag: tc_cTag,
 25 |       tc_expr: tc_expr
 26 |     };
 27 |     const tokTypes = {
 28 |       jsxName: new TokenType('jsxName'),
 29 |       jsxText: new TokenType('jsxText', {beforeExpr: true}),
 30 |       jsxTagStart: new TokenType('jsxTagStart', {startsExpr: true}),
 31 |       jsxTagEnd: new TokenType('jsxTagEnd')
 32 |     };
 33 | 
 34 |     tokTypes.jsxTagStart.updateContext = function() {
 35 |       this.context.push(tc_expr); // treat as beginning of JSX expression
 36 |       this.context.push(tc_oTag); // start opening tag context
 37 |       this.exprAllowed = false;
 38 |     };
 39 |     tokTypes.jsxTagEnd.updateContext = function(prevType) {
 40 |       let out = this.context.pop();
 41 |       if (out === tc_oTag && prevType === tt.slash || out === tc_cTag) {
 42 |         this.context.pop();
 43 |         this.exprAllowed = this.curContext() === tc_expr;
 44 |       } else {
 45 |         this.exprAllowed = true;
 46 |       }
 47 |     };
 48 | 
 49 |     acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };
 50 |     acornJsxMap.set(acorn, acornJsx);
 51 |   }
 52 | 
 53 |   return acornJsx;
 54 | }
 55 | 
 56 | // Transforms JSX element name to string.
 57 | 
 58 | function getQualifiedJSXName(object) {
 59 |   if (!object)
 60 |     return object;
 61 | 
 62 |   if (object.type === 'JSXIdentifier')
 63 |     return object.name;
 64 | 
 65 |   if (object.type === 'JSXNamespacedName')
 66 |     return object.namespace.name + ':' + object.name.name;
 67 | 
 68 |   if (object.type === 'JSXMemberExpression')
 69 |     return getQualifiedJSXName(object.object) + '.' +
 70 |     getQualifiedJSXName(object.property);
 71 | }
 72 | 
 73 | module.exports = function(options) {
 74 |   options = options || {};
 75 |   return function(Parser) {
 76 |     return plugin({
 77 |       allowNamespaces: options.allowNamespaces !== false,
 78 |       allowNamespacedObjects: !!options.allowNamespacedObjects
 79 |     }, Parser);
 80 |   };
 81 | };
 82 | 
 83 | // This is `tokTypes` of the peer dep.
 84 | // This can be different instances from the actual `tokTypes` this plugin uses.
 85 | Object.defineProperty(module.exports, "tokTypes", {
 86 |   get: function get_tokTypes() {
 87 |     return getJsxTokens(require("acorn")).tokTypes;
 88 |   },
 89 |   configurable: true,
 90 |   enumerable: true
 91 | });
 92 | 
 93 | function plugin(options, Parser) {
 94 |   const acorn = Parser.acorn || require("acorn");
 95 |   const acornJsx = getJsxTokens(acorn);
 96 |   const tt = acorn.tokTypes;
 97 |   const tok = acornJsx.tokTypes;
 98 |   const tokContexts = acorn.tokContexts;
 99 |   const tc_oTag = acornJsx.tokContexts.tc_oTag;
100 |   const tc_cTag = acornJsx.tokContexts.tc_cTag;
101 |   const tc_expr = acornJsx.tokContexts.tc_expr;
102 |   const isNewLine = acorn.isNewLine;
103 |   const isIdentifierStart = acorn.isIdentifierStart;
104 |   const isIdentifierChar = acorn.isIdentifierChar;
105 | 
106 |   return class extends Parser {
107 |     // Expose actual `tokTypes` and `tokContexts` to other plugins.
108 |     static get acornJsx() {
109 |       return acornJsx;
110 |     }
111 | 
112 |     // Reads inline JSX contents token.
113 |     jsx_readToken() {
114 |       let out = '', chunkStart = this.pos;
115 |       for (;;) {
116 |         if (this.pos >= this.input.length)
117 |           this.raise(this.start, 'Unterminated JSX contents');
118 |         let ch = this.input.charCodeAt(this.pos);
119 | 
120 |         switch (ch) {
121 |         case 60: // '<'
122 |         case 123: // '{'
123 |           if (this.pos === this.start) {
124 |             if (ch === 60 && this.exprAllowed) {
125 |               ++this.pos;
126 |               return this.finishToken(tok.jsxTagStart);
127 |             }
128 |             return this.getTokenFromCode(ch);
129 |           }
130 |           out += this.input.slice(chunkStart, this.pos);
131 |           return this.finishToken(tok.jsxText, out);
132 | 
133 |         case 38: // '&'
134 |           out += this.input.slice(chunkStart, this.pos);
135 |           out += this.jsx_readEntity();
136 |           chunkStart = this.pos;
137 |           break;
138 | 
139 |         case 62: // '>'
140 |         case 125: // '}'
141 |           this.raise(
142 |             this.pos,
143 |             "Unexpected token `" + this.input[this.pos] + "`. Did you mean `" +
144 |               (ch === 62 ? "&gt;" : "&rbrace;") + "` or " + "`{\"" + this.input[this.pos] + "\"}" + "`?"
145 |           );
146 | 
147 |         default:
148 |           if (isNewLine(ch)) {
149 |             out += this.input.slice(chunkStart, this.pos);
150 |             out += this.jsx_readNewLine(true);
151 |             chunkStart = this.pos;
152 |           } else {
153 |             ++this.pos;
154 |           }
155 |         }
156 |       }
157 |     }
158 | 
159 |     jsx_readNewLine(normalizeCRLF) {
160 |       let ch = this.input.charCodeAt(this.pos);
161 |       let out;
162 |       ++this.pos;
163 |       if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
164 |         ++this.pos;
165 |         out = normalizeCRLF ? '\n' : '\r\n';
166 |       } else {
167 |         out = String.fromCharCode(ch);
168 |       }
169 |       if (this.options.locations) {
170 |         ++this.curLine;
171 |         this.lineStart = this.pos;
172 |       }
173 | 
174 |       return out;
175 |     }
176 | 
177 |     jsx_readString(quote) {
178 |       let out = '', chunkStart = ++this.pos;
179 |       for (;;) {
180 |         if (this.pos >= this.input.length)
181 |           this.raise(this.start, 'Unterminated string constant');
182 |         let ch = this.input.charCodeAt(this.pos);
183 |         if (ch === quote) break;
184 |         if (ch === 38) { // '&'
185 |           out += this.input.slice(chunkStart, this.pos);
186 |           out += this.jsx_readEntity();
187 |           chunkStart = this.pos;
188 |         } else if (isNewLine(ch)) {
189 |           out += this.input.slice(chunkStart, this.pos);
190 |           out += this.jsx_readNewLine(false);
191 |           chunkStart = this.pos;
192 |         } else {
193 |           ++this.pos;
194 |         }
195 |       }
196 |       out += this.input.slice(chunkStart, this.pos++);
197 |       return this.finishToken(tt.string, out);
198 |     }
199 | 
200 |     jsx_readEntity() {
201 |       let str = '', count = 0, entity;
202 |       let ch = this.input[this.pos];
203 |       if (ch !== '&')
204 |         this.raise(this.pos, 'Entity must start with an ampersand');
205 |       let startPos = ++this.pos;
206 |       while (this.pos < this.input.length && count++ < 10) {
207 |         ch = this.input[this.pos++];
208 |         if (ch === ';') {
209 |           if (str[0] === '#') {
210 |             if (str[1] === 'x') {
211 |               str = str.substr(2);
212 |               if (hexNumber.test(str))
213 |                 entity = String.fromCharCode(parseInt(str, 16));
214 |             } else {
215 |               str = str.substr(1);
216 |               if (decimalNumber.test(str))
217 |                 entity = String.fromCharCode(parseInt(str, 10));
218 |             }
219 |           } else {
220 |             entity = XHTMLEntities[str];
221 |           }
222 |           break;
223 |         }
224 |         str += ch;
225 |       }
226 |       if (!entity) {
227 |         this.pos = startPos;
228 |         return '&';
229 |       }
230 |       return entity;
231 |     }
232 | 
233 |     // Read a JSX identifier (valid tag or attribute name).
234 |     //
235 |     // Optimized version since JSX identifiers can't contain
236 |     // escape characters and so can be read as single slice.
237 |     // Also assumes that first character was already checked
238 |     // by isIdentifierStart in readToken.
239 | 
240 |     jsx_readWord() {
241 |       let ch, start = this.pos;
242 |       do {
243 |         ch = this.input.charCodeAt(++this.pos);
244 |       } while (isIdentifierChar(ch) || ch === 45); // '-'
245 |       return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));
246 |     }
247 | 
248 |     // Parse next token as JSX identifier
249 | 
250 |     jsx_parseIdentifier() {
251 |       let node = this.startNode();
252 |       if (this.type === tok.jsxName)
253 |         node.name = this.value;
254 |       else if (this.type.keyword)
255 |         node.name = this.type.keyword;
256 |       else
257 |         this.unexpected();
258 |       this.next();
259 |       return this.finishNode(node, 'JSXIdentifier');
260 |     }
261 | 
262 |     // Parse namespaced identifier.
263 | 
264 |     jsx_parseNamespacedName() {
265 |       let startPos = this.start, startLoc = this.startLoc;
266 |       let name = this.jsx_parseIdentifier();
267 |       if (!options.allowNamespaces || !this.eat(tt.colon)) return name;
268 |       var node = this.startNodeAt(startPos, startLoc);
269 |       node.namespace = name;
270 |       node.name = this.jsx_parseIdentifier();
271 |       return this.finishNode(node, 'JSXNamespacedName');
272 |     }
273 | 
274 |     // Parses element name in any form - namespaced, member
275 |     // or single identifier.
276 | 
277 |     jsx_parseElementName() {
278 |       if (this.type === tok.jsxTagEnd) return '';
279 |       let startPos = this.start, startLoc = this.startLoc;
280 |       let node = this.jsx_parseNamespacedName();
281 |       if (this.type === tt.dot && node.type === 'JSXNamespacedName' && !options.allowNamespacedObjects) {
282 |         this.unexpected();
283 |       }
284 |       while (this.eat(tt.dot)) {
285 |         let newNode = this.startNodeAt(startPos, startLoc);
286 |         newNode.object = node;
287 |         newNode.property = this.jsx_parseIdentifier();
288 |         node = this.finishNode(newNode, 'JSXMemberExpression');
289 |       }
290 |       return node;
291 |     }
292 | 
293 |     // Parses any type of JSX attribute value.
294 | 
295 |     jsx_parseAttributeValue() {
296 |       switch (this.type) {
297 |       case tt.braceL:
298 |         let node = this.jsx_parseExpressionContainer();
299 |         if (node.expression.type === 'JSXEmptyExpression')
300 |           this.raise(node.start, 'JSX attributes must only be assigned a non-empty expression');
301 |         return node;
302 | 
303 |       case tok.jsxTagStart:
304 |       case tt.string:
305 |         return this.parseExprAtom();
306 | 
307 |       default:
308 |         this.raise(this.start, 'JSX value should be either an expression or a quoted JSX text');
309 |       }
310 |     }
311 | 
312 |     // JSXEmptyExpression is unique type since it doesn't actually parse anything,
313 |     // and so it should start at the end of last read token (left brace) and finish
314 |     // at the beginning of the next one (right brace).
315 | 
316 |     jsx_parseEmptyExpression() {
317 |       let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
318 |       return this.finishNodeAt(node, 'JSXEmptyExpression', this.start, this.startLoc);
319 |     }
320 | 
321 |     // Parses JSX expression enclosed into curly brackets.
322 | 
323 |     jsx_parseExpressionContainer() {
324 |       let node = this.startNode();
325 |       this.next();
326 |       node.expression = this.type === tt.braceR
327 |         ? this.jsx_parseEmptyExpression()
328 |         : this.parseExpression();
329 |       this.expect(tt.braceR);
330 |       return this.finishNode(node, 'JSXExpressionContainer');
331 |     }
332 | 
333 |     // Parses following JSX attribute name-value pair.
334 | 
335 |     jsx_parseAttribute() {
336 |       let node = this.startNode();
337 |       if (this.eat(tt.braceL)) {
338 |         this.expect(tt.ellipsis);
339 |         node.argument = this.parseMaybeAssign();
340 |         this.expect(tt.braceR);
341 |         return this.finishNode(node, 'JSXSpreadAttribute');
342 |       }
343 |       node.name = this.jsx_parseNamespacedName();
344 |       node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
345 |       return this.finishNode(node, 'JSXAttribute');
346 |     }
347 | 
348 |     // Parses JSX opening tag starting after '<'.
349 | 
350 |     jsx_parseOpeningElementAt(startPos, startLoc) {
351 |       let node = this.startNodeAt(startPos, startLoc);
352 |       node.attributes = [];
353 |       let nodeName = this.jsx_parseElementName();
354 |       if (nodeName) node.name = nodeName;
355 |       while (this.type !== tt.slash && this.type !== tok.jsxTagEnd)
356 |         node.attributes.push(this.jsx_parseAttribute());
357 |       node.selfClosing = this.eat(tt.slash);
358 |       this.expect(tok.jsxTagEnd);
359 |       return this.finishNode(node, nodeName ? 'JSXOpeningElement' : 'JSXOpeningFragment');
360 |     }
361 | 
362 |     // Parses JSX closing tag starting after '</'.
363 | 
364 |     jsx_parseClosingElementAt(startPos, startLoc) {
365 |       let node = this.startNodeAt(startPos, startLoc);
366 |       let nodeName = this.jsx_parseElementName();
367 |       if (nodeName) node.name = nodeName;
368 |       this.expect(tok.jsxTagEnd);
369 |       return this.finishNode(node, nodeName ? 'JSXClosingElement' : 'JSXClosingFragment');
370 |     }
371 | 
372 |     // Parses entire JSX element, including it's opening tag
373 |     // (starting after '<'), attributes, contents and closing tag.
374 | 
375 |     jsx_parseElementAt(startPos, startLoc) {
376 |       let node = this.startNodeAt(startPos, startLoc);
377 |       let children = [];
378 |       let openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);
379 |       let closingElement = null;
380 | 
381 |       if (!openingElement.selfClosing) {
382 |         contents: for (;;) {
383 |           switch (this.type) {
384 |           case tok.jsxTagStart:
385 |             startPos = this.start; startLoc = this.startLoc;
386 |             this.next();
387 |             if (this.eat(tt.slash)) {
388 |               closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);
389 |               break contents;
390 |             }
391 |             children.push(this.jsx_parseElementAt(startPos, startLoc));
392 |             break;
393 | 
394 |           case tok.jsxText:
395 |             children.push(this.parseExprAtom());
396 |             break;
397 | 
398 |           case tt.braceL:
399 |             children.push(this.jsx_parseExpressionContainer());
400 |             break;
401 | 
402 |           default:
403 |             this.unexpected();
404 |           }
405 |         }
406 |         if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
407 |           this.raise(
408 |             closingElement.start,
409 |             'Expected corresponding JSX closing tag for <' + getQualifiedJSXName(openingElement.name) + '>');
410 |         }
411 |       }
412 |       let fragmentOrElement = openingElement.name ? 'Element' : 'Fragment';
413 | 
414 |       node['opening' + fragmentOrElement] = openingElement;
415 |       node['closing' + fragmentOrElement] = closingElement;
416 |       node.children = children;
417 |       if (this.type === tt.relational && this.value === "<") {
418 |         this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag");
419 |       }
420 |       return this.finishNode(node, 'JSX' + fragmentOrElement);
421 |     }
422 | 
423 |     // Parse JSX text
424 | 
425 |     jsx_parseText() {
426 |       let node = this.parseLiteral(this.value);
427 |       node.type = "JSXText";
428 |       return node;
429 |     }
430 | 
431 |     // Parses entire JSX element from current position.
432 | 
433 |     jsx_parseElement() {
434 |       let startPos = this.start, startLoc = this.startLoc;
435 |       this.next();
436 |       return this.jsx_parseElementAt(startPos, startLoc);
437 |     }
438 | 
439 |     parseExprAtom(refShortHandDefaultPos) {
440 |       if (this.type === tok.jsxText)
441 |         return this.jsx_parseText();
442 |       else if (this.type === tok.jsxTagStart)
443 |         return this.jsx_parseElement();
444 |       else
445 |         return super.parseExprAtom(refShortHandDefaultPos);
446 |     }
447 | 
448 |     readToken(code) {
449 |       let context = this.curContext();
450 | 
451 |       if (context === tc_expr) return this.jsx_readToken();
452 | 
453 |       if (context === tc_oTag || context === tc_cTag) {
454 |         if (isIdentifierStart(code)) return this.jsx_readWord();
455 | 
456 |         if (code == 62) {
457 |           ++this.pos;
458 |           return this.finishToken(tok.jsxTagEnd);
459 |         }
460 | 
461 |         if ((code === 34 || code === 39) && context == tc_oTag)
462 |           return this.jsx_readString(code);
463 |       }
464 | 
465 |       if (code === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {
466 |         ++this.pos;
467 |         return this.finishToken(tok.jsxTagStart);
468 |       }
469 |       return super.readToken(code);
470 |     }
471 | 
472 |     updateContext(prevType) {
473 |       if (this.type == tt.braceL) {
474 |         var curContext = this.curContext();
475 |         if (curContext == tc_oTag) this.context.push(tokContexts.b_expr);
476 |         else if (curContext == tc_expr) this.context.push(tokContexts.b_tmpl);
477 |         else super.updateContext(prevType);
478 |         this.exprAllowed = true;
479 |       } else if (this.type === tt.slash && prevType === tok.jsxTagStart) {
480 |         this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
481 |         this.context.push(tc_cTag); // reconsider as closing tag context
482 |         this.exprAllowed = false;
483 |       } else {
484 |         return super.updateContext(prevType);
485 |       }
486 |     }
487 |   };
488 | }
489 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "acorn-jsx",
 3 |   "description": "Modern, fast React.js JSX parser",
 4 |   "homepage": "https://github.com/acornjs/acorn-jsx",
 5 |   "version": "5.3.2",
 6 |   "maintainers": [
 7 |     {
 8 |       "name": "Ingvar Stepanyan",
 9 |       "email": "me@rreverser.com",
10 |       "web": "http://rreverser.com/"
11 |     }
12 |   ],
13 |   "repository": {
14 |     "type": "git",
15 |     "url": "https://github.com/acornjs/acorn-jsx"
16 |   },
17 |   "license": "MIT",
18 |   "scripts": {
19 |     "test": "node test/run.js"
20 |   },
21 |   "peerDependencies": {
22 |     "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
23 |   },
24 |   "devDependencies": {
25 |     "acorn": "^8.0.1"
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/test/driver.js:
--------------------------------------------------------------------------------
  1 | var tests = [];
  2 | 
  3 | exports.test = function(code, ast, options, pluginOptions) {
  4 |   tests.push({code, ast, options, pluginOptions});
  5 | };
  6 | exports.testFail = function(code, message, options, pluginOptions) {
  7 |   tests.push({code, error: message, options, pluginOptions});
  8 | };
  9 | exports.testAssert = function(code, assert, options) {
 10 |   tests.push({code, assert, options});
 11 | };
 12 | 
 13 | exports.runTests = function(config, callback) {
 14 |   var parse = config.parse;
 15 | 
 16 |   for (var i = 0; i < tests.length; ++i) {
 17 |     var test = tests[i];
 18 |     if (config.filter && !config.filter(test)) continue;
 19 |     try {
 20 |       var testOpts = Object.assign({ecmaVersion: 11}, test.options || {locations: true});
 21 |       var expected = {};
 22 |       if (expected.onComment = testOpts.onComment) {
 23 |         testOpts.onComment = []
 24 |       }
 25 |       if (expected.onToken = testOpts.onToken) {
 26 |         testOpts.onToken = [];
 27 |       }
 28 |       var ast = parse(test.code, testOpts, test.pluginOptions);
 29 |       if (test.error) {
 30 |         if (config.loose) {
 31 |           callback("ok", test.code);
 32 |         } else {
 33 |           callback("fail", test.code, "Expected error message: " + test.error + "\nBut parsing succeeded.");
 34 |         }
 35 |       }
 36 |       else if (test.assert) {
 37 |         var error = test.assert(ast);
 38 |         if (error) callback("fail", test.code,
 39 |                                "\n  Assertion failed:\n " + error);
 40 |         else callback("ok", test.code);
 41 |       } else {
 42 |         var mis = misMatch(test.ast, ast);
 43 |         for (var name in expected) {
 44 |           if (mis) break;
 45 |           if (expected[name]) {
 46 |             mis = misMatch(expected[name], testOpts[name]);
 47 |             testOpts[name] = expected[name];
 48 |           }
 49 |         }
 50 |         if (mis) callback("fail", test.code, mis);
 51 |         else callback("ok", test.code);
 52 |       }
 53 |     } catch(e) {
 54 |       if (!(e instanceof SyntaxError)) {
 55 |         throw e;
 56 |       }
 57 |       if (test.error) {
 58 |         if (e.message == test.error) callback("ok", test.code);
 59 |         else callback("fail", test.code,
 60 |                       "Expected error message: " + test.error + "\nGot error message: " + e.message);
 61 |       } else {
 62 |         callback("error", test.code, e.stack || e.toString());
 63 |       }
 64 |     }
 65 |   }
 66 | };
 67 | 
 68 | function ppJSON(v) { return v instanceof RegExp ? v.toString() : JSON.stringify(v, null, 2); }
 69 | function addPath(str, pt) {
 70 |   if (str.charAt(str.length-1) == ")")
 71 |     return str.slice(0, str.length-1) + "/" + pt + ")";
 72 |   return str + " (" + pt + ")";
 73 | }
 74 | 
 75 | var misMatch = exports.misMatch = function(exp, act) {
 76 |   if (!exp || !act || (typeof exp != "object") || (typeof act != "object")) {
 77 |     if (exp !== act) return ppJSON(exp) + " !== " + ppJSON(act);
 78 |   } else if (exp instanceof RegExp || act instanceof RegExp) {
 79 |     var left = ppJSON(exp), right = ppJSON(act);
 80 |     if (left !== right) return left + " !== " + right;
 81 |   } else if (exp.splice) {
 82 |     if (!act.slice) return ppJSON(exp) + " != " + ppJSON(act);
 83 |     if (act.length != exp.length) return "array length mismatch " + exp.length + " != " + act.length;
 84 |     for (var i = 0; i < act.length; ++i) {
 85 |       var mis = misMatch(exp[i], act[i]);
 86 |       if (mis) return addPath(mis, i);
 87 |     }
 88 |   } else {
 89 |     for (var prop in exp) {
 90 |       var mis = misMatch(exp[prop], act[prop]);
 91 |       if (mis) return addPath(mis, prop);
 92 |     }
 93 |   }
 94 | };
 95 | 
 96 | function mangle(ast) {
 97 |   if (typeof ast != "object" || !ast) return;
 98 |   if (ast.slice) {
 99 |     for (var i = 0; i < ast.length; ++i) mangle(ast[i]);
100 |   } else {
101 |     var loc = ast.start && ast.end && {start: ast.start, end: ast.end};
102 |     if (loc) { delete ast.start; delete ast.end; }
103 |     for (var name in ast) if (ast.hasOwnProperty(name)) mangle(ast[name]);
104 |     if (loc) ast.loc = loc;
105 |   }
106 | }
107 | 


--------------------------------------------------------------------------------
/test/run.js:
--------------------------------------------------------------------------------
 1 | var driver = require("./driver.js");
 2 | require("./tests-jsx.js");
 3 | require("./tests-misc.js");
 4 | 
 5 | function group(name) {
 6 |   if (typeof console === "object" && console.group) {
 7 |     console.group(name);
 8 |   }
 9 | }
10 | 
11 | function groupEnd() {
12 |   if (typeof console === "object" && console.groupEnd) {
13 |     console.groupEnd(name);
14 |   }
15 | }
16 | 
17 | function log(title, message) {
18 |   if (typeof console === "object") console.log(title, message);
19 | }
20 | 
21 | const acorn = require("acorn"), jsx = require("..")
22 | const Parser = acorn.Parser.extend(jsx())
23 | 
24 | var stats, modes = {
25 |   Normal: {
26 |     config: {
27 |       parse: (input, options, pluginOptions) => {
28 |         if (!pluginOptions) return Parser.parse(input, options)
29 |         else return acorn.Parser.extend(jsx(pluginOptions)).parse(input, options)
30 |       }
31 |     }
32 |   }
33 | };
34 | 
35 | function report(state, code, message) {
36 |   if (state != "ok") {++stats.failed; log(code, message);}
37 |   ++stats.testsRun;
38 | }
39 | 
40 | group("Errors");
41 | 
42 | for (var name in modes) {
43 |   group(name);
44 |   var mode = modes[name];
45 |   stats = mode.stats = {testsRun: 0, failed: 0};
46 |   var t0 = +new Date;
47 |   driver.runTests(mode.config, report);
48 |   mode.stats.duration = +new Date - t0;
49 |   groupEnd();
50 | }
51 | 
52 | groupEnd();
53 | 
54 | function outputStats(name, stats) {
55 |   log(name + ":", stats.testsRun + " tests run in " + stats.duration + "ms; " +
56 |     (stats.failed ? stats.failed + " failures." : "all passed."));
57 | }
58 | 
59 | var total = {testsRun: 0, failed: 0, duration: 0};
60 | 
61 | group("Stats");
62 | 
63 | for (var name in modes) {
64 |   var stats = modes[name].stats;
65 |   outputStats(name + " parser", stats);
66 |   for (var key in stats) total[key] += stats[key];
67 | }
68 | 
69 | outputStats("Total", total);
70 | 
71 | groupEnd();
72 | 
73 | if (total.failed && typeof process === "object") {
74 |   process.stdout.write("", function() {
75 |     process.exit(1);
76 |   });
77 | }
78 | 


--------------------------------------------------------------------------------
/test/tests-jsx.js:
--------------------------------------------------------------------------------
   1 | /*
   2 | Redistribution and use in source and binary forms, with or without
   3 | modification, are permitted provided that the following conditions are met:
   4 | 
   5 |   * Redistributions of source code must retain the above copyright
   6 |     notice, this list of conditions and the following disclaimer.
   7 |   * Redistributions in binary form must reproduce the above copyright
   8 |     notice, this list of conditions and the following disclaimer in the
   9 |     documentation and/or other materials provided with the distribution.
  10 | 
  11 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  12 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  13 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  14 | ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  15 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  16 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  17 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  18 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  19 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  20 | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  21 | */
  22 | 
  23 | var fbTestFixture = {
  24 |   // Taken and adapted from esprima-fb/fbtest.js.
  25 |   'JSX': {
  26 |     '<a />': {
  27 |       type: "ExpressionStatement",
  28 |       expression: {
  29 |         type: "JSXElement",
  30 |         openingElement: {
  31 |           type: "JSXOpeningElement",
  32 |           name: {
  33 |             type: "JSXIdentifier",
  34 |             name: "a",
  35 |             range: [1, 2],
  36 |             loc: {
  37 |               start: { line: 1, column: 1 },
  38 |               end: { line: 1, column: 2 }
  39 |             }
  40 |           },
  41 |           selfClosing: true,
  42 |           attributes: [],
  43 |           range: [0, 5],
  44 |           loc: {
  45 |             start: { line: 1, column: 0 },
  46 |             end: { line: 1, column: 5 }
  47 |           }
  48 |         },
  49 |         closingElement: null,
  50 |         children: [],
  51 |         range: [0, 5],
  52 |         loc: {
  53 |           start: { line: 1, column: 0 },
  54 |           end: { line: 1, column: 5 }
  55 |         }
  56 |       },
  57 |       range: [0, 5],
  58 |       loc: {
  59 |         start: { line: 1, column: 0 },
  60 |         end: { line: 1, column: 5 }
  61 |       }
  62 |     },
  63 | 
  64 |     '<n:a n:v />': {
  65 |       type: 'ExpressionStatement',
  66 |       expression: {
  67 |         type: 'JSXElement',
  68 |         openingElement: {
  69 |           type: 'JSXOpeningElement',
  70 |           name: {
  71 |             type: 'JSXNamespacedName',
  72 |             namespace: {
  73 |               type: 'JSXIdentifier',
  74 |               name: 'n',
  75 |               range: [1, 2],
  76 |               loc: {
  77 |                 start: { line: 1, column: 1 },
  78 |                 end: { line: 1, column: 2 }
  79 |               }
  80 |             },
  81 |             name: {
  82 |               type: 'JSXIdentifier',
  83 |               name: 'a',
  84 |               range: [3, 4],
  85 |               loc: {
  86 |                 start: { line: 1, column: 3 },
  87 |                 end: { line: 1, column: 4 }
  88 |               }
  89 |             },
  90 |             range: [1, 4],
  91 |             loc: {
  92 |               start: { line: 1, column: 1 },
  93 |               end: { line: 1, column: 4 }
  94 |             }
  95 |           },
  96 |           selfClosing: true,
  97 |           attributes: [{
  98 |             type: 'JSXAttribute',
  99 |             name: {
 100 |               type: 'JSXNamespacedName',
 101 |               namespace: {
 102 |                 type: 'JSXIdentifier',
 103 |                 name: 'n',
 104 |                 range: [5, 6],
 105 |                 loc: {
 106 |                   start: { line: 1, column: 5 },
 107 |                   end: { line: 1, column: 6 }
 108 |                 }
 109 |               },
 110 |               name: {
 111 |                 type: 'JSXIdentifier',
 112 |                 name: 'v',
 113 |                 range: [7, 8],
 114 |                 loc: {
 115 |                   start: { line: 1, column: 7 },
 116 |                   end: { line: 1, column: 8 }
 117 |                 }
 118 |               },
 119 |               range: [5, 8],
 120 |               loc: {
 121 |                 start: { line: 1, column: 5 },
 122 |                 end: { line: 1, column: 8 }
 123 |               }
 124 |             },
 125 |             value: null,
 126 |             range: [5, 8],
 127 |             loc: {
 128 |               start: { line: 1, column: 5 },
 129 |               end: { line: 1, column: 8 }
 130 |             }
 131 |           }],
 132 |           range: [0, 11],
 133 |           loc: {
 134 |             start: { line: 1, column: 0 },
 135 |             end: { line: 1, column: 11 }
 136 |           }
 137 |         },
 138 |         closingElement: null,
 139 |         children: [],
 140 |         range: [0, 11],
 141 |         loc: {
 142 |           start: { line: 1, column: 0 },
 143 |           end: { line: 1, column: 11 }
 144 |         }
 145 |       },
 146 |       range: [0, 11],
 147 |       loc: {
 148 |         start: { line: 1, column: 0 },
 149 |         end: { line: 1, column: 11 }
 150 |       }
 151 |     },
 152 | 
 153 |     '<a n:foo="bar"> {value} <b><c /></b></a>': {
 154 |       type: 'ExpressionStatement',
 155 |       expression: {
 156 |         type: 'JSXElement',
 157 |         openingElement: {
 158 |           type: 'JSXOpeningElement',
 159 |           name: {
 160 |             type: 'JSXIdentifier',
 161 |             name: 'a',
 162 |             range: [1, 2],
 163 |             loc: {
 164 |               start: { line: 1, column: 1 },
 165 |               end: { line: 1, column: 2 }
 166 |             }
 167 |           },
 168 |           selfClosing: false,
 169 |           attributes: [{
 170 |             type: 'JSXAttribute',
 171 |             name: {
 172 |               type: 'JSXNamespacedName',
 173 |               namespace: {
 174 |                 type: 'JSXIdentifier',
 175 |                 name: 'n',
 176 |                 range: [3, 4],
 177 |                 loc: {
 178 |                   start: { line: 1, column: 3 },
 179 |                   end: { line: 1, column: 4 }
 180 |                 }
 181 |               },
 182 |               name: {
 183 |                 type: 'JSXIdentifier',
 184 |                 name: 'foo',
 185 |                 range: [5, 8],
 186 |                 loc: {
 187 |                   start: { line: 1, column: 5 },
 188 |                   end: { line: 1, column: 8 }
 189 |                 }
 190 |               },
 191 |               range: [3, 8],
 192 |               loc: {
 193 |                 start: { line: 1, column: 3 },
 194 |                 end: { line: 1, column: 8 }
 195 |               }
 196 |             },
 197 |             value: {
 198 |               type: 'Literal',
 199 |               value: 'bar',
 200 |               raw: '"bar"',
 201 |               range: [9, 14],
 202 |               loc: {
 203 |                 start: { line: 1, column: 9 },
 204 |                 end: { line: 1, column: 14 }
 205 |               }
 206 |             },
 207 |             range: [3, 14],
 208 |             loc: {
 209 |               start: { line: 1, column: 3 },
 210 |               end: { line: 1, column: 14 }
 211 |             }
 212 |           }],
 213 |           range: [0, 15],
 214 |           loc: {
 215 |             start: { line: 1, column: 0 },
 216 |             end: { line: 1, column: 15 }
 217 |           }
 218 |         },
 219 |         closingElement: {
 220 |           type: 'JSXClosingElement',
 221 |           name: {
 222 |             type: 'JSXIdentifier',
 223 |             name: 'a',
 224 |             range: [38, 39],
 225 |             loc: {
 226 |               start: { line: 1, column: 38 },
 227 |               end: { line: 1, column: 39 }
 228 |             }
 229 |           },
 230 |           range: [36, 40],
 231 |           loc: {
 232 |             start: { line: 1, column: 36 },
 233 |             end: { line: 1, column: 40 }
 234 |           }
 235 |         },
 236 |         children: [{
 237 |           type: 'JSXText',
 238 |           value: ' ',
 239 |           raw: ' ',
 240 |           range: [15, 16],
 241 |           loc: {
 242 |             start: { line: 1, column: 15 },
 243 |             end: { line: 1, column: 16 }
 244 |           }
 245 |         }, {
 246 |           type: 'JSXExpressionContainer',
 247 |           expression: {
 248 |             type: 'Identifier',
 249 |             name: 'value',
 250 |             range: [17, 22],
 251 |             loc: {
 252 |               start: { line: 1, column: 17 },
 253 |               end: { line: 1, column: 22 }
 254 |             }
 255 |           },
 256 |           range: [16, 23],
 257 |           loc: {
 258 |             start: { line: 1, column: 16 },
 259 |             end: { line: 1, column: 23 }
 260 |           }
 261 |         }, {
 262 |           type: 'JSXText',
 263 |           value: ' ',
 264 |           raw: ' ',
 265 |           range: [23, 24],
 266 |           loc: {
 267 |             start: { line: 1, column: 23 },
 268 |             end: { line: 1, column: 24 }
 269 |           }
 270 |         }, {
 271 |           type: 'JSXElement',
 272 |           openingElement: {
 273 |             type: 'JSXOpeningElement',
 274 |             name: {
 275 |               type: 'JSXIdentifier',
 276 |               name: 'b',
 277 |               range: [25, 26],
 278 |               loc: {
 279 |                 start: { line: 1, column: 25 },
 280 |                 end: { line: 1, column: 26 }
 281 |               }
 282 |             },
 283 |             selfClosing: false,
 284 |             attributes: [],
 285 |             range: [24, 27],
 286 |             loc: {
 287 |               start: { line: 1, column: 24 },
 288 |               end: { line: 1, column: 27 }
 289 |             }
 290 |           },
 291 |           closingElement: {
 292 |             type: 'JSXClosingElement',
 293 |             name: {
 294 |               type: 'JSXIdentifier',
 295 |               name: 'b',
 296 |               range: [34, 35],
 297 |               loc: {
 298 |                 start: { line: 1, column: 34 },
 299 |                 end: { line: 1, column: 35 }
 300 |               }
 301 |             },
 302 |             range: [32, 36],
 303 |             loc: {
 304 |               start: { line: 1, column: 32 },
 305 |               end: { line: 1, column: 36 }
 306 |             }
 307 |           },
 308 |           children: [{
 309 |             type: 'JSXElement',
 310 |             openingElement: {
 311 |               type: 'JSXOpeningElement',
 312 |               name: {
 313 |                 type: 'JSXIdentifier',
 314 |                 name: 'c',
 315 |                 range: [28, 29],
 316 |                 loc: {
 317 |                   start: { line: 1, column: 28 },
 318 |                   end: { line: 1, column: 29 }
 319 |                 }
 320 |               },
 321 |               selfClosing: true,
 322 |               attributes: [],
 323 |               range: [27, 32],
 324 |               loc: {
 325 |                 start: { line: 1, column: 27 },
 326 |                 end: { line: 1, column: 32 }
 327 |               }
 328 |             },
 329 |             closingElement: null,
 330 |             children: [],
 331 |             range: [27, 32],
 332 |             loc: {
 333 |               start: { line: 1, column: 27 },
 334 |               end: { line: 1, column: 32 }
 335 |             }
 336 |           }],
 337 |           range: [24, 36],
 338 |           loc: {
 339 |             start: { line: 1, column: 24 },
 340 |             end: { line: 1, column: 36 }
 341 |           }
 342 |         }],
 343 |         range: [0, 40],
 344 |         loc: {
 345 |           start: { line: 1, column: 0 },
 346 |           end: { line: 1, column: 40 }
 347 |         }
 348 |       },
 349 |       range: [0, 40],
 350 |       loc: {
 351 |         start: { line: 1, column: 0 },
 352 |         end: { line: 1, column: 40 }
 353 |       }
 354 |     },
 355 | 
 356 |     '<a b={" "} c=" " d="&amp;" e="&ampr;" />': {
 357 |       type: "ExpressionStatement",
 358 |       expression: {
 359 |         type: "JSXElement",
 360 |         openingElement: {
 361 |           type: "JSXOpeningElement",
 362 |           name: {
 363 |             type: "JSXIdentifier",
 364 |             name: "a",
 365 |             range: [1, 2]
 366 |           },
 367 |           selfClosing: true,
 368 |           attributes: [
 369 |             {
 370 |               type: "JSXAttribute",
 371 |               name: {
 372 |                 type: "JSXIdentifier",
 373 |                 name: "b",
 374 |                 range: [3, 4]
 375 |               },
 376 |               value: {
 377 |                 type: "JSXExpressionContainer",
 378 |                 expression: {
 379 |                   type: "Literal",
 380 |                   value: " ",
 381 |                   raw: "\" \"",
 382 |                   range: [6, 9]
 383 |                 },
 384 |                 range: [5, 10]
 385 |               },
 386 |               range: [3, 10]
 387 |             },
 388 |             {
 389 |               type: "JSXAttribute",
 390 |               name: {
 391 |                 type: "JSXIdentifier",
 392 |                 name: "c",
 393 |                 range: [11, 12]
 394 |               },
 395 |               value: {
 396 |                 type: "Literal",
 397 |                 value: " ",
 398 |                 raw: "\" \"",
 399 |                 range: [13, 16]
 400 |               },
 401 |               range: [11, 16]
 402 |             },
 403 |             {
 404 |               type: "JSXAttribute",
 405 |               name: {
 406 |                 type: "JSXIdentifier",
 407 |                 name: "d",
 408 |                 range: [17, 18]
 409 |               },
 410 |               value: {
 411 |                 type: "Literal",
 412 |                 value: "&",
 413 |                 raw: "\"&amp;\"",
 414 |                 range: [19, 26]
 415 |               },
 416 |               range: [17, 26]
 417 |             },
 418 |             {
 419 |               type: "JSXAttribute",
 420 |               name: {
 421 |                 type: "JSXIdentifier",
 422 |                 name: "e",
 423 |                 range: [27, 28]
 424 |               },
 425 |               value: {
 426 |                 type: "Literal",
 427 |                 value: "&ampr;",
 428 |                 raw: "\"&ampr;\"",
 429 |                 range: [29, 37]
 430 |               },
 431 |               range: [27, 37]
 432 |             }
 433 |           ],
 434 |           range: [0, 40]
 435 |         },
 436 |         closingElement: null,
 437 |         children: [],
 438 |         range: [0, 40]
 439 |       },
 440 |       range: [0, 40]
 441 |     },
 442 | 
 443 |     '<a\n/>': {
 444 |       type: "ExpressionStatement",
 445 |       expression: {
 446 |         type: "JSXElement",
 447 |         openingElement: {
 448 |           type: "JSXOpeningElement",
 449 |           name: {
 450 |             type: "JSXIdentifier",
 451 |             name: "a",
 452 |             range: [
 453 |               1,
 454 |               2
 455 |             ],
 456 |             loc: {
 457 |               start: {
 458 |                 line: 1,
 459 |                 column: 1
 460 |               },
 461 |               end: {
 462 |                 line: 1,
 463 |                 column: 2
 464 |               }
 465 |             }
 466 |           },
 467 |           selfClosing: true,
 468 |           attributes: [],
 469 |           range: [
 470 |             0,
 471 |             5
 472 |           ],
 473 |           loc: {
 474 |             start: {
 475 |               line: 1,
 476 |               column: 0
 477 |             },
 478 |             end: {
 479 |               line: 2,
 480 |               column: 2
 481 |             }
 482 |           }
 483 |         },
 484 |         closingElement: null,
 485 |         children: [],
 486 |         range: [
 487 |           0,
 488 |           5
 489 |         ],
 490 |         loc: {
 491 |           start: {
 492 |             line: 1,
 493 |             column: 0
 494 |           },
 495 |           end: {
 496 |             line: 2,
 497 |             column: 2
 498 |           }
 499 |         }
 500 |       },
 501 |       range: [
 502 |         0,
 503 |         5
 504 |       ],
 505 |       loc: {
 506 |         start: {
 507 |           line: 1,
 508 |           column: 0
 509 |         },
 510 |         end: {
 511 |           line: 2,
 512 |           column: 2
 513 |         }
 514 |       }
 515 |     },
 516 | 
 517 |     '<日本語></日本語>': {
 518 |       type: "ExpressionStatement",
 519 |       expression: {
 520 |         type: "JSXElement",
 521 |         openingElement: {
 522 |           type: "JSXOpeningElement",
 523 |           name: {
 524 |             type: "JSXIdentifier",
 525 |             name: "日本語",
 526 |             range: [
 527 |               1,
 528 |               4
 529 |             ],
 530 |             loc: {
 531 |               start: {
 532 |                 line: 1,
 533 |                 column: 1
 534 |               },
 535 |               end: {
 536 |                 line: 1,
 537 |                 column: 4
 538 |               }
 539 |             }
 540 |           },
 541 |           selfClosing: false,
 542 |           attributes: [],
 543 |           range: [
 544 |             0,
 545 |             5
 546 |           ],
 547 |           loc: {
 548 |             start: {
 549 |               line: 1,
 550 |               column: 0
 551 |             },
 552 |             end: {
 553 |               line: 1,
 554 |               column: 5
 555 |             }
 556 |           }
 557 |         },
 558 |         closingElement: {
 559 |           type: "JSXClosingElement",
 560 |           name: {
 561 |             type: "JSXIdentifier",
 562 |             name: "日本語",
 563 |             range: [
 564 |               7,
 565 |               10
 566 |             ],
 567 |             loc: {
 568 |               start: {
 569 |                 line: 1,
 570 |                 column: 7
 571 |               },
 572 |               end: {
 573 |                 line: 1,
 574 |                 column: 10
 575 |               }
 576 |             }
 577 |           },
 578 |           range: [
 579 |             5,
 580 |             11
 581 |           ],
 582 |           loc: {
 583 |             start: {
 584 |               line: 1,
 585 |               column: 5
 586 |             },
 587 |             end: {
 588 |               line: 1,
 589 |               column: 11
 590 |             }
 591 |           }
 592 |         },
 593 |         children: [],
 594 |         range: [
 595 |           0,
 596 |           11
 597 |         ],
 598 |         loc: {
 599 |           start: {
 600 |             line: 1,
 601 |             column: 0
 602 |           },
 603 |           end: {
 604 |             line: 1,
 605 |             column: 11
 606 |           }
 607 |         }
 608 |       },
 609 |       range: [
 610 |         0,
 611 |         11
 612 |       ],
 613 |       loc: {
 614 |         start: {
 615 |           line: 1,
 616 |           column: 0
 617 |         },
 618 |         end: {
 619 |           line: 1,
 620 |           column: 11
 621 |         }
 622 |       }
 623 |     },
 624 | 
 625 |     '<AbC-def\n  test="&#x0026;&#38;">\nbar\nbaz\n</AbC-def>': {
 626 |       type: "ExpressionStatement",
 627 |       expression: {
 628 |         type: "JSXElement",
 629 |         openingElement: {
 630 |           type: "JSXOpeningElement",
 631 |           name: {
 632 |             type: "JSXIdentifier",
 633 |             name: "AbC-def",
 634 |             range: [
 635 |               1,
 636 |               8
 637 |             ],
 638 |             loc: {
 639 |               start: {
 640 |                 line: 1,
 641 |                 column: 1
 642 |               },
 643 |               end: {
 644 |                 line: 1,
 645 |                 column: 8
 646 |               }
 647 |             }
 648 |           },
 649 |           selfClosing: false,
 650 |           attributes: [
 651 |             {
 652 |               type: "JSXAttribute",
 653 |               name: {
 654 |                 type: "JSXIdentifier",
 655 |                 name: "test",
 656 |                 range: [
 657 |                   11,
 658 |                   15
 659 |                 ],
 660 |                 loc: {
 661 |                   start: {
 662 |                     line: 2,
 663 |                     column: 2
 664 |                   },
 665 |                   end: {
 666 |                     line: 2,
 667 |                     column: 6
 668 |                   }
 669 |                 }
 670 |               },
 671 |               value: {
 672 |                 type: "Literal",
 673 |                 value: "&&",
 674 |                 raw: "\"&#x0026;&#38;\"",
 675 |                 range: [
 676 |                   16,
 677 |                   31
 678 |                 ],
 679 |                 loc: {
 680 |                   start: {
 681 |                     line: 2,
 682 |                     column: 7
 683 |                   },
 684 |                   end: {
 685 |                     line: 2,
 686 |                     column: 22
 687 |                   }
 688 |                 }
 689 |               },
 690 |               range: [
 691 |                 11,
 692 |                 31
 693 |               ],
 694 |               loc: {
 695 |                 start: {
 696 |                   line: 2,
 697 |                   column: 2
 698 |                 },
 699 |                 end: {
 700 |                   line: 2,
 701 |                   column: 22
 702 |                 }
 703 |               }
 704 |             }
 705 |           ],
 706 |           range: [
 707 |             0,
 708 |             32
 709 |           ],
 710 |           loc: {
 711 |             start: {
 712 |               line: 1,
 713 |               column: 0
 714 |             },
 715 |             end: {
 716 |               line: 2,
 717 |               column: 23
 718 |             }
 719 |           }
 720 |         },
 721 |         closingElement: {
 722 |           type: "JSXClosingElement",
 723 |           name: {
 724 |             type: "JSXIdentifier",
 725 |             name: "AbC-def",
 726 |             range: [
 727 |               43,
 728 |               50
 729 |             ],
 730 |             loc: {
 731 |               start: {
 732 |                 line: 5,
 733 |                 column: 2
 734 |               },
 735 |               end: {
 736 |                 line: 5,
 737 |                 column: 9
 738 |               }
 739 |             }
 740 |           },
 741 |           range: [
 742 |             41,
 743 |             51
 744 |           ],
 745 |           loc: {
 746 |             start: {
 747 |               line: 5,
 748 |               column: 0
 749 |             },
 750 |             end: {
 751 |               line: 5,
 752 |               column: 10
 753 |             }
 754 |           }
 755 |         },
 756 |         children: [
 757 |           {
 758 |             type: "JSXText",
 759 |             value: "\nbar\nbaz\n",
 760 |             raw: "\nbar\nbaz\n",
 761 |             range: [
 762 |               32,
 763 |               41
 764 |             ],
 765 |             loc: {
 766 |               start: {
 767 |                 line: 2,
 768 |                 column: 23
 769 |               },
 770 |               end: {
 771 |                 line: 5,
 772 |                 column: 0
 773 |               }
 774 |             }
 775 |           }
 776 |         ],
 777 |         range: [
 778 |           0,
 779 |           51
 780 |         ],
 781 |         loc: {
 782 |           start: {
 783 |             line: 1,
 784 |             column: 0
 785 |           },
 786 |           end: {
 787 |             line: 5,
 788 |             column: 10
 789 |           }
 790 |         }
 791 |       },
 792 |       range: [
 793 |         0,
 794 |         51
 795 |       ],
 796 |       loc: {
 797 |         start: {
 798 |           line: 1,
 799 |           column: 0
 800 |         },
 801 |         end: {
 802 |           line: 5,
 803 |           column: 10
 804 |         }
 805 |       }
 806 |     },
 807 | 
 808 |     '<a b={x ? <c /> : <d />} />': {
 809 |       type: "ExpressionStatement",
 810 |       expression: {
 811 |         type: "JSXElement",
 812 |         openingElement: {
 813 |           type: "JSXOpeningElement",
 814 |           name: {
 815 |             type: "JSXIdentifier",
 816 |             name: "a",
 817 |             range: [
 818 |               1,
 819 |               2
 820 |             ],
 821 |             loc: {
 822 |               start: {
 823 |                 line: 1,
 824 |                 column: 1
 825 |               },
 826 |               end: {
 827 |                 line: 1,
 828 |                 column: 2
 829 |               }
 830 |             }
 831 |           },
 832 |           selfClosing: true,
 833 |           attributes: [
 834 |             {
 835 |               type: "JSXAttribute",
 836 |               name: {
 837 |                 type: "JSXIdentifier",
 838 |                 name: "b",
 839 |                 range: [
 840 |                   3,
 841 |                   4
 842 |                 ],
 843 |                 loc: {
 844 |                   start: {
 845 |                     line: 1,
 846 |                     column: 3
 847 |                   },
 848 |                   end: {
 849 |                     line: 1,
 850 |                     column: 4
 851 |                   }
 852 |                 }
 853 |               },
 854 |               value: {
 855 |                 type: "JSXExpressionContainer",
 856 |                 expression: {
 857 |                   type: "ConditionalExpression",
 858 |                   test: {
 859 |                     type: "Identifier",
 860 |                     name: "x",
 861 |                     range: [
 862 |                       6,
 863 |                       7
 864 |                     ],
 865 |                     loc: {
 866 |                       start: {
 867 |                         line: 1,
 868 |                         column: 6
 869 |                       },
 870 |                       end: {
 871 |                         line: 1,
 872 |                         column: 7
 873 |                       }
 874 |                     }
 875 |                   },
 876 |                   consequent: {
 877 |                     type: "JSXElement",
 878 |                     openingElement: {
 879 |                       type: "JSXOpeningElement",
 880 |                       name: {
 881 |                         type: "JSXIdentifier",
 882 |                         name: "c",
 883 |                         range: [
 884 |                           11,
 885 |                           12
 886 |                         ],
 887 |                         loc: {
 888 |                           start: {
 889 |                             line: 1,
 890 |                             column: 11
 891 |                           },
 892 |                           end: {
 893 |                             line: 1,
 894 |                             column: 12
 895 |                           }
 896 |                         }
 897 |                       },
 898 |                       selfClosing: true,
 899 |                       attributes: [],
 900 |                       range: [
 901 |                         10,
 902 |                         15
 903 |                       ],
 904 |                       loc: {
 905 |                         start: {
 906 |                           line: 1,
 907 |                           column: 10
 908 |                         },
 909 |                         end: {
 910 |                           line: 1,
 911 |                           column: 15
 912 |                         }
 913 |                       }
 914 |                     },
 915 |                     closingElement: null,
 916 |                     children: [],
 917 |                     range: [
 918 |                       10,
 919 |                       15
 920 |                     ],
 921 |                     loc: {
 922 |                       start: {
 923 |                         line: 1,
 924 |                         column: 10
 925 |                       },
 926 |                       end: {
 927 |                         line: 1,
 928 |                         column: 15
 929 |                       }
 930 |                     }
 931 |                   },
 932 |                   alternate: {
 933 |                     type: "JSXElement",
 934 |                     openingElement: {
 935 |                       type: "JSXOpeningElement",
 936 |                       name: {
 937 |                         type: "JSXIdentifier",
 938 |                         name: "d",
 939 |                         range: [
 940 |                           19,
 941 |                           20
 942 |                         ],
 943 |                         loc: {
 944 |                           start: {
 945 |                             line: 1,
 946 |                             column: 19
 947 |                           },
 948 |                           end: {
 949 |                             line: 1,
 950 |                             column: 20
 951 |                           }
 952 |                         }
 953 |                       },
 954 |                       selfClosing: true,
 955 |                       attributes: [],
 956 |                       range: [
 957 |                         18,
 958 |                         23
 959 |                       ],
 960 |                       loc: {
 961 |                         start: {
 962 |                           line: 1,
 963 |                           column: 18
 964 |                         },
 965 |                         end: {
 966 |                           line: 1,
 967 |                           column: 23
 968 |                         }
 969 |                       }
 970 |                     },
 971 |                     closingElement: null,
 972 |                     children: [],
 973 |                     range: [
 974 |                       18,
 975 |                       23
 976 |                     ],
 977 |                     loc: {
 978 |                       start: {
 979 |                         line: 1,
 980 |                         column: 18
 981 |                       },
 982 |                       end: {
 983 |                         line: 1,
 984 |                         column: 23
 985 |                       }
 986 |                     }
 987 |                   },
 988 |                   range: [
 989 |                     6,
 990 |                     23
 991 |                   ],
 992 |                   loc: {
 993 |                     start: {
 994 |                       line: 1,
 995 |                       column: 6
 996 |                     },
 997 |                     end: {
 998 |                       line: 1,
 999 |                       column: 23
1000 |                     }
1001 |                   }
1002 |                 },
1003 |                 range: [
1004 |                   5,
1005 |                   24
1006 |                 ],
1007 |                 loc: {
1008 |                   start: {
1009 |                     line: 1,
1010 |                     column: 5
1011 |                   },
1012 |                   end: {
1013 |                     line: 1,
1014 |                     column: 24
1015 |                   }
1016 |                 }
1017 |               },
1018 |               range: [
1019 |                 3,
1020 |                 24
1021 |               ],
1022 |               loc: {
1023 |                 start: {
1024 |                   line: 1,
1025 |                   column: 3
1026 |                 },
1027 |                 end: {
1028 |                   line: 1,
1029 |                   column: 24
1030 |                 }
1031 |               }
1032 |             }
1033 |           ],
1034 |           range: [
1035 |             0,
1036 |             27
1037 |           ],
1038 |           loc: {
1039 |             start: {
1040 |               line: 1,
1041 |               column: 0
1042 |             },
1043 |             end: {
1044 |               line: 1,
1045 |               column: 27
1046 |             }
1047 |           }
1048 |         },
1049 |         closingElement: null,
1050 |         children: [],
1051 |         range: [
1052 |           0,
1053 |           27
1054 |         ],
1055 |         loc: {
1056 |           start: {
1057 |             line: 1,
1058 |             column: 0
1059 |           },
1060 |           end: {
1061 |             line: 1,
1062 |             column: 27
1063 |           }
1064 |         }
1065 |       },
1066 |       range: [
1067 |         0,
1068 |         27
1069 |       ],
1070 |       loc: {
1071 |         start: {
1072 |           line: 1,
1073 |           column: 0
1074 |         },
1075 |         end: {
1076 |           line: 1,
1077 |           column: 27
1078 |         }
1079 |       }
1080 |     },
1081 | 
1082 |     '<a>{}</a>': {
1083 |       type: 'ExpressionStatement',
1084 |       expression: {
1085 |         type: 'JSXElement',
1086 |         openingElement: {
1087 |           type: 'JSXOpeningElement',
1088 |           name: {
1089 |             type: 'JSXIdentifier',
1090 |             name: 'a',
1091 |             range: [1, 2],
1092 |             loc: {
1093 |               start: { line: 1, column: 1 },
1094 |               end: { line: 1, column: 2 }
1095 |             }
1096 |           },
1097 |           selfClosing: false,
1098 |           attributes: [],
1099 |           range: [0, 3],
1100 |           loc: {
1101 |             start: { line: 1, column: 0 },
1102 |             end: { line: 1, column: 3 }
1103 |           }
1104 |         },
1105 |         closingElement: {
1106 |           type: 'JSXClosingElement',
1107 |           name: {
1108 |             type: 'JSXIdentifier',
1109 |             name: 'a',
1110 |             range: [7, 8],
1111 |             loc: {
1112 |               start: { line: 1, column: 7 },
1113 |               end: { line: 1, column: 8 }
1114 |             }
1115 |           },
1116 |           range: [5, 9],
1117 |           loc: {
1118 |             start: { line: 1, column: 5 },
1119 |             end: { line: 1, column: 9 }
1120 |           }
1121 |         },
1122 |         children: [{
1123 |           type: 'JSXExpressionContainer',
1124 |           expression: {
1125 |             type: 'JSXEmptyExpression',
1126 |             range: [4, 4],
1127 |             loc: {
1128 |               start: { line: 1, column: 4 },
1129 |               end: { line: 1, column: 4 }
1130 |             }
1131 |           },
1132 |           range: [3, 5],
1133 |           loc: {
1134 |             start: { line: 1, column: 3 },
1135 |             end: { line: 1, column: 5 }
1136 |           }
1137 |         }],
1138 |         range: [0, 9],
1139 |         loc: {
1140 |           start: { line: 1, column: 0 },
1141 |           end: { line: 1, column: 9 }
1142 |         }
1143 |       },
1144 |       range: [0, 9],
1145 |       loc: {
1146 |         start: { line: 1, column: 0 },
1147 |         end: { line: 1, column: 9 }
1148 |       }
1149 |     },
1150 | 
1151 |     '<a>{/* this is a comment */}</a>': {
1152 |       type: 'ExpressionStatement',
1153 |       expression: {
1154 |         type: 'JSXElement',
1155 |         openingElement: {
1156 |           type: 'JSXOpeningElement',
1157 |           name: {
1158 |             type: 'JSXIdentifier',
1159 |             name: 'a',
1160 |             range: [1, 2],
1161 |             loc: {
1162 |               start: { line: 1, column: 1 },
1163 |               end: { line: 1, column: 2 }
1164 |             }
1165 |           },
1166 |           selfClosing: false,
1167 |           attributes: [],
1168 |           range: [0, 3],
1169 |           loc: {
1170 |             start: { line: 1, column: 0 },
1171 |             end: { line: 1, column: 3 }
1172 |           }
1173 |         },
1174 |         closingElement: {
1175 |           type: 'JSXClosingElement',
1176 |           name: {
1177 |             type: 'JSXIdentifier',
1178 |             name: 'a',
1179 |             range: [30, 31],
1180 |             loc: {
1181 |               start: { line: 1, column: 30 },
1182 |               end: { line: 1, column: 31 }
1183 |             }
1184 |           },
1185 |           range: [28, 32],
1186 |           loc: {
1187 |             start: { line: 1, column: 28 },
1188 |             end: { line: 1, column: 32 }
1189 |           }
1190 |         },
1191 |         children: [{
1192 |           type: 'JSXExpressionContainer',
1193 |           expression: {
1194 |             type: 'JSXEmptyExpression',
1195 |             range: [4, 27],
1196 |             loc: {
1197 |               start: { line: 1, column: 4 },
1198 |               end: { line: 1, column: 27 }
1199 |             }
1200 |           },
1201 |           range: [3, 28],
1202 |           loc: {
1203 |             start: { line: 1, column: 3 },
1204 |             end: { line: 1, column: 28 }
1205 |           }
1206 |         }],
1207 |         range: [0, 32],
1208 |         loc: {
1209 |           start: { line: 1, column: 0 },
1210 |           end: { line: 1, column: 32 }
1211 |         }
1212 |       },
1213 |       range: [0, 32],
1214 |       loc: {
1215 |         start: { line: 1, column: 0 },
1216 |         end: { line: 1, column: 32 }
1217 |       }
1218 |     },
1219 | 
1220 |     '<div>@test content</div>': {
1221 |       type: 'ExpressionStatement',
1222 |       expression: {
1223 |         type: 'JSXElement',
1224 |         openingElement: {
1225 |           type: 'JSXOpeningElement',
1226 |           name: {
1227 |             type: 'JSXIdentifier',
1228 |             name: 'div',
1229 |             range: [1, 4],
1230 |             loc: {
1231 |               start: { line: 1, column: 1 },
1232 |               end: { line: 1, column: 4 }
1233 |             }
1234 |           },
1235 |           selfClosing: false,
1236 |           attributes: [],
1237 |           range: [0, 5],
1238 |           loc: {
1239 |             start: { line: 1, column: 0 },
1240 |             end: { line: 1, column: 5 }
1241 |           }
1242 |         },
1243 |         closingElement: {
1244 |           type: 'JSXClosingElement',
1245 |           name: {
1246 |             type: 'JSXIdentifier',
1247 |             name: 'div',
1248 |             range: [20, 23],
1249 |             loc: {
1250 |               start: { line: 1, column: 20 },
1251 |               end: { line: 1, column: 23 }
1252 |             }
1253 |           },
1254 |           range: [18, 24],
1255 |           loc: {
1256 |             start: { line: 1, column: 18 },
1257 |             end: { line: 1, column: 24 }
1258 |           }
1259 |         },
1260 |         children: [{
1261 |           type: 'JSXText',
1262 |           value: '@test content',
1263 |           raw: '@test content',
1264 |           range: [5, 18],
1265 |           loc: {
1266 |             start: { line: 1, column: 5 },
1267 |             end: { line: 1, column: 18 }
1268 |           }
1269 |         }],
1270 |         range: [0, 24],
1271 |         loc: {
1272 |           start: { line: 1, column: 0 },
1273 |           end: { line: 1, column: 24 }
1274 |         }
1275 |       },
1276 |       range: [0, 24],
1277 |       loc: {
1278 |         start: { line: 1, column: 0 },
1279 |         end: { line: 1, column: 24 }
1280 |       }
1281 |     },
1282 | 
1283 |     '<div><br />7x invalid-js-identifier</div>': {
1284 |       type: 'ExpressionStatement',
1285 |       expression: {
1286 |         type: 'JSXElement',
1287 |         openingElement: {
1288 |           type: 'JSXOpeningElement',
1289 |           name: {
1290 |             type: 'JSXIdentifier',
1291 |             name: 'div',
1292 |             range: [
1293 |               1,
1294 |               4
1295 |             ],
1296 |             loc: {
1297 |               start: {
1298 |                 line: 1,
1299 |                 column: 1
1300 |               },
1301 |               end: {
1302 |                 line: 1,
1303 |                 column: 4
1304 |               }
1305 |             }
1306 |           },
1307 |           selfClosing: false,
1308 |           attributes: [],
1309 |           range: [
1310 |             0,
1311 |             5
1312 |           ],
1313 |           loc: {
1314 |             start: {
1315 |               line: 1,
1316 |               column: 0
1317 |             },
1318 |             end: {
1319 |               line: 1,
1320 |               column: 5
1321 |             }
1322 |           }
1323 |         },
1324 |         closingElement: {
1325 |           type: 'JSXClosingElement',
1326 |           name: {
1327 |             type: 'JSXIdentifier',
1328 |             name: 'div',
1329 |             range: [
1330 |               37,
1331 |               40
1332 |             ],
1333 |             loc: {
1334 |               start: {
1335 |                 line: 1,
1336 |                 column: 37
1337 |               },
1338 |               end: {
1339 |                 line: 1,
1340 |                 column: 40
1341 |               }
1342 |             }
1343 |           },
1344 |           range: [
1345 |             35,
1346 |             41
1347 |           ],
1348 |           loc: {
1349 |             start: {
1350 |               line: 1,
1351 |               column: 35
1352 |             },
1353 |             end: {
1354 |               line: 1,
1355 |               column: 41
1356 |             }
1357 |           }
1358 |         },
1359 |         children: [{
1360 |           type: 'JSXElement',
1361 |           openingElement: {
1362 |             type: 'JSXOpeningElement',
1363 |             name: {
1364 |               type: 'JSXIdentifier',
1365 |               name: 'br',
1366 |               range: [
1367 |                 6,
1368 |                 8
1369 |               ],
1370 |               loc: {
1371 |                 start: {
1372 |                   line: 1,
1373 |                   column: 6
1374 |                 },
1375 |                 end: {
1376 |                   line: 1,
1377 |                   column: 8
1378 |                 }
1379 |               }
1380 |             },
1381 |             selfClosing: true,
1382 |             attributes: [],
1383 |             range: [
1384 |               5,
1385 |               11
1386 |             ],
1387 |             loc: {
1388 |               start: {
1389 |                 line: 1,
1390 |                 column: 5
1391 |               },
1392 |               end: {
1393 |                 line: 1,
1394 |                 column: 11
1395 |               }
1396 |             }
1397 |           },
1398 |           closingElement: null,
1399 |           children: [],
1400 |           range: [
1401 |             5,
1402 |             11
1403 |           ],
1404 |           loc: {
1405 |             start: {
1406 |               line: 1,
1407 |               column: 5
1408 |             },
1409 |             end: {
1410 |               line: 1,
1411 |               column: 11
1412 |             }
1413 |           }
1414 |         }, {
1415 |           type: 'JSXText',
1416 |           value: '7x invalid-js-identifier',
1417 |           raw: '7x invalid-js-identifier',
1418 |           range: [
1419 |             11,
1420 |             35
1421 |           ],
1422 |           loc: {
1423 |             start: {
1424 |               line: 1,
1425 |               column: 11
1426 |             },
1427 |             end: {
1428 |               line: 1,
1429 |               column: 35
1430 |             }
1431 |           }
1432 |         }],
1433 |         range: [
1434 |           0,
1435 |           41
1436 |         ],
1437 |         loc: {
1438 |           start: {
1439 |             line: 1,
1440 |             column: 0
1441 |           },
1442 |           end: {
1443 |             line: 1,
1444 |             column: 41
1445 |           }
1446 |         }
1447 |       },
1448 |       range: [
1449 |         0,
1450 |         41
1451 |       ],
1452 |       loc: {
1453 |         start: {
1454 |           line: 1,
1455 |           column: 0
1456 |         },
1457 |         end: {
1458 |           line: 1,
1459 |           column: 41
1460 |         }
1461 |       }
1462 |     },
1463 | 
1464 |     '<LeftRight left=<a /> right=<b>monkeys /{">"} gorillas</b> />': {
1465 |       "type": "ExpressionStatement",
1466 |       "start": 0,
1467 |       "end": 61,
1468 |       "expression": {
1469 |         "type": "JSXElement",
1470 |         "start": 0,
1471 |         "end": 61,
1472 |         "openingElement": {
1473 |           "type": "JSXOpeningElement",
1474 |           "start": 0,
1475 |           "end": 61,
1476 |           "attributes": [
1477 |             {
1478 |               "type": "JSXAttribute",
1479 |               "start": 11,
1480 |               "end": 21,
1481 |               "name": {
1482 |                 "type": "JSXIdentifier",
1483 |                 "start": 11,
1484 |                 "end": 15,
1485 |                 "name": "left"
1486 |               },
1487 |               "value": {
1488 |                 "type": "JSXElement",
1489 |                 "start": 16,
1490 |                 "end": 21,
1491 |                 "openingElement": {
1492 |                   "type": "JSXOpeningElement",
1493 |                   "start": 16,
1494 |                   "end": 21,
1495 |                   "attributes": [],
1496 |                   "name": {
1497 |                     "type": "JSXIdentifier",
1498 |                     "start": 17,
1499 |                     "end": 18,
1500 |                     "name": "a"
1501 |                   },
1502 |                   "selfClosing": true
1503 |                 },
1504 |                 "closingElement": null,
1505 |                 "children": []
1506 |               }
1507 |             },
1508 |             {
1509 |               "type": "JSXAttribute",
1510 |               "start": 22,
1511 |               "end": 58,
1512 |               "name": {
1513 |                 "type": "JSXIdentifier",
1514 |                 "start": 22,
1515 |                 "end": 27,
1516 |                 "name": "right"
1517 |               },
1518 |               "value": {
1519 |                 "type": "JSXElement",
1520 |                 "start": 28,
1521 |                 "end": 58,
1522 |                 "openingElement": {
1523 |                   "type": "JSXOpeningElement",
1524 |                   "start": 28,
1525 |                   "end": 31,
1526 |                   "attributes": [],
1527 |                   "name": {
1528 |                     "type": "JSXIdentifier",
1529 |                     "start": 29,
1530 |                     "end": 30,
1531 |                     "name": "b"
1532 |                   },
1533 |                   "selfClosing": false
1534 |                 },
1535 |                 "closingElement": {
1536 |                   "type": "JSXClosingElement",
1537 |                   "start": 54,
1538 |                   "end": 58,
1539 |                   "name": {
1540 |                     "type": "JSXIdentifier",
1541 |                     "start": 56,
1542 |                     "end": 57,
1543 |                     "name": "b"
1544 |                   }
1545 |                 },
1546 |                 "children": [
1547 |                   {
1548 |                     "type": "JSXText",
1549 |                     "start": 31,
1550 |                     "end": 40,
1551 |                     "value": "monkeys /",
1552 |                     "raw": "monkeys /"
1553 |                   },
1554 |                   {
1555 |                     "type": "JSXExpressionContainer",
1556 |                     "start": 40,
1557 |                     "end": 45,
1558 |                     "expression": {
1559 |                       "type": "Literal",
1560 |                       "start": 41,
1561 |                       "end": 44,
1562 |                       "value": ">",
1563 |                       "raw": "\">\""
1564 |                     }
1565 |                   },
1566 |                   {
1567 |                     "type": "JSXText",
1568 |                     "start": 45,
1569 |                     "end": 54,
1570 |                     "value": " gorillas",
1571 |                     "raw": " gorillas"
1572 |                   }
1573 |                 ]
1574 |               }
1575 |             }
1576 |           ],
1577 |           "name": {
1578 |             "type": "JSXIdentifier",
1579 |             "start": 1,
1580 |             "end": 10,
1581 |             "name": "LeftRight"
1582 |           },
1583 |           "selfClosing": true
1584 |         },
1585 |         "closingElement": null,
1586 |         "children": []
1587 |       }
1588 |     },
1589 | 
1590 |     '<LeftRight left=<a /> right=<b>monkeys /&gt; gorillas</b> />': {
1591 |       "type": "ExpressionStatement",
1592 |       "start": 0,
1593 |       "end": 60,
1594 |       "expression": {
1595 |         "type": "JSXElement",
1596 |         "start": 0,
1597 |         "end": 60,
1598 |         "openingElement": {
1599 |           "type": "JSXOpeningElement",
1600 |           "start": 0,
1601 |           "end": 60,
1602 |           "attributes": [
1603 |             {
1604 |               "type": "JSXAttribute",
1605 |               "start": 11,
1606 |               "end": 21,
1607 |               "name": {
1608 |                 "type": "JSXIdentifier",
1609 |                 "start": 11,
1610 |                 "end": 15,
1611 |                 "name": "left"
1612 |               },
1613 |               "value": {
1614 |                 "type": "JSXElement",
1615 |                 "start": 16,
1616 |                 "end": 21,
1617 |                 "openingElement": {
1618 |                   "type": "JSXOpeningElement",
1619 |                   "start": 16,
1620 |                   "end": 21,
1621 |                   "attributes": [],
1622 |                   "name": {
1623 |                     "type": "JSXIdentifier",
1624 |                     "start": 17,
1625 |                     "end": 18,
1626 |                     "name": "a"
1627 |                   },
1628 |                   "selfClosing": true
1629 |                 },
1630 |                 "closingElement": null,
1631 |                 "children": []
1632 |               }
1633 |             },
1634 |             {
1635 |               "type": "JSXAttribute",
1636 |               "start": 22,
1637 |               "end": 57,
1638 |               "name": {
1639 |                 "type": "JSXIdentifier",
1640 |                 "start": 22,
1641 |                 "end": 27,
1642 |                 "name": "right"
1643 |               },
1644 |               "value": {
1645 |                 "type": "JSXElement",
1646 |                 "start": 28,
1647 |                 "end": 57,
1648 |                 "openingElement": {
1649 |                   "type": "JSXOpeningElement",
1650 |                   "start": 28,
1651 |                   "end": 31,
1652 |                   "attributes": [],
1653 |                   "name": {
1654 |                     "type": "JSXIdentifier",
1655 |                     "start": 29,
1656 |                     "end": 30,
1657 |                     "name": "b"
1658 |                   },
1659 |                   "selfClosing": false
1660 |                 },
1661 |                 "closingElement": {
1662 |                   "type": "JSXClosingElement",
1663 |                   "start": 53,
1664 |                   "end": 57,
1665 |                   "name": {
1666 |                     "type": "JSXIdentifier",
1667 |                     "start": 55,
1668 |                     "end": 56,
1669 |                     "name": "b"
1670 |                   }
1671 |                 },
1672 |                 "children": [
1673 |                   {
1674 |                     "type": "JSXText",
1675 |                     "start": 31,
1676 |                     "end": 53,
1677 |                     "value": "monkeys /> gorillas",
1678 |                     "raw": "monkeys /&gt; gorillas"
1679 |                   }
1680 |                 ]
1681 |               }
1682 |             }
1683 |           ],
1684 |           "name": {
1685 |             "type": "JSXIdentifier",
1686 |             "start": 1,
1687 |             "end": 10,
1688 |             "name": "LeftRight"
1689 |           },
1690 |           "selfClosing": true
1691 |         },
1692 |         "closingElement": null,
1693 |         "children": []
1694 |       }
1695 |     },
1696 | 
1697 |     '<a.b></a.b>': {
1698 |       type: 'ExpressionStatement',
1699 |       expression: {
1700 |         type: 'JSXElement',
1701 |         openingElement: {
1702 |           type: 'JSXOpeningElement',
1703 |           name: {
1704 |             type: 'JSXMemberExpression',
1705 |             object: {
1706 |               type: 'JSXIdentifier',
1707 |               name: 'a',
1708 |               range: [1, 2],
1709 |               loc: {
1710 |                 start: { line: 1, column: 1 },
1711 |                 end: { line: 1, column: 2 }
1712 |               }
1713 |             },
1714 |             property: {
1715 |               type: 'JSXIdentifier',
1716 |               name: 'b',
1717 |               range: [3, 4],
1718 |               loc: {
1719 |                 start: { line: 1, column: 3 },
1720 |                 end: { line: 1, column: 4 }
1721 |               }
1722 |             },
1723 |             range: [1, 4],
1724 |             loc: {
1725 |               start: { line: 1, column: 1 },
1726 |               end: { line: 1, column: 4 }
1727 |             }
1728 |           },
1729 |           selfClosing: false,
1730 |           attributes: [],
1731 |           range: [0, 5],
1732 |           loc: {
1733 |             start: { line: 1, column: 0 },
1734 |             end: { line: 1, column: 5 }
1735 |           }
1736 |         },
1737 |         closingElement: {
1738 |           type: 'JSXClosingElement',
1739 |           name: {
1740 |             type: 'JSXMemberExpression',
1741 |             object: {
1742 |               type: 'JSXIdentifier',
1743 |               name: 'a',
1744 |               range: [7, 8],
1745 |               loc: {
1746 |                 start: { line: 1, column: 7 },
1747 |                 end: { line: 1, column: 8 }
1748 |               }
1749 |             },
1750 |             property: {
1751 |               type: 'JSXIdentifier',
1752 |               name: 'b',
1753 |               range: [9, 10],
1754 |               loc: {
1755 |                 start: { line: 1, column: 9 },
1756 |                 end: { line: 1, column: 10 }
1757 |               }
1758 |             },
1759 |             range: [7, 10],
1760 |             loc: {
1761 |               start: { line: 1, column: 7 },
1762 |               end: { line: 1, column: 10 }
1763 |             }
1764 |           },
1765 |           range: [5, 11],
1766 |           loc: {
1767 |             start: { line: 1, column: 5 },
1768 |             end: { line: 1, column: 11 }
1769 |           }
1770 |         },
1771 |         children: [],
1772 |         range: [0, 11],
1773 |         loc: {
1774 |           start: { line: 1, column: 0 },
1775 |           end: { line: 1, column: 11 }
1776 |         }
1777 |       },
1778 |       range: [0, 11],
1779 |       loc: {
1780 |         start: { line: 1, column: 0 },
1781 |         end: { line: 1, column: 11 }
1782 |       }
1783 |     },
1784 | 
1785 |     '<a.b.c></a.b.c>': {
1786 |       type: 'ExpressionStatement',
1787 |       expression: {
1788 |         type: 'JSXElement',
1789 |         openingElement: {
1790 |           type: 'JSXOpeningElement',
1791 |           name: {
1792 |             type: 'JSXMemberExpression',
1793 |             object: {
1794 |               type: 'JSXMemberExpression',
1795 |               object: {
1796 |                 type: 'JSXIdentifier',
1797 |                 name: 'a',
1798 |                 range: [1, 2],
1799 |                 loc: {
1800 |                   start: { line: 1, column: 1 },
1801 |                   end: { line: 1, column: 2 }
1802 |                 }
1803 |               },
1804 |               property: {
1805 |                 type: 'JSXIdentifier',
1806 |                 name: 'b',
1807 |                 range: [3, 4],
1808 |                 loc: {
1809 |                   start: { line: 1, column: 3 },
1810 |                   end: { line: 1, column: 4 }
1811 |                 }
1812 |               },
1813 |               range: [1, 4],
1814 |               loc: {
1815 |                 start: { line: 1, column: 1 },
1816 |                 end: { line: 1, column: 4 }
1817 |               }
1818 |             },
1819 |             property: {
1820 |               type: 'JSXIdentifier',
1821 |               name: 'c',
1822 |               range: [5, 6],
1823 |               loc: {
1824 |                 start: { line: 1, column: 5 },
1825 |                 end: { line: 1, column: 6 }
1826 |               }
1827 |             },
1828 |             range: [1, 6],
1829 |             loc: {
1830 |               start: { line: 1, column: 1 },
1831 |               end: { line: 1, column: 6 }
1832 |             }
1833 |           },
1834 |           selfClosing: false,
1835 |           attributes: [],
1836 |           range: [0, 7],
1837 |           loc: {
1838 |             start: { line: 1, column: 0 },
1839 |             end: { line: 1, column: 7 }
1840 |           }
1841 |         },
1842 |         closingElement: {
1843 |           type: 'JSXClosingElement',
1844 |           name: {
1845 |             type: 'JSXMemberExpression',
1846 |             object: {
1847 |               type: 'JSXMemberExpression',
1848 |               object: {
1849 |                 type: 'JSXIdentifier',
1850 |                 name: 'a',
1851 |                 range: [9, 10],
1852 |                 loc: {
1853 |                   start: { line: 1, column: 9 },
1854 |                   end: { line: 1, column: 10 }
1855 |                 }
1856 |               },
1857 |               property: {
1858 |                 type: 'JSXIdentifier',
1859 |                 name: 'b',
1860 |                 range: [11, 12],
1861 |                 loc: {
1862 |                   start: { line: 1, column: 11 },
1863 |                   end: { line: 1, column: 12 }
1864 |                 }
1865 |               },
1866 |               range: [9, 12],
1867 |               loc: {
1868 |                 start: { line: 1, column: 9 },
1869 |                 end: { line: 1, column: 12 }
1870 |               }
1871 |             },
1872 |             property: {
1873 |               type: 'JSXIdentifier',
1874 |               name: 'c',
1875 |               range: [13, 14],
1876 |               loc: {
1877 |                 start: { line: 1, column: 13 },
1878 |                 end: { line: 1, column: 14 }
1879 |               }
1880 |             },
1881 |             range: [9, 14],
1882 |             loc: {
1883 |               start: { line: 1, column: 9 },
1884 |               end: { line: 1, column: 14 }
1885 |             }
1886 |           },
1887 |           range: [7, 15],
1888 |           loc: {
1889 |             start: { line: 1, column: 7 },
1890 |             end: { line: 1, column: 15 }
1891 |           }
1892 |         },
1893 |         children: [],
1894 |         range: [0, 15],
1895 |         loc: {
1896 |           start: { line: 1, column: 0 },
1897 |           end: { line: 1, column: 15 }
1898 |         }
1899 |       },
1900 |       range: [0, 15],
1901 |       loc: {
1902 |         start: { line: 1, column: 0 },
1903 |         end: { line: 1, column: 15 }
1904 |       }
1905 |     },
1906 | 
1907 |     // In order to more useful parse errors, we disallow following an
1908 |     // JSXElement by a less-than symbol. In the rare case that the binary
1909 |     // operator was intended, the tag can be wrapped in parentheses:
1910 |     '(<div />) < x;': {
1911 |       type: 'ExpressionStatement',
1912 |       expression: {
1913 |         type: 'BinaryExpression',
1914 |         operator: '<',
1915 |         left: {
1916 |           type: 'JSXElement',
1917 |           openingElement: {
1918 |             type: 'JSXOpeningElement',
1919 |             name: {
1920 |               type: 'JSXIdentifier',
1921 |               name: 'div',
1922 |               range: [2, 5],
1923 |               loc: {
1924 |                 start: { line: 1, column: 2 },
1925 |                 end: { line: 1, column: 5 }
1926 |               }
1927 |             },
1928 |             selfClosing: true,
1929 |             attributes: [],
1930 |             range: [1, 8],
1931 |             loc: {
1932 |               start: { line: 1, column: 1 },
1933 |               end: { line: 1, column: 8 }
1934 |             }
1935 |           },
1936 |           closingElement: null,
1937 |           children: [],
1938 |           range: [1, 8],
1939 |           loc: {
1940 |             start: { line: 1, column: 1 },
1941 |             end: { line: 1, column: 8 }
1942 |           }
1943 |         },
1944 |         right: {
1945 |           type: 'Identifier',
1946 |           name: 'x',
1947 |           range: [12, 13],
1948 |           loc: {
1949 |             start: { line: 1, column: 12 },
1950 |             end: { line: 1, column: 13 }
1951 |           }
1952 |         },
1953 |         range: [0, 13],
1954 |         loc: {
1955 |           start: { line: 1, column: 0 },
1956 |           end: { line: 1, column: 13 }
1957 |         }
1958 |       },
1959 |       range: [0, 14],
1960 |       loc: {
1961 |         start: { line: 1, column: 0 },
1962 |         end: { line: 1, column: 14 }
1963 |       }
1964 |     },
1965 | 
1966 |     '<div {...props} />': {
1967 |       "type": "ExpressionStatement",
1968 |       "expression": {
1969 |         "type": "JSXElement",
1970 |         "openingElement": {
1971 |           "type": "JSXOpeningElement",
1972 |           "name": {
1973 |             "type": "JSXIdentifier",
1974 |             "name": "div",
1975 |             "range": [
1976 |               1,
1977 |               4
1978 |             ],
1979 |             "loc": {
1980 |               "start": {
1981 |                 "line": 1,
1982 |                 "column": 1
1983 |               },
1984 |               "end": {
1985 |                 "line": 1,
1986 |                 "column": 4
1987 |               }
1988 |             }
1989 |           },
1990 |           "selfClosing": true,
1991 |           "attributes": [
1992 |             {
1993 |               "type": "JSXSpreadAttribute",
1994 |               "argument": {
1995 |                 "type": "Identifier",
1996 |                 "name": "props",
1997 |                 "range": [
1998 |                   9,
1999 |                   14
2000 |                 ],
2001 |                 "loc": {
2002 |                   "start": {
2003 |                     "line": 1,
2004 |                     "column": 9
2005 |                   },
2006 |                   "end": {
2007 |                     "line": 1,
2008 |                     "column": 14
2009 |                   }
2010 |                 }
2011 |               },
2012 |               "range": [
2013 |                 5,
2014 |                 15
2015 |               ],
2016 |               "loc": {
2017 |                 "start": {
2018 |                   "line": 1,
2019 |                   "column": 5
2020 |                 },
2021 |                 "end": {
2022 |                   "line": 1,
2023 |                   "column": 15
2024 |                 }
2025 |               }
2026 |             }
2027 |           ],
2028 |           "range": [
2029 |             0,
2030 |             18
2031 |           ],
2032 |           "loc": {
2033 |             "start": {
2034 |               "line": 1,
2035 |               "column": 0
2036 |             },
2037 |             "end": {
2038 |               "line": 1,
2039 |               "column": 18
2040 |             }
2041 |           }
2042 |         },
2043 |         closingElement: null,
2044 |         "children": [],
2045 |         "range": [
2046 |           0,
2047 |           18
2048 |         ],
2049 |         "loc": {
2050 |           "start": {
2051 |             "line": 1,
2052 |             "column": 0
2053 |           },
2054 |           "end": {
2055 |             "line": 1,
2056 |             "column": 18
2057 |           }
2058 |         }
2059 |       },
2060 |       "range": [
2061 |         0,
2062 |         18
2063 |       ],
2064 |       "loc": {
2065 |         "start": {
2066 |           "line": 1,
2067 |           "column": 0
2068 |         },
2069 |         "end": {
2070 |           "line": 1,
2071 |           "column": 18
2072 |         }
2073 |       }
2074 |     },
2075 | 
2076 |     '<div {...props} post="attribute" />': {
2077 |       "type": "ExpressionStatement",
2078 |       "expression": {
2079 |         "type": "JSXElement",
2080 |         "openingElement": {
2081 |           "type": "JSXOpeningElement",
2082 |           "name": {
2083 |             "type": "JSXIdentifier",
2084 |             "name": "div",
2085 |             "range": [
2086 |               1,
2087 |               4
2088 |             ],
2089 |             "loc": {
2090 |               "start": {
2091 |                 "line": 1,
2092 |                 "column": 1
2093 |               },
2094 |               "end": {
2095 |                 "line": 1,
2096 |                 "column": 4
2097 |               }
2098 |             }
2099 |           },
2100 |           "selfClosing": true,
2101 |           "attributes": [
2102 |             {
2103 |               "type": "JSXSpreadAttribute",
2104 |               "argument": {
2105 |                 "type": "Identifier",
2106 |                 "name": "props",
2107 |                 "range": [
2108 |                   9,
2109 |                   14
2110 |                 ],
2111 |                 "loc": {
2112 |                   "start": {
2113 |                     "line": 1,
2114 |                     "column": 9
2115 |                   },
2116 |                   "end": {
2117 |                     "line": 1,
2118 |                     "column": 14
2119 |                   }
2120 |                 }
2121 |               },
2122 |               "range": [
2123 |                 5,
2124 |                 15
2125 |               ],
2126 |               "loc": {
2127 |                 "start": {
2128 |                   "line": 1,
2129 |                   "column": 5
2130 |                 },
2131 |                 "end": {
2132 |                   "line": 1,
2133 |                   "column": 15
2134 |                 }
2135 |               }
2136 |             },
2137 |             {
2138 |               "type": "JSXAttribute",
2139 |               "name": {
2140 |                 "type": "JSXIdentifier",
2141 |                 "name": "post",
2142 |                 "range": [
2143 |                   16,
2144 |                   20
2145 |                 ],
2146 |                 "loc": {
2147 |                   "start": {
2148 |                     "line": 1,
2149 |                     "column": 16
2150 |                   },
2151 |                   "end": {
2152 |                     "line": 1,
2153 |                     "column": 20
2154 |                   }
2155 |                 }
2156 |               },
2157 |               "value": {
2158 |                 "type": "Literal",
2159 |                 "value": "attribute",
2160 |                 "raw": "\"attribute\"",
2161 |                 "range": [
2162 |                   21,
2163 |                   32
2164 |                 ],
2165 |                 "loc": {
2166 |                   "start": {
2167 |                     "line": 1,
2168 |                     "column": 21
2169 |                   },
2170 |                   "end": {
2171 |                     "line": 1,
2172 |                     "column": 32
2173 |                   }
2174 |                 }
2175 |               },
2176 |               "range": [
2177 |                 16,
2178 |                 32
2179 |               ],
2180 |               "loc": {
2181 |                 "start": {
2182 |                   "line": 1,
2183 |                   "column": 16
2184 |                 },
2185 |                 "end": {
2186 |                   "line": 1,
2187 |                   "column": 32
2188 |                 }
2189 |               }
2190 |             }
2191 |           ],
2192 |           "range": [
2193 |             0,
2194 |             35
2195 |           ],
2196 |           "loc": {
2197 |             "start": {
2198 |               "line": 1,
2199 |               "column": 0
2200 |             },
2201 |             "end": {
2202 |               "line": 1,
2203 |               "column": 35
2204 |             }
2205 |           }
2206 |         },
2207 |         closingElement: null,
2208 |         "children": [],
2209 |         "range": [
2210 |           0,
2211 |           35
2212 |         ],
2213 |         "loc": {
2214 |           "start": {
2215 |             "line": 1,
2216 |             "column": 0
2217 |           },
2218 |           "end": {
2219 |             "line": 1,
2220 |             "column": 35
2221 |           }
2222 |         }
2223 |       },
2224 |       "range": [
2225 |         0,
2226 |         35
2227 |       ],
2228 |       "loc": {
2229 |         "start": {
2230 |           "line": 1,
2231 |           "column": 0
2232 |         },
2233 |         "end": {
2234 |           "line": 1,
2235 |           "column": 35
2236 |         }
2237 |       }
2238 |     },
2239 | 
2240 |     '<div pre="leading" pre2="attribute" {...props}></div>': {
2241 |       "type": "ExpressionStatement",
2242 |       "expression": {
2243 |         "type": "JSXElement",
2244 |         "openingElement": {
2245 |           "type": "JSXOpeningElement",
2246 |           "name": {
2247 |             "type": "JSXIdentifier",
2248 |             "name": "div",
2249 |             "range": [
2250 |               1,
2251 |               4
2252 |             ],
2253 |             "loc": {
2254 |               "start": {
2255 |                 "line": 1,
2256 |                 "column": 1
2257 |               },
2258 |               "end": {
2259 |                 "line": 1,
2260 |                 "column": 4
2261 |               }
2262 |             }
2263 |           },
2264 |           "selfClosing": false,
2265 |           "attributes": [
2266 |             {
2267 |               "type": "JSXAttribute",
2268 |               "name": {
2269 |                 "type": "JSXIdentifier",
2270 |                 "name": "pre",
2271 |                 "range": [
2272 |                   5,
2273 |                   8
2274 |                 ],
2275 |                 "loc": {
2276 |                   "start": {
2277 |                     "line": 1,
2278 |                     "column": 5
2279 |                   },
2280 |                   "end": {
2281 |                     "line": 1,
2282 |                     "column": 8
2283 |                   }
2284 |                 }
2285 |               },
2286 |               "value": {
2287 |                 "type": "Literal",
2288 |                 "value": "leading",
2289 |                 "raw": "\"leading\"",
2290 |                 "range": [
2291 |                   9,
2292 |                   18
2293 |                 ],
2294 |                 "loc": {
2295 |                   "start": {
2296 |                     "line": 1,
2297 |                     "column": 9
2298 |                   },
2299 |                   "end": {
2300 |                     "line": 1,
2301 |                     "column": 18
2302 |                   }
2303 |                 }
2304 |               },
2305 |               "range": [
2306 |                 5,
2307 |                 18
2308 |               ],
2309 |               "loc": {
2310 |                 "start": {
2311 |                   "line": 1,
2312 |                   "column": 5
2313 |                 },
2314 |                 "end": {
2315 |                   "line": 1,
2316 |                   "column": 18
2317 |                 }
2318 |               }
2319 |             },
2320 |             {
2321 |               "type": "JSXAttribute",
2322 |               "name": {
2323 |                 "type": "JSXIdentifier",
2324 |                 "name": "pre2",
2325 |                 "range": [
2326 |                   19,
2327 |                   23
2328 |                 ],
2329 |                 "loc": {
2330 |                   "start": {
2331 |                     "line": 1,
2332 |                     "column": 19
2333 |                   },
2334 |                   "end": {
2335 |                     "line": 1,
2336 |                     "column": 23
2337 |                   }
2338 |                 }
2339 |               },
2340 |               "value": {
2341 |                 "type": "Literal",
2342 |                 "value": "attribute",
2343 |                 "raw": "\"attribute\"",
2344 |                 "range": [
2345 |                   24,
2346 |                   35
2347 |                 ],
2348 |                 "loc": {
2349 |                   "start": {
2350 |                     "line": 1,
2351 |                     "column": 24
2352 |                   },
2353 |                   "end": {
2354 |                     "line": 1,
2355 |                     "column": 35
2356 |                   }
2357 |                 }
2358 |               },
2359 |               "range": [
2360 |                 19,
2361 |                 35
2362 |               ],
2363 |               "loc": {
2364 |                 "start": {
2365 |                   "line": 1,
2366 |                   "column": 19
2367 |                 },
2368 |                 "end": {
2369 |                   "line": 1,
2370 |                   "column": 35
2371 |                 }
2372 |               }
2373 |             },
2374 |             {
2375 |               "type": "JSXSpreadAttribute",
2376 |               "argument": {
2377 |                 "type": "Identifier",
2378 |                 "name": "props",
2379 |                 "range": [
2380 |                   40,
2381 |                   45
2382 |                 ],
2383 |                 "loc": {
2384 |                   "start": {
2385 |                     "line": 1,
2386 |                     "column": 40
2387 |                   },
2388 |                   "end": {
2389 |                     "line": 1,
2390 |                     "column": 45
2391 |                   }
2392 |                 }
2393 |               },
2394 |               "range": [
2395 |                 36,
2396 |                 46
2397 |               ],
2398 |               "loc": {
2399 |                 "start": {
2400 |                   "line": 1,
2401 |                   "column": 36
2402 |                 },
2403 |                 "end": {
2404 |                   "line": 1,
2405 |                   "column": 46
2406 |                 }
2407 |               }
2408 |             }
2409 |           ],
2410 |           "range": [
2411 |             0,
2412 |             47
2413 |           ],
2414 |           "loc": {
2415 |             "start": {
2416 |               "line": 1,
2417 |               "column": 0
2418 |             },
2419 |             "end": {
2420 |               "line": 1,
2421 |               "column": 47
2422 |             }
2423 |           }
2424 |         },
2425 |         "closingElement": {
2426 |           "type": "JSXClosingElement",
2427 |           "name": {
2428 |             "type": "JSXIdentifier",
2429 |             "name": "div",
2430 |             "range": [
2431 |               49,
2432 |               52
2433 |             ],
2434 |             "loc": {
2435 |               "start": {
2436 |                 "line": 1,
2437 |                 "column": 49
2438 |               },
2439 |               "end": {
2440 |                 "line": 1,
2441 |                 "column": 52
2442 |               }
2443 |             }
2444 |           },
2445 |           "range": [
2446 |             47,
2447 |             53
2448 |           ],
2449 |           "loc": {
2450 |             "start": {
2451 |               "line": 1,
2452 |               "column": 47
2453 |             },
2454 |             "end": {
2455 |               "line": 1,
2456 |               "column": 53
2457 |             }
2458 |           }
2459 |         },
2460 |         "children": [],
2461 |         "range": [
2462 |           0,
2463 |           53
2464 |         ],
2465 |         "loc": {
2466 |           "start": {
2467 |             "line": 1,
2468 |             "column": 0
2469 |           },
2470 |           "end": {
2471 |             "line": 1,
2472 |             "column": 53
2473 |           }
2474 |         }
2475 |       },
2476 |       "range": [
2477 |         0,
2478 |         53
2479 |       ],
2480 |       "loc": {
2481 |         "start": {
2482 |           "line": 1,
2483 |           "column": 0
2484 |         },
2485 |         "end": {
2486 |           "line": 1,
2487 |           "column": 53
2488 |         }
2489 |       }
2490 |     },
2491 | 
2492 |     '<A aa={aa.bb.cc} bb={bb.cc.dd}><div>{aa.b}</div></A>': {
2493 |       "type": "ExpressionStatement",
2494 |       "start": 0,
2495 |       "end": 52,
2496 |       "loc": {
2497 |         "start": {
2498 |           "line": 1,
2499 |           "column": 0
2500 |         },
2501 |         "end": {
2502 |           "line": 1,
2503 |           "column": 52
2504 |         }
2505 |       },
2506 |       "range": [
2507 |         0,
2508 |         52
2509 |       ],
2510 |       "expression": {
2511 |         "type": "JSXElement",
2512 |         "start": 0,
2513 |         "end": 52,
2514 |         "loc": {
2515 |           "start": {
2516 |             "line": 1,
2517 |             "column": 0
2518 |           },
2519 |           "end": {
2520 |             "line": 1,
2521 |             "column": 52
2522 |           }
2523 |         },
2524 |         "range": [
2525 |           0,
2526 |           52
2527 |         ],
2528 |         "openingElement": {
2529 |           "type": "JSXOpeningElement",
2530 |           "start": 0,
2531 |           "end": 31,
2532 |           "loc": {
2533 |             "start": {
2534 |               "line": 1,
2535 |               "column": 0
2536 |             },
2537 |             "end": {
2538 |               "line": 1,
2539 |               "column": 31
2540 |             }
2541 |           },
2542 |           "range": [
2543 |             0,
2544 |             31
2545 |           ],
2546 |           "attributes": [
2547 |             {
2548 |               "type": "JSXAttribute",
2549 |               "start": 3,
2550 |               "end": 16,
2551 |               "loc": {
2552 |                 "start": {
2553 |                   "line": 1,
2554 |                   "column": 3
2555 |                 },
2556 |                 "end": {
2557 |                   "line": 1,
2558 |                   "column": 16
2559 |                 }
2560 |               },
2561 |               "range": [
2562 |                 3,
2563 |                 16
2564 |               ],
2565 |               "name": {
2566 |                 "type": "JSXIdentifier",
2567 |                 "start": 3,
2568 |                 "end": 5,
2569 |                 "loc": {
2570 |                   "start": {
2571 |                     "line": 1,
2572 |                     "column": 3
2573 |                   },
2574 |                   "end": {
2575 |                     "line": 1,
2576 |                     "column": 5
2577 |                   }
2578 |                 },
2579 |                 "range": [
2580 |                   3,
2581 |                   5
2582 |                 ],
2583 |                 "name": "aa"
2584 |               },
2585 |               "value": {
2586 |                 "type": "JSXExpressionContainer",
2587 |                 "start": 6,
2588 |                 "end": 16,
2589 |                 "loc": {
2590 |                   "start": {
2591 |                     "line": 1,
2592 |                     "column": 6
2593 |                   },
2594 |                   "end": {
2595 |                     "line": 1,
2596 |                     "column": 16
2597 |                   }
2598 |                 },
2599 |                 "range": [
2600 |                   6,
2601 |                   16
2602 |                 ],
2603 |                 "expression": {
2604 |                   "type": "MemberExpression",
2605 |                   "start": 7,
2606 |                   "end": 15,
2607 |                   "loc": {
2608 |                     "start": {
2609 |                       "line": 1,
2610 |                       "column": 7
2611 |                     },
2612 |                     "end": {
2613 |                       "line": 1,
2614 |                       "column": 15
2615 |                     }
2616 |                   },
2617 |                   "range": [
2618 |                     7,
2619 |                     15
2620 |                   ],
2621 |                   "object": {
2622 |                     "type": "MemberExpression",
2623 |                     "start": 7,
2624 |                     "end": 12,
2625 |                     "loc": {
2626 |                       "start": {
2627 |                         "line": 1,
2628 |                         "column": 7
2629 |                       },
2630 |                       "end": {
2631 |                         "line": 1,
2632 |                         "column": 12
2633 |                       }
2634 |                     },
2635 |                     "range": [
2636 |                       7,
2637 |                       12
2638 |                     ],
2639 |                     "object": {
2640 |                       "type": "Identifier",
2641 |                       "start": 7,
2642 |                       "end": 9,
2643 |                       "loc": {
2644 |                         "start": {
2645 |                           "line": 1,
2646 |                           "column": 7
2647 |                         },
2648 |                         "end": {
2649 |                           "line": 1,
2650 |                           "column": 9
2651 |                         }
2652 |                       },
2653 |                       "range": [
2654 |                         7,
2655 |                         9
2656 |                       ],
2657 |                       "name": "aa"
2658 |                     },
2659 |                     "property": {
2660 |                       "type": "Identifier",
2661 |                       "start": 10,
2662 |                       "end": 12,
2663 |                       "loc": {
2664 |                         "start": {
2665 |                           "line": 1,
2666 |                           "column": 10
2667 |                         },
2668 |                         "end": {
2669 |                           "line": 1,
2670 |                           "column": 12
2671 |                         }
2672 |                       },
2673 |                       "range": [
2674 |                         10,
2675 |                         12
2676 |                       ],
2677 |                       "name": "bb"
2678 |                     },
2679 |                     "computed": false
2680 |                   },
2681 |                   "property": {
2682 |                     "type": "Identifier",
2683 |                     "start": 13,
2684 |                     "end": 15,
2685 |                     "loc": {
2686 |                       "start": {
2687 |                         "line": 1,
2688 |                         "column": 13
2689 |                       },
2690 |                       "end": {
2691 |                         "line": 1,
2692 |                         "column": 15
2693 |                       }
2694 |                     },
2695 |                     "range": [
2696 |                       13,
2697 |                       15
2698 |                     ],
2699 |                     "name": "cc"
2700 |                   },
2701 |                   "computed": false
2702 |                 }
2703 |               }
2704 |             },
2705 |             {
2706 |               "type": "JSXAttribute",
2707 |               "start": 17,
2708 |               "end": 30,
2709 |               "loc": {
2710 |                 "start": {
2711 |                   "line": 1,
2712 |                   "column": 17
2713 |                 },
2714 |                 "end": {
2715 |                   "line": 1,
2716 |                   "column": 30
2717 |                 }
2718 |               },
2719 |               "range": [
2720 |                 17,
2721 |                 30
2722 |               ],
2723 |               "name": {
2724 |                 "type": "JSXIdentifier",
2725 |                 "start": 17,
2726 |                 "end": 19,
2727 |                 "loc": {
2728 |                   "start": {
2729 |                     "line": 1,
2730 |                     "column": 17
2731 |                   },
2732 |                   "end": {
2733 |                     "line": 1,
2734 |                     "column": 19
2735 |                   }
2736 |                 },
2737 |                 "range": [
2738 |                   17,
2739 |                   19
2740 |                 ],
2741 |                 "name": "bb"
2742 |               },
2743 |               "value": {
2744 |                 "type": "JSXExpressionContainer",
2745 |                 "start": 20,
2746 |                 "end": 30,
2747 |                 "loc": {
2748 |                   "start": {
2749 |                     "line": 1,
2750 |                     "column": 20
2751 |                   },
2752 |                   "end": {
2753 |                     "line": 1,
2754 |                     "column": 30
2755 |                   }
2756 |                 },
2757 |                 "range": [
2758 |                   20,
2759 |                   30
2760 |                 ],
2761 |                 "expression": {
2762 |                   "type": "MemberExpression",
2763 |                   "start": 21,
2764 |                   "end": 29,
2765 |                   "loc": {
2766 |                     "start": {
2767 |                       "line": 1,
2768 |                       "column": 21
2769 |                     },
2770 |                     "end": {
2771 |                       "line": 1,
2772 |                       "column": 29
2773 |                     }
2774 |                   },
2775 |                   "range": [
2776 |                     21,
2777 |                     29
2778 |                   ],
2779 |                   "object": {
2780 |                     "type": "MemberExpression",
2781 |                     "start": 21,
2782 |                     "end": 26,
2783 |                     "loc": {
2784 |                       "start": {
2785 |                         "line": 1,
2786 |                         "column": 21
2787 |                       },
2788 |                       "end": {
2789 |                         "line": 1,
2790 |                         "column": 26
2791 |                       }
2792 |                     },
2793 |                     "range": [
2794 |                       21,
2795 |                       26
2796 |                     ],
2797 |                     "object": {
2798 |                       "type": "Identifier",
2799 |                       "start": 21,
2800 |                       "end": 23,
2801 |                       "loc": {
2802 |                         "start": {
2803 |                           "line": 1,
2804 |                           "column": 21
2805 |                         },
2806 |                         "end": {
2807 |                           "line": 1,
2808 |                           "column": 23
2809 |                         }
2810 |                       },
2811 |                       "range": [
2812 |                         21,
2813 |                         23
2814 |                       ],
2815 |                       "name": "bb"
2816 |                     },
2817 |                     "property": {
2818 |                       "type": "Identifier",
2819 |                       "start": 24,
2820 |                       "end": 26,
2821 |                       "loc": {
2822 |                         "start": {
2823 |                           "line": 1,
2824 |                           "column": 24
2825 |                         },
2826 |                         "end": {
2827 |                           "line": 1,
2828 |                           "column": 26
2829 |                         }
2830 |                       },
2831 |                       "range": [
2832 |                         24,
2833 |                         26
2834 |                       ],
2835 |                       "name": "cc"
2836 |                     },
2837 |                     "computed": false
2838 |                   },
2839 |                   "property": {
2840 |                     "type": "Identifier",
2841 |                     "start": 27,
2842 |                     "end": 29,
2843 |                     "loc": {
2844 |                       "start": {
2845 |                         "line": 1,
2846 |                         "column": 27
2847 |                       },
2848 |                       "end": {
2849 |                         "line": 1,
2850 |                         "column": 29
2851 |                       }
2852 |                     },
2853 |                     "range": [
2854 |                       27,
2855 |                       29
2856 |                     ],
2857 |                     "name": "dd"
2858 |                   },
2859 |                   "computed": false
2860 |                 }
2861 |               }
2862 |             }
2863 |           ],
2864 |           "name": {
2865 |             "type": "JSXIdentifier",
2866 |             "start": 1,
2867 |             "end": 2,
2868 |             "loc": {
2869 |               "start": {
2870 |                 "line": 1,
2871 |                 "column": 1
2872 |               },
2873 |               "end": {
2874 |                 "line": 1,
2875 |                 "column": 2
2876 |               }
2877 |             },
2878 |             "range": [
2879 |               1,
2880 |               2
2881 |             ],
2882 |             "name": "A"
2883 |           },
2884 |           "selfClosing": false
2885 |         },
2886 |         "closingElement": {
2887 |           "type": "JSXClosingElement",
2888 |           "start": 48,
2889 |           "end": 52,
2890 |           "loc": {
2891 |             "start": {
2892 |               "line": 1,
2893 |               "column": 48
2894 |             },
2895 |             "end": {
2896 |               "line": 1,
2897 |               "column": 52
2898 |             }
2899 |           },
2900 |           "range": [
2901 |             48,
2902 |             52
2903 |           ],
2904 |           "name": {
2905 |             "type": "JSXIdentifier",
2906 |             "start": 50,
2907 |             "end": 51,
2908 |             "loc": {
2909 |               "start": {
2910 |                 "line": 1,
2911 |                 "column": 50
2912 |               },
2913 |               "end": {
2914 |                 "line": 1,
2915 |                 "column": 51
2916 |               }
2917 |             },
2918 |             "range": [
2919 |               50,
2920 |               51
2921 |             ],
2922 |             "name": "A"
2923 |           }
2924 |         },
2925 |         "children": [
2926 |           {
2927 |             "type": "JSXElement",
2928 |             "start": 31,
2929 |             "end": 48,
2930 |             "loc": {
2931 |               "start": {
2932 |                 "line": 1,
2933 |                 "column": 31
2934 |               },
2935 |               "end": {
2936 |                 "line": 1,
2937 |                 "column": 48
2938 |               }
2939 |             },
2940 |             "range": [
2941 |               31,
2942 |               48
2943 |             ],
2944 |             "openingElement": {
2945 |               "type": "JSXOpeningElement",
2946 |               "start": 31,
2947 |               "end": 36,
2948 |               "loc": {
2949 |                 "start": {
2950 |                   "line": 1,
2951 |                   "column": 31
2952 |                 },
2953 |                 "end": {
2954 |                   "line": 1,
2955 |                   "column": 36
2956 |                 }
2957 |               },
2958 |               "range": [
2959 |                 31,
2960 |                 36
2961 |               ],
2962 |               "attributes": [],
2963 |               "name": {
2964 |                 "type": "JSXIdentifier",
2965 |                 "start": 32,
2966 |                 "end": 35,
2967 |                 "loc": {
2968 |                   "start": {
2969 |                     "line": 1,
2970 |                     "column": 32
2971 |                   },
2972 |                   "end": {
2973 |                     "line": 1,
2974 |                     "column": 35
2975 |                   }
2976 |                 },
2977 |                 "range": [
2978 |                   32,
2979 |                   35
2980 |                 ],
2981 |                 "name": "div"
2982 |               },
2983 |               "selfClosing": false
2984 |             },
2985 |             "closingElement": {
2986 |               "type": "JSXClosingElement",
2987 |               "start": 42,
2988 |               "end": 48,
2989 |               "loc": {
2990 |                 "start": {
2991 |                   "line": 1,
2992 |                   "column": 42
2993 |                 },
2994 |                 "end": {
2995 |                   "line": 1,
2996 |                   "column": 48
2997 |                 }
2998 |               },
2999 |               "range": [
3000 |                 42,
3001 |                 48
3002 |               ],
3003 |               "name": {
3004 |                 "type": "JSXIdentifier",
3005 |                 "start": 44,
3006 |                 "end": 47,
3007 |                 "loc": {
3008 |                   "start": {
3009 |                     "line": 1,
3010 |                     "column": 44
3011 |                   },
3012 |                   "end": {
3013 |                     "line": 1,
3014 |                     "column": 47
3015 |                   }
3016 |                 },
3017 |                 "range": [
3018 |                   44,
3019 |                   47
3020 |                 ],
3021 |                 "name": "div"
3022 |               }
3023 |             },
3024 |             "children": [
3025 |               {
3026 |                 "type": "JSXExpressionContainer",
3027 |                 "start": 36,
3028 |                 "end": 42,
3029 |                 "loc": {
3030 |                   "start": {
3031 |                     "line": 1,
3032 |                     "column": 36
3033 |                   },
3034 |                   "end": {
3035 |                     "line": 1,
3036 |                     "column": 42
3037 |                   }
3038 |                 },
3039 |                 "range": [
3040 |                   36,
3041 |                   42
3042 |                 ],
3043 |                 "expression": {
3044 |                   "type": "MemberExpression",
3045 |                   "start": 37,
3046 |                   "end": 41,
3047 |                   "loc": {
3048 |                     "start": {
3049 |                       "line": 1,
3050 |                       "column": 37
3051 |                     },
3052 |                     "end": {
3053 |                       "line": 1,
3054 |                       "column": 41
3055 |                     }
3056 |                   },
3057 |                   "range": [
3058 |                     37,
3059 |                     41
3060 |                   ],
3061 |                   "object": {
3062 |                     "type": "Identifier",
3063 |                     "start": 37,
3064 |                     "end": 39,
3065 |                     "loc": {
3066 |                       "start": {
3067 |                         "line": 1,
3068 |                         "column": 37
3069 |                       },
3070 |                       "end": {
3071 |                         "line": 1,
3072 |                         "column": 39
3073 |                       }
3074 |                     },
3075 |                     "range": [
3076 |                       37,
3077 |                       39
3078 |                     ],
3079 |                     "name": "aa"
3080 |                   },
3081 |                   "property": {
3082 |                     "type": "Identifier",
3083 |                     "start": 40,
3084 |                     "end": 41,
3085 |                     "loc": {
3086 |                       "start": {
3087 |                         "line": 1,
3088 |                         "column": 40
3089 |                       },
3090 |                       "end": {
3091 |                         "line": 1,
3092 |                         "column": 41
3093 |                       }
3094 |                     },
3095 |                     "range": [
3096 |                       40,
3097 |                       41
3098 |                     ],
3099 |                     "name": "b"
3100 |                   },
3101 |                   "computed": false
3102 |                 }
3103 |               }
3104 |             ]
3105 |           }
3106 |         ]
3107 |       }
3108 |     },
3109 | 
3110 |     '<><div></div></>': {
3111 |       type: 'ExpressionStatement',
3112 |       start: 0,
3113 |       end: 16,
3114 |       loc: {
3115 |         start: {
3116 |           line: 1,
3117 |           column: 0
3118 |         },
3119 |         end: {
3120 |           line: 1,
3121 |           column: 16
3122 |         }
3123 |       },
3124 |       range: [0, 16],
3125 |       expression: {
3126 |         type: 'JSXFragment',
3127 |         start: 0,
3128 |         end: 16,
3129 |         loc: {
3130 |           start: {
3131 |             line: 1,
3132 |             column: 0
3133 |           },
3134 |           end: {
3135 |             line: 1,
3136 |             column: 16
3137 |           }
3138 |         },
3139 |         range: [0, 16],
3140 |         openingFragment: {
3141 |           type: 'JSXOpeningFragment',
3142 |           start: 0,
3143 |           end: 2,
3144 |           loc: {
3145 |             start: {
3146 |               line: 1,
3147 |               column: 0
3148 |             },
3149 |             end: {
3150 |               line: 1,
3151 |               column: 2
3152 |             }
3153 |           },
3154 |           range: [0, 2],
3155 |           attributes: [],
3156 |           selfClosing: false
3157 |         },
3158 |         closingFragment: {
3159 |           type: 'JSXClosingFragment',
3160 |           start: 13,
3161 |           end: 16,
3162 |           loc: {
3163 |             start: {
3164 |               line: 1,
3165 |               column: 13
3166 |             },
3167 |             end: {
3168 |               line: 1,
3169 |               column: 16
3170 |             }
3171 |           },
3172 |           range: [13, 16]
3173 |         },
3174 |         children: [{
3175 |           type: 'JSXElement',
3176 |           start: 2,
3177 |           end: 13,
3178 |           loc: {
3179 |             start: {
3180 |               line: 1,
3181 |               column: 2
3182 |             },
3183 |             end: {
3184 |               line: 1,
3185 |               column: 13
3186 |             }
3187 |           },
3188 |           range: [2, 13],
3189 |           openingElement: {
3190 |             type: 'JSXOpeningElement',
3191 |             start: 2,
3192 |             end: 7,
3193 |             loc: {
3194 |               start: {
3195 |                 line: 1,
3196 |                 column: 2
3197 |               },
3198 |               end: {
3199 |                 line: 1,
3200 |                 column: 7
3201 |               }
3202 |             },
3203 |             range: [2, 7],
3204 |             attributes: [],
3205 |             name: {
3206 |               type: 'JSXIdentifier',
3207 |               start: 3,
3208 |               end: 6,
3209 |               loc: {
3210 |                 start: {
3211 |                   line: 1,
3212 |                   column: 3
3213 |                 },
3214 |                 end: {
3215 |                   line: 1,
3216 |                   column: 6
3217 |                 }
3218 |               },
3219 |               range: [3, 6],
3220 |               name: 'div'
3221 |             },
3222 |             selfClosing: false
3223 |           },
3224 |           closingElement: {
3225 |             type: 'JSXClosingElement',
3226 |             start: 7,
3227 |             end: 13,
3228 |             loc: {
3229 |               start: {
3230 |                 line: 1,
3231 |                 column: 7
3232 |               },
3233 |               end: {
3234 |                 line: 1,
3235 |                 column: 13
3236 |               }
3237 |             },
3238 |             range: [7, 13],
3239 |             name: {
3240 |               type: 'JSXIdentifier',
3241 |               start: 9,
3242 |               end: 12,
3243 |               loc: {
3244 |                 start: {
3245 |                   line: 1,
3246 |                   column: 9
3247 |                 },
3248 |                 end: {
3249 |                   line: 1,
3250 |                   column: 12
3251 |                 }
3252 |               },
3253 |               range: [9, 12],
3254 |               name: 'div'
3255 |             }
3256 |           },
3257 |           children: []
3258 |         }]
3259 |       }
3260 |     }
3261 |   },
3262 |   'Regression': {
3263 |     '<p>foo <a href="test"> bar</a> baz</p> ;': {
3264 |       type: "ExpressionStatement",
3265 |       start: 0,
3266 |       end: 40,
3267 |       expression: {
3268 |         type: "JSXElement",
3269 |         start: 0,
3270 |         end: 38,
3271 |         openingElement: {
3272 |           type: "JSXOpeningElement",
3273 |           start: 0,
3274 |           end: 3,
3275 |           attributes: [],
3276 |           name: {
3277 |             type: "JSXIdentifier",
3278 |             start: 1,
3279 |             end: 2,
3280 |             name: "p"
3281 |           },
3282 |           selfClosing: false
3283 |         },
3284 |         closingElement: {
3285 |           type: "JSXClosingElement",
3286 |           start: 34,
3287 |           end: 38,
3288 |           name: {
3289 |             type: "JSXIdentifier",
3290 |             start: 36,
3291 |             end: 37,
3292 |             name: "p"
3293 |           }
3294 |         },
3295 |         children: [
3296 |           {
3297 |             type: "JSXText",
3298 |             start: 3,
3299 |             end: 7,
3300 |             value: "foo ",
3301 |             raw: "foo "
3302 |           },
3303 |           {
3304 |             type: "JSXElement",
3305 |             start: 7,
3306 |             end: 30,
3307 |             openingElement: {
3308 |               type: "JSXOpeningElement",
3309 |               start: 7,
3310 |               end: 22,
3311 |               attributes: [{
3312 |                 type: "JSXAttribute",
3313 |                 start: 10,
3314 |                 end: 21,
3315 |                 name: {
3316 |                   type: "JSXIdentifier",
3317 |                   start: 10,
3318 |                   end: 14,
3319 |                   name: "href"
3320 |                 },
3321 |                 value: {
3322 |                   type: "Literal",
3323 |                   start: 15,
3324 |                   end: 21,
3325 |                   value: "test",
3326 |                   raw: "\"test\""
3327 |                 }
3328 |               }],
3329 |               name: {
3330 |                 type: "JSXIdentifier",
3331 |                 start: 8,
3332 |                 end: 9,
3333 |                 name: "a"
3334 |               },
3335 |               selfClosing: false
3336 |             },
3337 |             closingElement: {
3338 |               type: "JSXClosingElement",
3339 |               start: 26,
3340 |               end: 30,
3341 |               name: {
3342 |                 type: "JSXIdentifier",
3343 |                 start: 28,
3344 |                 end: 29,
3345 |                 name: "a"
3346 |               }
3347 |             },
3348 |             children: [{
3349 |               type: "JSXText",
3350 |               start: 22,
3351 |               end: 26,
3352 |               value: " bar",
3353 |               raw: " bar"
3354 |             }]
3355 |           },
3356 |           {
3357 |             type: "JSXText",
3358 |             start: 30,
3359 |             end: 34,
3360 |             value: " baz",
3361 |             raw: " baz"
3362 |           }
3363 |         ]
3364 |       }
3365 |     },
3366 | 
3367 |     '<div>{<div {...test} />}</div>': {
3368 |       type: 'ExpressionStatement',
3369 |       start: 0,
3370 |       end: 30,
3371 |       expression: {
3372 |         type: 'JSXElement',
3373 |         start: 0,
3374 |         end: 30,
3375 |         openingElement: {
3376 |           type: 'JSXOpeningElement',
3377 |           start: 0,
3378 |           end: 5,
3379 |           attributes: [],
3380 |           name: {
3381 |             type: 'JSXIdentifier',
3382 |             start: 1,
3383 |             end: 4,
3384 |             name: 'div'
3385 |           },
3386 |           selfClosing: false
3387 |         },
3388 |         closingElement: {
3389 |           type: 'JSXClosingElement',
3390 |           start: 24,
3391 |           end: 30,
3392 |           name: {
3393 |             type: 'JSXIdentifier',
3394 |             start: 26,
3395 |             end: 29,
3396 |             name: 'div'
3397 |           }
3398 |         },
3399 |         children: [{
3400 |           type: 'JSXExpressionContainer',
3401 |           start: 5,
3402 |           end: 24,
3403 |           expression: {
3404 |             type: 'JSXElement',
3405 |             start: 6,
3406 |             end: 23,
3407 |             openingElement: {
3408 |               type: 'JSXOpeningElement',
3409 |               start: 6,
3410 |               end: 23,
3411 |               attributes: [
3412 |                 {
3413 |                   type: 'JSXSpreadAttribute',
3414 |                   start: 11,
3415 |                   end: 20,
3416 |                   argument: {
3417 |                     type: 'Identifier',
3418 |                     start: 15,
3419 |                     end: 19,
3420 |                     name: 'test'
3421 |                   }
3422 |                 }
3423 |               ],
3424 |               name: {
3425 |                 type: 'JSXIdentifier',
3426 |                 start: 7,
3427 |                 end: 10,
3428 |                 name: 'div'
3429 |               },
3430 |               selfClosing: true
3431 |             },
3432 |             closingElement: null,
3433 |             children: []
3434 |           }
3435 |         }]
3436 |       }
3437 |     },
3438 | 
3439 |     '<div>{ {a} }</div>': {
3440 |       type: "ExpressionStatement",
3441 |       start: 0,
3442 |       end: 18,
3443 |       expression: {
3444 |         type: "JSXElement",
3445 |         start: 0,
3446 |         end: 18,
3447 |         openingElement: {
3448 |           type: "JSXOpeningElement",
3449 |           start: 0,
3450 |           end: 5,
3451 |           attributes: [],
3452 |           name: {
3453 |             type: "JSXIdentifier",
3454 |             start: 1,
3455 |             end: 4,
3456 |             name: "div"
3457 |           },
3458 |           selfClosing: false
3459 |         },
3460 |         closingElement: {
3461 |           type: "JSXClosingElement",
3462 |           start: 12,
3463 |           end: 18,
3464 |           name: {
3465 |             type: "JSXIdentifier",
3466 |             start: 14,
3467 |             end: 17,
3468 |             name: "div"
3469 |           }
3470 |         },
3471 |         children: [{
3472 |           type: "JSXExpressionContainer",
3473 |           start: 5,
3474 |           end: 12,
3475 |           expression: {
3476 |             type: "ObjectExpression",
3477 |             start: 7,
3478 |             end: 10,
3479 |             properties: [{
3480 |               type: "Property",
3481 |               start: 8,
3482 |               end: 9,
3483 |               method: false,
3484 |               shorthand: true,
3485 |               computed: false,
3486 |               key: {
3487 |                 type: "Identifier",
3488 |                 start: 8,
3489 |                 end: 9,
3490 |                 name: "a"
3491 |               },
3492 |               kind: "init",
3493 |               value: {
3494 |                 type: "Identifier",
3495 |                 start: 8,
3496 |                 end: 9,
3497 |                 name: "a"
3498 |               }
3499 |             }]
3500 |           }
3501 |         }]
3502 |       }
3503 |     },
3504 | 
3505 |     '<div>/text</div>': {
3506 |       type: "ExpressionStatement",
3507 |       start: 0,
3508 |       end: 16,
3509 |       expression: {
3510 |         type: "JSXElement",
3511 |         start: 0,
3512 |         end: 16,
3513 |         openingElement: {
3514 |           type: "JSXOpeningElement",
3515 |           start: 0,
3516 |           end: 5,
3517 |           attributes: [],
3518 |           name: {
3519 |             type: "JSXIdentifier",
3520 |             start: 1,
3521 |             end: 4,
3522 |             name: "div"
3523 |           },
3524 |           selfClosing: false
3525 |         },
3526 |         closingElement: {
3527 |           type: "JSXClosingElement",
3528 |           start: 10,
3529 |           end: 16,
3530 |           name: {
3531 |             type: "JSXIdentifier",
3532 |             start: 12,
3533 |             end: 15,
3534 |             name: "div"
3535 |           }
3536 |         },
3537 |         children: [{
3538 |           type: "JSXText",
3539 |           start: 5,
3540 |           end: 10,
3541 |           value: "/text",
3542 |           raw: "/text"
3543 |         }]
3544 |       }
3545 |     },
3546 | 
3547 |     '<div>{a}{b}</div>': {
3548 |       type: "ExpressionStatement",
3549 |       start: 0,
3550 |       end: 17,
3551 |       expression: {
3552 |         type: "JSXElement",
3553 |         start: 0,
3554 |         end: 17,
3555 |         openingElement: {
3556 |           type: "JSXOpeningElement",
3557 |           start: 0,
3558 |           end: 5,
3559 |           attributes: [],
3560 |           name: {
3561 |             type: "JSXIdentifier",
3562 |             start: 1,
3563 |             end: 4,
3564 |             name: "div"
3565 |           },
3566 |           selfClosing: false
3567 |         },
3568 |         closingElement: {
3569 |           type: "JSXClosingElement",
3570 |           start: 11,
3571 |           end: 17,
3572 |           name: {
3573 |             type: "JSXIdentifier",
3574 |             start: 13,
3575 |             end: 16,
3576 |             name: "div"
3577 |           }
3578 |         },
3579 |         children: [{
3580 |             type: 'JSXExpressionContainer',
3581 |             expression: {
3582 |               type: 'Identifier',
3583 |               name: 'a',
3584 |               range: [6, 7],
3585 |               loc: {
3586 |                 start: {
3587 |                   line: 1,
3588 |                   column: 6
3589 |                 },
3590 |                 end: {
3591 |                   line: 1,
3592 |                   column: 7
3593 |                 }
3594 |               }
3595 |             },
3596 |             range: [5, 8],
3597 |             loc: {
3598 |               start: {
3599 |                 line: 1,
3600 |                 column: 5
3601 |               },
3602 |               end: {
3603 |                 line: 1,
3604 |                 column: 8
3605 |               }
3606 |             }
3607 |           }, {
3608 |             type: 'JSXExpressionContainer',
3609 |             expression: {
3610 |               type: 'Identifier',
3611 |               name: 'b',
3612 |               range: [9, 10],
3613 |               loc: {
3614 |                 start: {
3615 |                   line: 1,
3616 |                   column: 9
3617 |                 },
3618 |                 end: {
3619 |                   line: 1,
3620 |                   column: 10
3621 |                 }
3622 |               }
3623 |             },
3624 |             range: [8, 11],
3625 |             loc: {
3626 |               start: {
3627 |                 line: 1,
3628 |                 column: 8
3629 |               },
3630 |               end: {
3631 |                 line: 1,
3632 |                 column: 11
3633 |               }
3634 |             }
3635 |           }
3636 |         ]
3637 |       }
3638 |     },
3639 | 
3640 |     '<div pre="leading" {...props} />': {
3641 |       type: "ExpressionStatement",
3642 |       range: [0, 32],
3643 |       expression: {
3644 |         type: "JSXElement",
3645 |         range: [0, 32],
3646 |         openingElement: {
3647 |           type: "JSXOpeningElement",
3648 |           range: [0, 32],
3649 |           attributes: [
3650 |             {
3651 |               type: "JSXAttribute",
3652 |               range: [5, 18],
3653 |               name: {
3654 |                 type: "JSXIdentifier",
3655 |                 range: [5, 8],
3656 |                 name: "pre"
3657 |               },
3658 |               value: {
3659 |                 type: "Literal",
3660 |                 range: [9, 18],
3661 |                 value: "leading"
3662 |               }
3663 |             },
3664 |             {
3665 |               type: "JSXSpreadAttribute",
3666 |               range: [19, 29],
3667 |               argument: {
3668 |                 type: "Identifier",
3669 |                 range: [23, 28],
3670 |                 name: "props"
3671 |               }
3672 |             }
3673 |           ],
3674 |           name: {
3675 |             type: "JSXIdentifier",
3676 |             range: [1, 4],
3677 |             name: "div"
3678 |           },
3679 |           selfClosing: true
3680 |         },
3681 |         closingElement: null,
3682 |         children: []
3683 |       }
3684 |     },
3685 |     '<path d="M230 80\n\t\tA 45 45, 0, 1, 0, 275 125 \r\n    L 275 80 Z"/>': {
3686 |       type: "ExpressionStatement",
3687 |       expression: {
3688 |         type: "JSXElement",
3689 |         range: [0, 64],
3690 |         openingElement: {
3691 |           type: "JSXOpeningElement",
3692 |           range: [0, 64],
3693 |           attributes: [
3694 |             {
3695 |               type: "JSXAttribute",
3696 |               range: [6, 62],
3697 |               name: {
3698 |                 type: "JSXIdentifier",
3699 |                 range: [6, 7],
3700 |                 name: "d"
3701 |               },
3702 |               value: {
3703 |                 type: "Literal",
3704 |                 loc: {
3705 |                   start: { line: 1, column: 8 },
3706 |                   end: { line: 3, column: 15 }
3707 |                 },
3708 |                 range: [8, 62],
3709 |                 value: "M230 80\n\t\tA 45 45, 0, 1, 0, 275 125 \r\n    L 275 80 Z",
3710 |                 raw: "\"M230 80\n\t\tA 45 45, 0, 1, 0, 275 125 \r\n    L 275 80 Z\""
3711 |               }
3712 |             }
3713 |           ],
3714 |           name: {
3715 |             type: "JSXIdentifier",
3716 |             range: [1, 5],
3717 |             name: "path"
3718 |           },
3719 |           selfClosing: true
3720 |         },
3721 |         closingElement: null,
3722 |         children: []
3723 |       }
3724 |     }
3725 |   }
3726 | };
3727 | 
3728 | if (typeof exports !== "undefined") {
3729 |   var test = require("./driver.js").test;
3730 |   var testFail = require("./driver.js").testFail;
3731 |   var jsxTokens = require("..").tokTypes;
3732 |   var acornTokens = require("acorn").tokTypes;
3733 | }
3734 | 
3735 | testFail("var x = <div>one</div><div>two</div>;", "Adjacent JSX elements must be wrapped in an enclosing tag (1:22)");
3736 | 
3737 | testFail("<a:b.c />", "Unexpected token (1:4)");
3738 | 
3739 | test("<a:b.c />", {
3740 |   type: "Program",
3741 |   range: [0, 9],
3742 |   body: [{
3743 |     type: "ExpressionStatement",
3744 |     range: [0, 9],
3745 |     expression: {
3746 |       type: "JSXElement",
3747 |       range: [0, 9],
3748 |       openingElement: {
3749 |         type: "JSXOpeningElement",
3750 |         range: [0, 9],
3751 |         attributes: [],
3752 |         name: {
3753 |           type: "JSXMemberExpression",
3754 |           range: [1, 6],
3755 |           object: {
3756 |             type: "JSXNamespacedName",
3757 |             range: [1, 4],
3758 |             namespace: {
3759 |               type: "JSXIdentifier",
3760 |               range: [1, 2],
3761 |               name: "a"
3762 |             },
3763 |             name: {
3764 |               type: "JSXIdentifier",
3765 |               range: [3, 4],
3766 |               name: "b"
3767 |             }
3768 |           },
3769 |           property: {
3770 |             type: "JSXIdentifier",
3771 |             range: [5, 6],
3772 |             name: "c"
3773 |           }
3774 |         },
3775 |         selfClosing: true
3776 |       },
3777 |       closingElement: null,
3778 |       children: []
3779 |     }
3780 |   }]
3781 | }, {
3782 |   ranges: true
3783 | }, {
3784 |   allowNamespacedObjects: true
3785 | });
3786 | 
3787 | testFail('<ns:div />', 'Unexpected token (1:3)', {}, {
3788 |   allowNamespaces: false
3789 | });
3790 | 
3791 | testFail('<div ns:attr />', 'Unexpected token (1:7)', {}, {
3792 |   allowNamespaces: false
3793 | });
3794 | 
3795 | test('<a>{/* foo */}</a>', {}, {
3796 |   onToken: [
3797 |     {
3798 |       type: jsxTokens.jsxTagStart,
3799 |       value: undefined,
3800 |       start: 0,
3801 |       end: 1
3802 |     },
3803 |     {
3804 |       type: jsxTokens.jsxName,
3805 |       value: 'a',
3806 |       start: 1,
3807 |       end: 2
3808 |     },
3809 |     {
3810 |       type: jsxTokens.jsxTagEnd,
3811 |       value: undefined,
3812 |       start: 2,
3813 |       end: 3
3814 |     },
3815 |     {
3816 |       type: acornTokens.braceL,
3817 |       value: undefined,
3818 |       start: 3,
3819 |       end: 4
3820 |     },
3821 |     {
3822 |       type: acornTokens.braceR,
3823 |       value: undefined,
3824 |       start: 13,
3825 |       end: 14
3826 |     },
3827 |     {
3828 |       type: jsxTokens.jsxTagStart,
3829 |       value: undefined,
3830 |       start: 14,
3831 |       end: 15
3832 |     },
3833 |     {
3834 |       type: acornTokens.slash,
3835 |       value: '/',
3836 |       start: 15,
3837 |       end: 16
3838 |     },
3839 |     {
3840 |       type: jsxTokens.jsxName,
3841 |       value: 'a',
3842 |       start: 16,
3843 |       end: 17
3844 |     },
3845 |     {
3846 |       type: jsxTokens.jsxTagEnd,
3847 |       value: undefined,
3848 |       start: 17,
3849 |       end: 18
3850 |     },
3851 |     {
3852 |       type: acornTokens.eof,
3853 |       value: undefined,
3854 |       start: 18,
3855 |       end: 18
3856 |     }
3857 |   ]
3858 | });
3859 | 
3860 | test('<!--a', {
3861 |   type: 'Program',
3862 |   body: []
3863 | }, {
3864 |   onComment: [{
3865 |     type: 'Line',
3866 |     value: 'a'
3867 |   }]
3868 | });
3869 | 
3870 | for (var ns in fbTestFixture) {
3871 |   ns = fbTestFixture[ns];
3872 |   for (var code in ns) {
3873 |     test(code, {
3874 |       type: 'Program',
3875 |       body: [ns[code]]
3876 |     }, {
3877 |       ecmaVersion: 6,
3878 |       locations: true,
3879 |       ranges: true
3880 |     });
3881 |   }
3882 | }
3883 | 
3884 | testFail("<LeftRight left=<a /> right=<b>monkeys /> gorillas</b> />", 'Unexpected token `>`. Did you mean `&gt;` or `{">"}`? (1:40)');
3885 | testFail("<A>foo{</A>", "Unexpected token (1:8)");
3886 | testFail("<A>foo<</A>", "Unexpected token (1:7)");
3887 | testFail("<A>foo}</A>", 'Unexpected token `}`. Did you mean `&rbrace;` or `{"}"}`? (1:6)');
3888 | testFail("<A>foo></A>", 'Unexpected token `>`. Did you mean `&gt;` or `{">"}`? (1:6)');
3889 | test('<A>foo{"{"}</A>', {
3890 |   "type": "Program",
3891 |   "start": 0,
3892 |   "end": 15,
3893 |   "loc": {
3894 |     "start": {
3895 |       "line": 1,
3896 |       "column": 0
3897 |     },
3898 |     "end": {
3899 |       "line": 1,
3900 |       "column": 15
3901 |     }
3902 |   },
3903 |   "body": [
3904 |     {
3905 |       "type": "ExpressionStatement",
3906 |       "start": 0,
3907 |       "end": 15,
3908 |       "loc": {
3909 |         "start": {
3910 |           "line": 1,
3911 |           "column": 0
3912 |         },
3913 |         "end": {
3914 |           "line": 1,
3915 |           "column": 15
3916 |         }
3917 |       },
3918 |       "expression": {
3919 |         "type": "JSXElement",
3920 |         "start": 0,
3921 |         "end": 15,
3922 |         "loc": {
3923 |           "start": {
3924 |             "line": 1,
3925 |             "column": 0
3926 |           },
3927 |           "end": {
3928 |             "line": 1,
3929 |             "column": 15
3930 |           }
3931 |         },
3932 |         "openingElement": {
3933 |           "type": "JSXOpeningElement",
3934 |           "start": 0,
3935 |           "end": 3,
3936 |           "loc": {
3937 |             "start": {
3938 |               "line": 1,
3939 |               "column": 0
3940 |             },
3941 |             "end": {
3942 |               "line": 1,
3943 |               "column": 3
3944 |             }
3945 |           },
3946 |           "attributes": [],
3947 |           "name": {
3948 |             "type": "JSXIdentifier",
3949 |             "start": 1,
3950 |             "end": 2,
3951 |             "loc": {
3952 |               "start": {
3953 |                 "line": 1,
3954 |                 "column": 1
3955 |               },
3956 |               "end": {
3957 |                 "line": 1,
3958 |                 "column": 2
3959 |               }
3960 |             },
3961 |             "name": "A"
3962 |           },
3963 |           "selfClosing": false
3964 |         },
3965 |         "closingElement": {
3966 |           "type": "JSXClosingElement",
3967 |           "start": 11,
3968 |           "end": 15,
3969 |           "loc": {
3970 |             "start": {
3971 |               "line": 1,
3972 |               "column": 11
3973 |             },
3974 |             "end": {
3975 |               "line": 1,
3976 |               "column": 15
3977 |             }
3978 |           },
3979 |           "name": {
3980 |             "type": "JSXIdentifier",
3981 |             "start": 13,
3982 |             "end": 14,
3983 |             "loc": {
3984 |               "start": {
3985 |                 "line": 1,
3986 |                 "column": 13
3987 |               },
3988 |               "end": {
3989 |                 "line": 1,
3990 |                 "column": 14
3991 |               }
3992 |             },
3993 |             "name": "A"
3994 |           }
3995 |         },
3996 |         "children": [
3997 |           {
3998 |             "type": "JSXText",
3999 |             "start": 3,
4000 |             "end": 6,
4001 |             "loc": {
4002 |               "start": {
4003 |                 "line": 1,
4004 |                 "column": 3
4005 |               },
4006 |               "end": {
4007 |                 "line": 1,
4008 |                 "column": 6
4009 |               }
4010 |             },
4011 |             "value": "foo",
4012 |             "raw": "foo"
4013 |           },
4014 |           {
4015 |             "type": "JSXExpressionContainer",
4016 |             "start": 6,
4017 |             "end": 11,
4018 |             "loc": {
4019 |               "start": {
4020 |                 "line": 1,
4021 |                 "column": 6
4022 |               },
4023 |               "end": {
4024 |                 "line": 1,
4025 |                 "column": 11
4026 |               }
4027 |             },
4028 |             "expression": {
4029 |               "type": "Literal",
4030 |               "start": 7,
4031 |               "end": 10,
4032 |               "loc": {
4033 |                 "start": {
4034 |                   "line": 1,
4035 |                   "column": 7
4036 |                 },
4037 |                 "end": {
4038 |                   "line": 1,
4039 |                   "column": 10
4040 |                 }
4041 |               },
4042 |               "value": "{",
4043 |               "raw": "\"{\""
4044 |             }
4045 |           }
4046 |         ]
4047 |       }
4048 |     }
4049 |   ]
4050 | });
4051 | test('<A>foo{"<"}</A>', {
4052 |   "type": "Program",
4053 |   "start": 0,
4054 |   "end": 15,
4055 |   "loc": {
4056 |     "start": {
4057 |       "line": 1,
4058 |       "column": 0
4059 |     },
4060 |     "end": {
4061 |       "line": 1,
4062 |       "column": 15
4063 |     }
4064 |   },
4065 |   "body": [
4066 |     {
4067 |       "type": "ExpressionStatement",
4068 |       "start": 0,
4069 |       "end": 15,
4070 |       "loc": {
4071 |         "start": {
4072 |           "line": 1,
4073 |           "column": 0
4074 |         },
4075 |         "end": {
4076 |           "line": 1,
4077 |           "column": 15
4078 |         }
4079 |       },
4080 |       "expression": {
4081 |         "type": "JSXElement",
4082 |         "start": 0,
4083 |         "end": 15,
4084 |         "loc": {
4085 |           "start": {
4086 |             "line": 1,
4087 |             "column": 0
4088 |           },
4089 |           "end": {
4090 |             "line": 1,
4091 |             "column": 15
4092 |           }
4093 |         },
4094 |         "openingElement": {
4095 |           "type": "JSXOpeningElement",
4096 |           "start": 0,
4097 |           "end": 3,
4098 |           "loc": {
4099 |             "start": {
4100 |               "line": 1,
4101 |               "column": 0
4102 |             },
4103 |             "end": {
4104 |               "line": 1,
4105 |               "column": 3
4106 |             }
4107 |           },
4108 |           "attributes": [],
4109 |           "name": {
4110 |             "type": "JSXIdentifier",
4111 |             "start": 1,
4112 |             "end": 2,
4113 |             "loc": {
4114 |               "start": {
4115 |                 "line": 1,
4116 |                 "column": 1
4117 |               },
4118 |               "end": {
4119 |                 "line": 1,
4120 |                 "column": 2
4121 |               }
4122 |             },
4123 |             "name": "A"
4124 |           },
4125 |           "selfClosing": false
4126 |         },
4127 |         "closingElement": {
4128 |           "type": "JSXClosingElement",
4129 |           "start": 11,
4130 |           "end": 15,
4131 |           "loc": {
4132 |             "start": {
4133 |               "line": 1,
4134 |               "column": 11
4135 |             },
4136 |             "end": {
4137 |               "line": 1,
4138 |               "column": 15
4139 |             }
4140 |           },
4141 |           "name": {
4142 |             "type": "JSXIdentifier",
4143 |             "start": 13,
4144 |             "end": 14,
4145 |             "loc": {
4146 |               "start": {
4147 |                 "line": 1,
4148 |                 "column": 13
4149 |               },
4150 |               "end": {
4151 |                 "line": 1,
4152 |                 "column": 14
4153 |               }
4154 |             },
4155 |             "name": "A"
4156 |           }
4157 |         },
4158 |         "children": [
4159 |           {
4160 |             "type": "JSXText",
4161 |             "start": 3,
4162 |             "end": 6,
4163 |             "loc": {
4164 |               "start": {
4165 |                 "line": 1,
4166 |                 "column": 3
4167 |               },
4168 |               "end": {
4169 |                 "line": 1,
4170 |                 "column": 6
4171 |               }
4172 |             },
4173 |             "value": "foo",
4174 |             "raw": "foo"
4175 |           },
4176 |           {
4177 |             "type": "JSXExpressionContainer",
4178 |             "start": 6,
4179 |             "end": 11,
4180 |             "loc": {
4181 |               "start": {
4182 |                 "line": 1,
4183 |                 "column": 6
4184 |               },
4185 |               "end": {
4186 |                 "line": 1,
4187 |                 "column": 11
4188 |               }
4189 |             },
4190 |             "expression": {
4191 |               "type": "Literal",
4192 |               "start": 7,
4193 |               "end": 10,
4194 |               "loc": {
4195 |                 "start": {
4196 |                   "line": 1,
4197 |                   "column": 7
4198 |                 },
4199 |                 "end": {
4200 |                   "line": 1,
4201 |                   "column": 10
4202 |                 }
4203 |               },
4204 |               "value": "<",
4205 |               "raw": "\"<\""
4206 |             }
4207 |           }
4208 |         ]
4209 |       }
4210 |     }
4211 |   ]
4212 | });
4213 | test('<A>foo{"}"}</A>', {
4214 |   "type": "Program",
4215 |   "start": 0,
4216 |   "end": 15,
4217 |   "loc": {
4218 |     "start": {
4219 |       "line": 1,
4220 |       "column": 0
4221 |     },
4222 |     "end": {
4223 |       "line": 1,
4224 |       "column": 15
4225 |     }
4226 |   },
4227 |   "body": [
4228 |     {
4229 |       "type": "ExpressionStatement",
4230 |       "start": 0,
4231 |       "end": 15,
4232 |       "loc": {
4233 |         "start": {
4234 |           "line": 1,
4235 |           "column": 0
4236 |         },
4237 |         "end": {
4238 |           "line": 1,
4239 |           "column": 15
4240 |         }
4241 |       },
4242 |       "expression": {
4243 |         "type": "JSXElement",
4244 |         "start": 0,
4245 |         "end": 15,
4246 |         "loc": {
4247 |           "start": {
4248 |             "line": 1,
4249 |             "column": 0
4250 |           },
4251 |           "end": {
4252 |             "line": 1,
4253 |             "column": 15
4254 |           }
4255 |         },
4256 |         "openingElement": {
4257 |           "type": "JSXOpeningElement",
4258 |           "start": 0,
4259 |           "end": 3,
4260 |           "loc": {
4261 |             "start": {
4262 |               "line": 1,
4263 |               "column": 0
4264 |             },
4265 |             "end": {
4266 |               "line": 1,
4267 |               "column": 3
4268 |             }
4269 |           },
4270 |           "attributes": [],
4271 |           "name": {
4272 |             "type": "JSXIdentifier",
4273 |             "start": 1,
4274 |             "end": 2,
4275 |             "loc": {
4276 |               "start": {
4277 |                 "line": 1,
4278 |                 "column": 1
4279 |               },
4280 |               "end": {
4281 |                 "line": 1,
4282 |                 "column": 2
4283 |               }
4284 |             },
4285 |             "name": "A"
4286 |           },
4287 |           "selfClosing": false
4288 |         },
4289 |         "closingElement": {
4290 |           "type": "JSXClosingElement",
4291 |           "start": 11,
4292 |           "end": 15,
4293 |           "loc": {
4294 |             "start": {
4295 |               "line": 1,
4296 |               "column": 11
4297 |             },
4298 |             "end": {
4299 |               "line": 1,
4300 |               "column": 15
4301 |             }
4302 |           },
4303 |           "name": {
4304 |             "type": "JSXIdentifier",
4305 |             "start": 13,
4306 |             "end": 14,
4307 |             "loc": {
4308 |               "start": {
4309 |                 "line": 1,
4310 |                 "column": 13
4311 |               },
4312 |               "end": {
4313 |                 "line": 1,
4314 |                 "column": 14
4315 |               }
4316 |             },
4317 |             "name": "A"
4318 |           }
4319 |         },
4320 |         "children": [
4321 |           {
4322 |             "type": "JSXText",
4323 |             "start": 3,
4324 |             "end": 6,
4325 |             "loc": {
4326 |               "start": {
4327 |                 "line": 1,
4328 |                 "column": 3
4329 |               },
4330 |               "end": {
4331 |                 "line": 1,
4332 |                 "column": 6
4333 |               }
4334 |             },
4335 |             "value": "foo",
4336 |             "raw": "foo"
4337 |           },
4338 |           {
4339 |             "type": "JSXExpressionContainer",
4340 |             "start": 6,
4341 |             "end": 11,
4342 |             "loc": {
4343 |               "start": {
4344 |                 "line": 1,
4345 |                 "column": 6
4346 |               },
4347 |               "end": {
4348 |                 "line": 1,
4349 |                 "column": 11
4350 |               }
4351 |             },
4352 |             "expression": {
4353 |               "type": "Literal",
4354 |               "start": 7,
4355 |               "end": 10,
4356 |               "loc": {
4357 |                 "start": {
4358 |                   "line": 1,
4359 |                   "column": 7
4360 |                 },
4361 |                 "end": {
4362 |                   "line": 1,
4363 |                   "column": 10
4364 |                 }
4365 |               },
4366 |               "value": "}",
4367 |               "raw": "\"}\""
4368 |             }
4369 |           }
4370 |         ]
4371 |       }
4372 |     }
4373 |   ]
4374 | });
4375 | test('<A>foo&rbrace;</A>', {
4376 |   "type": "Program",
4377 |   "start": 0,
4378 |   "end": 18,
4379 |   "body": [
4380 |     {
4381 |       "type": "ExpressionStatement",
4382 |       "start": 0,
4383 |       "end": 18,
4384 |       "expression": {
4385 |         "type": "JSXElement",
4386 |         "start": 0,
4387 |         "end": 18,
4388 |         "openingElement": {
4389 |           "type": "JSXOpeningElement",
4390 |           "start": 0,
4391 |           "end": 3,
4392 |           "attributes": [],
4393 |           "name": {
4394 |             "type": "JSXIdentifier",
4395 |             "start": 1,
4396 |             "end": 2,
4397 |             "name": "A"
4398 |           },
4399 |           "selfClosing": false
4400 |         },
4401 |         "closingElement": {
4402 |           "type": "JSXClosingElement",
4403 |           "start": 14,
4404 |           "end": 18,
4405 |           "name": {
4406 |             "type": "JSXIdentifier",
4407 |             "start": 16,
4408 |             "end": 17,
4409 |             "name": "A"
4410 |           }
4411 |         },
4412 |         "children": [
4413 |           {
4414 |             "type": "JSXText",
4415 |             "start": 3,
4416 |             "end": 14,
4417 |             "value": "foo&rbrace;",
4418 |             "raw": "foo&rbrace;"
4419 |           }
4420 |         ]
4421 |       }
4422 |     }
4423 |   ]
4424 | });
4425 | test('<A>foo{">"}</A>', {
4426 |   "type": "Program",
4427 |   "start": 0,
4428 |   "end": 15,
4429 |   "loc": {
4430 |     "start": {
4431 |       "line": 1,
4432 |       "column": 0
4433 |     },
4434 |     "end": {
4435 |       "line": 1,
4436 |       "column": 15
4437 |     }
4438 |   },
4439 |   "body": [
4440 |     {
4441 |       "type": "ExpressionStatement",
4442 |       "start": 0,
4443 |       "end": 15,
4444 |       "loc": {
4445 |         "start": {
4446 |           "line": 1,
4447 |           "column": 0
4448 |         },
4449 |         "end": {
4450 |           "line": 1,
4451 |           "column": 15
4452 |         }
4453 |       },
4454 |       "expression": {
4455 |         "type": "JSXElement",
4456 |         "start": 0,
4457 |         "end": 15,
4458 |         "loc": {
4459 |           "start": {
4460 |             "line": 1,
4461 |             "column": 0
4462 |           },
4463 |           "end": {
4464 |             "line": 1,
4465 |             "column": 15
4466 |           }
4467 |         },
4468 |         "openingElement": {
4469 |           "type": "JSXOpeningElement",
4470 |           "start": 0,
4471 |           "end": 3,
4472 |           "loc": {
4473 |             "start": {
4474 |               "line": 1,
4475 |               "column": 0
4476 |             },
4477 |             "end": {
4478 |               "line": 1,
4479 |               "column": 3
4480 |             }
4481 |           },
4482 |           "attributes": [],
4483 |           "name": {
4484 |             "type": "JSXIdentifier",
4485 |             "start": 1,
4486 |             "end": 2,
4487 |             "loc": {
4488 |               "start": {
4489 |                 "line": 1,
4490 |                 "column": 1
4491 |               },
4492 |               "end": {
4493 |                 "line": 1,
4494 |                 "column": 2
4495 |               }
4496 |             },
4497 |             "name": "A"
4498 |           },
4499 |           "selfClosing": false
4500 |         },
4501 |         "closingElement": {
4502 |           "type": "JSXClosingElement",
4503 |           "start": 11,
4504 |           "end": 15,
4505 |           "loc": {
4506 |             "start": {
4507 |               "line": 1,
4508 |               "column": 11
4509 |             },
4510 |             "end": {
4511 |               "line": 1,
4512 |               "column": 15
4513 |             }
4514 |           },
4515 |           "name": {
4516 |             "type": "JSXIdentifier",
4517 |             "start": 13,
4518 |             "end": 14,
4519 |             "loc": {
4520 |               "start": {
4521 |                 "line": 1,
4522 |                 "column": 13
4523 |               },
4524 |               "end": {
4525 |                 "line": 1,
4526 |                 "column": 14
4527 |               }
4528 |             },
4529 |             "name": "A"
4530 |           }
4531 |         },
4532 |         "children": [
4533 |           {
4534 |             "type": "JSXText",
4535 |             "start": 3,
4536 |             "end": 6,
4537 |             "loc": {
4538 |               "start": {
4539 |                 "line": 1,
4540 |                 "column": 3
4541 |               },
4542 |               "end": {
4543 |                 "line": 1,
4544 |                 "column": 6
4545 |               }
4546 |             },
4547 |             "value": "foo",
4548 |             "raw": "foo"
4549 |           },
4550 |           {
4551 |             "type": "JSXExpressionContainer",
4552 |             "start": 6,
4553 |             "end": 11,
4554 |             "loc": {
4555 |               "start": {
4556 |                 "line": 1,
4557 |                 "column": 6
4558 |               },
4559 |               "end": {
4560 |                 "line": 1,
4561 |                 "column": 11
4562 |               }
4563 |             },
4564 |             "expression": {
4565 |               "type": "Literal",
4566 |               "start": 7,
4567 |               "end": 10,
4568 |               "loc": {
4569 |                 "start": {
4570 |                   "line": 1,
4571 |                   "column": 7
4572 |                 },
4573 |                 "end": {
4574 |                   "line": 1,
4575 |                   "column": 10
4576 |                 }
4577 |               },
4578 |               "value": ">",
4579 |               "raw": "\">\""
4580 |             }
4581 |           }
4582 |         ]
4583 |       }
4584 |     }
4585 |   ]
4586 | });
4587 | test('<A>foo&gt;</A>', {
4588 |   "type": "Program",
4589 |   "start": 0,
4590 |   "end": 14,
4591 |   "body": [
4592 |     {
4593 |       "type": "ExpressionStatement",
4594 |       "start": 0,
4595 |       "end": 14,
4596 |       "expression": {
4597 |         "type": "JSXElement",
4598 |         "start": 0,
4599 |         "end": 14,
4600 |         "openingElement": {
4601 |           "type": "JSXOpeningElement",
4602 |           "start": 0,
4603 |           "end": 3,
4604 |           "attributes": [],
4605 |           "name": {
4606 |             "type": "JSXIdentifier",
4607 |             "start": 1,
4608 |             "end": 2,
4609 |             "name": "A"
4610 |           },
4611 |           "selfClosing": false
4612 |         },
4613 |         "closingElement": {
4614 |           "type": "JSXClosingElement",
4615 |           "start": 10,
4616 |           "end": 14,
4617 |           "name": {
4618 |             "type": "JSXIdentifier",
4619 |             "start": 12,
4620 |             "end": 13,
4621 |             "name": "A"
4622 |           }
4623 |         },
4624 |         "children": [
4625 |           {
4626 |             "type": "JSXText",
4627 |             "start": 3,
4628 |             "end": 10,
4629 |             "value": "foo>",
4630 |             "raw": "foo&gt;"
4631 |           }
4632 |         ]
4633 |       }
4634 |     }
4635 |   ]
4636 | });
4637 | test('function*it(){yield <a></a>}', {
4638 |   "type": "Program",
4639 |   "start": 0,
4640 |   "end": 28,
4641 |   "body": [
4642 |     {
4643 |       "type": "FunctionDeclaration",
4644 |       "start": 0,
4645 |       "end": 28,
4646 |       "id": {
4647 |         "type": "Identifier",
4648 |         "start": 9,
4649 |         "end": 11,
4650 |         "name": "it"
4651 |       },
4652 |       "expression": false,
4653 |       "generator": true,
4654 |       "async": false,
4655 |       "params": [],
4656 |       "body": {
4657 |         "type": "BlockStatement",
4658 |         "start": 13,
4659 |         "end": 28,
4660 |         "body": [
4661 |           {
4662 |             "type": "ExpressionStatement",
4663 |             "start": 14,
4664 |             "end": 27,
4665 |             "expression": {
4666 |               "type": "YieldExpression",
4667 |               "start": 14,
4668 |               "end": 27,
4669 |               "delegate": false,
4670 |               "argument": {
4671 |                 "type": "JSXElement",
4672 |                 "start": 20,
4673 |                 "end": 27,
4674 |                 "openingElement": {
4675 |                   "type": "JSXOpeningElement",
4676 |                   "start": 20,
4677 |                   "end": 23,
4678 |                   "attributes": [],
4679 |                   "name": {
4680 |                     "type": "JSXIdentifier",
4681 |                     "start": 21,
4682 |                     "end": 22,
4683 |                     "name": "a"
4684 |                   },
4685 |                   "selfClosing": false
4686 |                 },
4687 |                 "closingElement": {
4688 |                   "type": "JSXClosingElement",
4689 |                   "start": 23,
4690 |                   "end": 27,
4691 |                   "name": {
4692 |                     "type": "JSXIdentifier",
4693 |                     "start": 25,
4694 |                     "end": 26,
4695 |                     "name": "a"
4696 |                   }
4697 |                 },
4698 |                 "children": []
4699 |               }
4700 |             }
4701 |           }
4702 |         ]
4703 |       }
4704 |     }
4705 |   ],
4706 |   "sourceType": "script"
4707 | });
4708 | 


--------------------------------------------------------------------------------
/test/tests-misc.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | 
 3 | if (typeof exports !== "undefined") {
 4 |   var assert = require("assert");
 5 |   var acorn = require("acorn");
 6 |   var jsx = require("..");
 7 |   var testAssert = require("./driver.js").testAssert;
 8 | }
 9 | 
10 | testAssert("// the enhanced Parser instance should have a static property 'acornJsx'.", function() {
11 |   const JsxParser = acorn.Parser.extend(jsx());
12 |   assert(JsxParser.acornJsx);
13 | });
14 | 
15 | testAssert("// 'acornJsx' should be the same instance for the same acorn.", function() {
16 |   const JsxParser1 = acorn.Parser.extend(jsx());
17 |   const JsxParser2 = acorn.Parser.extend(jsx());
18 |   assert.strictEqual(JsxParser1.acornJsx, JsxParser2.acornJsx);
19 | });
20 | 
21 | testAssert("// the static property 'acornJsx' should have two properties.", function() {
22 |   const JsxParser = acorn.Parser.extend(jsx());
23 |   assert(JsxParser.acornJsx.tokTypes, "should have 'tokTypes'.");
24 |   assert(JsxParser.acornJsx.tokContexts, "should have 'tokContexts'.");
25 | });
26 | 
27 | testAssert("// 'acornJsx.tokTypes' should be used.", function() {
28 |   const JsxParser = acorn.Parser.extend(jsx());
29 |   const code = '<a>{/* foo */}</a>';
30 |   const expectedTokTypes = [
31 |     JsxParser.acornJsx.tokTypes.jsxTagStart,
32 |     JsxParser.acornJsx.tokTypes.jsxName,
33 |     JsxParser.acornJsx.tokTypes.jsxTagEnd,
34 |     acorn.tokTypes.braceL,
35 |     acorn.tokTypes.braceR,
36 |     JsxParser.acornJsx.tokTypes.jsxTagStart,
37 |     acorn.tokTypes.slash,
38 |     JsxParser.acornJsx.tokTypes.jsxName,
39 |     JsxParser.acornJsx.tokTypes.jsxTagEnd,
40 |     acorn.tokTypes.eof
41 |   ]
42 |   const actualTokens = []
43 | 
44 |   JsxParser.parse(code, {ecmaVersion: 11, onToken: actualTokens})
45 | 
46 |   assert.strictEqual(actualTokens.length, expectedTokTypes.length);
47 |   for (let i = 0; i < actualTokens.length; ++i) {
48 |     assert.strictEqual(actualTokens[i].type, expectedTokTypes[i]);
49 |   }
50 | });
51 | 


--------------------------------------------------------------------------------
/xhtml.js:
--------------------------------------------------------------------------------
  1 | module.exports = {
  2 |   quot: '\u0022',
  3 |   amp: '&',
  4 |   apos: '\u0027',
  5 |   lt: '<',
  6 |   gt: '>',
  7 |   nbsp: '\u00A0',
  8 |   iexcl: '\u00A1',
  9 |   cent: '\u00A2',
 10 |   pound: '\u00A3',
 11 |   curren: '\u00A4',
 12 |   yen: '\u00A5',
 13 |   brvbar: '\u00A6',
 14 |   sect: '\u00A7',
 15 |   uml: '\u00A8',
 16 |   copy: '\u00A9',
 17 |   ordf: '\u00AA',
 18 |   laquo: '\u00AB',
 19 |   not: '\u00AC',
 20 |   shy: '\u00AD',
 21 |   reg: '\u00AE',
 22 |   macr: '\u00AF',
 23 |   deg: '\u00B0',
 24 |   plusmn: '\u00B1',
 25 |   sup2: '\u00B2',
 26 |   sup3: '\u00B3',
 27 |   acute: '\u00B4',
 28 |   micro: '\u00B5',
 29 |   para: '\u00B6',
 30 |   middot: '\u00B7',
 31 |   cedil: '\u00B8',
 32 |   sup1: '\u00B9',
 33 |   ordm: '\u00BA',
 34 |   raquo: '\u00BB',
 35 |   frac14: '\u00BC',
 36 |   frac12: '\u00BD',
 37 |   frac34: '\u00BE',
 38 |   iquest: '\u00BF',
 39 |   Agrave: '\u00C0',
 40 |   Aacute: '\u00C1',
 41 |   Acirc: '\u00C2',
 42 |   Atilde: '\u00C3',
 43 |   Auml: '\u00C4',
 44 |   Aring: '\u00C5',
 45 |   AElig: '\u00C6',
 46 |   Ccedil: '\u00C7',
 47 |   Egrave: '\u00C8',
 48 |   Eacute: '\u00C9',
 49 |   Ecirc: '\u00CA',
 50 |   Euml: '\u00CB',
 51 |   Igrave: '\u00CC',
 52 |   Iacute: '\u00CD',
 53 |   Icirc: '\u00CE',
 54 |   Iuml: '\u00CF',
 55 |   ETH: '\u00D0',
 56 |   Ntilde: '\u00D1',
 57 |   Ograve: '\u00D2',
 58 |   Oacute: '\u00D3',
 59 |   Ocirc: '\u00D4',
 60 |   Otilde: '\u00D5',
 61 |   Ouml: '\u00D6',
 62 |   times: '\u00D7',
 63 |   Oslash: '\u00D8',
 64 |   Ugrave: '\u00D9',
 65 |   Uacute: '\u00DA',
 66 |   Ucirc: '\u00DB',
 67 |   Uuml: '\u00DC',
 68 |   Yacute: '\u00DD',
 69 |   THORN: '\u00DE',
 70 |   szlig: '\u00DF',
 71 |   agrave: '\u00E0',
 72 |   aacute: '\u00E1',
 73 |   acirc: '\u00E2',
 74 |   atilde: '\u00E3',
 75 |   auml: '\u00E4',
 76 |   aring: '\u00E5',
 77 |   aelig: '\u00E6',
 78 |   ccedil: '\u00E7',
 79 |   egrave: '\u00E8',
 80 |   eacute: '\u00E9',
 81 |   ecirc: '\u00EA',
 82 |   euml: '\u00EB',
 83 |   igrave: '\u00EC',
 84 |   iacute: '\u00ED',
 85 |   icirc: '\u00EE',
 86 |   iuml: '\u00EF',
 87 |   eth: '\u00F0',
 88 |   ntilde: '\u00F1',
 89 |   ograve: '\u00F2',
 90 |   oacute: '\u00F3',
 91 |   ocirc: '\u00F4',
 92 |   otilde: '\u00F5',
 93 |   ouml: '\u00F6',
 94 |   divide: '\u00F7',
 95 |   oslash: '\u00F8',
 96 |   ugrave: '\u00F9',
 97 |   uacute: '\u00FA',
 98 |   ucirc: '\u00FB',
 99 |   uuml: '\u00FC',
100 |   yacute: '\u00FD',
101 |   thorn: '\u00FE',
102 |   yuml: '\u00FF',
103 |   OElig: '\u0152',
104 |   oelig: '\u0153',
105 |   Scaron: '\u0160',
106 |   scaron: '\u0161',
107 |   Yuml: '\u0178',
108 |   fnof: '\u0192',
109 |   circ: '\u02C6',
110 |   tilde: '\u02DC',
111 |   Alpha: '\u0391',
112 |   Beta: '\u0392',
113 |   Gamma: '\u0393',
114 |   Delta: '\u0394',
115 |   Epsilon: '\u0395',
116 |   Zeta: '\u0396',
117 |   Eta: '\u0397',
118 |   Theta: '\u0398',
119 |   Iota: '\u0399',
120 |   Kappa: '\u039A',
121 |   Lambda: '\u039B',
122 |   Mu: '\u039C',
123 |   Nu: '\u039D',
124 |   Xi: '\u039E',
125 |   Omicron: '\u039F',
126 |   Pi: '\u03A0',
127 |   Rho: '\u03A1',
128 |   Sigma: '\u03A3',
129 |   Tau: '\u03A4',
130 |   Upsilon: '\u03A5',
131 |   Phi: '\u03A6',
132 |   Chi: '\u03A7',
133 |   Psi: '\u03A8',
134 |   Omega: '\u03A9',
135 |   alpha: '\u03B1',
136 |   beta: '\u03B2',
137 |   gamma: '\u03B3',
138 |   delta: '\u03B4',
139 |   epsilon: '\u03B5',
140 |   zeta: '\u03B6',
141 |   eta: '\u03B7',
142 |   theta: '\u03B8',
143 |   iota: '\u03B9',
144 |   kappa: '\u03BA',
145 |   lambda: '\u03BB',
146 |   mu: '\u03BC',
147 |   nu: '\u03BD',
148 |   xi: '\u03BE',
149 |   omicron: '\u03BF',
150 |   pi: '\u03C0',
151 |   rho: '\u03C1',
152 |   sigmaf: '\u03C2',
153 |   sigma: '\u03C3',
154 |   tau: '\u03C4',
155 |   upsilon: '\u03C5',
156 |   phi: '\u03C6',
157 |   chi: '\u03C7',
158 |   psi: '\u03C8',
159 |   omega: '\u03C9',
160 |   thetasym: '\u03D1',
161 |   upsih: '\u03D2',
162 |   piv: '\u03D6',
163 |   ensp: '\u2002',
164 |   emsp: '\u2003',
165 |   thinsp: '\u2009',
166 |   zwnj: '\u200C',
167 |   zwj: '\u200D',
168 |   lrm: '\u200E',
169 |   rlm: '\u200F',
170 |   ndash: '\u2013',
171 |   mdash: '\u2014',
172 |   lsquo: '\u2018',
173 |   rsquo: '\u2019',
174 |   sbquo: '\u201A',
175 |   ldquo: '\u201C',
176 |   rdquo: '\u201D',
177 |   bdquo: '\u201E',
178 |   dagger: '\u2020',
179 |   Dagger: '\u2021',
180 |   bull: '\u2022',
181 |   hellip: '\u2026',
182 |   permil: '\u2030',
183 |   prime: '\u2032',
184 |   Prime: '\u2033',
185 |   lsaquo: '\u2039',
186 |   rsaquo: '\u203A',
187 |   oline: '\u203E',
188 |   frasl: '\u2044',
189 |   euro: '\u20AC',
190 |   image: '\u2111',
191 |   weierp: '\u2118',
192 |   real: '\u211C',
193 |   trade: '\u2122',
194 |   alefsym: '\u2135',
195 |   larr: '\u2190',
196 |   uarr: '\u2191',
197 |   rarr: '\u2192',
198 |   darr: '\u2193',
199 |   harr: '\u2194',
200 |   crarr: '\u21B5',
201 |   lArr: '\u21D0',
202 |   uArr: '\u21D1',
203 |   rArr: '\u21D2',
204 |   dArr: '\u21D3',
205 |   hArr: '\u21D4',
206 |   forall: '\u2200',
207 |   part: '\u2202',
208 |   exist: '\u2203',
209 |   empty: '\u2205',
210 |   nabla: '\u2207',
211 |   isin: '\u2208',
212 |   notin: '\u2209',
213 |   ni: '\u220B',
214 |   prod: '\u220F',
215 |   sum: '\u2211',
216 |   minus: '\u2212',
217 |   lowast: '\u2217',
218 |   radic: '\u221A',
219 |   prop: '\u221D',
220 |   infin: '\u221E',
221 |   ang: '\u2220',
222 |   and: '\u2227',
223 |   or: '\u2228',
224 |   cap: '\u2229',
225 |   cup: '\u222A',
226 |   'int': '\u222B',
227 |   there4: '\u2234',
228 |   sim: '\u223C',
229 |   cong: '\u2245',
230 |   asymp: '\u2248',
231 |   ne: '\u2260',
232 |   equiv: '\u2261',
233 |   le: '\u2264',
234 |   ge: '\u2265',
235 |   sub: '\u2282',
236 |   sup: '\u2283',
237 |   nsub: '\u2284',
238 |   sube: '\u2286',
239 |   supe: '\u2287',
240 |   oplus: '\u2295',
241 |   otimes: '\u2297',
242 |   perp: '\u22A5',
243 |   sdot: '\u22C5',
244 |   lceil: '\u2308',
245 |   rceil: '\u2309',
246 |   lfloor: '\u230A',
247 |   rfloor: '\u230B',
248 |   lang: '\u2329',
249 |   rang: '\u232A',
250 |   loz: '\u25CA',
251 |   spades: '\u2660',
252 |   clubs: '\u2663',
253 |   hearts: '\u2665',
254 |   diams: '\u2666'
255 | };
256 | 


--------------------------------------------------------------------------------