diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..f699b4ec
Binary files /dev/null and b/.DS_Store differ
diff --git a/README.md b/README.md
index 71a9296d..ee68ea7f 100644
--- a/README.md
+++ b/README.md
@@ -1,112 +1,166 @@
-# CIS700 Procedural Graphics: Final Project
+# Voxel Run: Procedural Graphics Final Project
-Time to show off your new bag of procedural tricks by creating one polished final project. For this assignment you will have four weeks to create and document a portfolio piece that demonstrates your mastery of procedural thinking and implementation. You may work in groups of up to three (working alone is fine too). You may use any language / platform you choose for this assignment (given our approval if it’s not JavaScript/WebGL or C++/OpenGL).
+## Design Document:
-As usual with this class, we want to encourage you to take this opportunity to explore and experiment. To get you started, however, we’ve provided a few open-ended prompts below. Interesting and complex visuals are the goal in all of these prompts, but they encourage focus on different aspects of proceduralism.
+ - ### Introduction
+ * Always wanted to make a technically challenging and aesthetically pleasing puzzle game. Had this game idea written down, and has been sitting there for a solid year or so. Want to actually make this game happen.
-## Prompts:
+ - ### Goal
+ * Create a challenging, addictive, isometric puzzle game using simple geometry and gradient colors.
-- ### A classic 4k demo
- * In the spirit of the demo scene, create an animation that fits into a 4k executable that runs in real-time. Feel free to take inspiration from the many existing demos. Focus on efficiency and elegance in your implementation.
- * Examples: [cdak by Quite & orange](https://www.youtube.com/watch?v=RCh3Q08HMfs&list=PLA5E2FF8E143DA58C)
+ - ### Inspiration
+ * Monument Valley
-- ### A forgery
- * Taking inspiration from a particular natural phenomenon or distinctive set of visuals, implement a detailed, procedural recreation of that aesthetic. This includes modeling, texturing and object placement within your scene. Does not need to be real-time. Focus on detail and visual accuracy in your implementation.
- * Examples:
- - [Snail](https://www.shadertoy.com/view/ld3Gz2), [Journey](https://www.shadertoy.com/view/ldlcRf), Big Hero 6 Wormhole: [Image 1](http://2.bp.blogspot.com/-R-6AN2cWjwg/VTyIzIQSQfI/AAAAAAAABLA/GC0yzzz4wHw/s1600/big-hero-6-disneyscreencaps.com-10092.jpg) , [Image 2](https://i.stack.imgur.com/a9RGL.jpg)
+ 
+
+ * Euclidean Lands
-- ### A game level
- * Like generations of game makers before us, create a game which generates an navigable environment (eg. a roguelike dungeon, platforms) and some sort of goal or conflict (eg. enemy agents to avoid or items to collect). Must run in real-time. Aim to create an experience that will challenge players and vary noticeably in different playthroughs, whether that means complex dungeon generation, careful resource management or a sophisticated AI model. Focus on designing a system that will generate complex challenges and goals.
- * Examples: Spore, Dwarf Fortress, Minecraft, Rogue
+ 
-- ### An animated environment / music visualizer
- * Create an environment full of interactive procedural animation. The goal of this project is to create an environment that feels responsive and alive. Whether or not animations are musically-driven, sound should be an important component. Focus on user interactions, motion design and experimental interfaces.
- * Examples: [Panoramical](https://www.youtube.com/watch?v=gBTTMNFXHTk), [Bound](https://www.youtube.com/watch?v=aE37l6RvF-c)
-- ### Own proposal
- * You are of course **welcome to propose your own topic**. Regardless of what you choose, you and your team must research your topic and relevant techniques and come up with a detailed plan of execution. You will meet with some subset of the procedural staff before starting implementation for approval.
+ * Skyward
+
+ 
-**Final grading will be individual** and will be based on both the final product and how well you were able to achieve your intended effect according to your execution plan. Plans change of course, and we don’t expect you to follow your execution plan to a T, but if your final project looks pretty good, but you cut corners and only did 30% of what you outlined in your design doc, you will be penalized.
+ - ### Specification
+ * This procedurally-generated puzzle game has a simple objective: flip a cube from grid cell to grid cell until you reach the finish cell. Each grid cell can be one of six colors corresponding to the six distinct face colors of the cube. What makes this game challenging is that the current cell the cube is on must have the same color as the bottom face of the cube. Once the cube lands on a grid cell, the cell color turns grey and the player cannot go back. There will only be one path to the finish, so the player must plan his or her moves accordingly.
-But overall, have fun! This is your opportunity to work on whatever procedural project inspires you. The best way to ensure a good result is to pick something you’re passionate about. :)
+ - ### Techniques
+ * The main technical challenge is generating each level. I have to make sure that each level has only one solution, and the path from start to finish is not a simple and straightforward line. In order to check that each level has only one solution, the alternative and incorrect paths cannot cannot provide the cube a way to walk back on the correct path. In a sense, this is a graph theory problem, where each vertex is a grid cell, and each edge is a possible path from grid cell to grid cell. As long as there are no cycles, there can only be one solution. Generating a windy and complicated solution is another beast to handle. Currently considering a Perlin Worms algorithm to generate the solution to each level, but this is subject to change. As the levels progress, the grid size will become bigger, making the level much harder. However, my algorithm should be flexible enough to generate a reasonable path for each grid size.
-## Timeline
+ - ### Structure
+ * Player Class: Class containing the state of the player, including the six faces and the direction the cube is facing.
+ * Grid Class: Class containing the grid of grid cells, and a level generator to compute a reasonable puzzle for the player.
+ * Main Class: Puts Cube and Grid class together, orchestrating the interaction between the two classes.
-- 4/08 Design doc due / Have met with procedural staff
-- 4/18 Milestone 1 (short write-up + demo)
-- 4/25 Milestone 2 (short write-up + demo)
-- 5/3 Final presentations (3-5 pm, Siglab), final reports due
+ - ### Timeline
+ * April 18, 2017: Finish setting up the player and grid, be able to generate a path from start to finish, but do not have to fill in alternative paths yet.
+ * April 25, 2017: Finish level generator with only a single solution to each level. Alternative, incorrect paths should be misleading to make the game difficult.
+ * May 3, 2017: Polishing up the project. Fixing bugs, adding sound effects and animation, adjusting color pallette and aesthetics.
-## Design Doc
+## Milestones:
-Your design doc should follow the following template. Note, each section can be pretty short, but cover them all! This will serve as valuable documentation when showing this project off in the future AND doing a good job will make it much easier for you to succeed, so please take this seriously.
+ - ### Milestone 1
+ * Finished setting up the player and grid class, where the player is able to rotate the cube using the arrow keys. For the player class, ran into the same problem with the turtle class in L-Systems project, where rotating the turtle using rotation.x, rotation.y, rotation.z has some issues. Still have to fix this by using quaternions instead. For the grid class, used Depth First Search to generate the whole level, instead of generating one single path. This part is currently operating, but will add more complexity to the Depth First Search level generation to make it more interesting.
-### Design Doc Template:
+ - ### Milestone 2
+ * Fixed cube rotation by using quaternions instead of mesh.rotation. Found out that it is because there is a local rotation and world rotation for each THREE.Mesh that can be easily mixed up. Better to just use matricies in a scene graph style. Adjusted camera placement so that it is centered at the grid center, no matter what the dimensions of the grid is. Made multiple checks so that the cube can only flip if the color of the cube face that is going to face down matches the grid cell color. Added levels, where after crossing the finish cell, a new level appears with an increase in grid dimension. Realized that the plain Depth First Search level generation is too simple because on the edge of the grid, there is a 50 percent chance that it remains on the edge of the grid. Often the level generated has an easy path along the edge to the finish cell. Added a Gaussian Distribution Function to weigh the cells closer to the center more, so that the Depth First Search generator tends to go toward the center, making the level more complicated.
-- #### Introduction
- * What motivates this project?
-- #### Goal
- * What do you intend to achieve with this project?
-- #### Inspiration/reference:
- * Attach some materials, visual or otherwise you intend as reference
-- #### Specification:
- * Outline the main features of your project
-- #### Techniques:
- * What are the main technical/algorithmic tools you’ll be using? Give an overview, citing specific papers/articles
-- #### Design:
- * How will your program fit together? Make a simple free-body diagram illustrating the pieces.
-- #### Timeline:
- * Create a week-by-week set of milestones for each person in your group.
+ - ### Milestone 3
+ * Added a finish cell cube, or else a new player of the game doesn't know where the finish line is. Realized that the Depth First Search and Gaussian Distribution function level generator still does not work quite as expected. Now the level generator tends to go in a snake path, toward the center of the grid, then toward the edge, then toward the center again. Added a "throughput" that starts off as 1.0 and slowly decreases to 0.0 the more often the generator walks straight. This makes the paths generated more twisty and complicated. Added animation so that, to the player, it makes sense how the cube is flipping. Used a gain function to make the animation more realistic and lively. Added sound effects so that when the cube impacts on the ground, there is a "thump," and also added dream-like background music. Used raymarching so that the user no longer has to use arrow keys to move the cube. Instead, the user can use his or her mouse to select the grid cell to move to. Used cosine waves to procedurally generate the color for each level.
+ - ### Final Tweaks
+ * Changed the color of the raymarching grid cell selection depending if it is a movable grid cell or not. Realized that the game is too easy because the player can always move back if he makes a mistake, and there is no game over case. Made it so that once the user steps off a grid cell, the grid cell falls into an abyss. No more take-back-sies. If the user is stuck, he or she must take his or her own life by jumping into the abyss. Then it is game over. Added a start menu and game over screen so that there actually is a clear/definite start and end to the game. Made it so that not only does the grid dimension increase as the levels get harder, but also adjusted the throughput value so that the level generated paths are more twisty as the levels get harder. Changed the camera from orthographic to perspective in order to give depth to the grid cells falling.
-Along with your final project demo, you will submit a final report, in which you will update correct your original design doc as needed and add a few post-mortem items.
+## Final Report
-## Milestones
+ - ### Introduction
+ * I always wanted to make a technically challenging, yet aesthetically pleasing puzzle game. I had this particular game idea written down, and it had been sitting on my desk for a solid year or so. Took this procedural final project as an opportunity to make this game actually happen and come to life.
-To keep you honest / on-track, we will be checking on your progress at weekly intervals, according to milestones you’ll define at the outset (pending our approval). For each of the two milestones prior to the final submission, you will submit a short write up explaining whether or not you individually achieved your goals (specifying the files where the work happened), along with a link to a demo / images. These don’t have to be super polished -- we just want to see that you’re getting things done.
+ - ### Goal
+ * Create a challenging, addictive, isometric puzzle game using simple geometry and gradient colors.
-Example:
+ - ### Inspiration
+ * Monument Valley
-“Milestone 1:
- Adam:
-Made some procedural terrain code in src/terrain.js. Implemented 3D simplex noise to do it. Also applied coloring via custom shader based on this cool paper X (see src/shaders/dirt.glsl). IMAGE
+ 
+
+ * Euclidean Lands
-Austin:
-I managed to set up my voronoi diagram shader (see src/shaders/voronoi.glsl).
-Experimented with different scattering techniques. It’s working with the euclidean distance metric. I’m using it in src/main.js to color stones. IMAGE
+ 
-Rachel:
-I tried really hard to make my toon shader work (src/shaders/toon.glsl), but I still have a bug! T_T BUGGY IMAGE. DEMO LINK”
+ * Skyward
+
+ 
-## Final Report
+ - ### Specification
+ * This procedurally-generated puzzle game has a simple objective: flip a cube from grid cell to grid cell until you reach the finish cell. Each grid cell can be one of six colors corresponding to the six distinct face colors of the cube. What makes this game challenging is that the current grid cell the cube is on must have the same color as the bottom face of the cube. Once the cube lands on a grid cell, the previous grid cell falls into an abyss and the player cannot go back. The player must plan his or her moves accordingly. In essence, this game is a maze without walls.
+
+ - ### Techniques
+ * Level Generation:
+ * Started off with a Depth First Search level generation algorithm where a simulated cube walks on a random path until all its neighboring grid cells are visited. Then the cube takes a step back, and checks if there are any neighboring grid cells that are not visited. If so, the cube walks on a random path again. This repeats until the simulated cube reaches its starting position. An emergent behavior that came out of this algorithm was that very frequently, a generated path would continue along the edge of the grid. This is because on an edge of a grid, there are only two possible directions the simulated cube can move: along the edge again, or toward the center of the grid. Since I weighed both choices equally, a grid-edge path was very common. In order to fix this, I tried using a Gaussian Distribution Function to weigh the choices of the simulated cube unequally; the grid cells near the center of the grid will have higher probability of being chosen. I picked the variance based on the empirical rule of the normal distribution, where the grid dimensions span from (mean-2sigma) to (mean+2sigma).
+
+ 
+
+ 
+
+ * I ran into another problem with this modification of the Depth First Search level generation algorithm. Because I picked such a large variance, the probability of the center grid cells is significantly higher than the edge grid cells. This ended up causing my simulated cube to walk straight toward the center of the grid, then around the center of the grid until there are no more unvisited grid cells, then along the grid edges. Again, grid-edge paths became very common. I decided to pick a smaller variance and this fixed the problem.
+
+ * The next emergent behavior I noticed was that the paths generated were too straight. I applied what I learned in Advanced Computer Graphics of a throughput variable that starts off at 1.0 and decreases over time to 0.0. Now, every time the simulated cube walks in the same direction as the previous step, the throughput variable is decreased by a factor of 0.5 and then multipled to the probability of the upcoming same-direction grid cell choice. In other words, the more consecutive straightforward steps the simulated cube takes, the least likely the next step will be straightforwarc. I later realized that depending on the throughput factor, the paths can be more or less twisty. I decided to have a smaller throughput factor at the start of the game and slowly increase it in each proceeding level.
+
+ * My original worry of making sure the player cannot cross though "walls" between generated paths quickly disappeared after I realized that even though the player can cross through "walls," it is very unlikely for the player to continue along the crossed path because the cube must be in a certain orientation/rotation. What I mean by this is that the bottom face of the cube may match with the grid cell after crossing through a "wall," but there are 4 possible ways the cube can be orientated, and only one orientation can allow the player to continue to move along the crossed path. And even if the player can move along the crossed path, the crossed path does not necessairly lead to the finish cell. As a result, I chose to ignore this case because it actually benefits my game by adding an extra layer of complexity: 3 out of the 4 times crossinb through a "wall" will lead to a dead end due to the incorrect orientation of the cube.
+
+ * Color:
+ * Originally, I was hand-picking color gradients using IQ's idea of a color palette based on three cosine functions corresponding to R, G, and B. However, this limited the possibilities of color to a finite, hand-picked amount. I thought to myself, since R, G, and B are represented as cosine functions anyway, why not generate the color procedurally? I first decided what general color the procedurally generated gradients should be. Basing my decision on the computer graphics concept of a yellow key light (from sun), and a blue fill light (from sky), I wanted the grid colors to have a general red to yellow gradient since the background was nice shade of blue already. Playing around with the equations, I noticed that the R and G cosine functions should be similar, but not equivalent in phase to produce a yellow shade. The R and G cosine functions should have high amplitude so that there is a visible change in color gradient, or else the 6 face colors of the cube will be too similar in hue. The B cosine function should generally be close to 0.1 because when B is too high, it causes the red to turn purple and yellow to turn brown, and when B is 0, the shades of red and yellow do not seem realistic enough (there is no such thing as perfectly red/green with no blue in real life). I also made sure that the R, G, and B functions do not get exceed the 0 to 1 range given the y-displacement and amplitude because this will cause some section of the color gradient to receive a consistent contribution of R, G, or B, making the gradient sections less distinctive for the 6 face colors. Here is a visualization of how my procedural color gradient generator looks like:
+
+ 
+
+ * Animation:
+ * In order for the cube rotations to make sense in the eyes of the viewer, there should be animation. The cube shouldn't "jump" from grid cell to grid cell. Rather, there should be some smooth transition. I originally thought of LERPing the start and final positions of the cube flip, and SLURPing the start and final quaternion rotations of the cube flip. To my surprise, the cube center does not remain at the same height when flipped, thus LERPing the start and final positions (which are at the same y height) would not work.
+
+ 
+
+ * SLURPing the start and final quaternions works for rotation about the center of an object, but SLURPING at an axis of rotation that is not the cube center (but a cube edge) requires extra translation transformation. I decided to manually use a T*R*T matrix transformation every time onUpdate is called, where the R matrix is a SLURP of the two quaternions. After getting the animation to work, I felt as though something was missing. The cube did not have character. I decided to add a Toolbox Function I learned, the gain function, to distort the speed at which the cube rotates, given a certain t value between 0 and 1. The first GIF below is an animation of a cube WITHOUT the gain function applied, and the second GIF below is an animation of a cube WITH the gain function.
+
+ 
+
+ 
+
+ * Raymarching:
+ * Originally I thought that fixing the camera rotation to a specific angle and allowing the user to view the back faces of the cube by hovering over the cube with a mouse was a good idea. That way, the arrow keys can stay in the same orientation. My good ol' pal Adam suggested to use ray marching to select a grid cell to move the cube instead. Then the user can rotate the grid to his or her discretion, while viewing all sides of the cube. That was a great idea. Thanks Adam! In the onUpdate function, I raymarch a ray originating at the mouse with a direction of the camera forward vector to find the closest intersected object. If the intersected object is a grid cell, then I highlight the top face light gray or dark gray, depending on if it is a valid move or not.
+
+ 
+
+ - ### Structure
+ * Player Class: Class containing the state of the player, including the six faces and the direction the cube is facing.
+ * Grid Class: Class containing the grid of grid cells, and a level generator to compute a reasonable puzzle for the player.
+ * Main Class: Puts Cube and Grid class together, orchestrating the interaction between the two classes. Also handles the logic for the game.
+
+ - ### Timeline
+ * April 18, 2017: Finish setting up the player and grid, be able to generate a path from start to finish, but do not have to fill in alternative paths yet.
+ * April 25, 2017: Finish level generator with only a single solution to each level. Alternative, incorrect paths should be misleading to make the game difficult.
+ * May 3, 2017: Polishing up the project. Fixing bugs, adding sound effects and animation, adjusting color pallette and aesthetics.
+
+ - ### Results:
+
+ 
+
+ 
+
+ 
+
+ - ### Evaluation:
+ * Overall, I feel like I have come a long way. I started this project thinking it will be almost impossible to generate the types of levels I imagined, but I took clever approaches and applied a lot of what I learned to solve difficult situations, such as keeping track of which face color is facing which direction in the world without the need of a rotation matrix but only 6 variables, fixing the unwanted emergent behavior of the Depth First Search level generator, and applying color and toolbox functions to make the game more aesthetically pleasing.
+
+ There were many tweaks that had to be made throughout the process. I changed the camera from orthographic to perspective in order to give depth to the falling grid cells, added a finish cube or else a new player doesn't know where the finish line is, used raymarching so that the user no longer has to use arrow keys to move the cube, used cosine waves to procedurally generate the color for each level, and changed the color of the raymarching grid cell selection depending if it is a movable grid cell or not. I also realized that the game is too easy because the player can always move back if he makes a mistake, and there is no game over case. I then made it so that once the user steps off a grid cell, the grid cell falls into an abyss. No more take-back-sies. If the user is stuck, he or she must take his or her own life by jumping into the abyss. Then it is game over. I also added a start menu and game over screen so that there actually is a clear/definite start and end to the game. Lastly, I modified the game design so that not only does the grid dimension increase as the levels get harder, but throughput factor decreases so that the level generated paths are more twisty as the levels get harder.
+
+ 
-In addition to your demo, you will create a final report documenting your project overall. This document should be clear enough to explain the value and details of your project to a random computer graphics person with no knowledge of this class.
+ 
-### Final Report Template:
+ - ### Future work:
+ * Given more time, I would add more complexity to the game, such as not only making the level a 2D grid. Instead, the cube can walk on walls and ceilings, as long as the cube face colors are matching both surfaces at the corner of the wall. In addition, I would want to add a way for users to keep track of their thought process, such as being able to add "flags" on the grid surface, similar to Minesweeper. This would keep the interest of the players rather than having them give up when the grid dimension becomes too big.
-- #### Updated design doc:
- * All the sections of your original design doc, corrected if necessary
-- #### Results:
- * Provide images of your finished project
-- #### Evaluation (this is a big one!):
- * How well did you do? What parameters did you tune along the way? Include some WIP shots that compare intermediate results to your final. Explain why you made the decisions you did.
-- #### Future work:
- * Given more time, what would you add/improve
-- #### Acknowledgements:
- * Cite _EVERYTHING_. Implemented a paper? Used some royalty-free music? Talked to classmates / a professor in a way that influenced your project? Attribute everything!
+ - ### Acknowledgements:
+ * Special thanks to Rachel Hwang, Adam Mally, Sally Kong, Trung Le, and Austin Eng for being so supportive throughout the semester, and especially throughout this project!
-## Logistics
+ * Gaussian Distribution
+ * https://en.wikipedia.org/wiki/Gaussian_function#Two-dimensional_Gaussian_function
+ * https://en.wikipedia.org/wiki/Normal_distribution#/media/File:Empirical_Rule.PNG
-Like every prior project, your code will be submitted via github. Fork the empty final project repo and start your code base from there. Take this as an opportunity to practice using git properly in a team setting if you’re a new user. For each weekly submission, provide a link to your pull request. Your repo will contain all the code and documentation associated with your project. The readme for your repo will eventually be your final report. At the top level, include a folder called “documentation”, where you’ll put your design doc and milestone write-ups.
+ * Colors
+ * http://www.iquilezles.org/www/articles/palettes/palettes.htm
+ * http://dev.thi.ng/gradients/
-Don’t wait to merge your code! Seriously, there be dragons. Try to have a working version including all your code so that compatibility and merge issues don’t sneak up on you near the end.
+ * Raymarching
+ * https://stemkoski.github.io/Three.js/Mouse-Over.html
+ * https://github.com/mrdoob/three.js/issues/5587
+ * http://stackoverflow.com/questions/20361776/orthographic-camera-and-pickingray
-## Grading
+ * Mouse Detection
+ * https://threejs.org/examples/?q=out#webgl_postprocessing_outline
-- 15% Design Doc (graded as a group)
-- 15% Milestone 1 (graded as a group)
-- 15% Milestone 2 (graded as a group)
-- 55% Final demo + report (graded individually)
+ * Camera Orbit Controls
+ * https://searchcode.com/codesearch/view/58375664/
-NOTE: We’ve been pretty lax about our late policy throughout the semester, but our margins on the final project are tight, therefore late submissions will NOT be accepted. If you have a significant reason for being unable to complete your goals, talk to us, and we’ll discuss getting you an incomplete and figure out an adjusted work plan with your group.
diff --git a/deploy.js b/deploy.js
new file mode 100644
index 00000000..9defe7c3
--- /dev/null
+++ b/deploy.js
@@ -0,0 +1,38 @@
+var colors = require('colors');
+var path = require('path');
+var git = require('simple-git')(__dirname);
+var deploy = require('gh-pages-deploy');
+var packageJSON = require('require-module')('./package.json');
+
+var success = 1;
+git.fetch('origin', 'master', function(err) {
+ if (err) throw err;
+ git.status(function(err, status) {
+ if (err) throw err;
+ if (!status.isClean()) {
+ success = 0;
+ console.error('Error: You have uncommitted changes! Please commit them first'.red);
+ }
+
+ if (status.current !== 'master') {
+ success = 0;
+ console.warn('Warning: Please deploy from the master branch!'.yellow)
+ }
+
+ git.diffSummary(['origin/master'], function(err, diff) {
+ if (err) throw err;
+
+ if (diff.files.length || diff.insertions || diff.deletions) {
+ success = 0;
+ console.error('Error: Current branch is different from origin/master! Please push all changes first'.red)
+ }
+
+ if (success) {
+ var cfg = packageJSON['gh-pages-deploy'] || {};
+ var buildCmd = deploy.getFullCmd(cfg);
+ deploy.displayCmds(deploy.getFullCmd(cfg));
+ deploy.execBuild(buildCmd, cfg);
+ }
+ })
+ })
+})
\ No newline at end of file
diff --git a/images/.DS_Store b/images/.DS_Store
new file mode 100644
index 00000000..5008ddfc
Binary files /dev/null and b/images/.DS_Store differ
diff --git a/images/WIP1.png b/images/WIP1.png
new file mode 100644
index 00000000..820c439b
Binary files /dev/null and b/images/WIP1.png differ
diff --git a/images/WIP2.png b/images/WIP2.png
new file mode 100644
index 00000000..bc7c895f
Binary files /dev/null and b/images/WIP2.png differ
diff --git a/images/gameover.png b/images/gameover.png
new file mode 100644
index 00000000..9516271d
Binary files /dev/null and b/images/gameover.png differ
diff --git a/images/menu.png b/images/menu.png
new file mode 100644
index 00000000..6b0e6409
Binary files /dev/null and b/images/menu.png differ
diff --git a/images/raymarch.gif b/images/raymarch.gif
new file mode 100644
index 00000000..7867e971
Binary files /dev/null and b/images/raymarch.gif differ
diff --git a/images/ref1.jpg b/images/ref1.jpg
new file mode 100644
index 00000000..e416e5ca
Binary files /dev/null and b/images/ref1.jpg differ
diff --git a/images/ref2.jpg b/images/ref2.jpg
new file mode 100644
index 00000000..85f738fc
Binary files /dev/null and b/images/ref2.jpg differ
diff --git a/images/ref3.jpg b/images/ref3.jpg
new file mode 100644
index 00000000..efba3f46
Binary files /dev/null and b/images/ref3.jpg differ
diff --git a/images/ref4.png b/images/ref4.png
new file mode 100644
index 00000000..b91719d5
Binary files /dev/null and b/images/ref4.png differ
diff --git a/images/ref5.png b/images/ref5.png
new file mode 100644
index 00000000..c100b55f
Binary files /dev/null and b/images/ref5.png differ
diff --git a/images/ref6.png b/images/ref6.png
new file mode 100644
index 00000000..300ddc8c
Binary files /dev/null and b/images/ref6.png differ
diff --git a/images/ref7.png b/images/ref7.png
new file mode 100644
index 00000000..d5912173
Binary files /dev/null and b/images/ref7.png differ
diff --git a/images/ref8.gif b/images/ref8.gif
new file mode 100644
index 00000000..6960ec61
Binary files /dev/null and b/images/ref8.gif differ
diff --git a/images/ref9.gif b/images/ref9.gif
new file mode 100644
index 00000000..dc12a420
Binary files /dev/null and b/images/ref9.gif differ
diff --git a/images/result1.png b/images/result1.png
new file mode 100644
index 00000000..652acf95
Binary files /dev/null and b/images/result1.png differ
diff --git a/images/result2.png b/images/result2.png
new file mode 100644
index 00000000..8e7e46c5
Binary files /dev/null and b/images/result2.png differ
diff --git a/images/result3.png b/images/result3.png
new file mode 100644
index 00000000..25a47e7d
Binary files /dev/null and b/images/result3.png differ
diff --git a/index.html b/index.html
new file mode 100644
index 00000000..07b8e2b7
--- /dev/null
+++ b/index.html
@@ -0,0 +1,25 @@
+
+
+
+ Voxel Run
+
+
+
+
+
+
diff --git a/node_modules/.bin/acorn b/node_modules/.bin/acorn
new file mode 120000
index 00000000..cf767603
--- /dev/null
+++ b/node_modules/.bin/acorn
@@ -0,0 +1 @@
+../acorn/bin/acorn
\ No newline at end of file
diff --git a/node_modules/.bin/babylon b/node_modules/.bin/babylon
new file mode 120000
index 00000000..c2adc01b
--- /dev/null
+++ b/node_modules/.bin/babylon
@@ -0,0 +1 @@
+../babylon/bin/babylon.js
\ No newline at end of file
diff --git a/node_modules/.bin/errno b/node_modules/.bin/errno
new file mode 120000
index 00000000..5a98e539
--- /dev/null
+++ b/node_modules/.bin/errno
@@ -0,0 +1 @@
+../errno/cli.js
\ No newline at end of file
diff --git a/node_modules/.bin/gasket b/node_modules/.bin/gasket
new file mode 120000
index 00000000..e9a96b9d
--- /dev/null
+++ b/node_modules/.bin/gasket
@@ -0,0 +1 @@
+../gasket/bin.js
\ No newline at end of file
diff --git a/node_modules/.bin/gh-pages-deploy b/node_modules/.bin/gh-pages-deploy
new file mode 120000
index 00000000..c7f6f8f5
--- /dev/null
+++ b/node_modules/.bin/gh-pages-deploy
@@ -0,0 +1 @@
+../gh-pages-deploy/bin/gh-pages-deploy
\ No newline at end of file
diff --git a/node_modules/.bin/jsesc b/node_modules/.bin/jsesc
new file mode 120000
index 00000000..7237604c
--- /dev/null
+++ b/node_modules/.bin/jsesc
@@ -0,0 +1 @@
+../jsesc/bin/jsesc
\ No newline at end of file
diff --git a/node_modules/.bin/json5 b/node_modules/.bin/json5
new file mode 120000
index 00000000..217f3798
--- /dev/null
+++ b/node_modules/.bin/json5
@@ -0,0 +1 @@
+../json5/lib/cli.js
\ No newline at end of file
diff --git a/node_modules/.bin/loose-envify b/node_modules/.bin/loose-envify
new file mode 120000
index 00000000..ed9009c5
--- /dev/null
+++ b/node_modules/.bin/loose-envify
@@ -0,0 +1 @@
+../loose-envify/cli.js
\ No newline at end of file
diff --git a/node_modules/.bin/mime b/node_modules/.bin/mime
new file mode 120000
index 00000000..fbb7ee0e
--- /dev/null
+++ b/node_modules/.bin/mime
@@ -0,0 +1 @@
+../mime/cli.js
\ No newline at end of file
diff --git a/node_modules/.bin/mkdirp b/node_modules/.bin/mkdirp
new file mode 120000
index 00000000..017896ce
--- /dev/null
+++ b/node_modules/.bin/mkdirp
@@ -0,0 +1 @@
+../mkdirp/bin/cmd.js
\ No newline at end of file
diff --git a/node_modules/.bin/ncp b/node_modules/.bin/ncp
new file mode 120000
index 00000000..1c026480
--- /dev/null
+++ b/node_modules/.bin/ncp
@@ -0,0 +1 @@
+../ncp/bin/ncp
\ No newline at end of file
diff --git a/node_modules/.bin/ndjson b/node_modules/.bin/ndjson
new file mode 120000
index 00000000..88b0e189
--- /dev/null
+++ b/node_modules/.bin/ndjson
@@ -0,0 +1 @@
+../ndjson/cli.js
\ No newline at end of file
diff --git a/node_modules/.bin/npm-execspawn b/node_modules/.bin/npm-execspawn
new file mode 120000
index 00000000..1198974f
--- /dev/null
+++ b/node_modules/.bin/npm-execspawn
@@ -0,0 +1 @@
+../npm-execspawn/bin.js
\ No newline at end of file
diff --git a/node_modules/.bin/regjsparser b/node_modules/.bin/regjsparser
new file mode 120000
index 00000000..91cec777
--- /dev/null
+++ b/node_modules/.bin/regjsparser
@@ -0,0 +1 @@
+../regjsparser/bin/parser
\ No newline at end of file
diff --git a/node_modules/.bin/rimraf b/node_modules/.bin/rimraf
new file mode 120000
index 00000000..4cd49a49
--- /dev/null
+++ b/node_modules/.bin/rimraf
@@ -0,0 +1 @@
+../rimraf/bin.js
\ No newline at end of file
diff --git a/node_modules/.bin/sha.js b/node_modules/.bin/sha.js
new file mode 120000
index 00000000..3c761051
--- /dev/null
+++ b/node_modules/.bin/sha.js
@@ -0,0 +1 @@
+../sha.js/bin.js
\ No newline at end of file
diff --git a/node_modules/.bin/uglifyjs b/node_modules/.bin/uglifyjs
new file mode 120000
index 00000000..fef3468b
--- /dev/null
+++ b/node_modules/.bin/uglifyjs
@@ -0,0 +1 @@
+../uglify-js/bin/uglifyjs
\ No newline at end of file
diff --git a/node_modules/.bin/webpack b/node_modules/.bin/webpack
new file mode 120000
index 00000000..d462c1d1
--- /dev/null
+++ b/node_modules/.bin/webpack
@@ -0,0 +1 @@
+../webpack/bin/webpack.js
\ No newline at end of file
diff --git a/node_modules/.bin/webpack-dev-server b/node_modules/.bin/webpack-dev-server
new file mode 120000
index 00000000..242fe0a6
--- /dev/null
+++ b/node_modules/.bin/webpack-dev-server
@@ -0,0 +1 @@
+../webpack-dev-server/bin/webpack-dev-server.js
\ No newline at end of file
diff --git a/node_modules/accepts/HISTORY.md b/node_modules/accepts/HISTORY.md
new file mode 100644
index 00000000..0477ed71
--- /dev/null
+++ b/node_modules/accepts/HISTORY.md
@@ -0,0 +1,212 @@
+1.3.3 / 2016-05-02
+==================
+
+ * deps: mime-types@~2.1.11
+ - deps: mime-db@~1.23.0
+ * deps: negotiator@0.6.1
+ - perf: improve `Accept` parsing speed
+ - perf: improve `Accept-Charset` parsing speed
+ - perf: improve `Accept-Encoding` parsing speed
+ - perf: improve `Accept-Language` parsing speed
+
+1.3.2 / 2016-03-08
+==================
+
+ * deps: mime-types@~2.1.10
+ - Fix extension of `application/dash+xml`
+ - Update primary extension for `audio/mp4`
+ - deps: mime-db@~1.22.0
+
+1.3.1 / 2016-01-19
+==================
+
+ * deps: mime-types@~2.1.9
+ - deps: mime-db@~1.21.0
+
+1.3.0 / 2015-09-29
+==================
+
+ * deps: mime-types@~2.1.7
+ - deps: mime-db@~1.19.0
+ * deps: negotiator@0.6.0
+ - Fix including type extensions in parameters in `Accept` parsing
+ - Fix parsing `Accept` parameters with quoted equals
+ - Fix parsing `Accept` parameters with quoted semicolons
+ - Lazy-load modules from main entry point
+ - perf: delay type concatenation until needed
+ - perf: enable strict mode
+ - perf: hoist regular expressions
+ - perf: remove closures getting spec properties
+ - perf: remove a closure from media type parsing
+ - perf: remove property delete from media type parsing
+
+1.2.13 / 2015-09-06
+===================
+
+ * deps: mime-types@~2.1.6
+ - deps: mime-db@~1.18.0
+
+1.2.12 / 2015-07-30
+===================
+
+ * deps: mime-types@~2.1.4
+ - deps: mime-db@~1.16.0
+
+1.2.11 / 2015-07-16
+===================
+
+ * deps: mime-types@~2.1.3
+ - deps: mime-db@~1.15.0
+
+1.2.10 / 2015-07-01
+===================
+
+ * deps: mime-types@~2.1.2
+ - deps: mime-db@~1.14.0
+
+1.2.9 / 2015-06-08
+==================
+
+ * deps: mime-types@~2.1.1
+ - perf: fix deopt during mapping
+
+1.2.8 / 2015-06-07
+==================
+
+ * deps: mime-types@~2.1.0
+ - deps: mime-db@~1.13.0
+ * perf: avoid argument reassignment & argument slice
+ * perf: avoid negotiator recursive construction
+ * perf: enable strict mode
+ * perf: remove unnecessary bitwise operator
+
+1.2.7 / 2015-05-10
+==================
+
+ * deps: negotiator@0.5.3
+ - Fix media type parameter matching to be case-insensitive
+
+1.2.6 / 2015-05-07
+==================
+
+ * deps: mime-types@~2.0.11
+ - deps: mime-db@~1.9.1
+ * deps: negotiator@0.5.2
+ - Fix comparing media types with quoted values
+ - Fix splitting media types with quoted commas
+
+1.2.5 / 2015-03-13
+==================
+
+ * deps: mime-types@~2.0.10
+ - deps: mime-db@~1.8.0
+
+1.2.4 / 2015-02-14
+==================
+
+ * Support Node.js 0.6
+ * deps: mime-types@~2.0.9
+ - deps: mime-db@~1.7.0
+ * deps: negotiator@0.5.1
+ - Fix preference sorting to be stable for long acceptable lists
+
+1.2.3 / 2015-01-31
+==================
+
+ * deps: mime-types@~2.0.8
+ - deps: mime-db@~1.6.0
+
+1.2.2 / 2014-12-30
+==================
+
+ * deps: mime-types@~2.0.7
+ - deps: mime-db@~1.5.0
+
+1.2.1 / 2014-12-30
+==================
+
+ * deps: mime-types@~2.0.5
+ - deps: mime-db@~1.3.1
+
+1.2.0 / 2014-12-19
+==================
+
+ * deps: negotiator@0.5.0
+ - Fix list return order when large accepted list
+ - Fix missing identity encoding when q=0 exists
+ - Remove dynamic building of Negotiator class
+
+1.1.4 / 2014-12-10
+==================
+
+ * deps: mime-types@~2.0.4
+ - deps: mime-db@~1.3.0
+
+1.1.3 / 2014-11-09
+==================
+
+ * deps: mime-types@~2.0.3
+ - deps: mime-db@~1.2.0
+
+1.1.2 / 2014-10-14
+==================
+
+ * deps: negotiator@0.4.9
+ - Fix error when media type has invalid parameter
+
+1.1.1 / 2014-09-28
+==================
+
+ * deps: mime-types@~2.0.2
+ - deps: mime-db@~1.1.0
+ * deps: negotiator@0.4.8
+ - Fix all negotiations to be case-insensitive
+ - Stable sort preferences of same quality according to client order
+
+1.1.0 / 2014-09-02
+==================
+
+ * update `mime-types`
+
+1.0.7 / 2014-07-04
+==================
+
+ * Fix wrong type returned from `type` when match after unknown extension
+
+1.0.6 / 2014-06-24
+==================
+
+ * deps: negotiator@0.4.7
+
+1.0.5 / 2014-06-20
+==================
+
+ * fix crash when unknown extension given
+
+1.0.4 / 2014-06-19
+==================
+
+ * use `mime-types`
+
+1.0.3 / 2014-06-11
+==================
+
+ * deps: negotiator@0.4.6
+ - Order by specificity when quality is the same
+
+1.0.2 / 2014-05-29
+==================
+
+ * Fix interpretation when header not in request
+ * deps: pin negotiator@0.4.5
+
+1.0.1 / 2014-01-18
+==================
+
+ * Identity encoding isn't always acceptable
+ * deps: negotiator@~0.4.0
+
+1.0.0 / 2013-12-27
+==================
+
+ * Genesis
diff --git a/node_modules/accepts/LICENSE b/node_modules/accepts/LICENSE
new file mode 100644
index 00000000..06166077
--- /dev/null
+++ b/node_modules/accepts/LICENSE
@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong
+Copyright (c) 2015 Douglas Christopher Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/accepts/README.md b/node_modules/accepts/README.md
new file mode 100644
index 00000000..ae36676f
--- /dev/null
+++ b/node_modules/accepts/README.md
@@ -0,0 +1,135 @@
+# accepts
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator). Extracted from [koa](https://www.npmjs.com/package/koa) for general use.
+
+In addition to negotiator, it allows:
+
+- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])` as well as `('text/html', 'application/json')`.
+- Allows type shorthands such as `json`.
+- Returns `false` when no types match
+- Treats non-existent headers as `*`
+
+## Installation
+
+```sh
+npm install accepts
+```
+
+## API
+
+```js
+var accepts = require('accepts')
+```
+
+### accepts(req)
+
+Create a new `Accepts` object for the given `req`.
+
+#### .charset(charsets)
+
+Return the first accepted charset. If nothing in `charsets` is accepted,
+then `false` is returned.
+
+#### .charsets()
+
+Return the charsets that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .encoding(encodings)
+
+Return the first accepted encoding. If nothing in `encodings` is accepted,
+then `false` is returned.
+
+#### .encodings()
+
+Return the encodings that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .language(languages)
+
+Return the first accepted language. If nothing in `languages` is accepted,
+then `false` is returned.
+
+#### .languages()
+
+Return the languages that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .type(types)
+
+Return the first accepted type (and it is returned as the same text as what
+appears in the `types` array). If nothing in `types` is accepted, then `false`
+is returned.
+
+The `types` array can contain full MIME types or file extensions. Any value
+that is not a full MIME types is passed to `require('mime-types').lookup`.
+
+#### .types()
+
+Return the types that the request accepts, in the order of the client's
+preference (most preferred first).
+
+## Examples
+
+### Simple type negotiation
+
+This simple example shows how to use `accepts` to return a different typed
+respond body based on what the client wants to accept. The server lists it's
+preferences in order and will get back the best match between the client and
+server.
+
+```js
+var accepts = require('accepts')
+var http = require('http')
+
+function app(req, res) {
+ var accept = accepts(req)
+
+ // the order of this list is significant; should be server preferred order
+ switch(accept.type(['json', 'html'])) {
+ case 'json':
+ res.setHeader('Content-Type', 'application/json')
+ res.write('{"hello":"world!"}')
+ break
+ case 'html':
+ res.setHeader('Content-Type', 'text/html')
+ res.write('hello, world!')
+ break
+ default:
+ // the fallback is text/plain, so no need to specify it above
+ res.setHeader('Content-Type', 'text/plain')
+ res.write('hello, world!')
+ break
+ }
+
+ res.end()
+}
+
+http.createServer(app).listen(3000)
+```
+
+You can test this out with the cURL program:
+```sh
+curl -I -H'Accept: text/html' http://localhost:3000/
+```
+
+## License
+
+[MIT](LICENSE)
+
+[npm-image]: https://img.shields.io/npm/v/accepts.svg
+[npm-url]: https://npmjs.org/package/accepts
+[node-version-image]: https://img.shields.io/node/v/accepts.svg
+[node-version-url]: http://nodejs.org/download/
+[travis-image]: https://img.shields.io/travis/jshttp/accepts/master.svg
+[travis-url]: https://travis-ci.org/jshttp/accepts
+[coveralls-image]: https://img.shields.io/coveralls/jshttp/accepts/master.svg
+[coveralls-url]: https://coveralls.io/r/jshttp/accepts
+[downloads-image]: https://img.shields.io/npm/dm/accepts.svg
+[downloads-url]: https://npmjs.org/package/accepts
diff --git a/node_modules/accepts/index.js b/node_modules/accepts/index.js
new file mode 100644
index 00000000..e80192ab
--- /dev/null
+++ b/node_modules/accepts/index.js
@@ -0,0 +1,231 @@
+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var Negotiator = require('negotiator')
+var mime = require('mime-types')
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = Accepts
+
+/**
+ * Create a new Accepts object for the given req.
+ *
+ * @param {object} req
+ * @public
+ */
+
+function Accepts(req) {
+ if (!(this instanceof Accepts))
+ return new Accepts(req)
+
+ this.headers = req.headers
+ this.negotiator = new Negotiator(req)
+}
+
+/**
+ * Check if the given `type(s)` is acceptable, returning
+ * the best match when true, otherwise `undefined`, in which
+ * case you should respond with 406 "Not Acceptable".
+ *
+ * The `type` value may be a single mime type string
+ * such as "application/json", the extension name
+ * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+ * or array is given the _best_ match, if any is returned.
+ *
+ * Examples:
+ *
+ * // Accept: text/html
+ * this.types('html');
+ * // => "html"
+ *
+ * // Accept: text/*, application/json
+ * this.types('html');
+ * // => "html"
+ * this.types('text/html');
+ * // => "text/html"
+ * this.types('json', 'text');
+ * // => "json"
+ * this.types('application/json');
+ * // => "application/json"
+ *
+ * // Accept: text/*, application/json
+ * this.types('image/png');
+ * this.types('png');
+ * // => undefined
+ *
+ * // Accept: text/*;q=.5, application/json
+ * this.types(['html', 'json']);
+ * this.types('html', 'json');
+ * // => "json"
+ *
+ * @param {String|Array} types...
+ * @return {String|Array|Boolean}
+ * @public
+ */
+
+Accepts.prototype.type =
+Accepts.prototype.types = function (types_) {
+ var types = types_
+
+ // support flattened arguments
+ if (types && !Array.isArray(types)) {
+ types = new Array(arguments.length)
+ for (var i = 0; i < types.length; i++) {
+ types[i] = arguments[i]
+ }
+ }
+
+ // no types, return all requested types
+ if (!types || types.length === 0) {
+ return this.negotiator.mediaTypes()
+ }
+
+ if (!this.headers.accept) return types[0];
+ var mimes = types.map(extToMime);
+ var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
+ var first = accepts[0];
+ if (!first) return false;
+ return types[mimes.indexOf(first)];
+}
+
+/**
+ * Return accepted encodings or best fit based on `encodings`.
+ *
+ * Given `Accept-Encoding: gzip, deflate`
+ * an array sorted by quality is returned:
+ *
+ * ['gzip', 'deflate']
+ *
+ * @param {String|Array} encodings...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.encoding =
+Accepts.prototype.encodings = function (encodings_) {
+ var encodings = encodings_
+
+ // support flattened arguments
+ if (encodings && !Array.isArray(encodings)) {
+ encodings = new Array(arguments.length)
+ for (var i = 0; i < encodings.length; i++) {
+ encodings[i] = arguments[i]
+ }
+ }
+
+ // no encodings, return all requested encodings
+ if (!encodings || encodings.length === 0) {
+ return this.negotiator.encodings()
+ }
+
+ return this.negotiator.encodings(encodings)[0] || false
+}
+
+/**
+ * Return accepted charsets or best fit based on `charsets`.
+ *
+ * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+ * an array sorted by quality is returned:
+ *
+ * ['utf-8', 'utf-7', 'iso-8859-1']
+ *
+ * @param {String|Array} charsets...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.charset =
+Accepts.prototype.charsets = function (charsets_) {
+ var charsets = charsets_
+
+ // support flattened arguments
+ if (charsets && !Array.isArray(charsets)) {
+ charsets = new Array(arguments.length)
+ for (var i = 0; i < charsets.length; i++) {
+ charsets[i] = arguments[i]
+ }
+ }
+
+ // no charsets, return all requested charsets
+ if (!charsets || charsets.length === 0) {
+ return this.negotiator.charsets()
+ }
+
+ return this.negotiator.charsets(charsets)[0] || false
+}
+
+/**
+ * Return accepted languages or best fit based on `langs`.
+ *
+ * Given `Accept-Language: en;q=0.8, es, pt`
+ * an array sorted by quality is returned:
+ *
+ * ['es', 'pt', 'en']
+ *
+ * @param {String|Array} langs...
+ * @return {Array|String}
+ * @public
+ */
+
+Accepts.prototype.lang =
+Accepts.prototype.langs =
+Accepts.prototype.language =
+Accepts.prototype.languages = function (languages_) {
+ var languages = languages_
+
+ // support flattened arguments
+ if (languages && !Array.isArray(languages)) {
+ languages = new Array(arguments.length)
+ for (var i = 0; i < languages.length; i++) {
+ languages[i] = arguments[i]
+ }
+ }
+
+ // no languages, return all requested languages
+ if (!languages || languages.length === 0) {
+ return this.negotiator.languages()
+ }
+
+ return this.negotiator.languages(languages)[0] || false
+}
+
+/**
+ * Convert extnames to mime.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function extToMime(type) {
+ return type.indexOf('/') === -1
+ ? mime.lookup(type)
+ : type
+}
+
+/**
+ * Check if mime is valid.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function validMime(type) {
+ return typeof type === 'string';
+}
diff --git a/node_modules/accepts/package.json b/node_modules/accepts/package.json
new file mode 100644
index 00000000..b634d580
--- /dev/null
+++ b/node_modules/accepts/package.json
@@ -0,0 +1,114 @@
+{
+ "_args": [
+ [
+ {
+ "raw": "accepts@~1.3.3",
+ "scope": null,
+ "escapedName": "accepts",
+ "name": "accepts",
+ "rawSpec": "~1.3.3",
+ "spec": ">=1.3.3 <1.4.0",
+ "type": "range"
+ },
+ "/Users/ericchiu/Desktop/CIS 700/HW3/Project3-LSystems/node_modules/compression"
+ ]
+ ],
+ "_from": "accepts@>=1.3.3 <1.4.0",
+ "_id": "accepts@1.3.3",
+ "_inCache": true,
+ "_location": "/accepts",
+ "_nodeVersion": "4.4.3",
+ "_npmOperationalInternal": {
+ "host": "packages-16-east.internal.npmjs.com",
+ "tmp": "tmp/accepts-1.3.3.tgz_1462251932032_0.7092335098423064"
+ },
+ "_npmUser": {
+ "name": "dougwilson",
+ "email": "doug@somethingdoug.com"
+ },
+ "_npmVersion": "2.15.1",
+ "_phantomChildren": {},
+ "_requested": {
+ "raw": "accepts@~1.3.3",
+ "scope": null,
+ "escapedName": "accepts",
+ "name": "accepts",
+ "rawSpec": "~1.3.3",
+ "spec": ">=1.3.3 <1.4.0",
+ "type": "range"
+ },
+ "_requiredBy": [
+ "/compression",
+ "/express",
+ "/serve-index"
+ ],
+ "_resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.3.tgz",
+ "_shasum": "c3ca7434938648c3e0d9c1e328dd68b622c284ca",
+ "_shrinkwrap": null,
+ "_spec": "accepts@~1.3.3",
+ "_where": "/Users/ericchiu/Desktop/CIS 700/HW3/Project3-LSystems/node_modules/compression",
+ "bugs": {
+ "url": "https://github.com/jshttp/accepts/issues"
+ },
+ "contributors": [
+ {
+ "name": "Douglas Christopher Wilson",
+ "email": "doug@somethingdoug.com"
+ },
+ {
+ "name": "Jonathan Ong",
+ "email": "me@jongleberry.com",
+ "url": "http://jongleberry.com"
+ }
+ ],
+ "dependencies": {
+ "mime-types": "~2.1.11",
+ "negotiator": "0.6.1"
+ },
+ "description": "Higher-level content negotiation",
+ "devDependencies": {
+ "istanbul": "0.4.3",
+ "mocha": "~1.21.5"
+ },
+ "directories": {},
+ "dist": {
+ "shasum": "c3ca7434938648c3e0d9c1e328dd68b622c284ca",
+ "tarball": "https://registry.npmjs.org/accepts/-/accepts-1.3.3.tgz"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ },
+ "files": [
+ "LICENSE",
+ "HISTORY.md",
+ "index.js"
+ ],
+ "gitHead": "3e925b1e65ed7da2798849683d49814680dfa426",
+ "homepage": "https://github.com/jshttp/accepts#readme",
+ "keywords": [
+ "content",
+ "negotiation",
+ "accept",
+ "accepts"
+ ],
+ "license": "MIT",
+ "maintainers": [
+ {
+ "name": "dougwilson",
+ "email": "doug@somethingdoug.com"
+ }
+ ],
+ "name": "accepts",
+ "optionalDependencies": {},
+ "readme": "ERROR: No README data found!",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jshttp/accepts.git"
+ },
+ "scripts": {
+ "test": "mocha --reporter spec --check-leaks --bail test/",
+ "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/",
+ "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/"
+ },
+ "version": "1.3.3"
+}
diff --git a/node_modules/acorn/.editorconfig b/node_modules/acorn/.editorconfig
new file mode 100644
index 00000000..c14d5c67
--- /dev/null
+++ b/node_modules/acorn/.editorconfig
@@ -0,0 +1,7 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
diff --git a/node_modules/acorn/.gitattributes b/node_modules/acorn/.gitattributes
new file mode 100644
index 00000000..fcadb2cf
--- /dev/null
+++ b/node_modules/acorn/.gitattributes
@@ -0,0 +1 @@
+* text eol=lf
diff --git a/node_modules/acorn/.npmignore b/node_modules/acorn/.npmignore
new file mode 100644
index 00000000..ecba2911
--- /dev/null
+++ b/node_modules/acorn/.npmignore
@@ -0,0 +1,3 @@
+/.tern-port
+/test
+/local
diff --git a/node_modules/acorn/.tern-project b/node_modules/acorn/.tern-project
new file mode 100644
index 00000000..6718ce07
--- /dev/null
+++ b/node_modules/acorn/.tern-project
@@ -0,0 +1,6 @@
+{
+ "plugins": {
+ "node": true,
+ "es_modules": true
+ }
+}
\ No newline at end of file
diff --git a/node_modules/acorn/.travis.yml b/node_modules/acorn/.travis.yml
new file mode 100644
index 00000000..d9ee88ba
--- /dev/null
+++ b/node_modules/acorn/.travis.yml
@@ -0,0 +1,7 @@
+language: node_js
+sudo: false
+node_js:
+ - '0.12'
+ - '4'
+ - '5'
+ - '6'
diff --git a/node_modules/acorn/AUTHORS b/node_modules/acorn/AUTHORS
new file mode 100644
index 00000000..1b2061cd
--- /dev/null
+++ b/node_modules/acorn/AUTHORS
@@ -0,0 +1,59 @@
+List of Acorn contributors. Updated before every release.
+
+Adrian Rakovsky
+Alistair Braidwood
+Amila Welihinda
+Andres Suarez
+Angelo
+Aparajita Fishman
+Arian Stolwijk
+Artem Govorov
+Brandon Mills
+Charles Hughes
+Conrad Irwin
+Daniel Tschinder
+David Bonnet
+Domenico Matteo
+ForbesLindesay
+Forbes Lindesay
+Gilad Peleg
+impinball
+Ingvar Stepanyan
+Jackson Ray Hamilton
+Jesse McCarthy
+Jiaxing Wang
+Joel Kemp
+Johannes Herr
+Jordan Klassen
+Jürg Lehni
+keeyipchan
+Keheliya Gallaba
+Kevin Irish
+Kevin Kwok
+krator
+Marijn Haverbeke
+Martin Carlberg
+Mathias Bynens
+Mathieu 'p01' Henri
+Matthew Bastien
+Max Schaefer
+Max Zerzouri
+Mihai Bazon
+Mike Rennie
+Nicholas C. Zakas
+Nick Fitzgerald
+Olivier Thomann
+Oskar Schöldström
+Paul Harper
+Peter Rust
+PlNG
+Prayag Verma
+ReadmeCritic
+r-e-d
+Richard Gibson
+Rich Harris
+Rich-Harris
+Sebastian McKenzie
+Timothy Gu
+Toru Nagashima
+zsjforcn
diff --git a/node_modules/acorn/CHANGELOG.md b/node_modules/acorn/CHANGELOG.md
new file mode 100644
index 00000000..16b8212e
--- /dev/null
+++ b/node_modules/acorn/CHANGELOG.md
@@ -0,0 +1,159 @@
+## 3.3.0 (2016-07-25)
+
+### Bug fixes
+
+Fix bug in tokenizing of regexp operator after a function declaration.
+
+Fix parser crash when parsing an array pattern with a hole.
+
+### New features
+
+Implement check against complex argument lists in functions that
+enable strict mode in ES7.
+
+## 3.2.0 (2016-06-07)
+
+### Bug fixes
+
+Improve handling of lack of unicode regexp support in host
+environment.
+
+Properly reject shorthand properties whose name is a keyword.
+
+Don't crash when the loose parser is called without options object.
+
+### New features
+
+Visitors created with `visit.make` now have their base as _prototype_,
+rather than copying properties into a fresh object.
+
+Make it possible to use `visit.ancestor` with a walk state.
+
+## 3.1.0 (2016-04-18)
+
+### Bug fixes
+
+Fix issue where the loose parser created invalid TemplateElement nodes
+for unclosed template literals.
+
+Properly tokenize the division operator directly after a function
+expression.
+
+Allow trailing comma in destructuring arrays.
+
+### New features
+
+The walker now allows defining handlers for `CatchClause` nodes.
+
+## 3.0.4 (2016-02-25)
+
+### Fixes
+
+Allow update expressions as left-hand-side of the ES7 exponential
+operator.
+
+## 3.0.2 (2016-02-10)
+
+### Fixes
+
+Fix bug that accidentally made `undefined` a reserved word when
+parsing ES7.
+
+## 3.0.0 (2016-02-10)
+
+### Breaking changes
+
+The default value of the `ecmaVersion` option is now 6 (used to be 5).
+
+Support for comprehension syntax (which was dropped from the draft
+spec) has been removed.
+
+### Fixes
+
+`let` and `yield` are now “contextual keywords”, meaning you can
+mostly use them as identifiers in ES5 non-strict code.
+
+A parenthesized class or function expression after `export default` is
+now parsed correctly.
+
+### New features
+
+When `ecmaVersion` is set to 7, Acorn will parse the exponentiation
+operator (`**`).
+
+The identifier character ranges are now based on Unicode 8.0.0.
+
+Plugins can now override the `raiseRecoverable` method to override the
+way non-critical errors are handled.
+
+## 2.7.0 (2016-01-04)
+
+### Fixes
+
+Stop allowing rest parameters in setters.
+
+Make sure the loose parser always attaches a `local` property to
+`ImportNamespaceSpecifier` nodes.
+
+Disallow `y` rexexp flag in ES5.
+
+Disallow `\00` and `\000` escapes in strict mode.
+
+Raise an error when an import name is a reserved word.
+
+## 2.6.4 (2015-11-12)
+
+### Fixes
+
+Fix crash in loose parser when parsing invalid object pattern.
+
+### New features
+
+Support plugins in the loose parser.
+
+## 2.6.2 (2015-11-10)
+
+### Fixes
+
+Don't crash when no options object is passed.
+
+## 2.6.0 (2015-11-09)
+
+### Fixes
+
+Add `await` as a reserved word in module sources.
+
+Disallow `yield` in a parameter default value for a generator.
+
+Forbid using a comma after a rest pattern in an array destructuring.
+
+### New features
+
+Support parsing stdin in command-line tool.
+
+## 2.5.2 (2015-10-27)
+
+### Fixes
+
+Fix bug where the walker walked an exported `let` statement as an
+expression.
+
+## 2.5.0 (2015-10-27)
+
+### Fixes
+
+Fix tokenizer support in the command-line tool.
+
+In the loose parser, don't allow non-string-literals as import
+sources.
+
+Stop allowing `new.target` outside of functions.
+
+Remove legacy `guard` and `guardedHandler` properties from try nodes.
+
+Stop allowing multiple `__proto__` properties on an object literal in
+strict mode.
+
+Don't allow rest parameters to be non-identifier patterns.
+
+Check for duplicate paramter names in arrow functions.
diff --git a/node_modules/acorn/LICENSE b/node_modules/acorn/LICENSE
new file mode 100644
index 00000000..a35ebf44
--- /dev/null
+++ b/node_modules/acorn/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2012-2016 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/acorn/README.md b/node_modules/acorn/README.md
new file mode 100644
index 00000000..0c514d5e
--- /dev/null
+++ b/node_modules/acorn/README.md
@@ -0,0 +1,407 @@
+# Acorn
+
+[](https://travis-ci.org/ternjs/acorn)
+[](https://www.npmjs.com/package/acorn)
+[Author funding status: ](https://marijnhaverbeke.nl/fund/)
+
+A tiny, fast JavaScript parser, written completely in JavaScript.
+
+## Community
+
+Acorn is open source software released under an
+[MIT license](https://github.com/ternjs/acorn/blob/master/LICENSE).
+
+You are welcome to
+[report bugs](https://github.com/ternjs/acorn/issues) or create pull
+requests on [github](https://github.com/ternjs/acorn). For questions
+and discussion, please use the
+[Tern discussion forum](https://discuss.ternjs.net).
+
+## Installation
+
+The easiest way to install acorn is with [`npm`][npm].
+
+[npm]: https://www.npmjs.com/
+
+```sh
+npm install acorn
+```
+
+Alternately, download the source.
+
+```sh
+git clone https://github.com/ternjs/acorn.git
+```
+
+## Components
+
+When run in a CommonJS (node.js) or AMD environment, exported values
+appear in the interfaces exposed by the individual files, as usual.
+When loaded in the browser (Acorn works in any JS-enabled browser more
+recent than IE5) without any kind of module management, a single
+global object `acorn` will be defined, and all the exported properties
+will be added to that.
+
+### Main parser
+
+This is implemented in `dist/acorn.js`, and is what you get when you
+`require("acorn")` in node.js.
+
+**parse**`(input, options)` is used to parse a JavaScript program.
+The `input` parameter is a string, `options` can be undefined or an
+object setting some of the options listed below. The return value will
+be an abstract syntax tree object as specified by the
+[ESTree spec][estree].
+
+When encountering a syntax error, the parser will raise a
+`SyntaxError` object with a meaningful message. The error object will
+have a `pos` property that indicates the character offset at which the
+error occurred, and a `loc` object that contains a `{line, column}`
+object referring to that same position.
+
+[estree]: https://github.com/estree/estree
+
+- **ecmaVersion**: Indicates the ECMAScript version to parse. Must be
+ either 3, 5, 6, or 7. This influences support for strict mode, the set
+ of reserved words, and support for new syntax features. Default is 6.
+
+ **NOTE**: Only 'stage 4' (finalized) ECMAScript 7 features are being
+ implemented by Acorn. That means that most of the draft standard is
+ not yet being parsed.
+
+- **sourceType**: Indicate the mode the code should be parsed in. Can be
+ either `"script"` or `"module"`.
+
+- **onInsertedSemicolon**: If given a callback, that callback will be
+ called whenever a missing semicolon is inserted by the parser. The
+ callback will be given the character offset of the point where the
+ semicolon is inserted as argument, and if `locations` is on, also a
+ `{line, column}` object representing this position.
+
+- **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing
+ commas.
+
+- **allowReserved**: If `false`, using a reserved word will generate
+ an error. Defaults to `true` for `ecmaVersion` 3, `false` for higher
+ versions. When given the value `"never"`, reserved words and
+ keywords can also not be used as property names (as in Internet
+ Explorer's old parser).
+
+- **allowReturnOutsideFunction**: By default, a return statement at
+ the top level raises an error. Set this to `true` to accept such
+ code.
+
+- **allowImportExportEverywhere**: By default, `import` and `export`
+ declarations can only appear at a program's top level. Setting this
+ option to `true` allows them anywhere where a statement is allowed.
+
+- **allowHashBang**: When this is enabled (off by default), if the
+ code starts with the characters `#!` (as in a shellscript), the
+ first line will be treated as a comment.
+
+- **locations**: When `true`, each node has a `loc` object attached
+ with `start` and `end` subobjects, each of which contains the
+ one-based line and zero-based column numbers in `{line, column}`
+ form. Default is `false`.
+
+- **onToken**: If a function is passed for this option, each found
+ token will be passed in same format as tokens returned from
+ `tokenizer().getToken()`.
+
+ If array is passed, each found token is pushed to it.
+
+ Note that you are not allowed to call the parser from the
+ callback—that will corrupt its internal state.
+
+- **onComment**: If a function is passed for this option, whenever a
+ comment is encountered the function will be called with the
+ following parameters:
+
+ - `block`: `true` if the comment is a block comment, false if it
+ is a line comment.
+ - `text`: The content of the comment.
+ - `start`: Character offset of the start of the comment.
+ - `end`: Character offset of the end of the comment.
+
+ When the `locations` options is on, the `{line, column}` locations
+ of the comment’s start and end are passed as two additional
+ parameters.
+
+ If array is passed for this option, each found comment is pushed
+ to it as object in Esprima format:
+
+ ```javascript
+ {
+ "type": "Line" | "Block",
+ "value": "comment text",
+ "start": Number,
+ "end": Number,
+ // If `locations` option is on:
+ "loc": {
+ "start": {line: Number, column: Number}
+ "end": {line: Number, column: Number}
+ },
+ // If `ranges` option is on:
+ "range": [Number, Number]
+ }
+ ```
+
+ Note that you are not allowed to call the parser from the
+ callback—that will corrupt its internal state.
+
+- **ranges**: Nodes have their start and end characters offsets
+ recorded in `start` and `end` properties (directly on the node,
+ rather than the `loc` object, which holds line/column data. To also
+ add a [semi-standardized][range] `range` property holding a
+ `[start, end]` array with the same numbers, set the `ranges` option
+ to `true`.
+
+- **program**: It is possible to parse multiple files into a single
+ AST by passing the tree produced by parsing the first file as the
+ `program` option in subsequent parses. This will add the toplevel
+ forms of the parsed file to the "Program" (top) node of an existing
+ parse tree.
+
+- **sourceFile**: When the `locations` option is `true`, you can pass
+ this option to add a `source` attribute in every node’s `loc`
+ object. Note that the contents of this option are not examined or
+ processed in any way; you are free to use whatever format you
+ choose.
+
+- **directSourceFile**: Like `sourceFile`, but a `sourceFile` property
+ will be added (regardless of the `location` option) directly to the
+ nodes, rather than the `loc` object.
+
+- **preserveParens**: If this option is `true`, parenthesized expressions
+ are represented by (non-standard) `ParenthesizedExpression` nodes
+ that have a single `expression` property containing the expression
+ inside parentheses.
+
+[range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+
+**parseExpressionAt**`(input, offset, options)` will parse a single
+expression in a string, and return its AST. It will not complain if
+there is more of the string left after the expression.
+
+**getLineInfo**`(input, offset)` can be used to get a `{line,
+column}` object for a given program string and character offset.
+
+**tokenizer**`(input, options)` returns an object with a `getToken`
+method that can be called repeatedly to get the next token, a `{start,
+end, type, value}` object (with added `loc` property when the
+`locations` option is enabled and `range` property when the `ranges`
+option is enabled). When the token's type is `tokTypes.eof`, you
+should stop calling the method, since it will keep returning that same
+token forever.
+
+In ES6 environment, returned result can be used as any other
+protocol-compliant iterable:
+
+```javascript
+for (let token of acorn.tokenizer(str)) {
+ // iterate over the tokens
+}
+
+// transform code to array of tokens:
+var tokens = [...acorn.tokenizer(str)];
+```
+
+**tokTypes** holds an object mapping names to the token type objects
+that end up in the `type` properties of tokens.
+
+#### Note on using with [Escodegen][escodegen]
+
+Escodegen supports generating comments from AST, attached in
+Esprima-specific format. In order to simulate same format in
+Acorn, consider following example:
+
+```javascript
+var comments = [], tokens = [];
+
+var ast = acorn.parse('var x = 42; // answer', {
+ // collect ranges for each node
+ ranges: true,
+ // collect comments in Esprima's format
+ onComment: comments,
+ // collect token ranges
+ onToken: tokens
+});
+
+// attach comments using collected information
+escodegen.attachComments(ast, comments, tokens);
+
+// generate code
+console.log(escodegen.generate(ast, {comment: true}));
+// > 'var x = 42; // answer'
+```
+
+[escodegen]: https://github.com/estools/escodegen
+
+### dist/acorn_loose.js ###
+
+This file implements an error-tolerant parser. It exposes a single
+function. The loose parser is accessible in node.js via `require("acorn/dist/acorn_loose")`.
+
+**parse_dammit**`(input, options)` takes the same arguments and
+returns the same syntax tree as the `parse` function in `acorn.js`,
+but never raises an error, and will do its best to parse syntactically
+invalid code in as meaningful a way as it can. It'll insert identifier
+nodes with name `"✖"` as placeholders in places where it can't make
+sense of the input. Depends on `acorn.js`, because it uses the same
+tokenizer.
+
+### dist/walk.js ###
+
+Implements an abstract syntax tree walker. Will store its interface in
+`acorn.walk` when loaded without a module system.
+
+**simple**`(node, visitors, base, state)` does a 'simple' walk over
+a tree. `node` should be the AST node to walk, and `visitors` an
+object with properties whose names correspond to node types in the
+[ESTree spec][estree]. The properties should contain functions
+that will be called with the node object and, if applicable the state
+at that point. The last two arguments are optional. `base` is a walker
+algorithm, and `state` is a start state. The default walker will
+simply visit all statements and expressions and not produce a
+meaningful state. (An example of a use of state is to track scope at
+each point in the tree.)
+
+**ancestor**`(node, visitors, base, state)` does a 'simple' walk over
+a tree, building up an array of ancestor nodes (including the current node)
+and passing the array to the callbacks as a third parameter.
+
+**recursive**`(node, state, functions, base)` does a 'recursive'
+walk, where the walker functions are responsible for continuing the
+walk on the child nodes of their target node. `state` is the start
+state, and `functions` should contain an object that maps node types
+to walker functions. Such functions are called with `(node, state, c)`
+arguments, and can cause the walk to continue on a sub-node by calling
+the `c` argument on it with `(node, state)` arguments. The optional
+`base` argument provides the fallback walker functions for node types
+that aren't handled in the `functions` object. If not given, the
+default walkers will be used.
+
+**make**`(functions, base)` builds a new walker object by using the
+walker functions in `functions` and filling in the missing ones by
+taking defaults from `base`.
+
+**findNodeAt**`(node, start, end, test, base, state)` tries to
+locate a node in a tree at the given start and/or end offsets, which
+satisfies the predicate `test`. `start` and `end` can be either `null`
+(as wildcard) or a number. `test` may be a string (indicating a node
+type) or a function that takes `(nodeType, node)` arguments and
+returns a boolean indicating whether this node is interesting. `base`
+and `state` are optional, and can be used to specify a custom walker.
+Nodes are tested from inner to outer, so if two nodes match the
+boundaries, the inner one will be preferred.
+
+**findNodeAround**`(node, pos, test, base, state)` is a lot like
+`findNodeAt`, but will match any node that exists 'around' (spanning)
+the given position.
+
+**findNodeAfter**`(node, pos, test, base, state)` is similar to
+`findNodeAround`, but will match all nodes *after* the given position
+(testing outer nodes before inner nodes).
+
+## Command line interface
+
+The `bin/acorn` utility can be used to parse a file from the command
+line. It accepts as arguments its input file and the following
+options:
+
+- `--ecma3|--ecma5|--ecma6|--ecma7`: Sets the ECMAScript version to parse. Default is
+ version 5.
+
+- `--module`: Sets the parsing mode to `"module"`. Is set to `"script"` otherwise.
+
+- `--locations`: Attaches a "loc" object to each node with "start" and
+ "end" subobjects, each of which contains the one-based line and
+ zero-based column numbers in `{line, column}` form.
+
+- `--allow-hash-bang`: If the code starts with the characters #! (as in a shellscript), the first line will be treated as a comment.
+
+- `--compact`: No whitespace is used in the AST output.
+
+- `--silent`: Do not output the AST, just return the exit status.
+
+- `--help`: Print the usage information and quit.
+
+The utility spits out the syntax tree as JSON data.
+
+## Build system
+
+Acorn is written in ECMAScript 6, as a set of small modules, in the
+project's `src` directory, and compiled down to bigger ECMAScript 3
+files in `dist` using [Browserify](http://browserify.org) and
+[Babel](http://babeljs.io/). If you are already using Babel, you can
+consider including the modules directly.
+
+The command-line test runner (`npm test`) uses the ES6 modules. The
+browser-based test page (`test/index.html`) uses the compiled modules.
+The `bin/build-acorn.js` script builds the latter from the former.
+
+If you are working on Acorn, you'll probably want to try the code out
+directly, without an intermediate build step. In your scripts, you can
+register the Babel require shim like this:
+
+ require("babel-core/register")
+
+That will allow you to directly `require` the ES6 modules.
+
+## Plugins
+
+Acorn is designed support allow plugins which, within reasonable
+bounds, redefine the way the parser works. Plugins can add new token
+types and new tokenizer contexts (if necessary), and extend methods in
+the parser object. This is not a clean, elegant API—using it requires
+an understanding of Acorn's internals, and plugins are likely to break
+whenever those internals are significantly changed. But still, it is
+_possible_, in this way, to create parsers for JavaScript dialects
+without forking all of Acorn. And in principle it is even possible to
+combine such plugins, so that if you have, for example, a plugin for
+parsing types and a plugin for parsing JSX-style XML literals, you
+could load them both and parse code with both JSX tags and types.
+
+A plugin should register itself by adding a property to
+`acorn.plugins`, which holds a function. Calling `acorn.parse`, a
+`plugins` option can be passed, holding an object mapping plugin names
+to configuration values (or just `true` for plugins that don't take
+options). After the parser object has been created, the initialization
+functions for the chosen plugins are called with `(parser,
+configValue)` arguments. They are expected to use the `parser.extend`
+method to extend parser methods. For example, the `readToken` method
+could be extended like this:
+
+```javascript
+parser.extend("readToken", function(nextMethod) {
+ return function(code) {
+ console.log("Reading a token!")
+ return nextMethod.call(this, code)
+ }
+})
+```
+
+The `nextMethod` argument passed to `extend`'s second argument is the
+previous value of this method, and should usually be called through to
+whenever the extended method does not handle the call itself.
+
+Similarly, the loose parser allows plugins to register themselves via
+`acorn.pluginsLoose`. The extension mechanism is the same as for the
+normal parser:
+
+```javascript
+looseParser.extend("readToken", function(nextMethod) {
+ return function() {
+ console.log("Reading a token in the loose parser!")
+ return nextMethod.call(this)
+ }
+})
+```
+
+### Existing plugins
+
+ - [`acorn-jsx`](https://github.com/RReverser/acorn-jsx): Parse [Facebook JSX syntax extensions](https://github.com/facebook/jsx)
+ - [`acorn-es7-plugin`](https://github.com/MatAtBread/acorn-es7-plugin/): Parse [async/await syntax proposal](https://github.com/tc39/ecmascript-asyncawait)
+ - [`acorn-object-spread`](https://github.com/UXtemple/acorn-object-spread): Parse [object spread syntax proposal](https://github.com/sebmarkbage/ecmascript-rest-spread)
+ - [`acorn-es7`](https://www.npmjs.com/package/acorn-es7): Parse [decorator syntax proposal](https://github.com/wycats/javascript-decorators)
+ - [`acorn-objj`](https://www.npmjs.com/package/acorn-objj): [Objective-J](http://www.cappuccino-project.org/learn/objective-j.html) language parser built as Acorn plugin
diff --git a/node_modules/acorn/bin/acorn b/node_modules/acorn/bin/acorn
new file mode 100755
index 00000000..cf4acd56
--- /dev/null
+++ b/node_modules/acorn/bin/acorn
@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var acorn = require('../dist/acorn.js');
+
+var infile;
+var forceFile;
+var silent = false;
+var compact = false;
+var tokenize = false;
+var options = {}
+
+function help(status) {
+ var print = (status == 0) ? console.log : console.error
+ print("usage: " + path.basename(process.argv[1]) + " [--ecma3|--ecma5|--ecma6|--ecma7]")
+ print(" [--tokenize] [--locations] [---allow-hash-bang] [--compact] [--silent] [--module] [--help] [--] [infile]")
+ process.exit(status)
+}
+
+for (var i = 2; i < process.argv.length; ++i) {
+ var arg = process.argv[i]
+ if ((arg == "-" || arg[0] != "-") && !infile) infile = arg
+ else if (arg == "--" && !infile && i + 2 == process.argv.length) forceFile = infile = process.argv[++i]
+ else if (arg == "--ecma3") options.ecmaVersion = 3
+ else if (arg == "--ecma5") options.ecmaVersion = 5
+ else if (arg == "--ecma6") options.ecmaVersion = 6
+ else if (arg == "--ecma7") options.ecmaVersion = 7
+ else if (arg == "--locations") options.locations = true
+ else if (arg == "--allow-hash-bang") options.allowHashBang = true
+ else if (arg == "--silent") silent = true
+ else if (arg == "--compact") compact = true
+ else if (arg == "--help") help(0)
+ else if (arg == "--tokenize") tokenize = true
+ else if (arg == "--module") options.sourceType = 'module'
+ else help(1)
+}
+
+function run(code) {
+ var result
+ if (!tokenize) {
+ try { result = acorn.parse(code, options) }
+ catch(e) { console.error(e.message); process.exit(1) }
+ } else {
+ result = []
+ var tokenizer = acorn.tokenizer(code, options), token
+ while (true) {
+ try { token = tokenizer.getToken() }
+ catch(e) { console.error(e.message); process.exit(1) }
+ result.push(token)
+ if (token.type == acorn.tokTypes.eof) break
+ }
+ }
+ if (!silent) console.log(JSON.stringify(result, null, compact ? null : 2))
+}
+
+if (forceFile || infile && infile != "-") {
+ run(fs.readFileSync(infile, "utf8"))
+} else {
+ var code = ""
+ process.stdin.resume()
+ process.stdin.on("data", function (chunk) { return code += chunk; })
+ process.stdin.on("end", function () { return run(code); })
+}
\ No newline at end of file
diff --git a/node_modules/acorn/bin/generate-identifier-regex.js b/node_modules/acorn/bin/generate-identifier-regex.js
new file mode 100644
index 00000000..100e8cf2
--- /dev/null
+++ b/node_modules/acorn/bin/generate-identifier-regex.js
@@ -0,0 +1,55 @@
+'use strict';
+
+// Which Unicode version should be used?
+var version = '9.0.0';
+
+var start = require('unicode-' + version + '/Binary_Property/ID_Start/code-points.js')
+ .filter(function(ch) { return ch > 0x7f; });
+var last = -1;
+var cont = [0x200c, 0x200d].concat(require('unicode-' + version + '/Binary_Property/ID_Continue/code-points.js')
+ .filter(function(ch) { return ch > 0x7f && search(start, ch, last + 1) == -1; }));
+
+function search(arr, ch, starting) {
+ for (var i = starting; arr[i] <= ch && i < arr.length; last = i++)
+ if (arr[i] === ch)
+ return i;
+ return -1;
+}
+
+function pad(str, width) {
+ while (str.length < width) str = "0" + str;
+ return str;
+}
+
+function esc(code) {
+ var hex = code.toString(16);
+ if (hex.length <= 2) return "\\x" + pad(hex, 2);
+ else return "\\u" + pad(hex, 4);
+}
+
+function generate(chars) {
+ var astral = [], re = "";
+ for (var i = 0, at = 0x10000; i < chars.length; i++) {
+ var from = chars[i], to = from;
+ while (i < chars.length - 1 && chars[i + 1] == to + 1) {
+ i++;
+ to++;
+ }
+ if (to <= 0xffff) {
+ if (from == to) re += esc(from);
+ else if (from + 1 == to) re += esc(from) + esc(to);
+ else re += esc(from) + "-" + esc(to);
+ } else {
+ astral.push(from - at, to - from);
+ at = to;
+ }
+ }
+ return {nonASCII: re, astral: astral};
+}
+
+var startData = generate(start), contData = generate(cont);
+
+console.log("let nonASCIIidentifierStartChars = \"" + startData.nonASCII + "\"");
+console.log("let nonASCIIidentifierChars = \"" + contData.nonASCII + "\"");
+console.log("const astralIdentifierStartCodes = " + JSON.stringify(startData.astral));
+console.log("const astralIdentifierCodes = " + JSON.stringify(contData.astral));
diff --git a/node_modules/acorn/bin/update_authors.sh b/node_modules/acorn/bin/update_authors.sh
new file mode 100755
index 00000000..466c8db5
--- /dev/null
+++ b/node_modules/acorn/bin/update_authors.sh
@@ -0,0 +1,6 @@
+# Combine existing list of authors with everyone known in git, sort, add header.
+tail --lines=+3 AUTHORS > AUTHORS.tmp
+git log --format='%aN' | grep -v abraidwood >> AUTHORS.tmp
+echo -e "List of Acorn contributors. Updated before every release.\n" > AUTHORS
+sort -u AUTHORS.tmp >> AUTHORS
+rm -f AUTHORS.tmp
diff --git a/node_modules/acorn/dist/.keep b/node_modules/acorn/dist/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/node_modules/acorn/dist/acorn.es.js b/node_modules/acorn/dist/acorn.es.js
new file mode 100644
index 00000000..4460957f
--- /dev/null
+++ b/node_modules/acorn/dist/acorn.es.js
@@ -0,0 +1,3112 @@
+// Reserved word lists for various dialects of the language
+
+var reservedWords = {
+ 3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
+ 5: "class enum extends super const export import",
+ 6: "enum",
+ 7: "enum",
+ strict: "implements interface let package private protected public static yield",
+ strictBind: "eval arguments"
+}
+
+// And the keywords
+
+var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this"
+
+var keywords = {
+ 5: ecma5AndLessKeywords,
+ 6: ecma5AndLessKeywords + " const class extends export import super"
+}
+
+// ## Character categories
+
+// Big ugly regular expressions that match characters in the
+// whitespace, identifier, and identifier-start categories. These
+// are only applied when a character is found to actually have a
+// code point above 128.
+// Generated by `bin/generate-identifier-regex.js`.
+
+var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fd5\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ae\ua7b0-\ua7b7\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab65\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc"
+var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d4-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d01-\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1cf8\u1cf9\u1dc0-\u1df5\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua900-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f"
+
+var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]")
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]")
+
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null
+
+// These are a run-length and offset encoded representation of the
+// >0xffff code points that are a valid part of identifiers. The
+// offset starts at 0x10000, and each pair of numbers represents an
+// offset to the next range, and then a size of the range. They were
+// generated by bin/generate-identifier-regex.js
+var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541]
+var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239]
+
+// This has a complexity linear to the value of the code. The
+// assumption is that looking up astral identifier characters is
+// rare.
+function isInAstralSet(code, set) {
+ var pos = 0x10000
+ for (var i = 0; i < set.length; i += 2) {
+ pos += set[i]
+ if (pos > code) return false
+ pos += set[i + 1]
+ if (pos >= code) return true
+ }
+}
+
+// Test whether a given character code starts an identifier.
+
+function isIdentifierStart(code, astral) {
+ if (code < 65) return code === 36
+ if (code < 91) return true
+ if (code < 97) return code === 95
+ if (code < 123) return true
+ if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))
+ if (astral === false) return false
+ return isInAstralSet(code, astralIdentifierStartCodes)
+}
+
+// Test whether a given character is part of an identifier.
+
+function isIdentifierChar(code, astral) {
+ if (code < 48) return code === 36
+ if (code < 58) return true
+ if (code < 65) return false
+ if (code < 91) return true
+ if (code < 97) return code === 95
+ if (code < 123) return true
+ if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code))
+ if (astral === false) return false
+ return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
+}
+
+// ## Token types
+
+// The assignment of fine-grained, information-carrying type objects
+// allows the tokenizer to store the information it has about a
+// token in a way that is very cheap for the parser to look up.
+
+// All token type variables start with an underscore, to make them
+// easy to recognize.
+
+// The `beforeExpr` property is used to disambiguate between regular
+// expressions and divisions. It is set on all token types that can
+// be followed by an expression (thus, a slash after them would be a
+// regular expression).
+//
+// The `startsExpr` property is used to check if the token ends a
+// `yield` expression. It is set on all token types that either can
+// directly start an expression (like a quotation mark) or can
+// continue an expression (like the body of a string).
+//
+// `isLoop` marks a keyword as starting a loop, which is important
+// to know when parsing a label, in order to allow or disallow
+// continue jumps to that label.
+
+var TokenType = function TokenType(label, conf) {
+ if ( conf === void 0 ) conf = {};
+
+ this.label = label
+ this.keyword = conf.keyword
+ this.beforeExpr = !!conf.beforeExpr
+ this.startsExpr = !!conf.startsExpr
+ this.isLoop = !!conf.isLoop
+ this.isAssign = !!conf.isAssign
+ this.prefix = !!conf.prefix
+ this.postfix = !!conf.postfix
+ this.binop = conf.binop || null
+ this.updateContext = null
+};
+
+function binop(name, prec) {
+ return new TokenType(name, {beforeExpr: true, binop: prec})
+}
+var beforeExpr = {beforeExpr: true};
+var startsExpr = {startsExpr: true};
+// Map keyword names to token types.
+
+var keywordTypes = {}
+
+// Succinct definitions of keyword token types
+function kw(name, options) {
+ if ( options === void 0 ) options = {};
+
+ options.keyword = name
+ return keywordTypes[name] = new TokenType(name, options)
+}
+
+var tt = {
+ num: new TokenType("num", startsExpr),
+ regexp: new TokenType("regexp", startsExpr),
+ string: new TokenType("string", startsExpr),
+ name: new TokenType("name", startsExpr),
+ eof: new TokenType("eof"),
+
+ // Punctuation token types.
+ bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
+ bracketR: new TokenType("]"),
+ braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
+ braceR: new TokenType("}"),
+ parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
+ parenR: new TokenType(")"),
+ comma: new TokenType(",", beforeExpr),
+ semi: new TokenType(";", beforeExpr),
+ colon: new TokenType(":", beforeExpr),
+ dot: new TokenType("."),
+ question: new TokenType("?", beforeExpr),
+ arrow: new TokenType("=>", beforeExpr),
+ template: new TokenType("template"),
+ ellipsis: new TokenType("...", beforeExpr),
+ backQuote: new TokenType("`", startsExpr),
+ dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
+
+ // Operators. These carry several kinds of properties to help the
+ // parser use them properly (the presence of these properties is
+ // what categorizes them as operators).
+ //
+ // `binop`, when present, specifies that this operator is a binary
+ // operator, and will refer to its precedence.
+ //
+ // `prefix` and `postfix` mark the operator as a prefix or postfix
+ // unary operator.
+ //
+ // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+ // binary operators with a very low precedence, that should result
+ // in AssignmentExpression nodes.
+
+ eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
+ assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
+ incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
+ prefix: new TokenType("prefix", {beforeExpr: true, prefix: true, startsExpr: true}),
+ logicalOR: binop("||", 1),
+ logicalAND: binop("&&", 2),
+ bitwiseOR: binop("|", 3),
+ bitwiseXOR: binop("^", 4),
+ bitwiseAND: binop("&", 5),
+ equality: binop("==/!=", 6),
+ relational: binop("", 7),
+ bitShift: binop("<>", 8),
+ plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
+ modulo: binop("%", 10),
+ star: binop("*", 10),
+ slash: binop("/", 10),
+ starstar: new TokenType("**", {beforeExpr: true}),
+
+ // Keyword token types.
+ _break: kw("break"),
+ _case: kw("case", beforeExpr),
+ _catch: kw("catch"),
+ _continue: kw("continue"),
+ _debugger: kw("debugger"),
+ _default: kw("default", beforeExpr),
+ _do: kw("do", {isLoop: true, beforeExpr: true}),
+ _else: kw("else", beforeExpr),
+ _finally: kw("finally"),
+ _for: kw("for", {isLoop: true}),
+ _function: kw("function", startsExpr),
+ _if: kw("if"),
+ _return: kw("return", beforeExpr),
+ _switch: kw("switch"),
+ _throw: kw("throw", beforeExpr),
+ _try: kw("try"),
+ _var: kw("var"),
+ _const: kw("const"),
+ _while: kw("while", {isLoop: true}),
+ _with: kw("with"),
+ _new: kw("new", {beforeExpr: true, startsExpr: true}),
+ _this: kw("this", startsExpr),
+ _super: kw("super", startsExpr),
+ _class: kw("class"),
+ _extends: kw("extends", beforeExpr),
+ _export: kw("export"),
+ _import: kw("import"),
+ _null: kw("null", startsExpr),
+ _true: kw("true", startsExpr),
+ _false: kw("false", startsExpr),
+ _in: kw("in", {beforeExpr: true, binop: 7}),
+ _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
+ _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
+ _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
+ _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
+}
+
+// Matches a whole line break (where CRLF is considered a single
+// line break). Used to count lines.
+
+var lineBreak = /\r\n?|\n|\u2028|\u2029/
+var lineBreakG = new RegExp(lineBreak.source, "g")
+
+function isNewLine(code) {
+ return code === 10 || code === 13 || code === 0x2028 || code == 0x2029
+}
+
+var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/
+
+var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g
+
+function isArray(obj) {
+ return Object.prototype.toString.call(obj) === "[object Array]"
+}
+
+// Checks if an object has a property.
+
+function has(obj, propName) {
+ return Object.prototype.hasOwnProperty.call(obj, propName)
+}
+
+// These are used when `options.locations` is on, for the
+// `startLoc` and `endLoc` properties.
+
+var Position = function Position(line, col) {
+ this.line = line
+ this.column = col
+};
+
+Position.prototype.offset = function offset (n) {
+ return new Position(this.line, this.column + n)
+};
+
+var SourceLocation = function SourceLocation(p, start, end) {
+ this.start = start
+ this.end = end
+ if (p.sourceFile !== null) this.source = p.sourceFile
+};
+
+// The `getLineInfo` function is mostly useful when the
+// `locations` option is off (for performance reasons) and you
+// want to find the line/column position for a given character
+// offset. `input` should be the code string that the offset refers
+// into.
+
+function getLineInfo(input, offset) {
+ for (var line = 1, cur = 0;;) {
+ lineBreakG.lastIndex = cur
+ var match = lineBreakG.exec(input)
+ if (match && match.index < offset) {
+ ++line
+ cur = match.index + match[0].length
+ } else {
+ return new Position(line, offset - cur)
+ }
+ }
+}
+
+// A second optional argument can be given to further configure
+// the parser process. These options are recognized:
+
+var defaultOptions = {
+ // `ecmaVersion` indicates the ECMAScript version to parse. Must
+ // be either 3, or 5, or 6. This influences support for strict
+ // mode, the set of reserved words, support for getters and
+ // setters and other features. The default is 6.
+ ecmaVersion: 6,
+ // Source type ("script" or "module") for different semantics
+ sourceType: "script",
+ // `onInsertedSemicolon` can be a callback that will be called
+ // when a semicolon is automatically inserted. It will be passed
+ // th position of the comma as an offset, and if `locations` is
+ // enabled, it is given the location as a `{line, column}` object
+ // as second argument.
+ onInsertedSemicolon: null,
+ // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
+ // trailing commas.
+ onTrailingComma: null,
+ // By default, reserved words are only enforced if ecmaVersion >= 5.
+ // Set `allowReserved` to a boolean value to explicitly turn this on
+ // an off. When this option has the value "never", reserved words
+ // and keywords can also not be used as property names.
+ allowReserved: null,
+ // When enabled, a return at the top level is not considered an
+ // error.
+ allowReturnOutsideFunction: false,
+ // When enabled, import/export statements are not constrained to
+ // appearing at the top of the program.
+ allowImportExportEverywhere: false,
+ // When enabled, hashbang directive in the beginning of file
+ // is allowed and treated as a line comment.
+ allowHashBang: false,
+ // When `locations` is on, `loc` properties holding objects with
+ // `start` and `end` properties in `{line, column}` form (with
+ // line being 1-based and column 0-based) will be attached to the
+ // nodes.
+ locations: false,
+ // A function can be passed as `onToken` option, which will
+ // cause Acorn to call that function with object in the same
+ // format as tokens returned from `tokenizer().getToken()`. Note
+ // that you are not allowed to call the parser from the
+ // callback—that will corrupt its internal state.
+ onToken: null,
+ // A function can be passed as `onComment` option, which will
+ // cause Acorn to call that function with `(block, text, start,
+ // end)` parameters whenever a comment is skipped. `block` is a
+ // boolean indicating whether this is a block (`/* */`) comment,
+ // `text` is the content of the comment, and `start` and `end` are
+ // character offsets that denote the start and end of the comment.
+ // When the `locations` option is on, two more parameters are
+ // passed, the full `{line, column}` locations of the start and
+ // end of the comments. Note that you are not allowed to call the
+ // parser from the callback—that will corrupt its internal state.
+ onComment: null,
+ // Nodes have their start and end characters offsets recorded in
+ // `start` and `end` properties (directly on the node, rather than
+ // the `loc` object, which holds line/column data. To also add a
+ // [semi-standardized][range] `range` property holding a `[start,
+ // end]` array with the same numbers, set the `ranges` option to
+ // `true`.
+ //
+ // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+ ranges: false,
+ // It is possible to parse multiple files into a single AST by
+ // passing the tree produced by parsing the first file as
+ // `program` option in subsequent parses. This will add the
+ // toplevel forms of the parsed file to the `Program` (top) node
+ // of an existing parse tree.
+ program: null,
+ // When `locations` is on, you can pass this to record the source
+ // file in every node's `loc` object.
+ sourceFile: null,
+ // This value, if given, is stored in every node, whether
+ // `locations` is on or off.
+ directSourceFile: null,
+ // When enabled, parenthesized expressions are represented by
+ // (non-standard) ParenthesizedExpression nodes
+ preserveParens: false,
+ plugins: {}
+}
+
+// Interpret and default an options object
+
+function getOptions(opts) {
+ var options = {}
+ for (var opt in defaultOptions)
+ options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
+ if (options.allowReserved == null)
+ options.allowReserved = options.ecmaVersion < 5
+
+ if (isArray(options.onToken)) {
+ var tokens = options.onToken
+ options.onToken = function (token) { return tokens.push(token); }
+ }
+ if (isArray(options.onComment))
+ options.onComment = pushComment(options, options.onComment)
+
+ return options
+}
+
+function pushComment(options, array) {
+ return function (block, text, start, end, startLoc, endLoc) {
+ var comment = {
+ type: block ? 'Block' : 'Line',
+ value: text,
+ start: start,
+ end: end
+ }
+ if (options.locations)
+ comment.loc = new SourceLocation(this, startLoc, endLoc)
+ if (options.ranges)
+ comment.range = [start, end]
+ array.push(comment)
+ }
+}
+
+// Registered plugins
+var plugins = {}
+
+function keywordRegexp(words) {
+ return new RegExp("^(" + words.replace(/ /g, "|") + ")$")
+}
+
+var Parser = function Parser(options, input, startPos) {
+ this.options = options = getOptions(options)
+ this.sourceFile = options.sourceFile
+ this.keywords = keywordRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5])
+ var reserved = options.allowReserved ? "" :
+ reservedWords[options.ecmaVersion] + (options.sourceType == "module" ? " await" : "")
+ this.reservedWords = keywordRegexp(reserved)
+ var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict
+ this.reservedWordsStrict = keywordRegexp(reservedStrict)
+ this.reservedWordsStrictBind = keywordRegexp(reservedStrict + " " + reservedWords.strictBind)
+ this.input = String(input)
+
+ // Used to signal to callers of `readWord1` whether the word
+ // contained any escape sequences. This is needed because words with
+ // escape sequences must not be interpreted as keywords.
+ this.containsEsc = false
+
+ // Load plugins
+ this.loadPlugins(options.plugins)
+
+ // Set up token state
+
+ // The current position of the tokenizer in the input.
+ if (startPos) {
+ this.pos = startPos
+ this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos))
+ this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length
+ } else {
+ this.pos = this.lineStart = 0
+ this.curLine = 1
+ }
+
+ // Properties of the current token:
+ // Its type
+ this.type = tt.eof
+ // For tokens that include more information than their type, the value
+ this.value = null
+ // Its start and end offset
+ this.start = this.end = this.pos
+ // And, if locations are used, the {line, column} object
+ // corresponding to those offsets
+ this.startLoc = this.endLoc = this.curPosition()
+
+ // Position information for the previous token
+ this.lastTokEndLoc = this.lastTokStartLoc = null
+ this.lastTokStart = this.lastTokEnd = this.pos
+
+ // The context stack is used to superficially track syntactic
+ // context to predict whether a regular expression is allowed in a
+ // given position.
+ this.context = this.initialContext()
+ this.exprAllowed = true
+
+ // Figure out if it's a module code.
+ this.strict = this.inModule = options.sourceType === "module"
+
+ // Used to signify the start of a potential arrow function
+ this.potentialArrowAt = -1
+
+ // Flags to track whether we are in a function, a generator.
+ this.inFunction = this.inGenerator = false
+ // Labels in scope.
+ this.labels = []
+
+ // If enabled, skip leading hashbang line.
+ if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === '#!')
+ this.skipLineComment(2)
+};
+
+// DEPRECATED Kept for backwards compatibility until 3.0 in case a plugin uses them
+Parser.prototype.isKeyword = function isKeyword (word) { return this.keywords.test(word) };
+Parser.prototype.isReservedWord = function isReservedWord (word) { return this.reservedWords.test(word) };
+
+Parser.prototype.extend = function extend (name, f) {
+ this[name] = f(this[name])
+};
+
+Parser.prototype.loadPlugins = function loadPlugins (pluginConfigs) {
+ var this$1 = this;
+
+ for (var name in pluginConfigs) {
+ var plugin = plugins[name]
+ if (!plugin) throw new Error("Plugin '" + name + "' not found")
+ plugin(this$1, pluginConfigs[name])
+ }
+};
+
+Parser.prototype.parse = function parse () {
+ var node = this.options.program || this.startNode()
+ this.nextToken()
+ return this.parseTopLevel(node)
+};
+
+var pp = Parser.prototype
+
+// ## Parser utilities
+
+// Test whether a statement node is the string literal `"use strict"`.
+
+pp.isUseStrict = function(stmt) {
+ return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+ stmt.expression.type === "Literal" &&
+ stmt.expression.raw.slice(1, -1) === "use strict"
+}
+
+// Predicate that tests whether the next token is of the given
+// type, and if yes, consumes it as a side effect.
+
+pp.eat = function(type) {
+ if (this.type === type) {
+ this.next()
+ return true
+ } else {
+ return false
+ }
+}
+
+// Tests whether parsed token is a contextual keyword.
+
+pp.isContextual = function(name) {
+ return this.type === tt.name && this.value === name
+}
+
+// Consumes contextual keyword if possible.
+
+pp.eatContextual = function(name) {
+ return this.value === name && this.eat(tt.name)
+}
+
+// Asserts that following token is given contextual keyword.
+
+pp.expectContextual = function(name) {
+ if (!this.eatContextual(name)) this.unexpected()
+}
+
+// Test whether a semicolon can be inserted at the current position.
+
+pp.canInsertSemicolon = function() {
+ return this.type === tt.eof ||
+ this.type === tt.braceR ||
+ lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+}
+
+pp.insertSemicolon = function() {
+ if (this.canInsertSemicolon()) {
+ if (this.options.onInsertedSemicolon)
+ this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc)
+ return true
+ }
+}
+
+// Consume a semicolon, or, failing that, see if we are allowed to
+// pretend that there is a semicolon at this position.
+
+pp.semicolon = function() {
+ if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected()
+}
+
+pp.afterTrailingComma = function(tokType) {
+ if (this.type == tokType) {
+ if (this.options.onTrailingComma)
+ this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc)
+ this.next()
+ return true
+ }
+}
+
+// Expect a token of a given type. If found, consume it, otherwise,
+// raise an unexpected token error.
+
+pp.expect = function(type) {
+ this.eat(type) || this.unexpected()
+}
+
+// Raise an unexpected token error.
+
+pp.unexpected = function(pos) {
+ this.raise(pos != null ? pos : this.start, "Unexpected token")
+}
+
+var DestructuringErrors = function DestructuringErrors() {
+ this.shorthandAssign = 0
+ this.trailingComma = 0
+};
+
+pp.checkPatternErrors = function(refDestructuringErrors, andThrow) {
+ var trailing = refDestructuringErrors && refDestructuringErrors.trailingComma
+ if (!andThrow) return !!trailing
+ if (trailing) this.raise(trailing, "Comma is not permitted after the rest element")
+}
+
+pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
+ var pos = refDestructuringErrors && refDestructuringErrors.shorthandAssign
+ if (!andThrow) return !!pos
+ if (pos) this.raise(pos, "Shorthand property assignments are valid only in destructuring patterns")
+}
+
+var pp$1 = Parser.prototype
+
+// ### Statement parsing
+
+// Parse a program. Initializes the parser, reads any number of
+// statements, and wraps them in a Program node. Optionally takes a
+// `program` argument. If present, the statements will be appended
+// to its body instead of creating a new node.
+
+pp$1.parseTopLevel = function(node) {
+ var this$1 = this;
+
+ var first = true
+ if (!node.body) node.body = []
+ while (this.type !== tt.eof) {
+ var stmt = this$1.parseStatement(true, true)
+ node.body.push(stmt)
+ if (first) {
+ if (this$1.isUseStrict(stmt)) this$1.setStrict(true)
+ first = false
+ }
+ }
+ this.next()
+ if (this.options.ecmaVersion >= 6) {
+ node.sourceType = this.options.sourceType
+ }
+ return this.finishNode(node, "Program")
+}
+
+var loopLabel = {kind: "loop"};
+var switchLabel = {kind: "switch"};
+pp$1.isLet = function() {
+ if (this.type !== tt.name || this.options.ecmaVersion < 6 || this.value != "let") return false
+ skipWhiteSpace.lastIndex = this.pos
+ var skip = skipWhiteSpace.exec(this.input)
+ var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next)
+ if (nextCh === 91 || nextCh == 123) return true // '{' and '['
+ if (isIdentifierStart(nextCh, true)) {
+ for (var pos = next + 1; isIdentifierChar(this.input.charCodeAt(pos), true); ++pos) {}
+ var ident = this.input.slice(next, pos)
+ if (!this.isKeyword(ident)) return true
+ }
+ return false
+}
+
+// Parse a single statement.
+//
+// If expecting a statement and finding a slash operator, parse a
+// regular expression literal. This is to handle cases like
+// `if (foo) /blah/.exec(foo)`, where looking at the previous token
+// does not help.
+
+pp$1.parseStatement = function(declaration, topLevel) {
+ var starttype = this.type, node = this.startNode(), kind
+
+ if (this.isLet()) {
+ starttype = tt._var
+ kind = "let"
+ }
+
+ // Most types of statements are recognized by the keyword they
+ // start with. Many are trivial to parse, some require a bit of
+ // complexity.
+
+ switch (starttype) {
+ case tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
+ case tt._debugger: return this.parseDebuggerStatement(node)
+ case tt._do: return this.parseDoStatement(node)
+ case tt._for: return this.parseForStatement(node)
+ case tt._function:
+ if (!declaration && this.options.ecmaVersion >= 6) this.unexpected()
+ return this.parseFunctionStatement(node)
+ case tt._class:
+ if (!declaration) this.unexpected()
+ return this.parseClass(node, true)
+ case tt._if: return this.parseIfStatement(node)
+ case tt._return: return this.parseReturnStatement(node)
+ case tt._switch: return this.parseSwitchStatement(node)
+ case tt._throw: return this.parseThrowStatement(node)
+ case tt._try: return this.parseTryStatement(node)
+ case tt._const: case tt._var:
+ kind = kind || this.value
+ if (!declaration && kind != "var") this.unexpected()
+ return this.parseVarStatement(node, kind)
+ case tt._while: return this.parseWhileStatement(node)
+ case tt._with: return this.parseWithStatement(node)
+ case tt.braceL: return this.parseBlock()
+ case tt.semi: return this.parseEmptyStatement(node)
+ case tt._export:
+ case tt._import:
+ if (!this.options.allowImportExportEverywhere) {
+ if (!topLevel)
+ this.raise(this.start, "'import' and 'export' may only appear at the top level")
+ if (!this.inModule)
+ this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'")
+ }
+ return starttype === tt._import ? this.parseImport(node) : this.parseExport(node)
+
+ // If the statement does not start with a statement keyword or a
+ // brace, it's an ExpressionStatement or LabeledStatement. We
+ // simply start parsing an expression, and afterwards, if the
+ // next token is a colon and the expression was a simple
+ // Identifier node, we switch to interpreting it as a label.
+ default:
+ var maybeName = this.value, expr = this.parseExpression()
+ if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
+ return this.parseLabeledStatement(node, maybeName, expr)
+ else return this.parseExpressionStatement(node, expr)
+ }
+}
+
+pp$1.parseBreakContinueStatement = function(node, keyword) {
+ var this$1 = this;
+
+ var isBreak = keyword == "break"
+ this.next()
+ if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null
+ else if (this.type !== tt.name) this.unexpected()
+ else {
+ node.label = this.parseIdent()
+ this.semicolon()
+ }
+
+ // Verify that there is an actual destination to break or
+ // continue to.
+ for (var i = 0; i < this.labels.length; ++i) {
+ var lab = this$1.labels[i]
+ if (node.label == null || lab.name === node.label.name) {
+ if (lab.kind != null && (isBreak || lab.kind === "loop")) break
+ if (node.label && isBreak) break
+ }
+ }
+ if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword)
+ return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+}
+
+pp$1.parseDebuggerStatement = function(node) {
+ this.next()
+ this.semicolon()
+ return this.finishNode(node, "DebuggerStatement")
+}
+
+pp$1.parseDoStatement = function(node) {
+ this.next()
+ this.labels.push(loopLabel)
+ node.body = this.parseStatement(false)
+ this.labels.pop()
+ this.expect(tt._while)
+ node.test = this.parseParenExpression()
+ if (this.options.ecmaVersion >= 6)
+ this.eat(tt.semi)
+ else
+ this.semicolon()
+ return this.finishNode(node, "DoWhileStatement")
+}
+
+// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+// loop is non-trivial. Basically, we have to parse the init `var`
+// statement or expression, disallowing the `in` operator (see
+// the second parameter to `parseExpression`), and then check
+// whether the next token is `in` or `of`. When there is no init
+// part (semicolon immediately after the opening parenthesis), it
+// is a regular `for` loop.
+
+pp$1.parseForStatement = function(node) {
+ this.next()
+ this.labels.push(loopLabel)
+ this.expect(tt.parenL)
+ if (this.type === tt.semi) return this.parseFor(node, null)
+ var isLet = this.isLet()
+ if (this.type === tt._var || this.type === tt._const || isLet) {
+ var init$1 = this.startNode(), kind = isLet ? "let" : this.value
+ this.next()
+ this.parseVar(init$1, true, kind)
+ this.finishNode(init$1, "VariableDeclaration")
+ if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1 &&
+ !(kind !== "var" && init$1.declarations[0].init))
+ return this.parseForIn(node, init$1)
+ return this.parseFor(node, init$1)
+ }
+ var refDestructuringErrors = new DestructuringErrors
+ var init = this.parseExpression(true, refDestructuringErrors)
+ if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+ this.checkPatternErrors(refDestructuringErrors, true)
+ this.toAssignable(init)
+ this.checkLVal(init)
+ return this.parseForIn(node, init)
+ } else {
+ this.checkExpressionErrors(refDestructuringErrors, true)
+ }
+ return this.parseFor(node, init)
+}
+
+pp$1.parseFunctionStatement = function(node) {
+ this.next()
+ return this.parseFunction(node, true)
+}
+
+pp$1.parseIfStatement = function(node) {
+ this.next()
+ node.test = this.parseParenExpression()
+ node.consequent = this.parseStatement(false)
+ node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null
+ return this.finishNode(node, "IfStatement")
+}
+
+pp$1.parseReturnStatement = function(node) {
+ if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+ this.raise(this.start, "'return' outside of function")
+ this.next()
+
+ // In `return` (and `break`/`continue`), the keywords with
+ // optional arguments, we eagerly look for a semicolon or the
+ // possibility to insert one.
+
+ if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null
+ else { node.argument = this.parseExpression(); this.semicolon() }
+ return this.finishNode(node, "ReturnStatement")
+}
+
+pp$1.parseSwitchStatement = function(node) {
+ var this$1 = this;
+
+ this.next()
+ node.discriminant = this.parseParenExpression()
+ node.cases = []
+ this.expect(tt.braceL)
+ this.labels.push(switchLabel)
+
+ // Statements under must be grouped (by label) in SwitchCase
+ // nodes. `cur` is used to keep the node that we are currently
+ // adding statements to.
+
+ for (var cur, sawDefault = false; this.type != tt.braceR;) {
+ if (this$1.type === tt._case || this$1.type === tt._default) {
+ var isCase = this$1.type === tt._case
+ if (cur) this$1.finishNode(cur, "SwitchCase")
+ node.cases.push(cur = this$1.startNode())
+ cur.consequent = []
+ this$1.next()
+ if (isCase) {
+ cur.test = this$1.parseExpression()
+ } else {
+ if (sawDefault) this$1.raiseRecoverable(this$1.lastTokStart, "Multiple default clauses")
+ sawDefault = true
+ cur.test = null
+ }
+ this$1.expect(tt.colon)
+ } else {
+ if (!cur) this$1.unexpected()
+ cur.consequent.push(this$1.parseStatement(true))
+ }
+ }
+ if (cur) this.finishNode(cur, "SwitchCase")
+ this.next() // Closing brace
+ this.labels.pop()
+ return this.finishNode(node, "SwitchStatement")
+}
+
+pp$1.parseThrowStatement = function(node) {
+ this.next()
+ if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
+ this.raise(this.lastTokEnd, "Illegal newline after throw")
+ node.argument = this.parseExpression()
+ this.semicolon()
+ return this.finishNode(node, "ThrowStatement")
+}
+
+// Reused empty array added for node fields that are always empty.
+
+var empty = []
+
+pp$1.parseTryStatement = function(node) {
+ this.next()
+ node.block = this.parseBlock()
+ node.handler = null
+ if (this.type === tt._catch) {
+ var clause = this.startNode()
+ this.next()
+ this.expect(tt.parenL)
+ clause.param = this.parseBindingAtom()
+ this.checkLVal(clause.param, true)
+ this.expect(tt.parenR)
+ clause.body = this.parseBlock()
+ node.handler = this.finishNode(clause, "CatchClause")
+ }
+ node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null
+ if (!node.handler && !node.finalizer)
+ this.raise(node.start, "Missing catch or finally clause")
+ return this.finishNode(node, "TryStatement")
+}
+
+pp$1.parseVarStatement = function(node, kind) {
+ this.next()
+ this.parseVar(node, false, kind)
+ this.semicolon()
+ return this.finishNode(node, "VariableDeclaration")
+}
+
+pp$1.parseWhileStatement = function(node) {
+ this.next()
+ node.test = this.parseParenExpression()
+ this.labels.push(loopLabel)
+ node.body = this.parseStatement(false)
+ this.labels.pop()
+ return this.finishNode(node, "WhileStatement")
+}
+
+pp$1.parseWithStatement = function(node) {
+ if (this.strict) this.raise(this.start, "'with' in strict mode")
+ this.next()
+ node.object = this.parseParenExpression()
+ node.body = this.parseStatement(false)
+ return this.finishNode(node, "WithStatement")
+}
+
+pp$1.parseEmptyStatement = function(node) {
+ this.next()
+ return this.finishNode(node, "EmptyStatement")
+}
+
+pp$1.parseLabeledStatement = function(node, maybeName, expr) {
+ var this$1 = this;
+
+ for (var i = 0; i < this.labels.length; ++i)
+ if (this$1.labels[i].name === maybeName) this$1.raise(expr.start, "Label '" + maybeName + "' is already declared")
+ var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null
+ for (var i$1 = this.labels.length - 1; i$1 >= 0; i$1--) {
+ var label = this$1.labels[i$1]
+ if (label.statementStart == node.start) {
+ label.statementStart = this$1.start
+ label.kind = kind
+ } else break
+ }
+ this.labels.push({name: maybeName, kind: kind, statementStart: this.start})
+ node.body = this.parseStatement(true)
+ this.labels.pop()
+ node.label = expr
+ return this.finishNode(node, "LabeledStatement")
+}
+
+pp$1.parseExpressionStatement = function(node, expr) {
+ node.expression = expr
+ this.semicolon()
+ return this.finishNode(node, "ExpressionStatement")
+}
+
+// Parse a semicolon-enclosed block of statements, handling `"use
+// strict"` declarations when `allowStrict` is true (used for
+// function bodies).
+
+pp$1.parseBlock = function(allowStrict) {
+ var this$1 = this;
+
+ var node = this.startNode(), first = true, oldStrict
+ node.body = []
+ this.expect(tt.braceL)
+ while (!this.eat(tt.braceR)) {
+ var stmt = this$1.parseStatement(true)
+ node.body.push(stmt)
+ if (first && allowStrict && this$1.isUseStrict(stmt)) {
+ oldStrict = this$1.strict
+ this$1.setStrict(this$1.strict = true)
+ }
+ first = false
+ }
+ if (oldStrict === false) this.setStrict(false)
+ return this.finishNode(node, "BlockStatement")
+}
+
+// Parse a regular `for` loop. The disambiguation code in
+// `parseStatement` will already have parsed the init statement or
+// expression.
+
+pp$1.parseFor = function(node, init) {
+ node.init = init
+ this.expect(tt.semi)
+ node.test = this.type === tt.semi ? null : this.parseExpression()
+ this.expect(tt.semi)
+ node.update = this.type === tt.parenR ? null : this.parseExpression()
+ this.expect(tt.parenR)
+ node.body = this.parseStatement(false)
+ this.labels.pop()
+ return this.finishNode(node, "ForStatement")
+}
+
+// Parse a `for`/`in` and `for`/`of` loop, which are almost
+// same from parser's perspective.
+
+pp$1.parseForIn = function(node, init) {
+ var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement"
+ this.next()
+ node.left = init
+ node.right = this.parseExpression()
+ this.expect(tt.parenR)
+ node.body = this.parseStatement(false)
+ this.labels.pop()
+ return this.finishNode(node, type)
+}
+
+// Parse a list of variable declarations.
+
+pp$1.parseVar = function(node, isFor, kind) {
+ var this$1 = this;
+
+ node.declarations = []
+ node.kind = kind
+ for (;;) {
+ var decl = this$1.startNode()
+ this$1.parseVarId(decl)
+ if (this$1.eat(tt.eq)) {
+ decl.init = this$1.parseMaybeAssign(isFor)
+ } else if (kind === "const" && !(this$1.type === tt._in || (this$1.options.ecmaVersion >= 6 && this$1.isContextual("of")))) {
+ this$1.unexpected()
+ } else if (decl.id.type != "Identifier" && !(isFor && (this$1.type === tt._in || this$1.isContextual("of")))) {
+ this$1.raise(this$1.lastTokEnd, "Complex binding patterns require an initialization value")
+ } else {
+ decl.init = null
+ }
+ node.declarations.push(this$1.finishNode(decl, "VariableDeclarator"))
+ if (!this$1.eat(tt.comma)) break
+ }
+ return node
+}
+
+pp$1.parseVarId = function(decl) {
+ decl.id = this.parseBindingAtom()
+ this.checkLVal(decl.id, true)
+}
+
+// Parse a function declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp$1.parseFunction = function(node, isStatement, allowExpressionBody) {
+ this.initFunction(node)
+ if (this.options.ecmaVersion >= 6)
+ node.generator = this.eat(tt.star)
+ var oldInGen = this.inGenerator
+ this.inGenerator = node.generator
+ if (isStatement || this.type === tt.name)
+ node.id = this.parseIdent()
+ this.parseFunctionParams(node)
+ this.parseFunctionBody(node, allowExpressionBody)
+ this.inGenerator = oldInGen
+ return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
+}
+
+pp$1.parseFunctionParams = function(node) {
+ this.expect(tt.parenL)
+ node.params = this.parseBindingList(tt.parenR, false, false, true)
+}
+
+// Parse a class declaration or literal (depending on the
+// `isStatement` parameter).
+
+pp$1.parseClass = function(node, isStatement) {
+ var this$1 = this;
+
+ this.next()
+ this.parseClassId(node, isStatement)
+ this.parseClassSuper(node)
+ var classBody = this.startNode()
+ var hadConstructor = false
+ classBody.body = []
+ this.expect(tt.braceL)
+ while (!this.eat(tt.braceR)) {
+ if (this$1.eat(tt.semi)) continue
+ var method = this$1.startNode()
+ var isGenerator = this$1.eat(tt.star)
+ var isMaybeStatic = this$1.type === tt.name && this$1.value === "static"
+ this$1.parsePropertyName(method)
+ method.static = isMaybeStatic && this$1.type !== tt.parenL
+ if (method.static) {
+ if (isGenerator) this$1.unexpected()
+ isGenerator = this$1.eat(tt.star)
+ this$1.parsePropertyName(method)
+ }
+ method.kind = "method"
+ var isGetSet = false
+ if (!method.computed) {
+ var key = method.key;
+ if (!isGenerator && key.type === "Identifier" && this$1.type !== tt.parenL && (key.name === "get" || key.name === "set")) {
+ isGetSet = true
+ method.kind = key.name
+ key = this$1.parsePropertyName(method)
+ }
+ if (!method.static && (key.type === "Identifier" && key.name === "constructor" ||
+ key.type === "Literal" && key.value === "constructor")) {
+ if (hadConstructor) this$1.raise(key.start, "Duplicate constructor in the same class")
+ if (isGetSet) this$1.raise(key.start, "Constructor can't have get/set modifier")
+ if (isGenerator) this$1.raise(key.start, "Constructor can't be a generator")
+ method.kind = "constructor"
+ hadConstructor = true
+ }
+ }
+ this$1.parseClassMethod(classBody, method, isGenerator)
+ if (isGetSet) {
+ var paramCount = method.kind === "get" ? 0 : 1
+ if (method.value.params.length !== paramCount) {
+ var start = method.value.start
+ if (method.kind === "get")
+ this$1.raiseRecoverable(start, "getter should have no params")
+ else
+ this$1.raiseRecoverable(start, "setter should have exactly one param")
+ }
+ if (method.kind === "set" && method.value.params[0].type === "RestElement")
+ this$1.raise(method.value.params[0].start, "Setter cannot use rest params")
+ }
+ }
+ node.body = this.finishNode(classBody, "ClassBody")
+ return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+}
+
+pp$1.parseClassMethod = function(classBody, method, isGenerator) {
+ method.value = this.parseMethod(isGenerator)
+ classBody.body.push(this.finishNode(method, "MethodDefinition"))
+}
+
+pp$1.parseClassId = function(node, isStatement) {
+ node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null
+}
+
+pp$1.parseClassSuper = function(node) {
+ node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null
+}
+
+// Parses module export declaration.
+
+pp$1.parseExport = function(node) {
+ var this$1 = this;
+
+ this.next()
+ // export * from '...'
+ if (this.eat(tt.star)) {
+ this.expectContextual("from")
+ node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+ this.semicolon()
+ return this.finishNode(node, "ExportAllDeclaration")
+ }
+ if (this.eat(tt._default)) { // export default ...
+ var parens = this.type == tt.parenL
+ var expr = this.parseMaybeAssign()
+ var needsSemi = true
+ if (!parens && (expr.type == "FunctionExpression" ||
+ expr.type == "ClassExpression")) {
+ needsSemi = false
+ if (expr.id) {
+ expr.type = expr.type == "FunctionExpression"
+ ? "FunctionDeclaration"
+ : "ClassDeclaration"
+ }
+ }
+ node.declaration = expr
+ if (needsSemi) this.semicolon()
+ return this.finishNode(node, "ExportDefaultDeclaration")
+ }
+ // export var|const|let|function|class ...
+ if (this.shouldParseExportStatement()) {
+ node.declaration = this.parseStatement(true)
+ node.specifiers = []
+ node.source = null
+ } else { // export { x, y as z } [from '...']
+ node.declaration = null
+ node.specifiers = this.parseExportSpecifiers()
+ if (this.eatContextual("from")) {
+ node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+ } else {
+ // check for keywords used as local names
+ for (var i = 0; i < node.specifiers.length; i++) {
+ if (this$1.keywords.test(node.specifiers[i].local.name) || this$1.reservedWords.test(node.specifiers[i].local.name)) {
+ this$1.unexpected(node.specifiers[i].local.start)
+ }
+ }
+
+ node.source = null
+ }
+ this.semicolon()
+ }
+ return this.finishNode(node, "ExportNamedDeclaration")
+}
+
+pp$1.shouldParseExportStatement = function() {
+ return this.type.keyword || this.isLet()
+}
+
+// Parses a comma-separated list of module exports.
+
+pp$1.parseExportSpecifiers = function() {
+ var this$1 = this;
+
+ var nodes = [], first = true
+ // export { x, y as z } [from '...']
+ this.expect(tt.braceL)
+ while (!this.eat(tt.braceR)) {
+ if (!first) {
+ this$1.expect(tt.comma)
+ if (this$1.afterTrailingComma(tt.braceR)) break
+ } else first = false
+
+ var node = this$1.startNode()
+ node.local = this$1.parseIdent(this$1.type === tt._default)
+ node.exported = this$1.eatContextual("as") ? this$1.parseIdent(true) : node.local
+ nodes.push(this$1.finishNode(node, "ExportSpecifier"))
+ }
+ return nodes
+}
+
+// Parses import declaration.
+
+pp$1.parseImport = function(node) {
+ this.next()
+ // import '...'
+ if (this.type === tt.string) {
+ node.specifiers = empty
+ node.source = this.parseExprAtom()
+ } else {
+ node.specifiers = this.parseImportSpecifiers()
+ this.expectContextual("from")
+ node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected()
+ }
+ this.semicolon()
+ return this.finishNode(node, "ImportDeclaration")
+}
+
+// Parses a comma-separated list of module imports.
+
+pp$1.parseImportSpecifiers = function() {
+ var this$1 = this;
+
+ var nodes = [], first = true
+ if (this.type === tt.name) {
+ // import defaultObj, { x, y as z } from '...'
+ var node = this.startNode()
+ node.local = this.parseIdent()
+ this.checkLVal(node.local, true)
+ nodes.push(this.finishNode(node, "ImportDefaultSpecifier"))
+ if (!this.eat(tt.comma)) return nodes
+ }
+ if (this.type === tt.star) {
+ var node$1 = this.startNode()
+ this.next()
+ this.expectContextual("as")
+ node$1.local = this.parseIdent()
+ this.checkLVal(node$1.local, true)
+ nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"))
+ return nodes
+ }
+ this.expect(tt.braceL)
+ while (!this.eat(tt.braceR)) {
+ if (!first) {
+ this$1.expect(tt.comma)
+ if (this$1.afterTrailingComma(tt.braceR)) break
+ } else first = false
+
+ var node$2 = this$1.startNode()
+ node$2.imported = this$1.parseIdent(true)
+ if (this$1.eatContextual("as")) {
+ node$2.local = this$1.parseIdent()
+ } else {
+ node$2.local = node$2.imported
+ if (this$1.isKeyword(node$2.local.name)) this$1.unexpected(node$2.local.start)
+ if (this$1.reservedWordsStrict.test(node$2.local.name)) this$1.raise(node$2.local.start, "The keyword '" + node$2.local.name + "' is reserved")
+ }
+ this$1.checkLVal(node$2.local, true)
+ nodes.push(this$1.finishNode(node$2, "ImportSpecifier"))
+ }
+ return nodes
+}
+
+var pp$2 = Parser.prototype
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+pp$2.toAssignable = function(node, isBinding) {
+ var this$1 = this;
+
+ if (this.options.ecmaVersion >= 6 && node) {
+ switch (node.type) {
+ case "Identifier":
+ case "ObjectPattern":
+ case "ArrayPattern":
+ break
+
+ case "ObjectExpression":
+ node.type = "ObjectPattern"
+ for (var i = 0; i < node.properties.length; i++) {
+ var prop = node.properties[i]
+ if (prop.kind !== "init") this$1.raise(prop.key.start, "Object pattern can't contain getter or setter")
+ this$1.toAssignable(prop.value, isBinding)
+ }
+ break
+
+ case "ArrayExpression":
+ node.type = "ArrayPattern"
+ this.toAssignableList(node.elements, isBinding)
+ break
+
+ case "AssignmentExpression":
+ if (node.operator === "=") {
+ node.type = "AssignmentPattern"
+ delete node.operator
+ // falls through to AssignmentPattern
+ } else {
+ this.raise(node.left.end, "Only '=' operator can be used for specifying default value.")
+ break
+ }
+
+ case "AssignmentPattern":
+ if (node.right.type === "YieldExpression")
+ this.raise(node.right.start, "Yield expression cannot be a default value")
+ break
+
+ case "ParenthesizedExpression":
+ node.expression = this.toAssignable(node.expression, isBinding)
+ break
+
+ case "MemberExpression":
+ if (!isBinding) break
+
+ default:
+ this.raise(node.start, "Assigning to rvalue")
+ }
+ }
+ return node
+}
+
+// Convert list of expression atoms to binding list.
+
+pp$2.toAssignableList = function(exprList, isBinding) {
+ var this$1 = this;
+
+ var end = exprList.length
+ if (end) {
+ var last = exprList[end - 1]
+ if (last && last.type == "RestElement") {
+ --end
+ } else if (last && last.type == "SpreadElement") {
+ last.type = "RestElement"
+ var arg = last.argument
+ this.toAssignable(arg, isBinding)
+ if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
+ this.unexpected(arg.start)
+ --end
+ }
+
+ if (isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
+ this.unexpected(last.argument.start)
+ }
+ for (var i = 0; i < end; i++) {
+ var elt = exprList[i]
+ if (elt) this$1.toAssignable(elt, isBinding)
+ }
+ return exprList
+}
+
+// Parses spread element.
+
+pp$2.parseSpread = function(refDestructuringErrors) {
+ var node = this.startNode()
+ this.next()
+ node.argument = this.parseMaybeAssign(false, refDestructuringErrors)
+ return this.finishNode(node, "SpreadElement")
+}
+
+pp$2.parseRest = function(allowNonIdent) {
+ var node = this.startNode()
+ this.next()
+
+ // RestElement inside of a function parameter must be an identifier
+ if (allowNonIdent) node.argument = this.type === tt.name ? this.parseIdent() : this.unexpected()
+ else node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected()
+
+ return this.finishNode(node, "RestElement")
+}
+
+// Parses lvalue (assignable) atom.
+
+pp$2.parseBindingAtom = function() {
+ if (this.options.ecmaVersion < 6) return this.parseIdent()
+ switch (this.type) {
+ case tt.name:
+ return this.parseIdent()
+
+ case tt.bracketL:
+ var node = this.startNode()
+ this.next()
+ node.elements = this.parseBindingList(tt.bracketR, true, true)
+ return this.finishNode(node, "ArrayPattern")
+
+ case tt.braceL:
+ return this.parseObj(true)
+
+ default:
+ this.unexpected()
+ }
+}
+
+pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma, allowNonIdent) {
+ var this$1 = this;
+
+ var elts = [], first = true
+ while (!this.eat(close)) {
+ if (first) first = false
+ else this$1.expect(tt.comma)
+ if (allowEmpty && this$1.type === tt.comma) {
+ elts.push(null)
+ } else if (allowTrailingComma && this$1.afterTrailingComma(close)) {
+ break
+ } else if (this$1.type === tt.ellipsis) {
+ var rest = this$1.parseRest(allowNonIdent)
+ this$1.parseBindingListItem(rest)
+ elts.push(rest)
+ if (this$1.type === tt.comma) this$1.raise(this$1.start, "Comma is not permitted after the rest element")
+ this$1.expect(close)
+ break
+ } else {
+ var elem = this$1.parseMaybeDefault(this$1.start, this$1.startLoc)
+ this$1.parseBindingListItem(elem)
+ elts.push(elem)
+ }
+ }
+ return elts
+}
+
+pp$2.parseBindingListItem = function(param) {
+ return param
+}
+
+// Parses assignment pattern around given atom if possible.
+
+pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
+ left = left || this.parseBindingAtom()
+ if (this.options.ecmaVersion < 6 || !this.eat(tt.eq)) return left
+ var node = this.startNodeAt(startPos, startLoc)
+ node.left = left
+ node.right = this.parseMaybeAssign()
+ return this.finishNode(node, "AssignmentPattern")
+}
+
+// Verify that a node is an lval — something that can be assigned
+// to.
+
+pp$2.checkLVal = function(expr, isBinding, checkClashes) {
+ var this$1 = this;
+
+ switch (expr.type) {
+ case "Identifier":
+ if (this.strict && this.reservedWordsStrictBind.test(expr.name))
+ this.raiseRecoverable(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode")
+ if (checkClashes) {
+ if (has(checkClashes, expr.name))
+ this.raiseRecoverable(expr.start, "Argument name clash")
+ checkClashes[expr.name] = true
+ }
+ break
+
+ case "MemberExpression":
+ if (isBinding) this.raiseRecoverable(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression")
+ break
+
+ case "ObjectPattern":
+ for (var i = 0; i < expr.properties.length; i++)
+ this$1.checkLVal(expr.properties[i].value, isBinding, checkClashes)
+ break
+
+ case "ArrayPattern":
+ for (var i$1 = 0; i$1 < expr.elements.length; i$1++) {
+ var elem = expr.elements[i$1]
+ if (elem) this$1.checkLVal(elem, isBinding, checkClashes)
+ }
+ break
+
+ case "AssignmentPattern":
+ this.checkLVal(expr.left, isBinding, checkClashes)
+ break
+
+ case "RestElement":
+ this.checkLVal(expr.argument, isBinding, checkClashes)
+ break
+
+ case "ParenthesizedExpression":
+ this.checkLVal(expr.expression, isBinding, checkClashes)
+ break
+
+ default:
+ this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue")
+ }
+}
+
+var pp$3 = Parser.prototype
+
+// Check if property name clashes with already added.
+// Object/class getters and setters are not allowed to clash —
+// either with each other or with an init property — and in
+// strict mode, init properties are also not allowed to be repeated.
+
+pp$3.checkPropClash = function(prop, propHash) {
+ if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
+ return
+ var key = prop.key;
+ var name
+ switch (key.type) {
+ case "Identifier": name = key.name; break
+ case "Literal": name = String(key.value); break
+ default: return
+ }
+ var kind = prop.kind;
+ if (this.options.ecmaVersion >= 6) {
+ if (name === "__proto__" && kind === "init") {
+ if (propHash.proto) this.raiseRecoverable(key.start, "Redefinition of __proto__ property")
+ propHash.proto = true
+ }
+ return
+ }
+ name = "$" + name
+ var other = propHash[name]
+ if (other) {
+ var isGetSet = kind !== "init"
+ if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
+ this.raiseRecoverable(key.start, "Redefinition of property")
+ } else {
+ other = propHash[name] = {
+ init: false,
+ get: false,
+ set: false
+ }
+ }
+ other[kind] = true
+}
+
+// ### Expression parsing
+
+// These nest, from the most general expression type at the top to
+// 'atomic', nondivisible expression types at the bottom. Most of
+// the functions will simply let the function(s) below them parse,
+// and, *if* the syntactic construct they handle is present, wrap
+// the AST node that the inner parser gave them in another node.
+
+// Parse a full expression. The optional arguments are used to
+// forbid the `in` operator (in for loops initalization expressions)
+// and provide reference for storing '=' operator inside shorthand
+// property assignment in contexts where both object expression
+// and object pattern might appear (so it's possible to raise
+// delayed syntax error at correct position).
+
+pp$3.parseExpression = function(noIn, refDestructuringErrors) {
+ var this$1 = this;
+
+ var startPos = this.start, startLoc = this.startLoc
+ var expr = this.parseMaybeAssign(noIn, refDestructuringErrors)
+ if (this.type === tt.comma) {
+ var node = this.startNodeAt(startPos, startLoc)
+ node.expressions = [expr]
+ while (this.eat(tt.comma)) node.expressions.push(this$1.parseMaybeAssign(noIn, refDestructuringErrors))
+ return this.finishNode(node, "SequenceExpression")
+ }
+ return expr
+}
+
+// Parse an assignment expression. This includes applications of
+// operators like `+=`.
+
+pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
+ if (this.inGenerator && this.isContextual("yield")) return this.parseYield()
+
+ var ownDestructuringErrors = false
+ if (!refDestructuringErrors) {
+ refDestructuringErrors = new DestructuringErrors
+ ownDestructuringErrors = true
+ }
+ var startPos = this.start, startLoc = this.startLoc
+ if (this.type == tt.parenL || this.type == tt.name)
+ this.potentialArrowAt = this.start
+ var left = this.parseMaybeConditional(noIn, refDestructuringErrors)
+ if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc)
+ if (this.type.isAssign) {
+ this.checkPatternErrors(refDestructuringErrors, true)
+ if (!ownDestructuringErrors) DestructuringErrors.call(refDestructuringErrors)
+ var node = this.startNodeAt(startPos, startLoc)
+ node.operator = this.value
+ node.left = this.type === tt.eq ? this.toAssignable(left) : left
+ refDestructuringErrors.shorthandAssign = 0 // reset because shorthand default was used correctly
+ this.checkLVal(left)
+ this.next()
+ node.right = this.parseMaybeAssign(noIn)
+ return this.finishNode(node, "AssignmentExpression")
+ } else {
+ if (ownDestructuringErrors) this.checkExpressionErrors(refDestructuringErrors, true)
+ }
+ return left
+}
+
+// Parse a ternary conditional (`?:`) operator.
+
+pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
+ var startPos = this.start, startLoc = this.startLoc
+ var expr = this.parseExprOps(noIn, refDestructuringErrors)
+ if (this.checkExpressionErrors(refDestructuringErrors)) return expr
+ if (this.eat(tt.question)) {
+ var node = this.startNodeAt(startPos, startLoc)
+ node.test = expr
+ node.consequent = this.parseMaybeAssign()
+ this.expect(tt.colon)
+ node.alternate = this.parseMaybeAssign(noIn)
+ return this.finishNode(node, "ConditionalExpression")
+ }
+ return expr
+}
+
+// Start the precedence parser.
+
+pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
+ var startPos = this.start, startLoc = this.startLoc
+ var expr = this.parseMaybeUnary(refDestructuringErrors, false)
+ if (this.checkExpressionErrors(refDestructuringErrors)) return expr
+ return this.parseExprOp(expr, startPos, startLoc, -1, noIn)
+}
+
+// Parse binary operators with the operator precedence parsing
+// algorithm. `left` is the left-hand side of the operator.
+// `minPrec` provides context that allows the function to stop and
+// defer further parser to one of its callers when it encounters an
+// operator that has a lower precedence than the set it is parsing.
+
+pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
+ var prec = this.type.binop
+ if (prec != null && (!noIn || this.type !== tt._in)) {
+ if (prec > minPrec) {
+ var logical = this.type === tt.logicalOR || this.type === tt.logicalAND
+ var op = this.value
+ this.next()
+ var startPos = this.start, startLoc = this.startLoc
+ var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn)
+ var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical)
+ return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
+ }
+ }
+ return left
+}
+
+pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
+ var node = this.startNodeAt(startPos, startLoc)
+ node.left = left
+ node.operator = op
+ node.right = right
+ return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
+}
+
+// Parse unary operators, both prefix and postfix.
+
+pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
+ var this$1 = this;
+
+ var startPos = this.start, startLoc = this.startLoc, expr
+ if (this.type.prefix) {
+ var node = this.startNode(), update = this.type === tt.incDec
+ node.operator = this.value
+ node.prefix = true
+ this.next()
+ node.argument = this.parseMaybeUnary(null, true)
+ this.checkExpressionErrors(refDestructuringErrors, true)
+ if (update) this.checkLVal(node.argument)
+ else if (this.strict && node.operator === "delete" &&
+ node.argument.type === "Identifier")
+ this.raiseRecoverable(node.start, "Deleting local variable in strict mode")
+ else sawUnary = true
+ expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression")
+ } else {
+ expr = this.parseExprSubscripts(refDestructuringErrors)
+ if (this.checkExpressionErrors(refDestructuringErrors)) return expr
+ while (this.type.postfix && !this.canInsertSemicolon()) {
+ var node$1 = this$1.startNodeAt(startPos, startLoc)
+ node$1.operator = this$1.value
+ node$1.prefix = false
+ node$1.argument = expr
+ this$1.checkLVal(expr)
+ this$1.next()
+ expr = this$1.finishNode(node$1, "UpdateExpression")
+ }
+ }
+
+ if (!sawUnary && this.eat(tt.starstar))
+ return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false)
+ else
+ return expr
+}
+
+// Parse call, dot, and `[]`-subscript expressions.
+
+pp$3.parseExprSubscripts = function(refDestructuringErrors) {
+ var startPos = this.start, startLoc = this.startLoc
+ var expr = this.parseExprAtom(refDestructuringErrors)
+ var skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")"
+ if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) return expr
+ return this.parseSubscripts(expr, startPos, startLoc)
+}
+
+pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
+ var this$1 = this;
+
+ for (;;) {
+ if (this$1.eat(tt.dot)) {
+ var node = this$1.startNodeAt(startPos, startLoc)
+ node.object = base
+ node.property = this$1.parseIdent(true)
+ node.computed = false
+ base = this$1.finishNode(node, "MemberExpression")
+ } else if (this$1.eat(tt.bracketL)) {
+ var node$1 = this$1.startNodeAt(startPos, startLoc)
+ node$1.object = base
+ node$1.property = this$1.parseExpression()
+ node$1.computed = true
+ this$1.expect(tt.bracketR)
+ base = this$1.finishNode(node$1, "MemberExpression")
+ } else if (!noCalls && this$1.eat(tt.parenL)) {
+ var node$2 = this$1.startNodeAt(startPos, startLoc)
+ node$2.callee = base
+ node$2.arguments = this$1.parseExprList(tt.parenR, false)
+ base = this$1.finishNode(node$2, "CallExpression")
+ } else if (this$1.type === tt.backQuote) {
+ var node$3 = this$1.startNodeAt(startPos, startLoc)
+ node$3.tag = base
+ node$3.quasi = this$1.parseTemplate()
+ base = this$1.finishNode(node$3, "TaggedTemplateExpression")
+ } else {
+ return base
+ }
+ }
+}
+
+// Parse an atomic expression — either a single token that is an
+// expression, an expression started by a keyword like `function` or
+// `new`, or an expression wrapped in punctuation like `()`, `[]`,
+// or `{}`.
+
+pp$3.parseExprAtom = function(refDestructuringErrors) {
+ var node, canBeArrow = this.potentialArrowAt == this.start
+ switch (this.type) {
+ case tt._super:
+ if (!this.inFunction)
+ this.raise(this.start, "'super' outside of function or class")
+
+ case tt._this:
+ var type = this.type === tt._this ? "ThisExpression" : "Super"
+ node = this.startNode()
+ this.next()
+ return this.finishNode(node, type)
+
+ case tt.name:
+ var startPos = this.start, startLoc = this.startLoc
+ var id = this.parseIdent(this.type !== tt.name)
+ if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow))
+ return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id])
+ return id
+
+ case tt.regexp:
+ var value = this.value
+ node = this.parseLiteral(value.value)
+ node.regex = {pattern: value.pattern, flags: value.flags}
+ return node
+
+ case tt.num: case tt.string:
+ return this.parseLiteral(this.value)
+
+ case tt._null: case tt._true: case tt._false:
+ node = this.startNode()
+ node.value = this.type === tt._null ? null : this.type === tt._true
+ node.raw = this.type.keyword
+ this.next()
+ return this.finishNode(node, "Literal")
+
+ case tt.parenL:
+ return this.parseParenAndDistinguishExpression(canBeArrow)
+
+ case tt.bracketL:
+ node = this.startNode()
+ this.next()
+ node.elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors)
+ return this.finishNode(node, "ArrayExpression")
+
+ case tt.braceL:
+ return this.parseObj(false, refDestructuringErrors)
+
+ case tt._function:
+ node = this.startNode()
+ this.next()
+ return this.parseFunction(node, false)
+
+ case tt._class:
+ return this.parseClass(this.startNode(), false)
+
+ case tt._new:
+ return this.parseNew()
+
+ case tt.backQuote:
+ return this.parseTemplate()
+
+ default:
+ this.unexpected()
+ }
+}
+
+pp$3.parseLiteral = function(value) {
+ var node = this.startNode()
+ node.value = value
+ node.raw = this.input.slice(this.start, this.end)
+ this.next()
+ return this.finishNode(node, "Literal")
+}
+
+pp$3.parseParenExpression = function() {
+ this.expect(tt.parenL)
+ var val = this.parseExpression()
+ this.expect(tt.parenR)
+ return val
+}
+
+pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
+ var this$1 = this;
+
+ var startPos = this.start, startLoc = this.startLoc, val
+ if (this.options.ecmaVersion >= 6) {
+ this.next()
+
+ var innerStartPos = this.start, innerStartLoc = this.startLoc
+ var exprList = [], first = true
+ var refDestructuringErrors = new DestructuringErrors, spreadStart, innerParenStart
+ while (this.type !== tt.parenR) {
+ first ? first = false : this$1.expect(tt.comma)
+ if (this$1.type === tt.ellipsis) {
+ spreadStart = this$1.start
+ exprList.push(this$1.parseParenItem(this$1.parseRest()))
+ break
+ } else {
+ if (this$1.type === tt.parenL && !innerParenStart) {
+ innerParenStart = this$1.start
+ }
+ exprList.push(this$1.parseMaybeAssign(false, refDestructuringErrors, this$1.parseParenItem))
+ }
+ }
+ var innerEndPos = this.start, innerEndLoc = this.startLoc
+ this.expect(tt.parenR)
+
+ if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
+ this.checkPatternErrors(refDestructuringErrors, true)
+ if (innerParenStart) this.unexpected(innerParenStart)
+ return this.parseParenArrowList(startPos, startLoc, exprList)
+ }
+
+ if (!exprList.length) this.unexpected(this.lastTokStart)
+ if (spreadStart) this.unexpected(spreadStart)
+ this.checkExpressionErrors(refDestructuringErrors, true)
+
+ if (exprList.length > 1) {
+ val = this.startNodeAt(innerStartPos, innerStartLoc)
+ val.expressions = exprList
+ this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc)
+ } else {
+ val = exprList[0]
+ }
+ } else {
+ val = this.parseParenExpression()
+ }
+
+ if (this.options.preserveParens) {
+ var par = this.startNodeAt(startPos, startLoc)
+ par.expression = val
+ return this.finishNode(par, "ParenthesizedExpression")
+ } else {
+ return val
+ }
+}
+
+pp$3.parseParenItem = function(item) {
+ return item
+}
+
+pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
+ return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
+}
+
+// New's precedence is slightly tricky. It must allow its argument to
+// be a `[]` or dot subscript expression, but not a call — at least,
+// not without wrapping it in parentheses. Thus, it uses the noCalls
+// argument to parseSubscripts to prevent it from consuming the
+// argument list.
+
+var empty$1 = []
+
+pp$3.parseNew = function() {
+ var node = this.startNode()
+ var meta = this.parseIdent(true)
+ if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
+ node.meta = meta
+ node.property = this.parseIdent(true)
+ if (node.property.name !== "target")
+ this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target")
+ if (!this.inFunction)
+ this.raiseRecoverable(node.start, "new.target can only be used in functions")
+ return this.finishNode(node, "MetaProperty")
+ }
+ var startPos = this.start, startLoc = this.startLoc
+ node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true)
+ if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
+ else node.arguments = empty$1
+ return this.finishNode(node, "NewExpression")
+}
+
+// Parse template expression.
+
+pp$3.parseTemplateElement = function() {
+ var elem = this.startNode()
+ elem.value = {
+ raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, '\n'),
+ cooked: this.value
+ }
+ this.next()
+ elem.tail = this.type === tt.backQuote
+ return this.finishNode(elem, "TemplateElement")
+}
+
+pp$3.parseTemplate = function() {
+ var this$1 = this;
+
+ var node = this.startNode()
+ this.next()
+ node.expressions = []
+ var curElt = this.parseTemplateElement()
+ node.quasis = [curElt]
+ while (!curElt.tail) {
+ this$1.expect(tt.dollarBraceL)
+ node.expressions.push(this$1.parseExpression())
+ this$1.expect(tt.braceR)
+ node.quasis.push(curElt = this$1.parseTemplateElement())
+ }
+ this.next()
+ return this.finishNode(node, "TemplateLiteral")
+}
+
+// Parse an object literal or binding pattern.
+
+pp$3.parseObj = function(isPattern, refDestructuringErrors) {
+ var this$1 = this;
+
+ var node = this.startNode(), first = true, propHash = {}
+ node.properties = []
+ this.next()
+ while (!this.eat(tt.braceR)) {
+ if (!first) {
+ this$1.expect(tt.comma)
+ if (this$1.afterTrailingComma(tt.braceR)) break
+ } else first = false
+
+ var prop = this$1.startNode(), isGenerator, startPos, startLoc
+ if (this$1.options.ecmaVersion >= 6) {
+ prop.method = false
+ prop.shorthand = false
+ if (isPattern || refDestructuringErrors) {
+ startPos = this$1.start
+ startLoc = this$1.startLoc
+ }
+ if (!isPattern)
+ isGenerator = this$1.eat(tt.star)
+ }
+ this$1.parsePropertyName(prop)
+ this$1.parsePropertyValue(prop, isPattern, isGenerator, startPos, startLoc, refDestructuringErrors)
+ this$1.checkPropClash(prop, propHash)
+ node.properties.push(this$1.finishNode(prop, "Property"))
+ }
+ return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
+}
+
+pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, startPos, startLoc, refDestructuringErrors) {
+ if (this.eat(tt.colon)) {
+ prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors)
+ prop.kind = "init"
+ } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
+ if (isPattern) this.unexpected()
+ prop.kind = "init"
+ prop.method = true
+ prop.value = this.parseMethod(isGenerator)
+ } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+ (prop.key.name === "get" || prop.key.name === "set") &&
+ (this.type != tt.comma && this.type != tt.braceR)) {
+ if (isGenerator || isPattern) this.unexpected()
+ prop.kind = prop.key.name
+ this.parsePropertyName(prop)
+ prop.value = this.parseMethod(false)
+ var paramCount = prop.kind === "get" ? 0 : 1
+ if (prop.value.params.length !== paramCount) {
+ var start = prop.value.start
+ if (prop.kind === "get")
+ this.raiseRecoverable(start, "getter should have no params")
+ else
+ this.raiseRecoverable(start, "setter should have exactly one param")
+ }
+ if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
+ this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params")
+ } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+ if (this.keywords.test(prop.key.name) ||
+ (this.strict ? this.reservedWordsStrictBind : this.reservedWords).test(prop.key.name) ||
+ (this.inGenerator && prop.key.name == "yield"))
+ this.raiseRecoverable(prop.key.start, "'" + prop.key.name + "' can not be used as shorthand property")
+ prop.kind = "init"
+ if (isPattern) {
+ prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)
+ } else if (this.type === tt.eq && refDestructuringErrors) {
+ if (!refDestructuringErrors.shorthandAssign)
+ refDestructuringErrors.shorthandAssign = this.start
+ prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key)
+ } else {
+ prop.value = prop.key
+ }
+ prop.shorthand = true
+ } else this.unexpected()
+}
+
+pp$3.parsePropertyName = function(prop) {
+ if (this.options.ecmaVersion >= 6) {
+ if (this.eat(tt.bracketL)) {
+ prop.computed = true
+ prop.key = this.parseMaybeAssign()
+ this.expect(tt.bracketR)
+ return prop.key
+ } else {
+ prop.computed = false
+ }
+ }
+ return prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true)
+}
+
+// Initialize empty function node.
+
+pp$3.initFunction = function(node) {
+ node.id = null
+ if (this.options.ecmaVersion >= 6) {
+ node.generator = false
+ node.expression = false
+ }
+}
+
+// Parse object or class method.
+
+pp$3.parseMethod = function(isGenerator) {
+ var node = this.startNode(), oldInGen = this.inGenerator
+ this.inGenerator = isGenerator
+ this.initFunction(node)
+ this.expect(tt.parenL)
+ node.params = this.parseBindingList(tt.parenR, false, false)
+ if (this.options.ecmaVersion >= 6)
+ node.generator = isGenerator
+ this.parseFunctionBody(node, false)
+ this.inGenerator = oldInGen
+ return this.finishNode(node, "FunctionExpression")
+}
+
+// Parse arrow function expression with given parameters.
+
+pp$3.parseArrowExpression = function(node, params) {
+ var oldInGen = this.inGenerator
+ this.inGenerator = false
+ this.initFunction(node)
+ node.params = this.toAssignableList(params, true)
+ this.parseFunctionBody(node, true)
+ this.inGenerator = oldInGen
+ return this.finishNode(node, "ArrowFunctionExpression")
+}
+
+// Parse function body and check parameters.
+
+pp$3.parseFunctionBody = function(node, isArrowFunction) {
+ var isExpression = isArrowFunction && this.type !== tt.braceL
+
+ if (isExpression) {
+ node.body = this.parseMaybeAssign()
+ node.expression = true
+ } else {
+ // Start a new scope with regard to labels and the `inFunction`
+ // flag (restore them to their old value afterwards).
+ var oldInFunc = this.inFunction, oldLabels = this.labels
+ this.inFunction = true; this.labels = []
+ node.body = this.parseBlock(true)
+ node.expression = false
+ this.inFunction = oldInFunc; this.labels = oldLabels
+ }
+
+ // If this is a strict mode function, verify that argument names
+ // are not repeated, and it does not try to bind the words `eval`
+ // or `arguments`.
+ var useStrict = (!isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) ? node.body.body[0] : null;
+ if (this.strict || useStrict) {
+ var oldStrict = this.strict
+ this.strict = true
+ if (node.id)
+ this.checkLVal(node.id, true)
+ this.checkParams(node, useStrict)
+ this.strict = oldStrict
+ } else if (isArrowFunction) {
+ this.checkParams(node, useStrict)
+ }
+}
+
+// Checks function params for various disallowed patterns such as using "eval"
+// or "arguments" and duplicate parameters.
+
+pp$3.checkParams = function(node, useStrict) {
+ var this$1 = this;
+
+ var nameHash = {}
+ for (var i = 0; i < node.params.length; i++) {
+ if (useStrict && this$1.options.ecmaVersion >= 7 && node.params[i].type !== "Identifier")
+ this$1.raiseRecoverable(useStrict.start, "Illegal 'use strict' directive in function with non-simple parameter list");
+ this$1.checkLVal(node.params[i], true, nameHash)
+ }
+}
+
+// Parses a comma-separated list of expressions, and returns them as
+// an array. `close` is the token type that ends the list, and
+// `allowEmpty` can be turned on to allow subsequent commas with
+// nothing in between them to be parsed as `null` (which is needed
+// for array literals).
+
+pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
+ var this$1 = this;
+
+ var elts = [], first = true
+ while (!this.eat(close)) {
+ if (!first) {
+ this$1.expect(tt.comma)
+ if (allowTrailingComma && this$1.afterTrailingComma(close)) break
+ } else first = false
+
+ var elt
+ if (allowEmpty && this$1.type === tt.comma)
+ elt = null
+ else if (this$1.type === tt.ellipsis) {
+ elt = this$1.parseSpread(refDestructuringErrors)
+ if (this$1.type === tt.comma && refDestructuringErrors && !refDestructuringErrors.trailingComma) {
+ refDestructuringErrors.trailingComma = this$1.lastTokStart
+ }
+ } else
+ elt = this$1.parseMaybeAssign(false, refDestructuringErrors)
+ elts.push(elt)
+ }
+ return elts
+}
+
+// Parse the next token as an identifier. If `liberal` is true (used
+// when parsing properties), it will also convert keywords into
+// identifiers.
+
+pp$3.parseIdent = function(liberal) {
+ var node = this.startNode()
+ if (liberal && this.options.allowReserved == "never") liberal = false
+ if (this.type === tt.name) {
+ if (!liberal && (this.strict ? this.reservedWordsStrict : this.reservedWords).test(this.value) &&
+ (this.options.ecmaVersion >= 6 ||
+ this.input.slice(this.start, this.end).indexOf("\\") == -1))
+ this.raiseRecoverable(this.start, "The keyword '" + this.value + "' is reserved")
+ if (!liberal && this.inGenerator && this.value === "yield")
+ this.raiseRecoverable(this.start, "Can not use 'yield' as identifier inside a generator")
+ node.name = this.value
+ } else if (liberal && this.type.keyword) {
+ node.name = this.type.keyword
+ } else {
+ this.unexpected()
+ }
+ this.next()
+ return this.finishNode(node, "Identifier")
+}
+
+// Parses yield expression inside generator.
+
+pp$3.parseYield = function() {
+ var node = this.startNode()
+ this.next()
+ if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) {
+ node.delegate = false
+ node.argument = null
+ } else {
+ node.delegate = this.eat(tt.star)
+ node.argument = this.parseMaybeAssign()
+ }
+ return this.finishNode(node, "YieldExpression")
+}
+
+var pp$4 = Parser.prototype
+
+// This function is used to raise exceptions on parse errors. It
+// takes an offset integer (into the current `input`) to indicate
+// the location of the error, attaches the position to the end
+// of the error message, and then raises a `SyntaxError` with that
+// message.
+
+pp$4.raise = function(pos, message) {
+ var loc = getLineInfo(this.input, pos)
+ message += " (" + loc.line + ":" + loc.column + ")"
+ var err = new SyntaxError(message)
+ err.pos = pos; err.loc = loc; err.raisedAt = this.pos
+ throw err
+}
+
+pp$4.raiseRecoverable = pp$4.raise
+
+pp$4.curPosition = function() {
+ if (this.options.locations) {
+ return new Position(this.curLine, this.pos - this.lineStart)
+ }
+}
+
+var Node = function Node(parser, pos, loc) {
+ this.type = ""
+ this.start = pos
+ this.end = 0
+ if (parser.options.locations)
+ this.loc = new SourceLocation(parser, loc)
+ if (parser.options.directSourceFile)
+ this.sourceFile = parser.options.directSourceFile
+ if (parser.options.ranges)
+ this.range = [pos, 0]
+};
+
+// Start an AST node, attaching a start offset.
+
+var pp$5 = Parser.prototype
+
+pp$5.startNode = function() {
+ return new Node(this, this.start, this.startLoc)
+}
+
+pp$5.startNodeAt = function(pos, loc) {
+ return new Node(this, pos, loc)
+}
+
+// Finish an AST node, adding `type` and `end` properties.
+
+function finishNodeAt(node, type, pos, loc) {
+ node.type = type
+ node.end = pos
+ if (this.options.locations)
+ node.loc.end = loc
+ if (this.options.ranges)
+ node.range[1] = pos
+ return node
+}
+
+pp$5.finishNode = function(node, type) {
+ return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
+}
+
+// Finish node at given position
+
+pp$5.finishNodeAt = function(node, type, pos, loc) {
+ return finishNodeAt.call(this, node, type, pos, loc)
+}
+
+var TokContext = function TokContext(token, isExpr, preserveSpace, override) {
+ this.token = token
+ this.isExpr = !!isExpr
+ this.preserveSpace = !!preserveSpace
+ this.override = override
+};
+
+var types = {
+ b_stat: new TokContext("{", false),
+ b_expr: new TokContext("{", true),
+ b_tmpl: new TokContext("${", true),
+ p_stat: new TokContext("(", false),
+ p_expr: new TokContext("(", true),
+ q_tmpl: new TokContext("`", true, true, function (p) { return p.readTmplToken(); }),
+ f_expr: new TokContext("function", true)
+}
+
+var pp$6 = Parser.prototype
+
+pp$6.initialContext = function() {
+ return [types.b_stat]
+}
+
+pp$6.braceIsBlock = function(prevType) {
+ if (prevType === tt.colon) {
+ var parent = this.curContext()
+ if (parent === types.b_stat || parent === types.b_expr)
+ return !parent.isExpr
+ }
+ if (prevType === tt._return)
+ return lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
+ if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof || prevType === tt.parenR)
+ return true
+ if (prevType == tt.braceL)
+ return this.curContext() === types.b_stat
+ return !this.exprAllowed
+}
+
+pp$6.updateContext = function(prevType) {
+ var update, type = this.type
+ if (type.keyword && prevType == tt.dot)
+ this.exprAllowed = false
+ else if (update = type.updateContext)
+ update.call(this, prevType)
+ else
+ this.exprAllowed = type.beforeExpr
+}
+
+// Token-specific context update code
+
+tt.parenR.updateContext = tt.braceR.updateContext = function() {
+ if (this.context.length == 1) {
+ this.exprAllowed = true
+ return
+ }
+ var out = this.context.pop()
+ if (out === types.b_stat && this.curContext() === types.f_expr) {
+ this.context.pop()
+ this.exprAllowed = false
+ } else if (out === types.b_tmpl) {
+ this.exprAllowed = true
+ } else {
+ this.exprAllowed = !out.isExpr
+ }
+}
+
+tt.braceL.updateContext = function(prevType) {
+ this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr)
+ this.exprAllowed = true
+}
+
+tt.dollarBraceL.updateContext = function() {
+ this.context.push(types.b_tmpl)
+ this.exprAllowed = true
+}
+
+tt.parenL.updateContext = function(prevType) {
+ var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while
+ this.context.push(statementParens ? types.p_stat : types.p_expr)
+ this.exprAllowed = true
+}
+
+tt.incDec.updateContext = function() {
+ // tokExprAllowed stays unchanged
+}
+
+tt._function.updateContext = function(prevType) {
+ if (prevType.beforeExpr && prevType !== tt.semi && prevType !== tt._else &&
+ !((prevType === tt.colon || prevType === tt.braceL) && this.curContext() === types.b_stat))
+ this.context.push(types.f_expr)
+ this.exprAllowed = false
+}
+
+tt.backQuote.updateContext = function() {
+ if (this.curContext() === types.q_tmpl)
+ this.context.pop()
+ else
+ this.context.push(types.q_tmpl)
+ this.exprAllowed = false
+}
+
+// Object type used to represent tokens. Note that normally, tokens
+// simply exist as properties on the parser object. This is only
+// used for the onToken callback and the external tokenizer.
+
+var Token = function Token(p) {
+ this.type = p.type
+ this.value = p.value
+ this.start = p.start
+ this.end = p.end
+ if (p.options.locations)
+ this.loc = new SourceLocation(p, p.startLoc, p.endLoc)
+ if (p.options.ranges)
+ this.range = [p.start, p.end]
+};
+
+// ## Tokenizer
+
+var pp$7 = Parser.prototype
+
+// Are we running under Rhino?
+var isRhino = typeof Packages == "object" && Object.prototype.toString.call(Packages) == "[object JavaPackage]"
+
+// Move to the next token
+
+pp$7.next = function() {
+ if (this.options.onToken)
+ this.options.onToken(new Token(this))
+
+ this.lastTokEnd = this.end
+ this.lastTokStart = this.start
+ this.lastTokEndLoc = this.endLoc
+ this.lastTokStartLoc = this.startLoc
+ this.nextToken()
+}
+
+pp$7.getToken = function() {
+ this.next()
+ return new Token(this)
+}
+
+// If we're in an ES6 environment, make parsers iterable
+if (typeof Symbol !== "undefined")
+ pp$7[Symbol.iterator] = function () {
+ var self = this
+ return {next: function () {
+ var token = self.getToken()
+ return {
+ done: token.type === tt.eof,
+ value: token
+ }
+ }}
+ }
+
+// Toggle strict mode. Re-reads the next number or string to please
+// pedantic tests (`"use strict"; 010;` should fail).
+
+pp$7.setStrict = function(strict) {
+ var this$1 = this;
+
+ this.strict = strict
+ if (this.type !== tt.num && this.type !== tt.string) return
+ this.pos = this.start
+ if (this.options.locations) {
+ while (this.pos < this.lineStart) {
+ this$1.lineStart = this$1.input.lastIndexOf("\n", this$1.lineStart - 2) + 1
+ --this$1.curLine
+ }
+ }
+ this.nextToken()
+}
+
+pp$7.curContext = function() {
+ return this.context[this.context.length - 1]
+}
+
+// Read a single token, updating the parser object's token-related
+// properties.
+
+pp$7.nextToken = function() {
+ var curContext = this.curContext()
+ if (!curContext || !curContext.preserveSpace) this.skipSpace()
+
+ this.start = this.pos
+ if (this.options.locations) this.startLoc = this.curPosition()
+ if (this.pos >= this.input.length) return this.finishToken(tt.eof)
+
+ if (curContext.override) return curContext.override(this)
+ else this.readToken(this.fullCharCodeAtPos())
+}
+
+pp$7.readToken = function(code) {
+ // Identifier or keyword. '\uXXXX' sequences are allowed in
+ // identifiers, so '\' also dispatches to that.
+ if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+ return this.readWord()
+
+ return this.getTokenFromCode(code)
+}
+
+pp$7.fullCharCodeAtPos = function() {
+ var code = this.input.charCodeAt(this.pos)
+ if (code <= 0xd7ff || code >= 0xe000) return code
+ var next = this.input.charCodeAt(this.pos + 1)
+ return (code << 10) + next - 0x35fdc00
+}
+
+pp$7.skipBlockComment = function() {
+ var this$1 = this;
+
+ var startLoc = this.options.onComment && this.curPosition()
+ var start = this.pos, end = this.input.indexOf("*/", this.pos += 2)
+ if (end === -1) this.raise(this.pos - 2, "Unterminated comment")
+ this.pos = end + 2
+ if (this.options.locations) {
+ lineBreakG.lastIndex = start
+ var match
+ while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
+ ++this$1.curLine
+ this$1.lineStart = match.index + match[0].length
+ }
+ }
+ if (this.options.onComment)
+ this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+ startLoc, this.curPosition())
+}
+
+pp$7.skipLineComment = function(startSkip) {
+ var this$1 = this;
+
+ var start = this.pos
+ var startLoc = this.options.onComment && this.curPosition()
+ var ch = this.input.charCodeAt(this.pos+=startSkip)
+ while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+ ++this$1.pos
+ ch = this$1.input.charCodeAt(this$1.pos)
+ }
+ if (this.options.onComment)
+ this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+ startLoc, this.curPosition())
+}
+
+// Called at the start of the parse and after every token. Skips
+// whitespace and comments, and.
+
+pp$7.skipSpace = function() {
+ var this$1 = this;
+
+ loop: while (this.pos < this.input.length) {
+ var ch = this$1.input.charCodeAt(this$1.pos)
+ switch (ch) {
+ case 32: case 160: // ' '
+ ++this$1.pos
+ break
+ case 13:
+ if (this$1.input.charCodeAt(this$1.pos + 1) === 10) {
+ ++this$1.pos
+ }
+ case 10: case 8232: case 8233:
+ ++this$1.pos
+ if (this$1.options.locations) {
+ ++this$1.curLine
+ this$1.lineStart = this$1.pos
+ }
+ break
+ case 47: // '/'
+ switch (this$1.input.charCodeAt(this$1.pos + 1)) {
+ case 42: // '*'
+ this$1.skipBlockComment()
+ break
+ case 47:
+ this$1.skipLineComment(2)
+ break
+ default:
+ break loop
+ }
+ break
+ default:
+ if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+ ++this$1.pos
+ } else {
+ break loop
+ }
+ }
+ }
+}
+
+// Called at the end of every token. Sets `end`, `val`, and
+// maintains `context` and `exprAllowed`, and skips the space after
+// the token, so that the next one's `start` will point at the
+// right position.
+
+pp$7.finishToken = function(type, val) {
+ this.end = this.pos
+ if (this.options.locations) this.endLoc = this.curPosition()
+ var prevType = this.type
+ this.type = type
+ this.value = val
+
+ this.updateContext(prevType)
+}
+
+// ### Token reading
+
+// This is the function that is called to fetch the next token. It
+// is somewhat obscure, because it works in character codes rather
+// than characters, and because operator parsing has been inlined
+// into it.
+//
+// All in the name of speed.
+//
+pp$7.readToken_dot = function() {
+ var next = this.input.charCodeAt(this.pos + 1)
+ if (next >= 48 && next <= 57) return this.readNumber(true)
+ var next2 = this.input.charCodeAt(this.pos + 2)
+ if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+ this.pos += 3
+ return this.finishToken(tt.ellipsis)
+ } else {
+ ++this.pos
+ return this.finishToken(tt.dot)
+ }
+}
+
+pp$7.readToken_slash = function() { // '/'
+ var next = this.input.charCodeAt(this.pos + 1)
+ if (this.exprAllowed) {++this.pos; return this.readRegexp()}
+ if (next === 61) return this.finishOp(tt.assign, 2)
+ return this.finishOp(tt.slash, 1)
+}
+
+pp$7.readToken_mult_modulo_exp = function(code) { // '%*'
+ var next = this.input.charCodeAt(this.pos + 1)
+ var size = 1
+ var tokentype = code === 42 ? tt.star : tt.modulo
+
+ // exponentiation operator ** and **=
+ if (this.options.ecmaVersion >= 7 && next === 42) {
+ ++size
+ tokentype = tt.starstar
+ next = this.input.charCodeAt(this.pos + 2)
+ }
+
+ if (next === 61) return this.finishOp(tt.assign, size + 1)
+ return this.finishOp(tokentype, size)
+}
+
+pp$7.readToken_pipe_amp = function(code) { // '|&'
+ var next = this.input.charCodeAt(this.pos + 1)
+ if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2)
+ if (next === 61) return this.finishOp(tt.assign, 2)
+ return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1)
+}
+
+pp$7.readToken_caret = function() { // '^'
+ var next = this.input.charCodeAt(this.pos + 1)
+ if (next === 61) return this.finishOp(tt.assign, 2)
+ return this.finishOp(tt.bitwiseXOR, 1)
+}
+
+pp$7.readToken_plus_min = function(code) { // '+-'
+ var next = this.input.charCodeAt(this.pos + 1)
+ if (next === code) {
+ if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
+ lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) {
+ // A `-->` line comment
+ this.skipLineComment(3)
+ this.skipSpace()
+ return this.nextToken()
+ }
+ return this.finishOp(tt.incDec, 2)
+ }
+ if (next === 61) return this.finishOp(tt.assign, 2)
+ return this.finishOp(tt.plusMin, 1)
+}
+
+pp$7.readToken_lt_gt = function(code) { // '<>'
+ var next = this.input.charCodeAt(this.pos + 1)
+ var size = 1
+ if (next === code) {
+ size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2
+ if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)
+ return this.finishOp(tt.bitShift, size)
+ }
+ if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+ this.input.charCodeAt(this.pos + 3) == 45) {
+ if (this.inModule) this.unexpected()
+ // `` line comment
+ this.skipLineComment(3)
+ this.skipSpace()
+ return this.nextToken()
+ }
+ return this.finishOp(tt.incDec, 2)
+ }
+ if (next === 61) return this.finishOp(tt.assign, 2)
+ return this.finishOp(tt.plusMin, 1)
+ }
+
+ pp$7.readToken_lt_gt = function(code) { // '<>'
+ var next = this.input.charCodeAt(this.pos + 1)
+ var size = 1
+ if (next === code) {
+ size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2
+ if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)
+ return this.finishOp(tt.bitShift, size)
+ }
+ if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+ this.input.charCodeAt(this.pos + 3) == 45) {
+ if (this.inModule) this.unexpected()
+ // `` line comment
+ this.skipLineComment(3)
+ this.skipSpace()
+ return this.nextToken()
+ }
+ return this.finishOp(tt.incDec, 2)
+ }
+ if (next === 61) return this.finishOp(tt.assign, 2)
+ return this.finishOp(tt.plusMin, 1)
+}
+
+pp.readToken_lt_gt = function(code) { // '<>'
+ let next = this.input.charCodeAt(this.pos + 1)
+ let size = 1
+ if (next === code) {
+ size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2
+ if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)
+ return this.finishOp(tt.bitShift, size)
+ }
+ if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+ this.input.charCodeAt(this.pos + 3) == 45) {
+ if (this.inModule) this.unexpected()
+ // `
+
+### anyTypeAnnotation
+```javascript
+t.anyTypeAnnotation()
+```
+
+See also `t.isAnyTypeAnnotation(node, opts)` and `t.assertAnyTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### arrayExpression
+```javascript
+t.arrayExpression(elements)
+```
+
+See also `t.isArrayExpression(node, opts)` and `t.assertArrayExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `elements`: `Array` (default: `[]`)
+
+---
+
+### arrayPattern
+```javascript
+t.arrayPattern(elements, typeAnnotation)
+```
+
+See also `t.isArrayPattern(node, opts)` and `t.assertArrayPattern(node, opts)`.
+
+Aliases: `Pattern`, `LVal`
+
+ - `elements`: `Array` (required)
+ - `typeAnnotation` (required)
+ - `decorators`: `Array` (default: `null`)
+
+---
+
+### arrayTypeAnnotation
+```javascript
+t.arrayTypeAnnotation(elementType)
+```
+
+See also `t.isArrayTypeAnnotation(node, opts)` and `t.assertArrayTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `elementType` (required)
+
+---
+
+### arrowFunctionExpression
+```javascript
+t.arrowFunctionExpression(params, body, async)
+```
+
+See also `t.isArrowFunctionExpression(node, opts)` and `t.assertArrowFunctionExpression(node, opts)`.
+
+Aliases: `Scopable`, `Function`, `BlockParent`, `FunctionParent`, `Expression`, `Pureish`
+
+ - `params`: `Array` (required)
+ - `body`: `BlockStatement | Expression` (required)
+ - `async`: `boolean` (default: `false`)
+ - `returnType` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### assignmentExpression
+```javascript
+t.assignmentExpression(operator, left, right)
+```
+
+See also `t.isAssignmentExpression(node, opts)` and `t.assertAssignmentExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `operator`: `string` (required)
+ - `left`: `LVal` (required)
+ - `right`: `Expression` (required)
+
+---
+
+### assignmentPattern
+```javascript
+t.assignmentPattern(left, right)
+```
+
+See also `t.isAssignmentPattern(node, opts)` and `t.assertAssignmentPattern(node, opts)`.
+
+Aliases: `Pattern`, `LVal`
+
+ - `left`: `Identifier` (required)
+ - `right`: `Expression` (required)
+ - `decorators`: `Array` (default: `null`)
+
+---
+
+### awaitExpression
+```javascript
+t.awaitExpression(argument)
+```
+
+See also `t.isAwaitExpression(node, opts)` and `t.assertAwaitExpression(node, opts)`.
+
+Aliases: `Expression`, `Terminatorless`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### binaryExpression
+```javascript
+t.binaryExpression(operator, left, right)
+```
+
+See also `t.isBinaryExpression(node, opts)` and `t.assertBinaryExpression(node, opts)`.
+
+Aliases: `Binary`, `Expression`
+
+ - `operator`: `'+' | '-' | '/' | '%' | '*' | '**' | '&' | '|' | '>>' | '>>>' | '<<' | '^' | '==' | '===' | '!=' | '!==' | 'in' | 'instanceof' | '>' | '<' | '>=' | '<='` (required)
+ - `left`: `Expression` (required)
+ - `right`: `Expression` (required)
+
+---
+
+### bindExpression
+```javascript
+t.bindExpression(object, callee)
+```
+
+See also `t.isBindExpression(node, opts)` and `t.assertBindExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `object` (required)
+ - `callee` (required)
+
+---
+
+### blockStatement
+```javascript
+t.blockStatement(body, directives)
+```
+
+See also `t.isBlockStatement(node, opts)` and `t.assertBlockStatement(node, opts)`.
+
+Aliases: `Scopable`, `BlockParent`, `Block`, `Statement`
+
+ - `body`: `Array` (required)
+ - `directives`: `Array` (default: `[]`)
+
+---
+
+### booleanLiteral
+```javascript
+t.booleanLiteral(value)
+```
+
+See also `t.isBooleanLiteral(node, opts)` and `t.assertBooleanLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+ - `value`: `boolean` (required)
+
+---
+
+### booleanLiteralTypeAnnotation
+```javascript
+t.booleanLiteralTypeAnnotation()
+```
+
+See also `t.isBooleanLiteralTypeAnnotation(node, opts)` and `t.assertBooleanLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+
+---
+
+### booleanTypeAnnotation
+```javascript
+t.booleanTypeAnnotation()
+```
+
+See also `t.isBooleanTypeAnnotation(node, opts)` and `t.assertBooleanTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### breakStatement
+```javascript
+t.breakStatement(label)
+```
+
+See also `t.isBreakStatement(node, opts)` and `t.assertBreakStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `label`: `Identifier` (default: `null`)
+
+---
+
+### callExpression
+```javascript
+t.callExpression(callee, arguments)
+```
+
+See also `t.isCallExpression(node, opts)` and `t.assertCallExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `callee`: `Expression` (required)
+ - `arguments`: `Array` (required)
+
+---
+
+### catchClause
+```javascript
+t.catchClause(param, body)
+```
+
+See also `t.isCatchClause(node, opts)` and `t.assertCatchClause(node, opts)`.
+
+Aliases: `Scopable`
+
+ - `param`: `Identifier` (required)
+ - `body`: `BlockStatement` (required)
+
+---
+
+### classBody
+```javascript
+t.classBody(body)
+```
+
+See also `t.isClassBody(node, opts)` and `t.assertClassBody(node, opts)`.
+
+ - `body`: `Array` (required)
+
+---
+
+### classDeclaration
+```javascript
+t.classDeclaration(id, superClass, body, decorators)
+```
+
+See also `t.isClassDeclaration(node, opts)` and `t.assertClassDeclaration(node, opts)`.
+
+Aliases: `Scopable`, `Class`, `Statement`, `Declaration`, `Pureish`
+
+ - `id`: `Identifier` (required)
+ - `superClass`: `Expression` (default: `null`)
+ - `body`: `ClassBody` (required)
+ - `decorators`: `Array` (required)
+ - `implements` (default: `null`)
+ - `mixins` (default: `null`)
+ - `superTypeParameters` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### classExpression
+```javascript
+t.classExpression(id, superClass, body, decorators)
+```
+
+See also `t.isClassExpression(node, opts)` and `t.assertClassExpression(node, opts)`.
+
+Aliases: `Scopable`, `Class`, `Expression`, `Pureish`
+
+ - `id`: `Identifier` (default: `null`)
+ - `superClass`: `Expression` (default: `null`)
+ - `body`: `ClassBody` (required)
+ - `decorators`: `Array` (required)
+ - `implements` (default: `null`)
+ - `mixins` (default: `null`)
+ - `superTypeParameters` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### classImplements
+```javascript
+t.classImplements(id, typeParameters)
+```
+
+See also `t.isClassImplements(node, opts)` and `t.assertClassImplements(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id` (required)
+ - `typeParameters` (required)
+
+---
+
+### classMethod
+```javascript
+t.classMethod(kind, key, params, body, computed, static)
+```
+
+See also `t.isClassMethod(node, opts)` and `t.assertClassMethod(node, opts)`.
+
+Aliases: `Function`, `Scopable`, `BlockParent`, `FunctionParent`, `Method`
+
+ - `kind`: `"get" | "set" | "method" | "constructor"` (default: `'method'`)
+ - `key`if computed then `Expression` else `Identifier | Literal` (required)
+ - `params`: `Array` (required)
+ - `body`: `BlockStatement` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `static`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `decorators` (default: `null`)
+ - `generator`: `boolean` (default: `false`)
+ - `returnType` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### classProperty
+```javascript
+t.classProperty(key, value, typeAnnotation, decorators, computed)
+```
+
+See also `t.isClassProperty(node, opts)` and `t.assertClassProperty(node, opts)`.
+
+Aliases: `Property`
+
+ - `key` (required)
+ - `value` (required)
+ - `typeAnnotation` (required)
+ - `decorators` (required)
+ - `computed`: `boolean` (default: `false`)
+
+---
+
+### conditionalExpression
+```javascript
+t.conditionalExpression(test, consequent, alternate)
+```
+
+See also `t.isConditionalExpression(node, opts)` and `t.assertConditionalExpression(node, opts)`.
+
+Aliases: `Expression`, `Conditional`
+
+ - `test`: `Expression` (required)
+ - `consequent`: `Expression` (required)
+ - `alternate`: `Expression` (required)
+
+---
+
+### continueStatement
+```javascript
+t.continueStatement(label)
+```
+
+See also `t.isContinueStatement(node, opts)` and `t.assertContinueStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `label`: `Identifier` (default: `null`)
+
+---
+
+### debuggerStatement
+```javascript
+t.debuggerStatement()
+```
+
+See also `t.isDebuggerStatement(node, opts)` and `t.assertDebuggerStatement(node, opts)`.
+
+Aliases: `Statement`
+
+
+---
+
+### declareClass
+```javascript
+t.declareClass(id, typeParameters, extends, body)
+```
+
+See also `t.isDeclareClass(node, opts)` and `t.assertDeclareClass(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+ - `typeParameters` (required)
+ - `extends` (required)
+ - `body` (required)
+
+---
+
+### declareFunction
+```javascript
+t.declareFunction(id)
+```
+
+See also `t.isDeclareFunction(node, opts)` and `t.assertDeclareFunction(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+
+---
+
+### declareInterface
+```javascript
+t.declareInterface(id, typeParameters, extends, body)
+```
+
+See also `t.isDeclareInterface(node, opts)` and `t.assertDeclareInterface(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+ - `typeParameters` (required)
+ - `extends` (required)
+ - `body` (required)
+
+---
+
+### declareModule
+```javascript
+t.declareModule(id, body)
+```
+
+See also `t.isDeclareModule(node, opts)` and `t.assertDeclareModule(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+ - `body` (required)
+
+---
+
+### declareModuleExports
+```javascript
+t.declareModuleExports(typeAnnotation)
+```
+
+See also `t.isDeclareModuleExports(node, opts)` and `t.assertDeclareModuleExports(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `typeAnnotation` (required)
+
+---
+
+### declareTypeAlias
+```javascript
+t.declareTypeAlias(id, typeParameters, right)
+```
+
+See also `t.isDeclareTypeAlias(node, opts)` and `t.assertDeclareTypeAlias(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+ - `typeParameters` (required)
+ - `right` (required)
+
+---
+
+### declareVariable
+```javascript
+t.declareVariable(id)
+```
+
+See also `t.isDeclareVariable(node, opts)` and `t.assertDeclareVariable(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+
+---
+
+### decorator
+```javascript
+t.decorator(expression)
+```
+
+See also `t.isDecorator(node, opts)` and `t.assertDecorator(node, opts)`.
+
+ - `expression`: `Expression` (required)
+
+---
+
+### directive
+```javascript
+t.directive(value)
+```
+
+See also `t.isDirective(node, opts)` and `t.assertDirective(node, opts)`.
+
+ - `value`: `DirectiveLiteral` (required)
+
+---
+
+### directiveLiteral
+```javascript
+t.directiveLiteral(value)
+```
+
+See also `t.isDirectiveLiteral(node, opts)` and `t.assertDirectiveLiteral(node, opts)`.
+
+ - `value`: `string` (required)
+
+---
+
+### doExpression
+```javascript
+t.doExpression(body)
+```
+
+See also `t.isDoExpression(node, opts)` and `t.assertDoExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `body`: `BlockStatement` (required)
+
+---
+
+### doWhileStatement
+```javascript
+t.doWhileStatement(test, body)
+```
+
+See also `t.isDoWhileStatement(node, opts)` and `t.assertDoWhileStatement(node, opts)`.
+
+Aliases: `Statement`, `BlockParent`, `Loop`, `While`, `Scopable`
+
+ - `test`: `Expression` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### emptyStatement
+```javascript
+t.emptyStatement()
+```
+
+See also `t.isEmptyStatement(node, opts)` and `t.assertEmptyStatement(node, opts)`.
+
+Aliases: `Statement`
+
+
+---
+
+### emptyTypeAnnotation
+```javascript
+t.emptyTypeAnnotation()
+```
+
+See also `t.isEmptyTypeAnnotation(node, opts)` and `t.assertEmptyTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### existentialTypeParam
+```javascript
+t.existentialTypeParam()
+```
+
+See also `t.isExistentialTypeParam(node, opts)` and `t.assertExistentialTypeParam(node, opts)`.
+
+Aliases: `Flow`
+
+
+---
+
+### exportAllDeclaration
+```javascript
+t.exportAllDeclaration(source)
+```
+
+See also `t.isExportAllDeclaration(node, opts)` and `t.assertExportAllDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`, `ExportDeclaration`
+
+ - `source`: `StringLiteral` (required)
+
+---
+
+### exportDefaultDeclaration
+```javascript
+t.exportDefaultDeclaration(declaration)
+```
+
+See also `t.isExportDefaultDeclaration(node, opts)` and `t.assertExportDefaultDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`, `ExportDeclaration`
+
+ - `declaration`: `FunctionDeclaration | ClassDeclaration | Expression` (required)
+
+---
+
+### exportDefaultSpecifier
+```javascript
+t.exportDefaultSpecifier(exported)
+```
+
+See also `t.isExportDefaultSpecifier(node, opts)` and `t.assertExportDefaultSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `exported`: `Identifier` (required)
+
+---
+
+### exportNamedDeclaration
+```javascript
+t.exportNamedDeclaration(declaration, specifiers, source)
+```
+
+See also `t.isExportNamedDeclaration(node, opts)` and `t.assertExportNamedDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`, `ExportDeclaration`
+
+ - `declaration`: `Declaration` (default: `null`)
+ - `specifiers`: `Array` (required)
+ - `source`: `StringLiteral` (default: `null`)
+
+---
+
+### exportNamespaceSpecifier
+```javascript
+t.exportNamespaceSpecifier(exported)
+```
+
+See also `t.isExportNamespaceSpecifier(node, opts)` and `t.assertExportNamespaceSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `exported`: `Identifier` (required)
+
+---
+
+### exportSpecifier
+```javascript
+t.exportSpecifier(local, exported)
+```
+
+See also `t.isExportSpecifier(node, opts)` and `t.assertExportSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+ - `exported`: `Identifier` (required)
+
+---
+
+### expressionStatement
+```javascript
+t.expressionStatement(expression)
+```
+
+See also `t.isExpressionStatement(node, opts)` and `t.assertExpressionStatement(node, opts)`.
+
+Aliases: `Statement`, `ExpressionWrapper`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### file
+```javascript
+t.file(program, comments, tokens)
+```
+
+See also `t.isFile(node, opts)` and `t.assertFile(node, opts)`.
+
+ - `program`: `Program` (required)
+ - `comments` (required)
+ - `tokens` (required)
+
+---
+
+### forAwaitStatement
+```javascript
+t.forAwaitStatement(left, right, body)
+```
+
+See also `t.isForAwaitStatement(node, opts)` and `t.assertForAwaitStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`, `ForXStatement`
+
+ - `left`: `VariableDeclaration | LVal` (required)
+ - `right`: `Expression` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### forInStatement
+```javascript
+t.forInStatement(left, right, body)
+```
+
+See also `t.isForInStatement(node, opts)` and `t.assertForInStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`, `ForXStatement`
+
+ - `left`: `VariableDeclaration | LVal` (required)
+ - `right`: `Expression` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### forOfStatement
+```javascript
+t.forOfStatement(left, right, body)
+```
+
+See also `t.isForOfStatement(node, opts)` and `t.assertForOfStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`, `ForXStatement`
+
+ - `left`: `VariableDeclaration | LVal` (required)
+ - `right`: `Expression` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### forStatement
+```javascript
+t.forStatement(init, test, update, body)
+```
+
+See also `t.isForStatement(node, opts)` and `t.assertForStatement(node, opts)`.
+
+Aliases: `Scopable`, `Statement`, `For`, `BlockParent`, `Loop`
+
+ - `init`: `VariableDeclaration | Expression` (default: `null`)
+ - `test`: `Expression` (default: `null`)
+ - `update`: `Expression` (default: `null`)
+ - `body`: `Statement` (required)
+
+---
+
+### functionDeclaration
+```javascript
+t.functionDeclaration(id, params, body, generator, async)
+```
+
+See also `t.isFunctionDeclaration(node, opts)` and `t.assertFunctionDeclaration(node, opts)`.
+
+Aliases: `Scopable`, `Function`, `BlockParent`, `FunctionParent`, `Statement`, `Pureish`, `Declaration`
+
+ - `id`: `Identifier` (required)
+ - `params`: `Array` (required)
+ - `body`: `BlockStatement` (required)
+ - `generator`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `returnType` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### functionExpression
+```javascript
+t.functionExpression(id, params, body, generator, async)
+```
+
+See also `t.isFunctionExpression(node, opts)` and `t.assertFunctionExpression(node, opts)`.
+
+Aliases: `Scopable`, `Function`, `BlockParent`, `FunctionParent`, `Expression`, `Pureish`
+
+ - `id`: `Identifier` (default: `null`)
+ - `params`: `Array` (required)
+ - `body`: `BlockStatement` (required)
+ - `generator`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `returnType` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### functionTypeAnnotation
+```javascript
+t.functionTypeAnnotation(typeParameters, params, rest, returnType)
+```
+
+See also `t.isFunctionTypeAnnotation(node, opts)` and `t.assertFunctionTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `typeParameters` (required)
+ - `params` (required)
+ - `rest` (required)
+ - `returnType` (required)
+
+---
+
+### functionTypeParam
+```javascript
+t.functionTypeParam(name, typeAnnotation)
+```
+
+See also `t.isFunctionTypeParam(node, opts)` and `t.assertFunctionTypeParam(node, opts)`.
+
+Aliases: `Flow`
+
+ - `name` (required)
+ - `typeAnnotation` (required)
+
+---
+
+### genericTypeAnnotation
+```javascript
+t.genericTypeAnnotation(id, typeParameters)
+```
+
+See also `t.isGenericTypeAnnotation(node, opts)` and `t.assertGenericTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id` (required)
+ - `typeParameters` (required)
+
+---
+
+### identifier
+```javascript
+t.identifier(name)
+```
+
+See also `t.isIdentifier(node, opts)` and `t.assertIdentifier(node, opts)`.
+
+Aliases: `Expression`, `LVal`
+
+ - `name``string` (required)
+ - `decorators`: `Array` (default: `null`)
+ - `typeAnnotation` (default: `null`)
+
+---
+
+### ifStatement
+```javascript
+t.ifStatement(test, consequent, alternate)
+```
+
+See also `t.isIfStatement(node, opts)` and `t.assertIfStatement(node, opts)`.
+
+Aliases: `Statement`, `Conditional`
+
+ - `test`: `Expression` (required)
+ - `consequent`: `Statement` (required)
+ - `alternate`: `Statement` (default: `null`)
+
+---
+
+### import
+```javascript
+t.import()
+```
+
+See also `t.isImport(node, opts)` and `t.assertImport(node, opts)`.
+
+Aliases: `Expression`
+
+
+---
+
+### importDeclaration
+```javascript
+t.importDeclaration(specifiers, source)
+```
+
+See also `t.isImportDeclaration(node, opts)` and `t.assertImportDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`, `ModuleDeclaration`
+
+ - `specifiers`: `Array` (required)
+ - `source`: `StringLiteral` (required)
+
+---
+
+### importDefaultSpecifier
+```javascript
+t.importDefaultSpecifier(local)
+```
+
+See also `t.isImportDefaultSpecifier(node, opts)` and `t.assertImportDefaultSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+
+---
+
+### importNamespaceSpecifier
+```javascript
+t.importNamespaceSpecifier(local)
+```
+
+See also `t.isImportNamespaceSpecifier(node, opts)` and `t.assertImportNamespaceSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+
+---
+
+### importSpecifier
+```javascript
+t.importSpecifier(local, imported)
+```
+
+See also `t.isImportSpecifier(node, opts)` and `t.assertImportSpecifier(node, opts)`.
+
+Aliases: `ModuleSpecifier`
+
+ - `local`: `Identifier` (required)
+ - `imported`: `Identifier` (required)
+ - `importKind`: `null | 'type' | 'typeof'` (default: `null`)
+
+---
+
+### interfaceDeclaration
+```javascript
+t.interfaceDeclaration(id, typeParameters, extends, body)
+```
+
+See also `t.isInterfaceDeclaration(node, opts)` and `t.assertInterfaceDeclaration(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+ - `typeParameters` (required)
+ - `extends` (required)
+ - `body` (required)
+
+---
+
+### interfaceExtends
+```javascript
+t.interfaceExtends(id, typeParameters)
+```
+
+See also `t.isInterfaceExtends(node, opts)` and `t.assertInterfaceExtends(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id` (required)
+ - `typeParameters` (required)
+
+---
+
+### intersectionTypeAnnotation
+```javascript
+t.intersectionTypeAnnotation(types)
+```
+
+See also `t.isIntersectionTypeAnnotation(node, opts)` and `t.assertIntersectionTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `types` (required)
+
+---
+
+### jSXAttribute
+```javascript
+t.jSXAttribute(name, value)
+```
+
+See also `t.isJSXAttribute(node, opts)` and `t.assertJSXAttribute(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `name`: `JSXIdentifier | JSXNamespacedName` (required)
+ - `value`: `JSXElement | StringLiteral | JSXExpressionContainer` (default: `null`)
+
+---
+
+### jSXClosingElement
+```javascript
+t.jSXClosingElement(name)
+```
+
+See also `t.isJSXClosingElement(node, opts)` and `t.assertJSXClosingElement(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `name`: `JSXIdentifier | JSXMemberExpression` (required)
+
+---
+
+### jSXElement
+```javascript
+t.jSXElement(openingElement, closingElement, children, selfClosing)
+```
+
+See also `t.isJSXElement(node, opts)` and `t.assertJSXElement(node, opts)`.
+
+Aliases: `JSX`, `Immutable`, `Expression`
+
+ - `openingElement`: `JSXOpeningElement` (required)
+ - `closingElement`: `JSXClosingElement` (default: `null`)
+ - `children`: `Array` (required)
+ - `selfClosing` (required)
+
+---
+
+### jSXEmptyExpression
+```javascript
+t.jSXEmptyExpression()
+```
+
+See also `t.isJSXEmptyExpression(node, opts)` and `t.assertJSXEmptyExpression(node, opts)`.
+
+Aliases: `JSX`, `Expression`
+
+
+---
+
+### jSXExpressionContainer
+```javascript
+t.jSXExpressionContainer(expression)
+```
+
+See also `t.isJSXExpressionContainer(node, opts)` and `t.assertJSXExpressionContainer(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### jSXIdentifier
+```javascript
+t.jSXIdentifier(name)
+```
+
+See also `t.isJSXIdentifier(node, opts)` and `t.assertJSXIdentifier(node, opts)`.
+
+Aliases: `JSX`, `Expression`
+
+ - `name`: `string` (required)
+
+---
+
+### jSXMemberExpression
+```javascript
+t.jSXMemberExpression(object, property)
+```
+
+See also `t.isJSXMemberExpression(node, opts)` and `t.assertJSXMemberExpression(node, opts)`.
+
+Aliases: `JSX`, `Expression`
+
+ - `object`: `JSXMemberExpression | JSXIdentifier` (required)
+ - `property`: `JSXIdentifier` (required)
+
+---
+
+### jSXNamespacedName
+```javascript
+t.jSXNamespacedName(namespace, name)
+```
+
+See also `t.isJSXNamespacedName(node, opts)` and `t.assertJSXNamespacedName(node, opts)`.
+
+Aliases: `JSX`
+
+ - `namespace`: `JSXIdentifier` (required)
+ - `name`: `JSXIdentifier` (required)
+
+---
+
+### jSXOpeningElement
+```javascript
+t.jSXOpeningElement(name, attributes, selfClosing)
+```
+
+See also `t.isJSXOpeningElement(node, opts)` and `t.assertJSXOpeningElement(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `name`: `JSXIdentifier | JSXMemberExpression` (required)
+ - `attributes`: `Array` (required)
+ - `selfClosing`: `boolean` (default: `false`)
+
+---
+
+### jSXSpreadAttribute
+```javascript
+t.jSXSpreadAttribute(argument)
+```
+
+See also `t.isJSXSpreadAttribute(node, opts)` and `t.assertJSXSpreadAttribute(node, opts)`.
+
+Aliases: `JSX`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### jSXSpreadChild
+```javascript
+t.jSXSpreadChild(expression)
+```
+
+See also `t.isJSXSpreadChild(node, opts)` and `t.assertJSXSpreadChild(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### jSXText
+```javascript
+t.jSXText(value)
+```
+
+See also `t.isJSXText(node, opts)` and `t.assertJSXText(node, opts)`.
+
+Aliases: `JSX`, `Immutable`
+
+ - `value`: `string` (required)
+
+---
+
+### labeledStatement
+```javascript
+t.labeledStatement(label, body)
+```
+
+See also `t.isLabeledStatement(node, opts)` and `t.assertLabeledStatement(node, opts)`.
+
+Aliases: `Statement`
+
+ - `label`: `Identifier` (required)
+ - `body`: `Statement` (required)
+
+---
+
+### logicalExpression
+```javascript
+t.logicalExpression(operator, left, right)
+```
+
+See also `t.isLogicalExpression(node, opts)` and `t.assertLogicalExpression(node, opts)`.
+
+Aliases: `Binary`, `Expression`
+
+ - `operator`: `'||' | '&&'` (required)
+ - `left`: `Expression` (required)
+ - `right`: `Expression` (required)
+
+---
+
+### memberExpression
+```javascript
+t.memberExpression(object, property, computed)
+```
+
+See also `t.isMemberExpression(node, opts)` and `t.assertMemberExpression(node, opts)`.
+
+Aliases: `Expression`, `LVal`
+
+ - `object`: `Expression` (required)
+ - `property`if computed then `Expression` else `Identifier` (required)
+ - `computed`: `boolean` (default: `false`)
+
+---
+
+### metaProperty
+```javascript
+t.metaProperty(meta, property)
+```
+
+See also `t.isMetaProperty(node, opts)` and `t.assertMetaProperty(node, opts)`.
+
+Aliases: `Expression`
+
+ - `meta`: `string` (required)
+ - `property`: `string` (required)
+
+---
+
+### mixedTypeAnnotation
+```javascript
+t.mixedTypeAnnotation()
+```
+
+See also `t.isMixedTypeAnnotation(node, opts)` and `t.assertMixedTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### newExpression
+```javascript
+t.newExpression(callee, arguments)
+```
+
+See also `t.isNewExpression(node, opts)` and `t.assertNewExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `callee`: `Expression` (required)
+ - `arguments`: `Array` (required)
+
+---
+
+### noop
+```javascript
+t.noop()
+```
+
+See also `t.isNoop(node, opts)` and `t.assertNoop(node, opts)`.
+
+
+---
+
+### nullLiteral
+```javascript
+t.nullLiteral()
+```
+
+See also `t.isNullLiteral(node, opts)` and `t.assertNullLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+
+---
+
+### nullLiteralTypeAnnotation
+```javascript
+t.nullLiteralTypeAnnotation()
+```
+
+See also `t.isNullLiteralTypeAnnotation(node, opts)` and `t.assertNullLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### nullableTypeAnnotation
+```javascript
+t.nullableTypeAnnotation(typeAnnotation)
+```
+
+See also `t.isNullableTypeAnnotation(node, opts)` and `t.assertNullableTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `typeAnnotation` (required)
+
+---
+
+### numberTypeAnnotation
+```javascript
+t.numberTypeAnnotation()
+```
+
+See also `t.isNumberTypeAnnotation(node, opts)` and `t.assertNumberTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### numericLiteral
+```javascript
+t.numericLiteral(value)
+```
+
+See also `t.isNumericLiteral(node, opts)` and `t.assertNumericLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+ - `value`: `number` (required)
+
+---
+
+### numericLiteralTypeAnnotation
+```javascript
+t.numericLiteralTypeAnnotation()
+```
+
+See also `t.isNumericLiteralTypeAnnotation(node, opts)` and `t.assertNumericLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+
+---
+
+### objectExpression
+```javascript
+t.objectExpression(properties)
+```
+
+See also `t.isObjectExpression(node, opts)` and `t.assertObjectExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `properties`: `Array` (required)
+
+---
+
+### objectMethod
+```javascript
+t.objectMethod(kind, key, params, body, computed)
+```
+
+See also `t.isObjectMethod(node, opts)` and `t.assertObjectMethod(node, opts)`.
+
+Aliases: `UserWhitespacable`, `Function`, `Scopable`, `BlockParent`, `FunctionParent`, `Method`, `ObjectMember`
+
+ - `kind`: `"method" | "get" | "set"` (default: `'method'`)
+ - `key`if computed then `Expression` else `Identifier | Literal` (required)
+ - `params` (required)
+ - `body`: `BlockStatement` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `async`: `boolean` (default: `false`)
+ - `decorators`: `Array` (default: `null`)
+ - `generator`: `boolean` (default: `false`)
+ - `returnType` (default: `null`)
+ - `typeParameters` (default: `null`)
+
+---
+
+### objectPattern
+```javascript
+t.objectPattern(properties, typeAnnotation)
+```
+
+See also `t.isObjectPattern(node, opts)` and `t.assertObjectPattern(node, opts)`.
+
+Aliases: `Pattern`, `LVal`
+
+ - `properties`: `Array` (required)
+ - `typeAnnotation` (required)
+ - `decorators`: `Array` (default: `null`)
+
+---
+
+### objectProperty
+```javascript
+t.objectProperty(key, value, computed, shorthand, decorators)
+```
+
+See also `t.isObjectProperty(node, opts)` and `t.assertObjectProperty(node, opts)`.
+
+Aliases: `UserWhitespacable`, `Property`, `ObjectMember`
+
+ - `key`if computed then `Expression` else `Identifier | Literal` (required)
+ - `value`: `Expression` (required)
+ - `computed`: `boolean` (default: `false`)
+ - `shorthand`: `boolean` (default: `false`)
+ - `decorators`: `Array` (default: `null`)
+
+---
+
+### objectTypeAnnotation
+```javascript
+t.objectTypeAnnotation(properties, indexers, callProperties)
+```
+
+See also `t.isObjectTypeAnnotation(node, opts)` and `t.assertObjectTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `properties` (required)
+ - `indexers` (required)
+ - `callProperties` (required)
+
+---
+
+### objectTypeCallProperty
+```javascript
+t.objectTypeCallProperty(value)
+```
+
+See also `t.isObjectTypeCallProperty(node, opts)` and `t.assertObjectTypeCallProperty(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `value` (required)
+
+---
+
+### objectTypeIndexer
+```javascript
+t.objectTypeIndexer(id, key, value)
+```
+
+See also `t.isObjectTypeIndexer(node, opts)` and `t.assertObjectTypeIndexer(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `id` (required)
+ - `key` (required)
+ - `value` (required)
+
+---
+
+### objectTypeProperty
+```javascript
+t.objectTypeProperty(key, value)
+```
+
+See also `t.isObjectTypeProperty(node, opts)` and `t.assertObjectTypeProperty(node, opts)`.
+
+Aliases: `Flow`, `UserWhitespacable`
+
+ - `key` (required)
+ - `value` (required)
+
+---
+
+### parenthesizedExpression
+```javascript
+t.parenthesizedExpression(expression)
+```
+
+See also `t.isParenthesizedExpression(node, opts)` and `t.assertParenthesizedExpression(node, opts)`.
+
+Aliases: `Expression`, `ExpressionWrapper`
+
+ - `expression`: `Expression` (required)
+
+---
+
+### program
+```javascript
+t.program(body, directives)
+```
+
+See also `t.isProgram(node, opts)` and `t.assertProgram(node, opts)`.
+
+Aliases: `Scopable`, `BlockParent`, `Block`, `FunctionParent`
+
+ - `body`: `Array` (required)
+ - `directives`: `Array` (default: `[]`)
+
+---
+
+### qualifiedTypeIdentifier
+```javascript
+t.qualifiedTypeIdentifier(id, qualification)
+```
+
+See also `t.isQualifiedTypeIdentifier(node, opts)` and `t.assertQualifiedTypeIdentifier(node, opts)`.
+
+Aliases: `Flow`
+
+ - `id` (required)
+ - `qualification` (required)
+
+---
+
+### regExpLiteral
+```javascript
+t.regExpLiteral(pattern, flags)
+```
+
+See also `t.isRegExpLiteral(node, opts)` and `t.assertRegExpLiteral(node, opts)`.
+
+Aliases: `Expression`, `Literal`
+
+ - `pattern`: `string` (required)
+ - `flags`: `string` (default: `''`)
+
+---
+
+### restElement
+```javascript
+t.restElement(argument, typeAnnotation)
+```
+
+See also `t.isRestElement(node, opts)` and `t.assertRestElement(node, opts)`.
+
+Aliases: `LVal`
+
+ - `argument`: `LVal` (required)
+ - `typeAnnotation` (required)
+ - `decorators`: `Array` (default: `null`)
+
+---
+
+### restProperty
+```javascript
+t.restProperty(argument)
+```
+
+See also `t.isRestProperty(node, opts)` and `t.assertRestProperty(node, opts)`.
+
+Aliases: `UnaryLike`
+
+ - `argument`: `LVal` (required)
+
+---
+
+### returnStatement
+```javascript
+t.returnStatement(argument)
+```
+
+See also `t.isReturnStatement(node, opts)` and `t.assertReturnStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `argument`: `Expression` (default: `null`)
+
+---
+
+### sequenceExpression
+```javascript
+t.sequenceExpression(expressions)
+```
+
+See also `t.isSequenceExpression(node, opts)` and `t.assertSequenceExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `expressions`: `Array` (required)
+
+---
+
+### spreadElement
+```javascript
+t.spreadElement(argument)
+```
+
+See also `t.isSpreadElement(node, opts)` and `t.assertSpreadElement(node, opts)`.
+
+Aliases: `UnaryLike`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### spreadProperty
+```javascript
+t.spreadProperty(argument)
+```
+
+See also `t.isSpreadProperty(node, opts)` and `t.assertSpreadProperty(node, opts)`.
+
+Aliases: `UnaryLike`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### stringLiteral
+```javascript
+t.stringLiteral(value)
+```
+
+See also `t.isStringLiteral(node, opts)` and `t.assertStringLiteral(node, opts)`.
+
+Aliases: `Expression`, `Pureish`, `Literal`, `Immutable`
+
+ - `value`: `string` (required)
+
+---
+
+### stringLiteralTypeAnnotation
+```javascript
+t.stringLiteralTypeAnnotation()
+```
+
+See also `t.isStringLiteralTypeAnnotation(node, opts)` and `t.assertStringLiteralTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+
+---
+
+### stringTypeAnnotation
+```javascript
+t.stringTypeAnnotation()
+```
+
+See also `t.isStringTypeAnnotation(node, opts)` and `t.assertStringTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### super
+```javascript
+t.super()
+```
+
+See also `t.isSuper(node, opts)` and `t.assertSuper(node, opts)`.
+
+Aliases: `Expression`
+
+
+---
+
+### switchCase
+```javascript
+t.switchCase(test, consequent)
+```
+
+See also `t.isSwitchCase(node, opts)` and `t.assertSwitchCase(node, opts)`.
+
+ - `test`: `Expression` (default: `null`)
+ - `consequent`: `Array` (required)
+
+---
+
+### switchStatement
+```javascript
+t.switchStatement(discriminant, cases)
+```
+
+See also `t.isSwitchStatement(node, opts)` and `t.assertSwitchStatement(node, opts)`.
+
+Aliases: `Statement`, `BlockParent`, `Scopable`
+
+ - `discriminant`: `Expression` (required)
+ - `cases`: `Array` (required)
+
+---
+
+### taggedTemplateExpression
+```javascript
+t.taggedTemplateExpression(tag, quasi)
+```
+
+See also `t.isTaggedTemplateExpression(node, opts)` and `t.assertTaggedTemplateExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `tag`: `Expression` (required)
+ - `quasi`: `TemplateLiteral` (required)
+
+---
+
+### templateElement
+```javascript
+t.templateElement(value, tail)
+```
+
+See also `t.isTemplateElement(node, opts)` and `t.assertTemplateElement(node, opts)`.
+
+ - `value` (required)
+ - `tail`: `boolean` (default: `false`)
+
+---
+
+### templateLiteral
+```javascript
+t.templateLiteral(quasis, expressions)
+```
+
+See also `t.isTemplateLiteral(node, opts)` and `t.assertTemplateLiteral(node, opts)`.
+
+Aliases: `Expression`, `Literal`
+
+ - `quasis`: `Array` (required)
+ - `expressions`: `Array` (required)
+
+---
+
+### thisExpression
+```javascript
+t.thisExpression()
+```
+
+See also `t.isThisExpression(node, opts)` and `t.assertThisExpression(node, opts)`.
+
+Aliases: `Expression`
+
+
+---
+
+### thisTypeAnnotation
+```javascript
+t.thisTypeAnnotation()
+```
+
+See also `t.isThisTypeAnnotation(node, opts)` and `t.assertThisTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### throwStatement
+```javascript
+t.throwStatement(argument)
+```
+
+See also `t.isThrowStatement(node, opts)` and `t.assertThrowStatement(node, opts)`.
+
+Aliases: `Statement`, `Terminatorless`, `CompletionStatement`
+
+ - `argument`: `Expression` (required)
+
+---
+
+### tryStatement
+```javascript
+t.tryStatement(block, handler, finalizer)
+```
+
+See also `t.isTryStatement(node, opts)` and `t.assertTryStatement(node, opts)`.
+
+Aliases: `Statement`
+
+ - `block` (required)
+ - `handler` (default: `null`)
+ - `finalizer`: `BlockStatement` (default: `null`)
+ - `body`: `BlockStatement` (default: `null`)
+
+---
+
+### tupleTypeAnnotation
+```javascript
+t.tupleTypeAnnotation(types)
+```
+
+See also `t.isTupleTypeAnnotation(node, opts)` and `t.assertTupleTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `types` (required)
+
+---
+
+### typeAlias
+```javascript
+t.typeAlias(id, typeParameters, right)
+```
+
+See also `t.isTypeAlias(node, opts)` and `t.assertTypeAlias(node, opts)`.
+
+Aliases: `Flow`, `FlowDeclaration`, `Statement`, `Declaration`
+
+ - `id` (required)
+ - `typeParameters` (required)
+ - `right` (required)
+
+---
+
+### typeAnnotation
+```javascript
+t.typeAnnotation(typeAnnotation)
+```
+
+See also `t.isTypeAnnotation(node, opts)` and `t.assertTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `typeAnnotation` (required)
+
+---
+
+### typeCastExpression
+```javascript
+t.typeCastExpression(expression, typeAnnotation)
+```
+
+See also `t.isTypeCastExpression(node, opts)` and `t.assertTypeCastExpression(node, opts)`.
+
+Aliases: `Flow`, `ExpressionWrapper`, `Expression`
+
+ - `expression` (required)
+ - `typeAnnotation` (required)
+
+---
+
+### typeParameter
+```javascript
+t.typeParameter(bound)
+```
+
+See also `t.isTypeParameter(node, opts)` and `t.assertTypeParameter(node, opts)`.
+
+Aliases: `Flow`
+
+ - `bound` (required)
+
+---
+
+### typeParameterDeclaration
+```javascript
+t.typeParameterDeclaration(params)
+```
+
+See also `t.isTypeParameterDeclaration(node, opts)` and `t.assertTypeParameterDeclaration(node, opts)`.
+
+Aliases: `Flow`
+
+ - `params` (required)
+
+---
+
+### typeParameterInstantiation
+```javascript
+t.typeParameterInstantiation(params)
+```
+
+See also `t.isTypeParameterInstantiation(node, opts)` and `t.assertTypeParameterInstantiation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `params` (required)
+
+---
+
+### typeofTypeAnnotation
+```javascript
+t.typeofTypeAnnotation(argument)
+```
+
+See also `t.isTypeofTypeAnnotation(node, opts)` and `t.assertTypeofTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `argument` (required)
+
+---
+
+### unaryExpression
+```javascript
+t.unaryExpression(operator, argument, prefix)
+```
+
+See also `t.isUnaryExpression(node, opts)` and `t.assertUnaryExpression(node, opts)`.
+
+Aliases: `UnaryLike`, `Expression`
+
+ - `operator`: `'void' | 'delete' | '!' | '+' | '-' | '++' | '--' | '~' | 'typeof'` (required)
+ - `argument`: `Expression` (required)
+ - `prefix`: `boolean` (default: `true`)
+
+---
+
+### unionTypeAnnotation
+```javascript
+t.unionTypeAnnotation(types)
+```
+
+See also `t.isUnionTypeAnnotation(node, opts)` and `t.assertUnionTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`
+
+ - `types` (required)
+
+---
+
+### updateExpression
+```javascript
+t.updateExpression(operator, argument, prefix)
+```
+
+See also `t.isUpdateExpression(node, opts)` and `t.assertUpdateExpression(node, opts)`.
+
+Aliases: `Expression`
+
+ - `operator`: `'++' | '--'` (required)
+ - `argument`: `Expression` (required)
+ - `prefix`: `boolean` (default: `false`)
+
+---
+
+### variableDeclaration
+```javascript
+t.variableDeclaration(kind, declarations)
+```
+
+See also `t.isVariableDeclaration(node, opts)` and `t.assertVariableDeclaration(node, opts)`.
+
+Aliases: `Statement`, `Declaration`
+
+ - `kind`: `"var" | "let" | "const"` (required)
+ - `declarations`: `Array` (required)
+
+---
+
+### variableDeclarator
+```javascript
+t.variableDeclarator(id, init)
+```
+
+See also `t.isVariableDeclarator(node, opts)` and `t.assertVariableDeclarator(node, opts)`.
+
+ - `id`: `LVal` (required)
+ - `init`: `Expression` (default: `null`)
+
+---
+
+### voidTypeAnnotation
+```javascript
+t.voidTypeAnnotation()
+```
+
+See also `t.isVoidTypeAnnotation(node, opts)` and `t.assertVoidTypeAnnotation(node, opts)`.
+
+Aliases: `Flow`, `FlowBaseAnnotation`
+
+
+---
+
+### whileStatement
+```javascript
+t.whileStatement(test, body)
+```
+
+See also `t.isWhileStatement(node, opts)` and `t.assertWhileStatement(node, opts)`.
+
+Aliases: `Statement`, `BlockParent`, `Loop`, `While`, `Scopable`
+
+ - `test`: `Expression` (required)
+ - `body`: `BlockStatement | Statement` (required)
+
+---
+
+### withStatement
+```javascript
+t.withStatement(object, body)
+```
+
+See also `t.isWithStatement(node, opts)` and `t.assertWithStatement(node, opts)`.
+
+Aliases: `Statement`
+
+ - `object` (required)
+ - `body`: `BlockStatement | Statement` (required)
+
+---
+
+### yieldExpression
+```javascript
+t.yieldExpression(argument, delegate)
+```
+
+See also `t.isYieldExpression(node, opts)` and `t.assertYieldExpression(node, opts)`.
+
+Aliases: `Expression`, `Terminatorless`
+
+ - `argument`: `Expression` (default: `null`)
+ - `delegate`: `boolean` (default: `false`)
+
+---
+
+
+
+
diff --git a/node_modules/babel-types/lib/constants.js b/node_modules/babel-types/lib/constants.js
new file mode 100644
index 00000000..ba15090b
--- /dev/null
+++ b/node_modules/babel-types/lib/constants.js
@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = undefined;
+
+var _for = require("babel-runtime/core-js/symbol/for");
+
+var _for2 = _interopRequireDefault(_for);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var STATEMENT_OR_BLOCK_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
+var FLATTENABLE_KEYS = exports.FLATTENABLE_KEYS = ["body", "expressions"];
+var FOR_INIT_KEYS = exports.FOR_INIT_KEYS = ["left", "init"];
+var COMMENT_KEYS = exports.COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
+
+var LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = ["||", "&&"];
+var UPDATE_OPERATORS = exports.UPDATE_OPERATORS = ["++", "--"];
+
+var BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
+var EQUALITY_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
+var COMPARISON_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = [].concat(EQUALITY_BINARY_OPERATORS, ["in", "instanceof"]);
+var BOOLEAN_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = [].concat(COMPARISON_BINARY_OPERATORS, BOOLEAN_NUMBER_BINARY_OPERATORS);
+var NUMBER_BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+var BINARY_OPERATORS = exports.BINARY_OPERATORS = ["+"].concat(NUMBER_BINARY_OPERATORS, BOOLEAN_BINARY_OPERATORS);
+
+var BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
+var NUMBER_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = ["+", "-", "++", "--", "~"];
+var STRING_UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = ["typeof"];
+var UNARY_OPERATORS = exports.UNARY_OPERATORS = ["void"].concat(BOOLEAN_UNARY_OPERATORS, NUMBER_UNARY_OPERATORS, STRING_UNARY_OPERATORS);
+
+var INHERIT_KEYS = exports.INHERIT_KEYS = {
+ optional: ["typeAnnotation", "typeParameters", "returnType"],
+ force: ["start", "loc", "end"]
+};
+
+var BLOCK_SCOPED_SYMBOL = exports.BLOCK_SCOPED_SYMBOL = (0, _for2.default)("var used to be block scoped");
+var NOT_LOCAL_BINDING = exports.NOT_LOCAL_BINDING = (0, _for2.default)("should not be considered a local binding");
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/converters.js b/node_modules/babel-types/lib/converters.js
new file mode 100644
index 00000000..94db954b
--- /dev/null
+++ b/node_modules/babel-types/lib/converters.js
@@ -0,0 +1,338 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _maxSafeInteger = require("babel-runtime/core-js/number/max-safe-integer");
+
+var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
+
+var _stringify = require("babel-runtime/core-js/json/stringify");
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.toComputedKey = toComputedKey;
+exports.toSequenceExpression = toSequenceExpression;
+exports.toKeyAlias = toKeyAlias;
+exports.toIdentifier = toIdentifier;
+exports.toBindingIdentifierName = toBindingIdentifierName;
+exports.toStatement = toStatement;
+exports.toExpression = toExpression;
+exports.toBlock = toBlock;
+exports.valueToNode = valueToNode;
+
+var _isPlainObject = require("lodash/isPlainObject");
+
+var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
+
+var _isRegExp = require("lodash/isRegExp");
+
+var _isRegExp2 = _interopRequireDefault(_isRegExp);
+
+var _index = require("./index");
+
+var t = _interopRequireWildcard(_index);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function toComputedKey(node) {
+ var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key || node.property;
+
+ if (!node.computed) {
+ if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
+ }
+ return key;
+}
+
+function toSequenceExpression(nodes, scope) {
+ if (!nodes || !nodes.length) return;
+
+ var declars = [];
+ var bailed = false;
+
+ var result = convert(nodes);
+ if (bailed) return;
+
+ for (var i = 0; i < declars.length; i++) {
+ scope.push(declars[i]);
+ }
+
+ return result;
+
+ function convert(nodes) {
+ var ensureLastUndefined = false;
+ var exprs = [];
+
+ for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var node = _ref;
+
+ if (t.isExpression(node)) {
+ exprs.push(node);
+ } else if (t.isExpressionStatement(node)) {
+ exprs.push(node.expression);
+ } else if (t.isVariableDeclaration(node)) {
+ if (node.kind !== "var") return bailed = true;
+
+ for (var _iterator2 = node.declarations, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var declar = _ref2;
+
+ var bindings = t.getBindingIdentifiers(declar);
+ for (var key in bindings) {
+ declars.push({
+ kind: node.kind,
+ id: bindings[key]
+ });
+ }
+
+ if (declar.init) {
+ exprs.push(t.assignmentExpression("=", declar.id, declar.init));
+ }
+ }
+
+ ensureLastUndefined = true;
+ continue;
+ } else if (t.isIfStatement(node)) {
+ var consequent = node.consequent ? convert([node.consequent]) : scope.buildUndefinedNode();
+ var alternate = node.alternate ? convert([node.alternate]) : scope.buildUndefinedNode();
+ if (!consequent || !alternate) return bailed = true;
+
+ exprs.push(t.conditionalExpression(node.test, consequent, alternate));
+ } else if (t.isBlockStatement(node)) {
+ exprs.push(convert(node.body));
+ } else if (t.isEmptyStatement(node)) {
+ ensureLastUndefined = true;
+ continue;
+ } else {
+ return bailed = true;
+ }
+
+ ensureLastUndefined = false;
+ }
+
+ if (ensureLastUndefined || exprs.length === 0) {
+ exprs.push(scope.buildUndefinedNode());
+ }
+
+ if (exprs.length === 1) {
+ return exprs[0];
+ } else {
+ return t.sequenceExpression(exprs);
+ }
+ }
+}
+
+function toKeyAlias(node) {
+ var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key;
+
+ var alias = void 0;
+
+ if (node.kind === "method") {
+ return toKeyAlias.increment() + "";
+ } else if (t.isIdentifier(key)) {
+ alias = key.name;
+ } else if (t.isStringLiteral(key)) {
+ alias = (0, _stringify2.default)(key.value);
+ } else {
+ alias = (0, _stringify2.default)(t.removePropertiesDeep(t.cloneDeep(key)));
+ }
+
+ if (node.computed) {
+ alias = "[" + alias + "]";
+ }
+
+ if (node.static) {
+ alias = "static:" + alias;
+ }
+
+ return alias;
+}
+
+toKeyAlias.uid = 0;
+
+toKeyAlias.increment = function () {
+ if (toKeyAlias.uid >= _maxSafeInteger2.default) {
+ return toKeyAlias.uid = 0;
+ } else {
+ return toKeyAlias.uid++;
+ }
+};
+
+function toIdentifier(name) {
+ name = name + "";
+
+ name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
+
+ name = name.replace(/^[-0-9]+/, "");
+
+ name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+ return c ? c.toUpperCase() : "";
+ });
+
+ if (!t.isValidIdentifier(name)) {
+ name = "_" + name;
+ }
+
+ return name || "_";
+}
+
+function toBindingIdentifierName(name) {
+ name = toIdentifier(name);
+ if (name === "eval" || name === "arguments") name = "_" + name;
+ return name;
+}
+
+function toStatement(node, ignore) {
+ if (t.isStatement(node)) {
+ return node;
+ }
+
+ var mustHaveId = false;
+ var newType = void 0;
+
+ if (t.isClass(node)) {
+ mustHaveId = true;
+ newType = "ClassDeclaration";
+ } else if (t.isFunction(node)) {
+ mustHaveId = true;
+ newType = "FunctionDeclaration";
+ } else if (t.isAssignmentExpression(node)) {
+ return t.expressionStatement(node);
+ }
+
+ if (mustHaveId && !node.id) {
+ newType = false;
+ }
+
+ if (!newType) {
+ if (ignore) {
+ return false;
+ } else {
+ throw new Error("cannot turn " + node.type + " to a statement");
+ }
+ }
+
+ node.type = newType;
+
+ return node;
+}
+
+function toExpression(node) {
+ if (t.isExpressionStatement(node)) {
+ node = node.expression;
+ }
+
+ if (t.isExpression(node)) {
+ return node;
+ }
+
+ if (t.isClass(node)) {
+ node.type = "ClassExpression";
+ } else if (t.isFunction(node)) {
+ node.type = "FunctionExpression";
+ }
+
+ if (!t.isExpression(node)) {
+ throw new Error("cannot turn " + node.type + " to an expression");
+ }
+
+ return node;
+}
+
+function toBlock(node, parent) {
+ if (t.isBlockStatement(node)) {
+ return node;
+ }
+
+ if (t.isEmptyStatement(node)) {
+ node = [];
+ }
+
+ if (!Array.isArray(node)) {
+ if (!t.isStatement(node)) {
+ if (t.isFunction(parent)) {
+ node = t.returnStatement(node);
+ } else {
+ node = t.expressionStatement(node);
+ }
+ }
+
+ node = [node];
+ }
+
+ return t.blockStatement(node);
+}
+
+function valueToNode(value) {
+ if (value === undefined) {
+ return t.identifier("undefined");
+ }
+
+ if (value === true || value === false) {
+ return t.booleanLiteral(value);
+ }
+
+ if (value === null) {
+ return t.nullLiteral();
+ }
+
+ if (typeof value === "string") {
+ return t.stringLiteral(value);
+ }
+
+ if (typeof value === "number") {
+ return t.numericLiteral(value);
+ }
+
+ if ((0, _isRegExp2.default)(value)) {
+ var pattern = value.source;
+ var flags = value.toString().match(/\/([a-z]+|)$/)[1];
+ return t.regExpLiteral(pattern, flags);
+ }
+
+ if (Array.isArray(value)) {
+ return t.arrayExpression(value.map(t.valueToNode));
+ }
+
+ if ((0, _isPlainObject2.default)(value)) {
+ var props = [];
+ for (var key in value) {
+ var nodeKey = void 0;
+ if (t.isValidIdentifier(key)) {
+ nodeKey = t.identifier(key);
+ } else {
+ nodeKey = t.stringLiteral(key);
+ }
+ props.push(t.objectProperty(nodeKey, t.valueToNode(value[key])));
+ }
+ return t.objectExpression(props);
+ }
+
+ throw new Error("don't know how to turn this value into a node");
+}
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/core.js b/node_modules/babel-types/lib/definitions/core.js
new file mode 100644
index 00000000..3b03262f
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/core.js
@@ -0,0 +1,701 @@
+"use strict";
+
+var _index = require("../index");
+
+var t = _interopRequireWildcard(_index);
+
+var _constants = require("../constants");
+
+var _index2 = require("./index");
+
+var _index3 = _interopRequireDefault(_index2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+(0, _index3.default)("ArrayExpression", {
+ fields: {
+ elements: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
+ default: []
+ }
+ },
+ visitor: ["elements"],
+ aliases: ["Expression"]
+});
+
+(0, _index3.default)("AssignmentExpression", {
+ fields: {
+ operator: {
+ validate: (0, _index2.assertValueType)("string")
+ },
+ left: {
+ validate: (0, _index2.assertNodeType)("LVal")
+ },
+ right: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ },
+ builder: ["operator", "left", "right"],
+ visitor: ["left", "right"],
+ aliases: ["Expression"]
+});
+
+(0, _index3.default)("BinaryExpression", {
+ builder: ["operator", "left", "right"],
+ fields: {
+ operator: {
+ validate: _index2.assertOneOf.apply(undefined, _constants.BINARY_OPERATORS)
+ },
+ left: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ right: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ },
+ visitor: ["left", "right"],
+ aliases: ["Binary", "Expression"]
+});
+
+(0, _index3.default)("Directive", {
+ visitor: ["value"],
+ fields: {
+ value: {
+ validate: (0, _index2.assertNodeType)("DirectiveLiteral")
+ }
+ }
+});
+
+(0, _index3.default)("DirectiveLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _index2.assertValueType)("string")
+ }
+ }
+});
+
+(0, _index3.default)("BlockStatement", {
+ builder: ["body", "directives"],
+ visitor: ["directives", "body"],
+ fields: {
+ directives: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Directive"))),
+ default: []
+ },
+ body: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Statement")))
+ }
+ },
+ aliases: ["Scopable", "BlockParent", "Block", "Statement"]
+});
+
+(0, _index3.default)("BreakStatement", {
+ visitor: ["label"],
+ fields: {
+ label: {
+ validate: (0, _index2.assertNodeType)("Identifier"),
+ optional: true
+ }
+ },
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"]
+});
+
+(0, _index3.default)("CallExpression", {
+ visitor: ["callee", "arguments"],
+ fields: {
+ callee: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ arguments: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Expression", "SpreadElement")))
+ }
+ },
+ aliases: ["Expression"]
+});
+
+(0, _index3.default)("CatchClause", {
+ visitor: ["param", "body"],
+ fields: {
+ param: {
+ validate: (0, _index2.assertNodeType)("Identifier")
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement")
+ }
+ },
+ aliases: ["Scopable"]
+});
+
+(0, _index3.default)("ConditionalExpression", {
+ visitor: ["test", "consequent", "alternate"],
+ fields: {
+ test: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ consequent: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ alternate: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ },
+ aliases: ["Expression", "Conditional"]
+});
+
+(0, _index3.default)("ContinueStatement", {
+ visitor: ["label"],
+ fields: {
+ label: {
+ validate: (0, _index2.assertNodeType)("Identifier"),
+ optional: true
+ }
+ },
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"]
+});
+
+(0, _index3.default)("DebuggerStatement", {
+ aliases: ["Statement"]
+});
+
+(0, _index3.default)("DoWhileStatement", {
+ visitor: ["test", "body"],
+ fields: {
+ test: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("Statement")
+ }
+ },
+ aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
+});
+
+(0, _index3.default)("EmptyStatement", {
+ aliases: ["Statement"]
+});
+
+(0, _index3.default)("ExpressionStatement", {
+ visitor: ["expression"],
+ fields: {
+ expression: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ },
+ aliases: ["Statement", "ExpressionWrapper"]
+});
+
+(0, _index3.default)("File", {
+ builder: ["program", "comments", "tokens"],
+ visitor: ["program"],
+ fields: {
+ program: {
+ validate: (0, _index2.assertNodeType)("Program")
+ }
+ }
+});
+
+(0, _index3.default)("ForInStatement", {
+ visitor: ["left", "right", "body"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+ fields: {
+ left: {
+ validate: (0, _index2.assertNodeType)("VariableDeclaration", "LVal")
+ },
+ right: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("Statement")
+ }
+ }
+});
+
+(0, _index3.default)("ForStatement", {
+ visitor: ["init", "test", "update", "body"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
+ fields: {
+ init: {
+ validate: (0, _index2.assertNodeType)("VariableDeclaration", "Expression"),
+ optional: true
+ },
+ test: {
+ validate: (0, _index2.assertNodeType)("Expression"),
+ optional: true
+ },
+ update: {
+ validate: (0, _index2.assertNodeType)("Expression"),
+ optional: true
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("Statement")
+ }
+ }
+});
+
+(0, _index3.default)("FunctionDeclaration", {
+ builder: ["id", "params", "body", "generator", "async"],
+ visitor: ["id", "params", "body", "returnType", "typeParameters"],
+ fields: {
+ id: {
+ validate: (0, _index2.assertNodeType)("Identifier")
+ },
+ params: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("LVal")))
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement")
+ },
+ generator: {
+ default: false,
+ validate: (0, _index2.assertValueType)("boolean")
+ },
+ async: {
+ default: false,
+ validate: (0, _index2.assertValueType)("boolean")
+ }
+ },
+ aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"]
+});
+
+(0, _index3.default)("FunctionExpression", {
+ inherits: "FunctionDeclaration",
+ aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
+ fields: {
+ id: {
+ validate: (0, _index2.assertNodeType)("Identifier"),
+ optional: true
+ },
+ params: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("LVal")))
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement")
+ },
+ generator: {
+ default: false,
+ validate: (0, _index2.assertValueType)("boolean")
+ },
+ async: {
+ default: false,
+ validate: (0, _index2.assertValueType)("boolean")
+ }
+ }
+});
+
+(0, _index3.default)("Identifier", {
+ builder: ["name"],
+ visitor: ["typeAnnotation"],
+ aliases: ["Expression", "LVal"],
+ fields: {
+ name: {
+ validate: function validate(node, key, val) {
+ if (!t.isValidIdentifier(val)) {}
+ }
+ },
+ decorators: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index3.default)("IfStatement", {
+ visitor: ["test", "consequent", "alternate"],
+ aliases: ["Statement", "Conditional"],
+ fields: {
+ test: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ consequent: {
+ validate: (0, _index2.assertNodeType)("Statement")
+ },
+ alternate: {
+ optional: true,
+ validate: (0, _index2.assertNodeType)("Statement")
+ }
+ }
+});
+
+(0, _index3.default)("LabeledStatement", {
+ visitor: ["label", "body"],
+ aliases: ["Statement"],
+ fields: {
+ label: {
+ validate: (0, _index2.assertNodeType)("Identifier")
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("Statement")
+ }
+ }
+});
+
+(0, _index3.default)("StringLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _index2.assertValueType)("string")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+
+(0, _index3.default)("NumericLiteral", {
+ builder: ["value"],
+ deprecatedAlias: "NumberLiteral",
+ fields: {
+ value: {
+ validate: (0, _index2.assertValueType)("number")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+
+(0, _index3.default)("NullLiteral", {
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+
+(0, _index3.default)("BooleanLiteral", {
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _index2.assertValueType)("boolean")
+ }
+ },
+ aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+
+(0, _index3.default)("RegExpLiteral", {
+ builder: ["pattern", "flags"],
+ deprecatedAlias: "RegexLiteral",
+ aliases: ["Expression", "Literal"],
+ fields: {
+ pattern: {
+ validate: (0, _index2.assertValueType)("string")
+ },
+ flags: {
+ validate: (0, _index2.assertValueType)("string"),
+ default: ""
+ }
+ }
+});
+
+(0, _index3.default)("LogicalExpression", {
+ builder: ["operator", "left", "right"],
+ visitor: ["left", "right"],
+ aliases: ["Binary", "Expression"],
+ fields: {
+ operator: {
+ validate: _index2.assertOneOf.apply(undefined, _constants.LOGICAL_OPERATORS)
+ },
+ left: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ right: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index3.default)("MemberExpression", {
+ builder: ["object", "property", "computed"],
+ visitor: ["object", "property"],
+ aliases: ["Expression", "LVal"],
+ fields: {
+ object: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ property: {
+ validate: function validate(node, key, val) {
+ var expectedType = node.computed ? "Expression" : "Identifier";
+ (0, _index2.assertNodeType)(expectedType)(node, key, val);
+ }
+ },
+ computed: {
+ default: false
+ }
+ }
+});
+
+(0, _index3.default)("NewExpression", {
+ visitor: ["callee", "arguments"],
+ aliases: ["Expression"],
+ fields: {
+ callee: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ arguments: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Expression", "SpreadElement")))
+ }
+ }
+});
+
+(0, _index3.default)("Program", {
+ visitor: ["directives", "body"],
+ builder: ["body", "directives"],
+ fields: {
+ directives: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Directive"))),
+ default: []
+ },
+ body: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Statement")))
+ }
+ },
+ aliases: ["Scopable", "BlockParent", "Block", "FunctionParent"]
+});
+
+(0, _index3.default)("ObjectExpression", {
+ visitor: ["properties"],
+ aliases: ["Expression"],
+ fields: {
+ properties: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadProperty")))
+ }
+ }
+});
+
+(0, _index3.default)("ObjectMethod", {
+ builder: ["kind", "key", "params", "body", "computed"],
+ fields: {
+ kind: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("string"), (0, _index2.assertOneOf)("method", "get", "set")),
+ default: "method"
+ },
+ computed: {
+ validate: (0, _index2.assertValueType)("boolean"),
+ default: false
+ },
+ key: {
+ validate: function validate(node, key, val) {
+ var expectedTypes = node.computed ? ["Expression"] : ["Identifier", "StringLiteral", "NumericLiteral"];
+ _index2.assertNodeType.apply(undefined, expectedTypes)(node, key, val);
+ }
+ },
+ decorators: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator")))
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement")
+ },
+ generator: {
+ default: false,
+ validate: (0, _index2.assertValueType)("boolean")
+ },
+ async: {
+ default: false,
+ validate: (0, _index2.assertValueType)("boolean")
+ }
+ },
+ visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+ aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
+});
+
+(0, _index3.default)("ObjectProperty", {
+ builder: ["key", "value", "computed", "shorthand", "decorators"],
+ fields: {
+ computed: {
+ validate: (0, _index2.assertValueType)("boolean"),
+ default: false
+ },
+ key: {
+ validate: function validate(node, key, val) {
+ var expectedTypes = node.computed ? ["Expression"] : ["Identifier", "StringLiteral", "NumericLiteral"];
+ _index2.assertNodeType.apply(undefined, expectedTypes)(node, key, val);
+ }
+ },
+ value: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ shorthand: {
+ validate: (0, _index2.assertValueType)("boolean"),
+ default: false
+ },
+ decorators: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator"))),
+ optional: true
+ }
+ },
+ visitor: ["key", "value", "decorators"],
+ aliases: ["UserWhitespacable", "Property", "ObjectMember"]
+});
+
+(0, _index3.default)("RestElement", {
+ visitor: ["argument", "typeAnnotation"],
+ aliases: ["LVal"],
+ fields: {
+ argument: {
+ validate: (0, _index2.assertNodeType)("LVal")
+ },
+ decorators: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index3.default)("ReturnStatement", {
+ visitor: ["argument"],
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"],
+ fields: {
+ argument: {
+ validate: (0, _index2.assertNodeType)("Expression"),
+ optional: true
+ }
+ }
+});
+
+(0, _index3.default)("SequenceExpression", {
+ visitor: ["expressions"],
+ fields: {
+ expressions: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Expression")))
+ }
+ },
+ aliases: ["Expression"]
+});
+
+(0, _index3.default)("SwitchCase", {
+ visitor: ["test", "consequent"],
+ fields: {
+ test: {
+ validate: (0, _index2.assertNodeType)("Expression"),
+ optional: true
+ },
+ consequent: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("Statement")))
+ }
+ }
+});
+
+(0, _index3.default)("SwitchStatement", {
+ visitor: ["discriminant", "cases"],
+ aliases: ["Statement", "BlockParent", "Scopable"],
+ fields: {
+ discriminant: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ cases: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("SwitchCase")))
+ }
+ }
+});
+
+(0, _index3.default)("ThisExpression", {
+ aliases: ["Expression"]
+});
+
+(0, _index3.default)("ThrowStatement", {
+ visitor: ["argument"],
+ aliases: ["Statement", "Terminatorless", "CompletionStatement"],
+ fields: {
+ argument: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index3.default)("TryStatement", {
+ visitor: ["block", "handler", "finalizer"],
+ aliases: ["Statement"],
+ fields: {
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement")
+ },
+ handler: {
+ optional: true,
+ handler: (0, _index2.assertNodeType)("BlockStatement")
+ },
+ finalizer: {
+ optional: true,
+ validate: (0, _index2.assertNodeType)("BlockStatement")
+ }
+ }
+});
+
+(0, _index3.default)("UnaryExpression", {
+ builder: ["operator", "argument", "prefix"],
+ fields: {
+ prefix: {
+ default: true
+ },
+ argument: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ operator: {
+ validate: _index2.assertOneOf.apply(undefined, _constants.UNARY_OPERATORS)
+ }
+ },
+ visitor: ["argument"],
+ aliases: ["UnaryLike", "Expression"]
+});
+
+(0, _index3.default)("UpdateExpression", {
+ builder: ["operator", "argument", "prefix"],
+ fields: {
+ prefix: {
+ default: false
+ },
+ argument: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ operator: {
+ validate: _index2.assertOneOf.apply(undefined, _constants.UPDATE_OPERATORS)
+ }
+ },
+ visitor: ["argument"],
+ aliases: ["Expression"]
+});
+
+(0, _index3.default)("VariableDeclaration", {
+ builder: ["kind", "declarations"],
+ visitor: ["declarations"],
+ aliases: ["Statement", "Declaration"],
+ fields: {
+ kind: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("string"), (0, _index2.assertOneOf)("var", "let", "const"))
+ },
+ declarations: {
+ validate: (0, _index2.chain)((0, _index2.assertValueType)("array"), (0, _index2.assertEach)((0, _index2.assertNodeType)("VariableDeclarator")))
+ }
+ }
+});
+
+(0, _index3.default)("VariableDeclarator", {
+ visitor: ["id", "init"],
+ fields: {
+ id: {
+ validate: (0, _index2.assertNodeType)("LVal")
+ },
+ init: {
+ optional: true,
+ validate: (0, _index2.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index3.default)("WhileStatement", {
+ visitor: ["test", "body"],
+ aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
+ fields: {
+ test: {
+ validate: (0, _index2.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement", "Statement")
+ }
+ }
+});
+
+(0, _index3.default)("WithStatement", {
+ visitor: ["object", "body"],
+ aliases: ["Statement"],
+ fields: {
+ object: {
+ object: (0, _index2.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _index2.assertNodeType)("BlockStatement", "Statement")
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/es2015.js b/node_modules/babel-types/lib/definitions/es2015.js
new file mode 100644
index 00000000..a823aa22
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/es2015.js
@@ -0,0 +1,354 @@
+"use strict";
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _index2.default)("AssignmentPattern", {
+ visitor: ["left", "right"],
+ aliases: ["Pattern", "LVal"],
+ fields: {
+ left: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ },
+ right: {
+ validate: (0, _index.assertNodeType)("Expression")
+ },
+ decorators: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index2.default)("ArrayPattern", {
+ visitor: ["elements", "typeAnnotation"],
+ aliases: ["Pattern", "LVal"],
+ fields: {
+ elements: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Expression")))
+ },
+ decorators: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index2.default)("ArrowFunctionExpression", {
+ builder: ["params", "body", "async"],
+ visitor: ["params", "body", "returnType", "typeParameters"],
+ aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
+ fields: {
+ params: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("LVal")))
+ },
+ body: {
+ validate: (0, _index.assertNodeType)("BlockStatement", "Expression")
+ },
+ async: {
+ validate: (0, _index.assertValueType)("boolean"),
+ default: false
+ }
+ }
+});
+
+(0, _index2.default)("ClassBody", {
+ visitor: ["body"],
+ fields: {
+ body: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("ClassMethod", "ClassProperty")))
+ }
+ }
+});
+
+(0, _index2.default)("ClassDeclaration", {
+ builder: ["id", "superClass", "body", "decorators"],
+ visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
+ aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"],
+ fields: {
+ id: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ },
+ body: {
+ validate: (0, _index.assertNodeType)("ClassBody")
+ },
+ superClass: {
+ optional: true,
+ validate: (0, _index.assertNodeType)("Expression")
+ },
+ decorators: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index2.default)("ClassExpression", {
+ inherits: "ClassDeclaration",
+ aliases: ["Scopable", "Class", "Expression", "Pureish"],
+ fields: {
+ id: {
+ optional: true,
+ validate: (0, _index.assertNodeType)("Identifier")
+ },
+ body: {
+ validate: (0, _index.assertNodeType)("ClassBody")
+ },
+ superClass: {
+ optional: true,
+ validate: (0, _index.assertNodeType)("Expression")
+ },
+ decorators: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index2.default)("ExportAllDeclaration", {
+ visitor: ["source"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+ fields: {
+ source: {
+ validate: (0, _index.assertNodeType)("StringLiteral")
+ }
+ }
+});
+
+(0, _index2.default)("ExportDefaultDeclaration", {
+ visitor: ["declaration"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+ fields: {
+ declaration: {
+ validate: (0, _index.assertNodeType)("FunctionDeclaration", "ClassDeclaration", "Expression")
+ }
+ }
+});
+
+(0, _index2.default)("ExportNamedDeclaration", {
+ visitor: ["declaration", "specifiers", "source"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
+ fields: {
+ declaration: {
+ validate: (0, _index.assertNodeType)("Declaration"),
+ optional: true
+ },
+ specifiers: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("ExportSpecifier")))
+ },
+ source: {
+ validate: (0, _index.assertNodeType)("StringLiteral"),
+ optional: true
+ }
+ }
+});
+
+(0, _index2.default)("ExportSpecifier", {
+ visitor: ["local", "exported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ },
+ exported: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ }
+ }
+});
+
+(0, _index2.default)("ForOfStatement", {
+ visitor: ["left", "right", "body"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+ fields: {
+ left: {
+ validate: (0, _index.assertNodeType)("VariableDeclaration", "LVal")
+ },
+ right: {
+ validate: (0, _index.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _index.assertNodeType)("Statement")
+ }
+ }
+});
+
+(0, _index2.default)("ImportDeclaration", {
+ visitor: ["specifiers", "source"],
+ aliases: ["Statement", "Declaration", "ModuleDeclaration"],
+ fields: {
+ specifiers: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
+ },
+ source: {
+ validate: (0, _index.assertNodeType)("StringLiteral")
+ }
+ }
+});
+
+(0, _index2.default)("ImportDefaultSpecifier", {
+ visitor: ["local"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ }
+ }
+});
+
+(0, _index2.default)("ImportNamespaceSpecifier", {
+ visitor: ["local"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ }
+ }
+});
+
+(0, _index2.default)("ImportSpecifier", {
+ visitor: ["local", "imported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ local: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ },
+ imported: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ },
+ importKind: {
+ validate: (0, _index.assertOneOf)(null, "type", "typeof")
+ }
+ }
+});
+
+(0, _index2.default)("MetaProperty", {
+ visitor: ["meta", "property"],
+ aliases: ["Expression"],
+ fields: {
+ meta: {
+ validate: (0, _index.assertValueType)("string")
+ },
+ property: {
+ validate: (0, _index.assertValueType)("string")
+ }
+ }
+});
+
+(0, _index2.default)("ClassMethod", {
+ aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
+ builder: ["kind", "key", "params", "body", "computed", "static"],
+ visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
+ fields: {
+ kind: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("string"), (0, _index.assertOneOf)("get", "set", "method", "constructor")),
+ default: "method"
+ },
+ computed: {
+ default: false,
+ validate: (0, _index.assertValueType)("boolean")
+ },
+ static: {
+ default: false,
+ validate: (0, _index.assertValueType)("boolean")
+ },
+ key: {
+ validate: function validate(node, key, val) {
+ var expectedTypes = node.computed ? ["Expression"] : ["Identifier", "StringLiteral", "NumericLiteral"];
+ _index.assertNodeType.apply(undefined, expectedTypes)(node, key, val);
+ }
+ },
+ params: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("LVal")))
+ },
+ body: {
+ validate: (0, _index.assertNodeType)("BlockStatement")
+ },
+ generator: {
+ default: false,
+ validate: (0, _index.assertValueType)("boolean")
+ },
+ async: {
+ default: false,
+ validate: (0, _index.assertValueType)("boolean")
+ }
+ }
+});
+
+(0, _index2.default)("ObjectPattern", {
+ visitor: ["properties", "typeAnnotation"],
+ aliases: ["Pattern", "LVal"],
+ fields: {
+ properties: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("RestProperty", "Property")))
+ },
+ decorators: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Decorator")))
+ }
+ }
+});
+
+(0, _index2.default)("SpreadElement", {
+ visitor: ["argument"],
+ aliases: ["UnaryLike"],
+ fields: {
+ argument: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index2.default)("Super", {
+ aliases: ["Expression"]
+});
+
+(0, _index2.default)("TaggedTemplateExpression", {
+ visitor: ["tag", "quasi"],
+ aliases: ["Expression"],
+ fields: {
+ tag: {
+ validate: (0, _index.assertNodeType)("Expression")
+ },
+ quasi: {
+ validate: (0, _index.assertNodeType)("TemplateLiteral")
+ }
+ }
+});
+
+(0, _index2.default)("TemplateElement", {
+ builder: ["value", "tail"],
+ fields: {
+ value: {},
+ tail: {
+ validate: (0, _index.assertValueType)("boolean"),
+ default: false
+ }
+ }
+});
+
+(0, _index2.default)("TemplateLiteral", {
+ visitor: ["quasis", "expressions"],
+ aliases: ["Expression", "Literal"],
+ fields: {
+ quasis: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("TemplateElement")))
+ },
+ expressions: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("Expression")))
+ }
+ }
+});
+
+(0, _index2.default)("YieldExpression", {
+ builder: ["argument", "delegate"],
+ visitor: ["argument"],
+ aliases: ["Expression", "Terminatorless"],
+ fields: {
+ delegate: {
+ validate: (0, _index.assertValueType)("boolean"),
+ default: false
+ },
+ argument: {
+ optional: true,
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/experimental.js b/node_modules/babel-types/lib/definitions/experimental.js
new file mode 100644
index 00000000..d65d6096
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/experimental.js
@@ -0,0 +1,103 @@
+"use strict";
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _index2.default)("AwaitExpression", {
+ builder: ["argument"],
+ visitor: ["argument"],
+ aliases: ["Expression", "Terminatorless"],
+ fields: {
+ argument: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index2.default)("ForAwaitStatement", {
+ visitor: ["left", "right", "body"],
+ aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
+ fields: {
+ left: {
+ validate: (0, _index.assertNodeType)("VariableDeclaration", "LVal")
+ },
+ right: {
+ validate: (0, _index.assertNodeType)("Expression")
+ },
+ body: {
+ validate: (0, _index.assertNodeType)("Statement")
+ }
+ }
+});
+
+(0, _index2.default)("BindExpression", {
+ visitor: ["object", "callee"],
+ aliases: ["Expression"],
+ fields: {}
+});
+
+(0, _index2.default)("Import", {
+ aliases: ["Expression"]
+});
+
+(0, _index2.default)("Decorator", {
+ visitor: ["expression"],
+ fields: {
+ expression: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index2.default)("DoExpression", {
+ visitor: ["body"],
+ aliases: ["Expression"],
+ fields: {
+ body: {
+ validate: (0, _index.assertNodeType)("BlockStatement")
+ }
+ }
+});
+
+(0, _index2.default)("ExportDefaultSpecifier", {
+ visitor: ["exported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ exported: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ }
+ }
+});
+
+(0, _index2.default)("ExportNamespaceSpecifier", {
+ visitor: ["exported"],
+ aliases: ["ModuleSpecifier"],
+ fields: {
+ exported: {
+ validate: (0, _index.assertNodeType)("Identifier")
+ }
+ }
+});
+
+(0, _index2.default)("RestProperty", {
+ visitor: ["argument"],
+ aliases: ["UnaryLike"],
+ fields: {
+ argument: {
+ validate: (0, _index.assertNodeType)("LVal")
+ }
+ }
+});
+
+(0, _index2.default)("SpreadProperty", {
+ visitor: ["argument"],
+ aliases: ["UnaryLike"],
+ fields: {
+ argument: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/flow.js b/node_modules/babel-types/lib/definitions/flow.js
new file mode 100644
index 00000000..dca21ec1
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/flow.js
@@ -0,0 +1,261 @@
+"use strict";
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _index2.default)("AnyTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
+
+(0, _index2.default)("ArrayTypeAnnotation", {
+ visitor: ["elementType"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("BooleanTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
+
+(0, _index2.default)("BooleanLiteralTypeAnnotation", {
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("NullLiteralTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
+
+(0, _index2.default)("ClassImplements", {
+ visitor: ["id", "typeParameters"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("ClassProperty", {
+ visitor: ["key", "value", "typeAnnotation", "decorators"],
+ builder: ["key", "value", "typeAnnotation", "decorators", "computed"],
+ aliases: ["Property"],
+ fields: {
+ computed: {
+ validate: (0, _index.assertValueType)("boolean"),
+ default: false
+ }
+ }
+});
+
+(0, _index2.default)("DeclareClass", {
+ visitor: ["id", "typeParameters", "extends", "body"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("DeclareFunction", {
+ visitor: ["id"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("DeclareInterface", {
+ visitor: ["id", "typeParameters", "extends", "body"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("DeclareModule", {
+ visitor: ["id", "body"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("DeclareModuleExports", {
+ visitor: ["typeAnnotation"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("DeclareTypeAlias", {
+ visitor: ["id", "typeParameters", "right"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("DeclareVariable", {
+ visitor: ["id"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("ExistentialTypeParam", {
+ aliases: ["Flow"]
+});
+
+(0, _index2.default)("FunctionTypeAnnotation", {
+ visitor: ["typeParameters", "params", "rest", "returnType"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("FunctionTypeParam", {
+ visitor: ["name", "typeAnnotation"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("GenericTypeAnnotation", {
+ visitor: ["id", "typeParameters"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("InterfaceExtends", {
+ visitor: ["id", "typeParameters"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("InterfaceDeclaration", {
+ visitor: ["id", "typeParameters", "extends", "body"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("IntersectionTypeAnnotation", {
+ visitor: ["types"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("MixedTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"]
+});
+
+(0, _index2.default)("EmptyTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"]
+});
+
+(0, _index2.default)("NullableTypeAnnotation", {
+ visitor: ["typeAnnotation"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("NumericLiteralTypeAnnotation", {
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("NumberTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
+
+(0, _index2.default)("StringLiteralTypeAnnotation", {
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("StringTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
+
+(0, _index2.default)("ThisTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
+
+(0, _index2.default)("TupleTypeAnnotation", {
+ visitor: ["types"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeofTypeAnnotation", {
+ visitor: ["argument"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeAlias", {
+ visitor: ["id", "typeParameters", "right"],
+ aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeAnnotation", {
+ visitor: ["typeAnnotation"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeCastExpression", {
+ visitor: ["expression", "typeAnnotation"],
+ aliases: ["Flow", "ExpressionWrapper", "Expression"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeParameter", {
+ visitor: ["bound"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeParameterDeclaration", {
+ visitor: ["params"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("TypeParameterInstantiation", {
+ visitor: ["params"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("ObjectTypeAnnotation", {
+ visitor: ["properties", "indexers", "callProperties"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("ObjectTypeCallProperty", {
+ visitor: ["value"],
+ aliases: ["Flow", "UserWhitespacable"],
+ fields: {}
+});
+
+(0, _index2.default)("ObjectTypeIndexer", {
+ visitor: ["id", "key", "value"],
+ aliases: ["Flow", "UserWhitespacable"],
+ fields: {}
+});
+
+(0, _index2.default)("ObjectTypeProperty", {
+ visitor: ["key", "value"],
+ aliases: ["Flow", "UserWhitespacable"],
+ fields: {}
+});
+
+(0, _index2.default)("QualifiedTypeIdentifier", {
+ visitor: ["id", "qualification"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("UnionTypeAnnotation", {
+ visitor: ["types"],
+ aliases: ["Flow"],
+ fields: {}
+});
+
+(0, _index2.default)("VoidTypeAnnotation", {
+ aliases: ["Flow", "FlowBaseAnnotation"],
+ fields: {}
+});
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/index.js b/node_modules/babel-types/lib/definitions/index.js
new file mode 100644
index 00000000..d5121144
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/index.js
@@ -0,0 +1,249 @@
+"use strict";
+
+exports.__esModule = true;
+exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = undefined;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _stringify = require("babel-runtime/core-js/json/stringify");
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _typeof2 = require("babel-runtime/helpers/typeof");
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+exports.assertEach = assertEach;
+exports.assertOneOf = assertOneOf;
+exports.assertNodeType = assertNodeType;
+exports.assertNodeOrValueType = assertNodeOrValueType;
+exports.assertValueType = assertValueType;
+exports.chain = chain;
+exports.default = defineType;
+
+var _index = require("../index");
+
+var t = _interopRequireWildcard(_index);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var VISITOR_KEYS = exports.VISITOR_KEYS = {};
+var ALIAS_KEYS = exports.ALIAS_KEYS = {};
+var NODE_FIELDS = exports.NODE_FIELDS = {};
+var BUILDER_KEYS = exports.BUILDER_KEYS = {};
+var DEPRECATED_KEYS = exports.DEPRECATED_KEYS = {};
+
+function getType(val) {
+ if (Array.isArray(val)) {
+ return "array";
+ } else if (val === null) {
+ return "null";
+ } else if (val === undefined) {
+ return "undefined";
+ } else {
+ return typeof val === "undefined" ? "undefined" : (0, _typeof3.default)(val);
+ }
+}
+
+function assertEach(callback) {
+ function validator(node, key, val) {
+ if (!Array.isArray(val)) return;
+
+ for (var i = 0; i < val.length; i++) {
+ callback(node, key + "[" + i + "]", val[i]);
+ }
+ }
+ validator.each = callback;
+ return validator;
+}
+
+function assertOneOf() {
+ for (var _len = arguments.length, vals = Array(_len), _key = 0; _key < _len; _key++) {
+ vals[_key] = arguments[_key];
+ }
+
+ function validate(node, key, val) {
+ if (vals.indexOf(val) < 0) {
+ throw new TypeError("Property " + key + " expected value to be one of " + (0, _stringify2.default)(vals) + " but got " + (0, _stringify2.default)(val));
+ }
+ }
+
+ validate.oneOf = vals;
+
+ return validate;
+}
+
+function assertNodeType() {
+ for (var _len2 = arguments.length, types = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ types[_key2] = arguments[_key2];
+ }
+
+ function validate(node, key, val) {
+ var valid = false;
+
+ for (var _iterator = types, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var type = _ref;
+
+ if (t.is(type, val)) {
+ valid = true;
+ break;
+ }
+ }
+
+ if (!valid) {
+ throw new TypeError("Property " + key + " of " + node.type + " expected node to be of a type " + (0, _stringify2.default)(types) + " " + ("but instead got " + (0, _stringify2.default)(val && val.type)));
+ }
+ }
+
+ validate.oneOfNodeTypes = types;
+
+ return validate;
+}
+
+function assertNodeOrValueType() {
+ for (var _len3 = arguments.length, types = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+ types[_key3] = arguments[_key3];
+ }
+
+ function validate(node, key, val) {
+ var valid = false;
+
+ for (var _iterator2 = types, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var type = _ref2;
+
+ if (getType(val) === type || t.is(type, val)) {
+ valid = true;
+ break;
+ }
+ }
+
+ if (!valid) {
+ throw new TypeError("Property " + key + " of " + node.type + " expected node to be of a type " + (0, _stringify2.default)(types) + " " + ("but instead got " + (0, _stringify2.default)(val && val.type)));
+ }
+ }
+
+ validate.oneOfNodeOrValueTypes = types;
+
+ return validate;
+}
+
+function assertValueType(type) {
+ function validate(node, key, val) {
+ var valid = getType(val) === type;
+
+ if (!valid) {
+ throw new TypeError("Property " + key + " expected type of " + type + " but got " + getType(val));
+ }
+ }
+
+ validate.type = type;
+
+ return validate;
+}
+
+function chain() {
+ for (var _len4 = arguments.length, fns = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ fns[_key4] = arguments[_key4];
+ }
+
+ function validate() {
+ for (var _iterator3 = fns, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
+ var _ref3;
+
+ if (_isArray3) {
+ if (_i3 >= _iterator3.length) break;
+ _ref3 = _iterator3[_i3++];
+ } else {
+ _i3 = _iterator3.next();
+ if (_i3.done) break;
+ _ref3 = _i3.value;
+ }
+
+ var fn = _ref3;
+
+ fn.apply(undefined, arguments);
+ }
+ }
+ validate.chainOf = fns;
+ return validate;
+}
+
+function defineType(type) {
+ var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+ var inherits = opts.inherits && store[opts.inherits] || {};
+
+ opts.fields = opts.fields || inherits.fields || {};
+ opts.visitor = opts.visitor || inherits.visitor || [];
+ opts.aliases = opts.aliases || inherits.aliases || [];
+ opts.builder = opts.builder || inherits.builder || opts.visitor || [];
+
+ if (opts.deprecatedAlias) {
+ DEPRECATED_KEYS[opts.deprecatedAlias] = type;
+ }
+
+ for (var _iterator4 = opts.visitor.concat(opts.builder), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) {
+ var _ref4;
+
+ if (_isArray4) {
+ if (_i4 >= _iterator4.length) break;
+ _ref4 = _iterator4[_i4++];
+ } else {
+ _i4 = _iterator4.next();
+ if (_i4.done) break;
+ _ref4 = _i4.value;
+ }
+
+ var _key5 = _ref4;
+
+ opts.fields[_key5] = opts.fields[_key5] || {};
+ }
+
+ for (var key in opts.fields) {
+ var field = opts.fields[key];
+
+ if (opts.builder.indexOf(key) === -1) {
+ field.optional = true;
+ }
+ if (field.default === undefined) {
+ field.default = null;
+ } else if (!field.validate) {
+ field.validate = assertValueType(getType(field.default));
+ }
+ }
+
+ VISITOR_KEYS[type] = opts.visitor;
+ BUILDER_KEYS[type] = opts.builder;
+ NODE_FIELDS[type] = opts.fields;
+ ALIAS_KEYS[type] = opts.aliases;
+
+ store[type] = opts;
+}
+
+var store = {};
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/init.js b/node_modules/babel-types/lib/definitions/init.js
new file mode 100644
index 00000000..a3334fed
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/init.js
@@ -0,0 +1,15 @@
+"use strict";
+
+require("./index");
+
+require("./core");
+
+require("./es2015");
+
+require("./flow");
+
+require("./jsx");
+
+require("./misc");
+
+require("./experimental");
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/jsx.js b/node_modules/babel-types/lib/definitions/jsx.js
new file mode 100644
index 00000000..1c0c0665
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/jsx.js
@@ -0,0 +1,147 @@
+"use strict";
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _index2.default)("JSXAttribute", {
+ visitor: ["name", "value"],
+ aliases: ["JSX", "Immutable"],
+ fields: {
+ name: {
+ validate: (0, _index.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
+ },
+ value: {
+ optional: true,
+ validate: (0, _index.assertNodeType)("JSXElement", "StringLiteral", "JSXExpressionContainer")
+ }
+ }
+});
+
+(0, _index2.default)("JSXClosingElement", {
+ visitor: ["name"],
+ aliases: ["JSX", "Immutable"],
+ fields: {
+ name: {
+ validate: (0, _index.assertNodeType)("JSXIdentifier", "JSXMemberExpression")
+ }
+ }
+});
+
+(0, _index2.default)("JSXElement", {
+ builder: ["openingElement", "closingElement", "children", "selfClosing"],
+ visitor: ["openingElement", "children", "closingElement"],
+ aliases: ["JSX", "Immutable", "Expression"],
+ fields: {
+ openingElement: {
+ validate: (0, _index.assertNodeType)("JSXOpeningElement")
+ },
+ closingElement: {
+ optional: true,
+ validate: (0, _index.assertNodeType)("JSXClosingElement")
+ },
+ children: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement")))
+ }
+ }
+});
+
+(0, _index2.default)("JSXEmptyExpression", {
+ aliases: ["JSX", "Expression"]
+});
+
+(0, _index2.default)("JSXExpressionContainer", {
+ visitor: ["expression"],
+ aliases: ["JSX", "Immutable"],
+ fields: {
+ expression: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index2.default)("JSXSpreadChild", {
+ visitor: ["expression"],
+ aliases: ["JSX", "Immutable"],
+ fields: {
+ expression: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index2.default)("JSXIdentifier", {
+ builder: ["name"],
+ aliases: ["JSX", "Expression"],
+ fields: {
+ name: {
+ validate: (0, _index.assertValueType)("string")
+ }
+ }
+});
+
+(0, _index2.default)("JSXMemberExpression", {
+ visitor: ["object", "property"],
+ aliases: ["JSX", "Expression"],
+ fields: {
+ object: {
+ validate: (0, _index.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
+ },
+ property: {
+ validate: (0, _index.assertNodeType)("JSXIdentifier")
+ }
+ }
+});
+
+(0, _index2.default)("JSXNamespacedName", {
+ visitor: ["namespace", "name"],
+ aliases: ["JSX"],
+ fields: {
+ namespace: {
+ validate: (0, _index.assertNodeType)("JSXIdentifier")
+ },
+ name: {
+ validate: (0, _index.assertNodeType)("JSXIdentifier")
+ }
+ }
+});
+
+(0, _index2.default)("JSXOpeningElement", {
+ builder: ["name", "attributes", "selfClosing"],
+ visitor: ["name", "attributes"],
+ aliases: ["JSX", "Immutable"],
+ fields: {
+ name: {
+ validate: (0, _index.assertNodeType)("JSXIdentifier", "JSXMemberExpression")
+ },
+ selfClosing: {
+ default: false,
+ validate: (0, _index.assertValueType)("boolean")
+ },
+ attributes: {
+ validate: (0, _index.chain)((0, _index.assertValueType)("array"), (0, _index.assertEach)((0, _index.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
+ }
+ }
+});
+
+(0, _index2.default)("JSXSpreadAttribute", {
+ visitor: ["argument"],
+ aliases: ["JSX"],
+ fields: {
+ argument: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
+
+(0, _index2.default)("JSXText", {
+ aliases: ["JSX", "Immutable"],
+ builder: ["value"],
+ fields: {
+ value: {
+ validate: (0, _index.assertValueType)("string")
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/definitions/misc.js b/node_modules/babel-types/lib/definitions/misc.js
new file mode 100644
index 00000000..f982b9a8
--- /dev/null
+++ b/node_modules/babel-types/lib/definitions/misc.js
@@ -0,0 +1,21 @@
+"use strict";
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _index2.default)("Noop", {
+ visitor: []
+});
+
+(0, _index2.default)("ParenthesizedExpression", {
+ visitor: ["expression"],
+ aliases: ["Expression", "ExpressionWrapper"],
+ fields: {
+ expression: {
+ validate: (0, _index.assertNodeType)("Expression")
+ }
+ }
+});
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/flow.js b/node_modules/babel-types/lib/flow.js
new file mode 100644
index 00000000..28579157
--- /dev/null
+++ b/node_modules/babel-types/lib/flow.js
@@ -0,0 +1,108 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createUnionTypeAnnotation = createUnionTypeAnnotation;
+exports.removeTypeDuplicates = removeTypeDuplicates;
+exports.createTypeAnnotationBasedOnTypeof = createTypeAnnotationBasedOnTypeof;
+
+var _index = require("./index");
+
+var t = _interopRequireWildcard(_index);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function createUnionTypeAnnotation(types) {
+ var flattened = removeTypeDuplicates(types);
+
+ if (flattened.length === 1) {
+ return flattened[0];
+ } else {
+ return t.unionTypeAnnotation(flattened);
+ }
+}
+
+function removeTypeDuplicates(nodes) {
+ var generics = {};
+ var bases = {};
+
+ var typeGroups = [];
+
+ var types = [];
+
+ for (var i = 0; i < nodes.length; i++) {
+ var node = nodes[i];
+ if (!node) continue;
+
+ if (types.indexOf(node) >= 0) {
+ continue;
+ }
+
+ if (t.isAnyTypeAnnotation(node)) {
+ return [node];
+ }
+
+ if (t.isFlowBaseAnnotation(node)) {
+ bases[node.type] = node;
+ continue;
+ }
+
+ if (t.isUnionTypeAnnotation(node)) {
+ if (typeGroups.indexOf(node.types) < 0) {
+ nodes = nodes.concat(node.types);
+ typeGroups.push(node.types);
+ }
+ continue;
+ }
+
+ if (t.isGenericTypeAnnotation(node)) {
+ var name = node.id.name;
+
+ if (generics[name]) {
+ var existing = generics[name];
+ if (existing.typeParameters) {
+ if (node.typeParameters) {
+ existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
+ }
+ } else {
+ existing = node.typeParameters;
+ }
+ } else {
+ generics[name] = node;
+ }
+
+ continue;
+ }
+
+ types.push(node);
+ }
+
+ for (var type in bases) {
+ types.push(bases[type]);
+ }
+
+ for (var _name in generics) {
+ types.push(generics[_name]);
+ }
+
+ return types;
+}
+
+function createTypeAnnotationBasedOnTypeof(type) {
+ if (type === "string") {
+ return t.stringTypeAnnotation();
+ } else if (type === "number") {
+ return t.numberTypeAnnotation();
+ } else if (type === "undefined") {
+ return t.voidTypeAnnotation();
+ } else if (type === "boolean") {
+ return t.booleanTypeAnnotation();
+ } else if (type === "function") {
+ return t.genericTypeAnnotation(t.identifier("Function"));
+ } else if (type === "object") {
+ return t.genericTypeAnnotation(t.identifier("Object"));
+ } else if (type === "symbol") {
+ return t.genericTypeAnnotation(t.identifier("Symbol"));
+ } else {
+ throw new Error("Invalid typeof value");
+ }
+}
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/index.js b/node_modules/babel-types/lib/index.js
new file mode 100644
index 00000000..3653bb74
--- /dev/null
+++ b/node_modules/babel-types/lib/index.js
@@ -0,0 +1,839 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createTypeAnnotationBasedOnTypeof = exports.removeTypeDuplicates = exports.createUnionTypeAnnotation = exports.valueToNode = exports.toBlock = exports.toExpression = exports.toStatement = exports.toBindingIdentifierName = exports.toIdentifier = exports.toKeyAlias = exports.toSequenceExpression = exports.toComputedKey = exports.isNodesEquivalent = exports.isImmutable = exports.isScope = exports.isSpecifierDefault = exports.isVar = exports.isBlockScoped = exports.isLet = exports.isValidIdentifier = exports.isReferenced = exports.isBinding = exports.getOuterBindingIdentifiers = exports.getBindingIdentifiers = exports.TYPES = exports.react = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = undefined;
+
+var _getOwnPropertySymbols = require("babel-runtime/core-js/object/get-own-property-symbols");
+
+var _getOwnPropertySymbols2 = _interopRequireDefault(_getOwnPropertySymbols);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _keys = require("babel-runtime/core-js/object/keys");
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _stringify = require("babel-runtime/core-js/json/stringify");
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _constants = require("./constants");
+
+Object.defineProperty(exports, "STATEMENT_OR_BLOCK_KEYS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.STATEMENT_OR_BLOCK_KEYS;
+ }
+});
+Object.defineProperty(exports, "FLATTENABLE_KEYS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.FLATTENABLE_KEYS;
+ }
+});
+Object.defineProperty(exports, "FOR_INIT_KEYS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.FOR_INIT_KEYS;
+ }
+});
+Object.defineProperty(exports, "COMMENT_KEYS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.COMMENT_KEYS;
+ }
+});
+Object.defineProperty(exports, "LOGICAL_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.LOGICAL_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "UPDATE_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.UPDATE_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "BOOLEAN_NUMBER_BINARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.BOOLEAN_NUMBER_BINARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "EQUALITY_BINARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.EQUALITY_BINARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "COMPARISON_BINARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.COMPARISON_BINARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "BOOLEAN_BINARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.BOOLEAN_BINARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "NUMBER_BINARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.NUMBER_BINARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "BINARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.BINARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "BOOLEAN_UNARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.BOOLEAN_UNARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "NUMBER_UNARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.NUMBER_UNARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "STRING_UNARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.STRING_UNARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "UNARY_OPERATORS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.UNARY_OPERATORS;
+ }
+});
+Object.defineProperty(exports, "INHERIT_KEYS", {
+ enumerable: true,
+ get: function get() {
+ return _constants.INHERIT_KEYS;
+ }
+});
+Object.defineProperty(exports, "BLOCK_SCOPED_SYMBOL", {
+ enumerable: true,
+ get: function get() {
+ return _constants.BLOCK_SCOPED_SYMBOL;
+ }
+});
+Object.defineProperty(exports, "NOT_LOCAL_BINDING", {
+ enumerable: true,
+ get: function get() {
+ return _constants.NOT_LOCAL_BINDING;
+ }
+});
+exports.is = is;
+exports.isType = isType;
+exports.validate = validate;
+exports.shallowEqual = shallowEqual;
+exports.appendToMemberExpression = appendToMemberExpression;
+exports.prependToMemberExpression = prependToMemberExpression;
+exports.ensureBlock = ensureBlock;
+exports.clone = clone;
+exports.cloneWithoutLoc = cloneWithoutLoc;
+exports.cloneDeep = cloneDeep;
+exports.buildMatchMemberExpression = buildMatchMemberExpression;
+exports.removeComments = removeComments;
+exports.inheritsComments = inheritsComments;
+exports.inheritTrailingComments = inheritTrailingComments;
+exports.inheritLeadingComments = inheritLeadingComments;
+exports.inheritInnerComments = inheritInnerComments;
+exports.inherits = inherits;
+exports.assertNode = assertNode;
+exports.isNode = isNode;
+exports.traverseFast = traverseFast;
+exports.removeProperties = removeProperties;
+exports.removePropertiesDeep = removePropertiesDeep;
+
+var _retrievers = require("./retrievers");
+
+Object.defineProperty(exports, "getBindingIdentifiers", {
+ enumerable: true,
+ get: function get() {
+ return _retrievers.getBindingIdentifiers;
+ }
+});
+Object.defineProperty(exports, "getOuterBindingIdentifiers", {
+ enumerable: true,
+ get: function get() {
+ return _retrievers.getOuterBindingIdentifiers;
+ }
+});
+
+var _validators = require("./validators");
+
+Object.defineProperty(exports, "isBinding", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isBinding;
+ }
+});
+Object.defineProperty(exports, "isReferenced", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isReferenced;
+ }
+});
+Object.defineProperty(exports, "isValidIdentifier", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isValidIdentifier;
+ }
+});
+Object.defineProperty(exports, "isLet", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isLet;
+ }
+});
+Object.defineProperty(exports, "isBlockScoped", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isBlockScoped;
+ }
+});
+Object.defineProperty(exports, "isVar", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isVar;
+ }
+});
+Object.defineProperty(exports, "isSpecifierDefault", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isSpecifierDefault;
+ }
+});
+Object.defineProperty(exports, "isScope", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isScope;
+ }
+});
+Object.defineProperty(exports, "isImmutable", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isImmutable;
+ }
+});
+Object.defineProperty(exports, "isNodesEquivalent", {
+ enumerable: true,
+ get: function get() {
+ return _validators.isNodesEquivalent;
+ }
+});
+
+var _converters = require("./converters");
+
+Object.defineProperty(exports, "toComputedKey", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toComputedKey;
+ }
+});
+Object.defineProperty(exports, "toSequenceExpression", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toSequenceExpression;
+ }
+});
+Object.defineProperty(exports, "toKeyAlias", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toKeyAlias;
+ }
+});
+Object.defineProperty(exports, "toIdentifier", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toIdentifier;
+ }
+});
+Object.defineProperty(exports, "toBindingIdentifierName", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toBindingIdentifierName;
+ }
+});
+Object.defineProperty(exports, "toStatement", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toStatement;
+ }
+});
+Object.defineProperty(exports, "toExpression", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toExpression;
+ }
+});
+Object.defineProperty(exports, "toBlock", {
+ enumerable: true,
+ get: function get() {
+ return _converters.toBlock;
+ }
+});
+Object.defineProperty(exports, "valueToNode", {
+ enumerable: true,
+ get: function get() {
+ return _converters.valueToNode;
+ }
+});
+
+var _flow = require("./flow");
+
+Object.defineProperty(exports, "createUnionTypeAnnotation", {
+ enumerable: true,
+ get: function get() {
+ return _flow.createUnionTypeAnnotation;
+ }
+});
+Object.defineProperty(exports, "removeTypeDuplicates", {
+ enumerable: true,
+ get: function get() {
+ return _flow.removeTypeDuplicates;
+ }
+});
+Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
+ enumerable: true,
+ get: function get() {
+ return _flow.createTypeAnnotationBasedOnTypeof;
+ }
+});
+
+var _toFastProperties = require("to-fast-properties");
+
+var _toFastProperties2 = _interopRequireDefault(_toFastProperties);
+
+var _compact = require("lodash/compact");
+
+var _compact2 = _interopRequireDefault(_compact);
+
+var _clone = require("lodash/clone");
+
+var _clone2 = _interopRequireDefault(_clone);
+
+var _uniq = require("lodash/uniq");
+
+var _uniq2 = _interopRequireDefault(_uniq);
+
+require("./definitions/init");
+
+var _definitions = require("./definitions");
+
+var _react2 = require("./react");
+
+var _react = _interopRequireWildcard(_react2);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var t = exports;
+
+function registerType(type) {
+ var is = t["is" + type];
+ if (!is) {
+ is = t["is" + type] = function (node, opts) {
+ return t.is(type, node, opts);
+ };
+ }
+
+ t["assert" + type] = function (node, opts) {
+ opts = opts || {};
+ if (!is(node, opts)) {
+ throw new Error("Expected type " + (0, _stringify2.default)(type) + " with option " + (0, _stringify2.default)(opts));
+ }
+ };
+}
+
+exports.VISITOR_KEYS = _definitions.VISITOR_KEYS;
+exports.ALIAS_KEYS = _definitions.ALIAS_KEYS;
+exports.NODE_FIELDS = _definitions.NODE_FIELDS;
+exports.BUILDER_KEYS = _definitions.BUILDER_KEYS;
+exports.DEPRECATED_KEYS = _definitions.DEPRECATED_KEYS;
+exports.react = _react;
+
+
+for (var type in t.VISITOR_KEYS) {
+ registerType(type);
+}
+
+t.FLIPPED_ALIAS_KEYS = {};
+
+(0, _keys2.default)(t.ALIAS_KEYS).forEach(function (type) {
+ t.ALIAS_KEYS[type].forEach(function (alias) {
+ var types = t.FLIPPED_ALIAS_KEYS[alias] = t.FLIPPED_ALIAS_KEYS[alias] || [];
+ types.push(type);
+ });
+});
+
+(0, _keys2.default)(t.FLIPPED_ALIAS_KEYS).forEach(function (type) {
+ t[type.toUpperCase() + "_TYPES"] = t.FLIPPED_ALIAS_KEYS[type];
+ registerType(type);
+});
+
+var TYPES = exports.TYPES = (0, _keys2.default)(t.VISITOR_KEYS).concat((0, _keys2.default)(t.FLIPPED_ALIAS_KEYS)).concat((0, _keys2.default)(t.DEPRECATED_KEYS));
+
+function is(type, node, opts) {
+ if (!node) return false;
+
+ var matches = isType(node.type, type);
+ if (!matches) return false;
+
+ if (typeof opts === "undefined") {
+ return true;
+ } else {
+ return t.shallowEqual(node, opts);
+ }
+}
+
+function isType(nodeType, targetType) {
+ if (nodeType === targetType) return true;
+
+ if (t.ALIAS_KEYS[targetType]) return false;
+
+ var aliases = t.FLIPPED_ALIAS_KEYS[targetType];
+ if (aliases) {
+ if (aliases[0] === nodeType) return true;
+
+ for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var alias = _ref;
+
+ if (nodeType === alias) return true;
+ }
+ }
+
+ return false;
+}
+
+(0, _keys2.default)(t.BUILDER_KEYS).forEach(function (type) {
+ var keys = t.BUILDER_KEYS[type];
+
+ function builder() {
+ if (arguments.length > keys.length) {
+ throw new Error("t." + type + ": Too many arguments passed. Received " + arguments.length + " but can receive " + ("no more than " + keys.length));
+ }
+
+ var node = {};
+ node.type = type;
+
+ var i = 0;
+
+ for (var _iterator2 = keys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var _key = _ref2;
+
+ var field = t.NODE_FIELDS[type][_key];
+
+ var arg = arguments[i++];
+ if (arg === undefined) arg = (0, _clone2.default)(field.default);
+
+ node[_key] = arg;
+ }
+
+ for (var key in node) {
+ validate(node, key, node[key]);
+ }
+
+ return node;
+ }
+
+ t[type] = builder;
+ t[type[0].toLowerCase() + type.slice(1)] = builder;
+});
+
+var _loop = function _loop(_type) {
+ var newType = t.DEPRECATED_KEYS[_type];
+
+ function proxy(fn) {
+ return function () {
+ console.trace("The node type " + _type + " has been renamed to " + newType);
+ return fn.apply(this, arguments);
+ };
+ }
+
+ t[_type] = t[_type[0].toLowerCase() + _type.slice(1)] = proxy(t[newType]);
+ t["is" + _type] = proxy(t["is" + newType]);
+ t["assert" + _type] = proxy(t["assert" + newType]);
+};
+
+for (var _type in t.DEPRECATED_KEYS) {
+ _loop(_type);
+}
+
+function validate(node, key, val) {
+ if (!node) return;
+
+ var fields = t.NODE_FIELDS[node.type];
+ if (!fields) return;
+
+ var field = fields[key];
+ if (!field || !field.validate) return;
+ if (field.optional && val == null) return;
+
+ field.validate(node, key, val);
+}
+
+function shallowEqual(actual, expected) {
+ var keys = (0, _keys2.default)(expected);
+
+ for (var _iterator3 = keys, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
+ var _ref3;
+
+ if (_isArray3) {
+ if (_i3 >= _iterator3.length) break;
+ _ref3 = _iterator3[_i3++];
+ } else {
+ _i3 = _iterator3.next();
+ if (_i3.done) break;
+ _ref3 = _i3.value;
+ }
+
+ var key = _ref3;
+
+ if (actual[key] !== expected[key]) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function appendToMemberExpression(member, append, computed) {
+ member.object = t.memberExpression(member.object, member.property, member.computed);
+ member.property = append;
+ member.computed = !!computed;
+ return member;
+}
+
+function prependToMemberExpression(member, prepend) {
+ member.object = t.memberExpression(prepend, member.object);
+ return member;
+}
+
+function ensureBlock(node) {
+ var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "body";
+
+ return node[key] = t.toBlock(node[key], node);
+}
+
+function clone(node) {
+ if (!node) return node;
+ var newNode = {};
+ for (var key in node) {
+ if (key[0] === "_") continue;
+ newNode[key] = node[key];
+ }
+ return newNode;
+}
+
+function cloneWithoutLoc(node) {
+ var newNode = clone(node);
+ delete newNode.loc;
+ return newNode;
+}
+
+function cloneDeep(node) {
+ if (!node) return node;
+ var newNode = {};
+
+ for (var key in node) {
+ if (key[0] === "_") continue;
+
+ var val = node[key];
+
+ if (val) {
+ if (val.type) {
+ val = t.cloneDeep(val);
+ } else if (Array.isArray(val)) {
+ val = val.map(t.cloneDeep);
+ }
+ }
+
+ newNode[key] = val;
+ }
+
+ return newNode;
+}
+
+function buildMatchMemberExpression(match, allowPartial) {
+ var parts = match.split(".");
+
+ return function (member) {
+ if (!t.isMemberExpression(member)) return false;
+
+ var search = [member];
+ var i = 0;
+
+ while (search.length) {
+ var node = search.shift();
+
+ if (allowPartial && i === parts.length) {
+ return true;
+ }
+
+ if (t.isIdentifier(node)) {
+ if (parts[i] !== node.name) return false;
+ } else if (t.isStringLiteral(node)) {
+ if (parts[i] !== node.value) return false;
+ } else if (t.isMemberExpression(node)) {
+ if (node.computed && !t.isStringLiteral(node.property)) {
+ return false;
+ } else {
+ search.push(node.object);
+ search.push(node.property);
+ continue;
+ }
+ } else {
+ return false;
+ }
+
+ if (++i > parts.length) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+}
+
+function removeComments(node) {
+ for (var _iterator4 = t.COMMENT_KEYS, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) {
+ var _ref4;
+
+ if (_isArray4) {
+ if (_i4 >= _iterator4.length) break;
+ _ref4 = _iterator4[_i4++];
+ } else {
+ _i4 = _iterator4.next();
+ if (_i4.done) break;
+ _ref4 = _i4.value;
+ }
+
+ var key = _ref4;
+
+ delete node[key];
+ }
+ return node;
+}
+
+function inheritsComments(child, parent) {
+ inheritTrailingComments(child, parent);
+ inheritLeadingComments(child, parent);
+ inheritInnerComments(child, parent);
+ return child;
+}
+
+function inheritTrailingComments(child, parent) {
+ _inheritComments("trailingComments", child, parent);
+}
+
+function inheritLeadingComments(child, parent) {
+ _inheritComments("leadingComments", child, parent);
+}
+
+function inheritInnerComments(child, parent) {
+ _inheritComments("innerComments", child, parent);
+}
+
+function _inheritComments(key, child, parent) {
+ if (child && parent) {
+ child[key] = (0, _uniq2.default)((0, _compact2.default)([].concat(child[key], parent[key])));
+ }
+}
+
+function inherits(child, parent) {
+ if (!child || !parent) return child;
+
+ for (var _iterator5 = t.INHERIT_KEYS.optional, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : (0, _getIterator3.default)(_iterator5);;) {
+ var _ref5;
+
+ if (_isArray5) {
+ if (_i5 >= _iterator5.length) break;
+ _ref5 = _iterator5[_i5++];
+ } else {
+ _i5 = _iterator5.next();
+ if (_i5.done) break;
+ _ref5 = _i5.value;
+ }
+
+ var _key2 = _ref5;
+
+ if (child[_key2] == null) {
+ child[_key2] = parent[_key2];
+ }
+ }
+
+ for (var key in parent) {
+ if (key[0] === "_") child[key] = parent[key];
+ }
+
+ for (var _iterator6 = t.INHERIT_KEYS.force, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : (0, _getIterator3.default)(_iterator6);;) {
+ var _ref6;
+
+ if (_isArray6) {
+ if (_i6 >= _iterator6.length) break;
+ _ref6 = _iterator6[_i6++];
+ } else {
+ _i6 = _iterator6.next();
+ if (_i6.done) break;
+ _ref6 = _i6.value;
+ }
+
+ var _key3 = _ref6;
+
+ child[_key3] = parent[_key3];
+ }
+
+ t.inheritsComments(child, parent);
+
+ return child;
+}
+
+function assertNode(node) {
+ if (!isNode(node)) {
+ throw new TypeError("Not a valid node " + (node && node.type));
+ }
+}
+
+function isNode(node) {
+ return !!(node && _definitions.VISITOR_KEYS[node.type]);
+}
+
+(0, _toFastProperties2.default)(t);
+(0, _toFastProperties2.default)(t.VISITOR_KEYS);
+
+function traverseFast(node, enter, opts) {
+ if (!node) return;
+
+ var keys = t.VISITOR_KEYS[node.type];
+ if (!keys) return;
+
+ opts = opts || {};
+ enter(node, opts);
+
+ for (var _iterator7 = keys, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : (0, _getIterator3.default)(_iterator7);;) {
+ var _ref7;
+
+ if (_isArray7) {
+ if (_i7 >= _iterator7.length) break;
+ _ref7 = _iterator7[_i7++];
+ } else {
+ _i7 = _iterator7.next();
+ if (_i7.done) break;
+ _ref7 = _i7.value;
+ }
+
+ var key = _ref7;
+
+ var subNode = node[key];
+
+ if (Array.isArray(subNode)) {
+ for (var _iterator8 = subNode, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : (0, _getIterator3.default)(_iterator8);;) {
+ var _ref8;
+
+ if (_isArray8) {
+ if (_i8 >= _iterator8.length) break;
+ _ref8 = _iterator8[_i8++];
+ } else {
+ _i8 = _iterator8.next();
+ if (_i8.done) break;
+ _ref8 = _i8.value;
+ }
+
+ var _node = _ref8;
+
+ traverseFast(_node, enter, opts);
+ }
+ } else {
+ traverseFast(subNode, enter, opts);
+ }
+ }
+}
+
+var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+
+var CLEAR_KEYS_PLUS_COMMENTS = t.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
+
+function removeProperties(node, opts) {
+ opts = opts || {};
+ var map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
+ for (var _iterator9 = map, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : (0, _getIterator3.default)(_iterator9);;) {
+ var _ref9;
+
+ if (_isArray9) {
+ if (_i9 >= _iterator9.length) break;
+ _ref9 = _iterator9[_i9++];
+ } else {
+ _i9 = _iterator9.next();
+ if (_i9.done) break;
+ _ref9 = _i9.value;
+ }
+
+ var _key4 = _ref9;
+
+ if (node[_key4] != null) node[_key4] = undefined;
+ }
+
+ for (var key in node) {
+ if (key[0] === "_" && node[key] != null) node[key] = undefined;
+ }
+
+ var syms = (0, _getOwnPropertySymbols2.default)(node);
+ for (var _iterator10 = syms, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : (0, _getIterator3.default)(_iterator10);;) {
+ var _ref10;
+
+ if (_isArray10) {
+ if (_i10 >= _iterator10.length) break;
+ _ref10 = _iterator10[_i10++];
+ } else {
+ _i10 = _iterator10.next();
+ if (_i10.done) break;
+ _ref10 = _i10.value;
+ }
+
+ var sym = _ref10;
+
+ node[sym] = null;
+ }
+}
+
+function removePropertiesDeep(tree, opts) {
+ traverseFast(tree, removeProperties, opts);
+ return tree;
+}
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/react.js b/node_modules/babel-types/lib/react.js
new file mode 100644
index 00000000..923ee123
--- /dev/null
+++ b/node_modules/babel-types/lib/react.js
@@ -0,0 +1,80 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isReactComponent = undefined;
+exports.isCompatTag = isCompatTag;
+exports.buildChildren = buildChildren;
+
+var _index = require("./index");
+
+var t = _interopRequireWildcard(_index);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var isReactComponent = exports.isReactComponent = t.buildMatchMemberExpression("React.Component");
+
+function isCompatTag(tagName) {
+ return !!tagName && /^[a-z]|\-/.test(tagName);
+}
+
+function cleanJSXElementLiteralChild(child, args) {
+ var lines = child.value.split(/\r\n|\n|\r/);
+
+ var lastNonEmptyLine = 0;
+
+ for (var i = 0; i < lines.length; i++) {
+ if (lines[i].match(/[^ \t]/)) {
+ lastNonEmptyLine = i;
+ }
+ }
+
+ var str = "";
+
+ for (var _i = 0; _i < lines.length; _i++) {
+ var line = lines[_i];
+
+ var isFirstLine = _i === 0;
+ var isLastLine = _i === lines.length - 1;
+ var isLastNonEmptyLine = _i === lastNonEmptyLine;
+
+ var trimmedLine = line.replace(/\t/g, " ");
+
+ if (!isFirstLine) {
+ trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+ }
+
+ if (!isLastLine) {
+ trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+ }
+
+ if (trimmedLine) {
+ if (!isLastNonEmptyLine) {
+ trimmedLine += " ";
+ }
+
+ str += trimmedLine;
+ }
+ }
+
+ if (str) args.push(t.stringLiteral(str));
+}
+
+function buildChildren(node) {
+ var elems = [];
+
+ for (var i = 0; i < node.children.length; i++) {
+ var child = node.children[i];
+
+ if (t.isJSXText(child)) {
+ cleanJSXElementLiteralChild(child, elems);
+ continue;
+ }
+
+ if (t.isJSXExpressionContainer(child)) child = child.expression;
+ if (t.isJSXEmptyExpression(child)) continue;
+
+ elems.push(child);
+ }
+
+ return elems;
+}
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/retrievers.js b/node_modules/babel-types/lib/retrievers.js
new file mode 100644
index 00000000..e5782e08
--- /dev/null
+++ b/node_modules/babel-types/lib/retrievers.js
@@ -0,0 +1,115 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _create = require("babel-runtime/core-js/object/create");
+
+var _create2 = _interopRequireDefault(_create);
+
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+
+var _index = require("./index");
+
+var t = _interopRequireWildcard(_index);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getBindingIdentifiers(node, duplicates, outerOnly) {
+ var search = [].concat(node);
+ var ids = (0, _create2.default)(null);
+
+ while (search.length) {
+ var id = search.shift();
+ if (!id) continue;
+
+ var keys = t.getBindingIdentifiers.keys[id.type];
+
+ if (t.isIdentifier(id)) {
+ if (duplicates) {
+ var _ids = ids[id.name] = ids[id.name] || [];
+ _ids.push(id);
+ } else {
+ ids[id.name] = id;
+ }
+ continue;
+ }
+
+ if (t.isExportDeclaration(id)) {
+ if (t.isDeclaration(id.declaration)) {
+ search.push(id.declaration);
+ }
+ continue;
+ }
+
+ if (outerOnly) {
+ if (t.isFunctionDeclaration(id)) {
+ search.push(id.id);
+ continue;
+ }
+
+ if (t.isFunctionExpression(id)) {
+ continue;
+ }
+ }
+
+ if (keys) {
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ if (id[key]) {
+ search = search.concat(id[key]);
+ }
+ }
+ }
+ }
+
+ return ids;
+}
+
+getBindingIdentifiers.keys = {
+ DeclareClass: ["id"],
+ DeclareFunction: ["id"],
+ DeclareModule: ["id"],
+ DeclareVariable: ["id"],
+ InterfaceDeclaration: ["id"],
+ TypeAlias: ["id"],
+
+ CatchClause: ["param"],
+ LabeledStatement: ["label"],
+ UnaryExpression: ["argument"],
+ AssignmentExpression: ["left"],
+
+ ImportSpecifier: ["local"],
+ ImportNamespaceSpecifier: ["local"],
+ ImportDefaultSpecifier: ["local"],
+ ImportDeclaration: ["specifiers"],
+
+ ExportSpecifier: ["exported"],
+ ExportNamespaceSpecifier: ["exported"],
+ ExportDefaultSpecifier: ["exported"],
+
+ FunctionDeclaration: ["id", "params"],
+ FunctionExpression: ["id", "params"],
+
+ ClassDeclaration: ["id"],
+ ClassExpression: ["id"],
+
+ RestElement: ["argument"],
+ UpdateExpression: ["argument"],
+
+ RestProperty: ["argument"],
+ ObjectProperty: ["value"],
+
+ AssignmentPattern: ["left"],
+ ArrayPattern: ["elements"],
+ ObjectPattern: ["properties"],
+
+ VariableDeclaration: ["declarations"],
+ VariableDeclarator: ["id"]
+};
+
+function getOuterBindingIdentifiers(node, duplicates) {
+ return getBindingIdentifiers(node, duplicates, true);
+}
\ No newline at end of file
diff --git a/node_modules/babel-types/lib/validators.js b/node_modules/babel-types/lib/validators.js
new file mode 100644
index 00000000..23578a1d
--- /dev/null
+++ b/node_modules/babel-types/lib/validators.js
@@ -0,0 +1,263 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _keys = require("babel-runtime/core-js/object/keys");
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _typeof2 = require("babel-runtime/helpers/typeof");
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.isBinding = isBinding;
+exports.isReferenced = isReferenced;
+exports.isValidIdentifier = isValidIdentifier;
+exports.isLet = isLet;
+exports.isBlockScoped = isBlockScoped;
+exports.isVar = isVar;
+exports.isSpecifierDefault = isSpecifierDefault;
+exports.isScope = isScope;
+exports.isImmutable = isImmutable;
+exports.isNodesEquivalent = isNodesEquivalent;
+
+var _retrievers = require("./retrievers");
+
+var _esutils = require("esutils");
+
+var _esutils2 = _interopRequireDefault(_esutils);
+
+var _index = require("./index");
+
+var t = _interopRequireWildcard(_index);
+
+var _constants = require("./constants");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isBinding(node, parent) {
+ var keys = _retrievers.getBindingIdentifiers.keys[parent.type];
+ if (keys) {
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var val = parent[key];
+ if (Array.isArray(val)) {
+ if (val.indexOf(node) >= 0) return true;
+ } else {
+ if (val === node) return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+function isReferenced(node, parent) {
+ switch (parent.type) {
+ case "BindExpression":
+ return parent.object === node || parent.callee === node;
+
+ case "MemberExpression":
+ case "JSXMemberExpression":
+ if (parent.property === node && parent.computed) {
+ return true;
+ } else if (parent.object === node) {
+ return true;
+ } else {
+ return false;
+ }
+
+ case "MetaProperty":
+ return false;
+
+ case "ObjectProperty":
+ if (parent.key === node) {
+ return parent.computed;
+ }
+
+ case "VariableDeclarator":
+ return parent.id !== node;
+
+ case "ArrowFunctionExpression":
+ case "FunctionDeclaration":
+ case "FunctionExpression":
+ for (var _iterator = parent.params, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var param = _ref;
+
+ if (param === node) return false;
+ }
+
+ return parent.id !== node;
+
+ case "ExportSpecifier":
+ if (parent.source) {
+ return false;
+ } else {
+ return parent.local === node;
+ }
+
+ case "ExportNamespaceSpecifier":
+ case "ExportDefaultSpecifier":
+ return false;
+
+ case "JSXAttribute":
+ return parent.name !== node;
+
+ case "ClassProperty":
+ if (parent.key === node) {
+ return parent.computed;
+ } else {
+ return parent.value === node;
+ }
+
+ case "ImportDefaultSpecifier":
+ case "ImportNamespaceSpecifier":
+ case "ImportSpecifier":
+ return false;
+
+ case "ClassDeclaration":
+ case "ClassExpression":
+ return parent.id !== node;
+
+ case "ClassMethod":
+ case "ObjectMethod":
+ return parent.key === node && parent.computed;
+
+ case "LabeledStatement":
+ return false;
+
+ case "CatchClause":
+ return parent.param !== node;
+
+ case "RestElement":
+ return false;
+
+ case "AssignmentExpression":
+ return parent.right === node;
+
+ case "AssignmentPattern":
+ return parent.right === node;
+
+ case "ObjectPattern":
+ case "ArrayPattern":
+ return false;
+ }
+
+ return true;
+}
+
+function isValidIdentifier(name) {
+ if (typeof name !== "string" || _esutils2.default.keyword.isReservedWordES6(name, true)) {
+ return false;
+ } else {
+ return _esutils2.default.keyword.isIdentifierNameES6(name);
+ }
+}
+
+function isLet(node) {
+ return t.isVariableDeclaration(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]);
+}
+
+function isBlockScoped(node) {
+ return t.isFunctionDeclaration(node) || t.isClassDeclaration(node) || t.isLet(node);
+}
+
+function isVar(node) {
+ return t.isVariableDeclaration(node, { kind: "var" }) && !node[_constants.BLOCK_SCOPED_SYMBOL];
+}
+
+function isSpecifierDefault(specifier) {
+ return t.isImportDefaultSpecifier(specifier) || t.isIdentifier(specifier.imported || specifier.exported, { name: "default" });
+}
+
+function isScope(node, parent) {
+ if (t.isBlockStatement(node) && t.isFunction(parent, { body: node })) {
+ return false;
+ }
+
+ return t.isScopable(node);
+}
+
+function isImmutable(node) {
+ if (t.isType(node.type, "Immutable")) return true;
+
+ if (t.isIdentifier(node)) {
+ if (node.name === "undefined") {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ return false;
+}
+
+function isNodesEquivalent(a, b) {
+ if ((typeof a === "undefined" ? "undefined" : (0, _typeof3.default)(a)) !== "object" || (typeof a === "undefined" ? "undefined" : (0, _typeof3.default)(a)) !== "object" || a == null || b == null) {
+ return a === b;
+ }
+
+ if (a.type !== b.type) {
+ return false;
+ }
+
+ var fields = (0, _keys2.default)(t.NODE_FIELDS[a.type] || a.type);
+
+ for (var _iterator2 = fields, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var field = _ref2;
+
+ if ((0, _typeof3.default)(a[field]) !== (0, _typeof3.default)(b[field])) {
+ return false;
+ }
+
+ if (Array.isArray(a[field])) {
+ if (!Array.isArray(b[field])) {
+ return false;
+ }
+ if (a[field].length !== b[field].length) {
+ return false;
+ }
+
+ for (var i = 0; i < a[field].length; i++) {
+ if (!isNodesEquivalent(a[field][i], b[field][i])) {
+ return false;
+ }
+ }
+ continue;
+ }
+
+ if (!isNodesEquivalent(a[field], b[field])) {
+ return false;
+ }
+ }
+
+ return true;
+}
\ No newline at end of file
diff --git a/node_modules/babel-types/package.json b/node_modules/babel-types/package.json
new file mode 100644
index 00000000..52f6f461
--- /dev/null
+++ b/node_modules/babel-types/package.json
@@ -0,0 +1,126 @@
+{
+ "_args": [
+ [
+ {
+ "raw": "babel-types@^6.22.0",
+ "scope": null,
+ "escapedName": "babel-types",
+ "name": "babel-types",
+ "rawSpec": "^6.22.0",
+ "spec": ">=6.22.0 <7.0.0",
+ "type": "range"
+ },
+ "/Users/ericchiu/Desktop/CIS 700/HW3/Project3-LSystems/node_modules/babel-core"
+ ]
+ ],
+ "_from": "babel-types@>=6.22.0 <7.0.0",
+ "_id": "babel-types@6.22.0",
+ "_inCache": true,
+ "_location": "/babel-types",
+ "_nodeVersion": "6.9.0",
+ "_npmOperationalInternal": {
+ "host": "packages-18-east.internal.npmjs.com",
+ "tmp": "tmp/babel-types-6.22.0.tgz_1484872469348_0.9042536793276668"
+ },
+ "_npmUser": {
+ "name": "hzoo",
+ "email": "hi@henryzoo.com"
+ },
+ "_npmVersion": "3.10.10",
+ "_phantomChildren": {},
+ "_requested": {
+ "raw": "babel-types@^6.22.0",
+ "scope": null,
+ "escapedName": "babel-types",
+ "name": "babel-types",
+ "rawSpec": "^6.22.0",
+ "spec": ">=6.22.0 <7.0.0",
+ "type": "range"
+ },
+ "_requiredBy": [
+ "/babel-core",
+ "/babel-generator",
+ "/babel-helper-call-delegate",
+ "/babel-helper-define-map",
+ "/babel-helper-function-name",
+ "/babel-helper-get-function-arity",
+ "/babel-helper-hoist-variables",
+ "/babel-helper-optimise-call-expression",
+ "/babel-helper-regex",
+ "/babel-helper-replace-supers",
+ "/babel-plugin-transform-es2015-block-scoping",
+ "/babel-plugin-transform-es2015-classes",
+ "/babel-plugin-transform-es2015-duplicate-keys",
+ "/babel-plugin-transform-es2015-function-name",
+ "/babel-plugin-transform-es2015-modules-commonjs",
+ "/babel-plugin-transform-es2015-parameters",
+ "/babel-plugin-transform-es2015-shorthand-properties",
+ "/babel-plugin-transform-es2015-sticky-regex",
+ "/babel-plugin-transform-strict-mode",
+ "/babel-template",
+ "/babel-traverse",
+ "/regenerator-transform"
+ ],
+ "_resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.22.0.tgz",
+ "_shasum": "2a447e8d0ea25d2512409e4175479fd78cc8b1db",
+ "_shrinkwrap": null,
+ "_spec": "babel-types@^6.22.0",
+ "_where": "/Users/ericchiu/Desktop/CIS 700/HW3/Project3-LSystems/node_modules/babel-core",
+ "author": {
+ "name": "Sebastian McKenzie",
+ "email": "sebmck@gmail.com"
+ },
+ "dependencies": {
+ "babel-runtime": "^6.22.0",
+ "esutils": "^2.0.2",
+ "lodash": "^4.2.0",
+ "to-fast-properties": "^1.0.1"
+ },
+ "description": "Babel Types is a Lodash-esque utility library for AST nodes",
+ "devDependencies": {
+ "babylon": "^6.8.2"
+ },
+ "directories": {},
+ "dist": {
+ "shasum": "2a447e8d0ea25d2512409e4175479fd78cc8b1db",
+ "tarball": "https://registry.npmjs.org/babel-types/-/babel-types-6.22.0.tgz"
+ },
+ "homepage": "https://babeljs.io/",
+ "license": "MIT",
+ "main": "lib/index.js",
+ "maintainers": [
+ {
+ "name": "amasad",
+ "email": "amjad.masad@gmail.com"
+ },
+ {
+ "name": "hzoo",
+ "email": "hi@henryzoo.com"
+ },
+ {
+ "name": "jmm",
+ "email": "npm-public@jessemccarthy.net"
+ },
+ {
+ "name": "loganfsmyth",
+ "email": "loganfsmyth@gmail.com"
+ },
+ {
+ "name": "sebmck",
+ "email": "sebmck@gmail.com"
+ },
+ {
+ "name": "thejameskyle",
+ "email": "me@thejameskyle.com"
+ }
+ ],
+ "name": "babel-types",
+ "optionalDependencies": {},
+ "readme": "ERROR: No README data found!",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/babel/babel/tree/master/packages/babel-types"
+ },
+ "scripts": {},
+ "version": "6.22.0"
+}
diff --git a/node_modules/babylon/CHANGELOG.md b/node_modules/babylon/CHANGELOG.md
new file mode 100644
index 00000000..d78294a4
--- /dev/null
+++ b/node_modules/babylon/CHANGELOG.md
@@ -0,0 +1,785 @@
+# Changelog
+
+> **Tags:**
+> - :boom: [Breaking Change]
+> - :eyeglasses: [Spec Compliancy]
+> - :rocket: [New Feature]
+> - :bug: [Bug Fix]
+> - :memo: [Documentation]
+> - :house: [Internal]
+> - :nail_care: [Polish]
+
+> Semver Policy: https://github.com/babel/babylon#semver
+
+_Note: Gaps between patch versions are faulty, broken or test releases._
+
+See the [Babel Changelog](https://github.com/babel/babel/blob/master/CHANGELOG.md) for the pre-6.8.0 version Changelog.
+
+## 6.15.0 (2017-01-10)
+
+### :eyeglasses: Spec Compliancy
+
+Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
+
+This change implements flows new shorthand import syntax
+and where previously you had to write this code:
+
+```js
+import {someValue} from "blah";
+import type {someType} from "blah";
+import typeof {someOtherValue} from "blah";
+```
+
+you can now write it like this:
+
+```js
+import {
+ someValue,
+ type someType,
+ typeof someOtherValue,
+} from "blah";
+```
+
+For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request.
+
+flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin)
+
+This change now allows a leading pipe everywhere types can be used:
+```js
+var f = (x): | 1 | 2 => 1;
+```
+
+Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo)
+
+Previously babylon parsed the following exports, although they are not valid:
+```js
+export typeof foo;
+export new Foo();
+export function() {};
+export for (;;);
+export while(foo);
+```
+
+### :bug: Bug Fix
+
+Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin)
+
+This fixes parsing of this case:
+
+```js
+const map = {
+ [age <= 17] : 'Too young'
+};
+```
+
+Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long)
+
+The following case produced an invalid AST
+```js
+
{/* foo */}
+```
+
+Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)
+
+When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.
+
+Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)
+
+Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)
+
+### :house: Internal
+
+User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)
+
+Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)
+
+Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)
+
+Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)
+
+Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)
+
+Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)
+
+Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])
+
+chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])
+
+chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])
+
+## 6.14.1 (2016-11-17)
+
+### :bug: Bug Fix
+
+Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)
+
+```js
+{
+ "plugins": ["*"]
+}
+```
+
+Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.
+
+## 6.14.0 (2016-11-16)
+
+### :eyeglasses: Spec Compliancy
+
+Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
+
+[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)
+
+Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).
+
+```
+class enum {} // throws
+class await {} // throws in strict mode (module)
+```
+
+Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)
+
+So where you used to have to write
+
+```js
+type A = (x: string, y: boolean) => number;
+type B = (z: string) => number;
+type C = { [key: string]: number };
+```
+
+you can now write (with flow 0.34.0)
+
+```js
+type A = (string, boolean) => number;
+type B = string => number;
+type C = { [string]: number };
+```
+
+Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)
+
+Supports these form now of specifying array types:
+
+```js
+var a: number[][][][];
+var b: string[][];
+```
+
+### :bug: Bug Fix
+
+Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223)) (Daniel Tschinder)
+
+```
+declare module "foo" { declare module.exports: number }
+declare module "foo" { declare module.exports: number; } // also allowed now
+```
+
+### :house: Internal
+
+ * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
+ * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
+ * Add node 7 (Daniel Tschinder)
+ * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)
+
+## v6.13.1 (2016-10-26)
+
+### :nail_care: Polish
+
+- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))
+
+```js
+const babylon = require('babylon');
+const ast = babylon.parse('var foo = "lol";');
+```
+
+With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.
+
+**Without bundling**
+
+
+**With bundling**
+
+
+- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
+- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)
+
+## v6.13.0 (2016-10-21)
+
+### :eyeglasses: Spec Compliancy
+
+Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
+
+> See https://flowtype.org/docs/variance.html for more information
+
+```js
+type T = { +p: T };
+interface T { -p: T };
+declare class T { +[k:K]: V };
+class T { -[k:K]: V };
+class C2 { +p: T = e };
+```
+
+Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)
+
+```js
+({ __proto__: 1, __proto__: 2 }) // Throws an error now
+```
+
+### :bug: Bug Fix
+
+Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)
+
+```js
+declare class A {
+ static: T;
+}
+```
+
+Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)
+
+```js
+var foo = { async, bar };
+```
+
+### :nail_care: Polish
+
+Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)
+
+> This improves the performance slightly (because of hidden classes)
+
+### :house: Internal
+
+Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)
+
+Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)
+
+Readd missin .eslinignore for IDEs (Daniel Tschinder)
+
+Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)
+
+Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)
+
+Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)
+
+## v6.12.0 (2016-10-14)
+
+### :eyeglasses: Spec Compliancy
+
+Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
+
+#### Dynamic Import
+
+- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
+- Championed by [@domenic](https://github.com/domenic)
+- stage-2
+- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)
+
+> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript
+
+```js
+import(`./section-modules/${link.dataset.entryModule}.js`)
+.then(module => {
+ module.loadPageInto(main);
+})
+```
+
+Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)
+
+#### EmptyTypeAnnotation
+
+Just wasn't covered before.
+
+```js
+type T = empty;
+```
+
+### :bug: Bug Fix
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing due to sparse array
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)
+
+```js
+declare class X {
+ foobar(): void;
+ static foobar(): void;
+}
+```
+
+Allow keyword in object/class property names with Flow type parameters ([#145](https://github.com/babel/babylon/pull/145)) (Dan Harper)
+
+```js
+class Foo {
+ delete(item: T): T {
+ return item;
+ }
+}
+```
+
+Allow typeAnnotations for yield expressions ([#174](https://github.com/babel/babylon/pull/174))) (Daniel Tschinder)
+
+```js
+function *foo() {
+ const x = (yield 5: any);
+}
+```
+
+### :nail_care: Polish
+
+Annotate more errors with expected token ([#172](https://github.com/babel/babylon/pull/172))) (Moti Zilberman)
+
+```js
+// Unexpected token, expected ; (1:6)
+{ set 1 }
+```
+
+### :house: Internal
+
+Remove kcheck ([#173](https://github.com/babel/babylon/pull/173))) (Daniel Tschinder)
+
+Also run flow, linting, babel tests on seperate instances (add back node 0.10)
+
+## v6.11.6 (2016-10-12)
+
+### :bug: Bug Fix/Regression
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing with `Cannot read property 'type' of null` because of null identifiers
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+## v6.11.5 (2016-10-12)
+
+### :eyeglasses: Spec Compliancy
+
+Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
+
+```js
+// `foo` has already been exported. Exported identifiers must be unique. (2:20)
+export function foo() {};
+export const { a: [{foo}] } = bar;
+```
+
+Fix: Check for duplicate named exports in exported rest elements/properties ([#164](https://github.com/babel/babylon/pull/164)) (Kai Cataldo)
+
+```js
+// `foo` has already been exported. Exported identifiers must be unique. (2:22)
+export const foo = 1;
+export const [bar, ...foo] = baz;
+```
+
+### :bug: Bug Fix
+
+Fix: Allow identifier `async` for default param in arrow expression ([#165](https://github.com/babel/babylon/pull/165)) (Kai Cataldo)
+
+```js
+// this is ok now
+const test = ({async = true}) => {};
+```
+
+### :nail_care: Polish
+
+Babylon will now print out the token it's expecting if there's a `SyntaxError` ([#150](https://github.com/babel/babylon/pull/150)) (Daniel Tschinder)
+
+```bash
+# So in the case of a missing ending curly (`}`)
+Module build failed: SyntaxError: Unexpected token, expected } (30:0)
+ 28 | }
+ 29 |
+> 30 |
+ | ^
+```
+
+## v6.11.4 (2016-10-03)
+
+Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
+
+## v6.11.3 (2016-10-01)
+
+### :eyeglasses: Spec Compliancy
+
+Add static errors for object rest (#149) ([@danez](https://github.com/danez))
+
+> https://github.com/sebmarkbage/ecmascript-rest-spread
+
+Object rest copies the *rest* of properties from the right hand side `obj` starting from the left to right.
+
+```js
+let { x, y, ...z } = { x: 1, y: 2, z: 3 };
+// x = 1
+// y = 2
+// z = { z: 3 }
+```
+
+#### New Syntax Errors:
+
+**SyntaxError**: The rest element has to be the last element when destructuring (1:10)
+```bash
+> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3};
+ | ^
+# Previous behavior:
+# x = { x: 1, y: 2, z: 3 }
+# y = 2
+# z = 3
+```
+
+Before, this was just a more verbose way of shallow copying `obj` since it doesn't actually do what you think.
+
+**SyntaxError**: Cannot have multiple rest elements when destructuring (1:13)
+
+```bash
+> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3};
+ | ^
+# Previous behavior:
+# x = 1
+# y = { y: 2, z: 3 }
+# z = { y: 2, z: 3 }
+```
+
+Before y and z would just be the same value anyway so there is no reason to need to have both.
+
+**SyntaxError**: A trailing comma is not permitted after the rest element (1:16)
+
+```js
+let { x, y, ...z, } = obj;
+```
+
+The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense.
+
+---
+
+get / set are valid property names in default assignment (#142) ([@jezell](https://github.com/jezell))
+
+```js
+// valid
+function something({ set = null, get = null }) {}
+```
+
+## v6.11.2 (2016-09-23)
+
+### Bug Fix
+
+- [#139](https://github.com/babel/babylon/issues/139) Don't do the duplicate check if not an identifier (#140) @hzoo
+
+```js
+// regression with duplicate export check
+SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13)
+ 20 |
+ 21 | export const { rhythm } = typography;
+> 22 | export const { TypographyStyle } = typography
+```
+
+Bail out for now, and make a change to account for destructuring in the next release.
+
+## 6.11.1 (2016-09-22)
+
+### Bug Fix
+- [#137](https://github.com/babel/babylon/pull/137) - Fix a regression with duplicate exports - it was erroring on all keys in `Object.prototype`. @danez
+
+```javascript
+export toString from './toString';
+```
+
+```bash
+`toString` has already been exported. Exported identifiers must be unique. (1:7)
+> 1 | export toString from './toString';
+ | ^
+ 2 |
+```
+
+## 6.11.0 (2016-09-22)
+
+### Spec Compliancy (will break CI)
+
+- Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
+
+```js
+// Only one default export allowed per module. (2:9)
+export default function() {};
+export { foo as default };
+
+// Only one default export allowed per module. (2:0)
+export default {};
+export default function() {};
+
+// `Foo` has already been exported. Exported identifiers must be unique. (2:0)
+export { Foo };
+export class Foo {};
+```
+
+### New Feature (Syntax)
+
+- Add support for computed class property names ([#121](https://github.com/babel/babylon/pull/121)) @motiz88
+
+```js
+// AST
+interface ClassProperty <: Node {
+ type: "ClassProperty";
+ key: Identifier;
+ value: Expression;
+ computed: boolean; // added
+}
+```
+
+```js
+// with "plugins": ["classProperties"]
+class Foo {
+ [x]
+ ['y']
+}
+
+class Bar {
+ [p]
+ [m] () {}
+}
+ ```
+
+### Bug Fix
+
+- Fix `static` property falling through in the declare class Flow AST ([#135](https://github.com/babel/babylon/pull/135)) @danharper
+
+```js
+declare class X {
+ a: number;
+ static b: number; // static
+ c: number; // this was being marked as static in the AST as well
+}
+```
+
+### Polish
+
+- Rephrase "assigning/binding to rvalue" errors to include context ([#119](https://github.com/babel/babylon/pull/119)) @motiz88
+
+```js
+// Used to error with:
+// SyntaxError: Assigning to rvalue (1:0)
+
+// Now:
+// Invalid left-hand side in assignment expression (1:0)
+3 = 4
+
+// Invalid left-hand side in for-in statement (1:5)
+for (+i in {});
+```
+
+### Internal
+
+- Fix call to `this.parseMaybeAssign` with correct arguments ([#133](https://github.com/babel/babylon/pull/133)) @danez
+- Add semver note to changelog ([#131](https://github.com/babel/babylon/pull/131)) @hzoo
+
+## 6.10.0 (2016-09-19)
+
+> We plan to include some spec compliancy bugs in patch versions. An example was the multiple default exports issue.
+
+### Spec Compliancy
+
+* Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
+
+> It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors
+
+More Context: [tc39-notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-29.md#611-the-scope-of-use-strict-with-respect-to-destructuring-in-parameter-lists)
+
+For example:
+
+```js
+// this errors because it uses destructuring and default parameters
+// in a function with a "use strict" directive
+function a([ option1, option2 ] = []) {
+ "use strict";
+}
+ ```
+
+The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to.
+
+### New Feature
+
+* Exact object type annotations for Flow plugin ([#104](https://github.com/babel/babylon/pull/104)) (Basil Hosmer)
+
+Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8
+
+Looks like:
+
+```js
+var a : {| x: number, y: string |} = { x: 0, y: 'foo' };
+```
+
+### Bug Fixes
+
+* Include `typeParameter` location in `ArrowFunctionExpression` ([#126](https://github.com/babel/babylon/pull/126)) (Daniel Tschinder)
+* Error on invalid flow type annotation with default assignment ([#122](https://github.com/babel/babylon/pull/122)) (Dan Harper)
+* Fix Flow return types on arrow functions ([#124](https://github.com/babel/babylon/pull/124)) (Dan Harper)
+
+### Misc
+
+* Add tests for export extensions ([#127](https://github.com/babel/babylon/pull/127)) (Daniel Tschinder)
+* Fix Contributing guidelines [skip ci] (Daniel Tschinder)
+
+## 6.9.2 (2016-09-09)
+
+The only change is to remove the `babel-runtime` dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller.
+
+## 6.9.1 (2016-08-23)
+
+This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for `exponentiationOperator`, `asyncFunctions` and `trailingFunctionCommas` which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops.
+
+### Bug Fixes
+
+- Fix issues with default object params in async functions ([#96](https://github.com/babel/babylon/pull/96)) @danez
+- Fix issues with flow-types and async function ([#95](https://github.com/babel/babylon/pull/95)) @danez
+- Fix arrow functions with destructuring, types & default value ([#94](https://github.com/babel/babylon/pull/94)) @danharper
+- Fix declare class with qualified type identifier ([#97](https://github.com/babel/babylon/pull/97)) @danez
+- Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default ([#98](https://github.com/babel/babylon/pull/98)) @danez
+
+## 6.9.0 (2016-08-16)
+
+### New syntax support
+
+- Add JSX spread children ([#42](https://github.com/babel/babylon/pull/42)) @calebmer
+
+(Be aware that React is not going to support this syntax)
+
+```js
+
+ {...todos.map(todo => )}
+
+```
+
+- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
+
+```js
+declare module "foo" {
+ declare module.exports: {}
+}
+```
+
+### New Features
+
+- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
+- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
+
+### Bug Fixes
+
+- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
+- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
+- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
+- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
+- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
+- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
+- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
+
+### Internal
+
+- Add codecoverage to tests @danez
+- Fix tests to not save expected output if we expect the test to fail @danez
+- Make a shallow clone of babel for testing @danez
+- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
+- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
+- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
+- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
+
+## 6.8.4 (2016-07-06)
+
+### Bug Fixes
+
+- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
+
+## 6.8.3 (2016-07-02)
+
+### Bug Fixes
+
+- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
+
+## 6.8.2 (2016-06-24)
+
+### Bug Fixes
+
+- Fix parse error with yielding jsx elements in generators `function* it() { yield ; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
+- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
+- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
+- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
+- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
+- Support negative numeric type literals @kittens
+- Remove line terminator restriction after await keyword @kittens
+- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
+- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
+- Fix parse error with arrow functions that have flow type parameter declarations `(x: T): T => x;` ([#54](https://github.com/babel/babylon/pull/54)) @gabelevi
+
+### Documentation
+
+- Document AST differences from ESTree ([#41](https://github.com/babel/babylon/pull/41)) @nene
+- Move ast spec from babel/babel ([#46](https://github.com/babel/babylon/pull/46)) @hzoo
+
+### Internal
+
+- Enable skipped tests ([#16](https://github.com/babel/babylon/pull/16)) @danez
+- Add script to test latest version of babylon with babel ([#21](https://github.com/babel/babylon/pull/21)) @danez
+- Upgrade test runner ava @kittens
+- Add missing generate-identifier-regex script @kittens
+- Rename parser context types @kittens
+- Add node v6 to travis testing @hzoo
+- Update to Unicode v9 ([#45](https://github.com/babel/babylon/pull/45)) @mathiasbynens
+
+## 6.8.1 (2016-06-06)
+
+### New Feature
+
+- Parse type parameter declarations with defaults like `type Foo = T`
+
+### Bug Fixes
+- Type parameter declarations need 1 or more type parameters.
+- The existential type `*` is not a valid type parameter.
+- The existential type `*` is a primary type
+
+### Spec Compliancy
+- The param list for type parameter declarations now consists of `TypeParameter` nodes
+- New `TypeParameter` AST Node (replaces using the `Identifier` node before)
+
+```
+interface TypeParameter <: Node {
+ bound: TypeAnnotation;
+ default: TypeAnnotation;
+ name: string;
+ variance: "plus" | "minus";
+}
+```
+
+## 6.8.0 (2016-05-02)
+
+#### New Feature
+
+##### Parse Method Parameter Decorators ([#12](https://github.com/babel/babylon/pull/12))
+
+> [Method Parameter Decorators](https://goo.gl/8MmCMG) is now a TC39 [stage 0 proposal](https://github.com/tc39/ecma262/blob/master/stage0.md).
+
+Examples:
+
+```js
+class Foo {
+ constructor(@foo() x, @bar({ a: 123 }) @baz() y) {}
+}
+
+export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {}
+
+var obj = {
+ method(@foo() x, @bar({ a: 123 }) @baz() y) {}
+};
+```
+
+##### Parse for-await statements (w/ `asyncGenerators` plugin) ([#17](https://github.com/babel/babylon/pull/17))
+
+There is also a new node type, `ForAwaitStatement`.
+
+> [Async generators and for-await](https://github.com/tc39/proposal-async-iteration) are now a [stage 2 proposal](https://github.com/tc39/ecma262#current-proposals).
+
+Example:
+
+```js
+async function f() {
+ for await (let x of y);
+}
+```
diff --git a/node_modules/babylon/LICENSE b/node_modules/babylon/LICENSE
new file mode 100644
index 00000000..d4c7fc58
--- /dev/null
+++ b/node_modules/babylon/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/babylon/README.md b/node_modules/babylon/README.md
new file mode 100644
index 00000000..68c136a8
--- /dev/null
+++ b/node_modules/babylon/README.md
@@ -0,0 +1,120 @@
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Node's domain module for the web browser. This is merely an evented try...catch with the same API as node, nothing more.
+
+
+
+
+
+
+
+
+