From 01a3ae5a1906bc2ce3e20074d4924943b97eba95 Mon Sep 17 00:00:00 2001 From: Andreas Dangel Date: Sat, 25 Apr 2020 18:04:29 +0200 Subject: [PATCH] [javascript] Add a treedump test --- .../lang/ecmascript/ast/JsTreeDumpTest.java | 33 + .../ast/testdata/SimpleJavascriptFile.js | 6 + .../ast/testdata/SimpleJavascriptFile.txt | 20 + .../ast/testdata/jquery-selector.js | 1638 ++++++ .../ast/testdata/jquery-selector.txt | 5219 +++++++++++++++++ 5 files changed, 6916 insertions(+) create mode 100644 pmd-javascript/src/test/java/net/sourceforge/pmd/lang/ecmascript/ast/JsTreeDumpTest.java create mode 100644 pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.js create mode 100644 pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.txt create mode 100644 pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.js create mode 100644 pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.txt diff --git a/pmd-javascript/src/test/java/net/sourceforge/pmd/lang/ecmascript/ast/JsTreeDumpTest.java b/pmd-javascript/src/test/java/net/sourceforge/pmd/lang/ecmascript/ast/JsTreeDumpTest.java new file mode 100644 index 0000000000..862afc6095 --- /dev/null +++ b/pmd-javascript/src/test/java/net/sourceforge/pmd/lang/ecmascript/ast/JsTreeDumpTest.java @@ -0,0 +1,33 @@ +/* + * BSD-style license; for more info see http://pmd.sourceforge.net/license.html + */ + + +package net.sourceforge.pmd.lang.ecmascript.ast; + +import org.junit.Test; + +import net.sourceforge.pmd.lang.ast.test.BaseParsingHelper; +import net.sourceforge.pmd.lang.ast.test.BaseTreeDumpTest; +import net.sourceforge.pmd.lang.ast.test.NodePrintersKt; + +public class JsTreeDumpTest extends BaseTreeDumpTest { + public JsTreeDumpTest() { + super(NodePrintersKt.getSimpleNodePrinter(), ".js"); + } + + @Override + public BaseParsingHelper getParser() { + return JsParsingHelper.DEFAULT.withResourceContext(JsTreeDumpTest.class, "testdata"); + } + + @Test + public void simpleJavascriptFile() { + doTest("SimpleJavascriptFile"); + } + + @Test + public void jquerySelector() { + doTest("jquery-selector"); + } +} diff --git a/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.js b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.js new file mode 100644 index 0000000000..85bded1b96 --- /dev/null +++ b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.js @@ -0,0 +1,6 @@ +var x = 1; +let z = 0; +function foo() { + var y = x + 1; + return y; +} diff --git a/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.txt b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.txt new file mode 100644 index 0000000000..1e3390bb20 --- /dev/null +++ b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/SimpleJavascriptFile.txt @@ -0,0 +1,20 @@ ++- AstRoot + +- VariableDeclaration + | +- VariableInitializer + | +- Name + | +- NumberLiteral + +- VariableDeclaration + | +- VariableInitializer + | +- Name + | +- NumberLiteral + +- FunctionNode + +- Name + +- Block + +- VariableDeclaration + | +- VariableInitializer + | +- Name + | +- InfixExpression + | +- Name + | +- NumberLiteral + +- ReturnStatement + +- Name diff --git a/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.js b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.js new file mode 100644 index 0000000000..c2f0bf10e5 --- /dev/null +++ b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.js @@ -0,0 +1,1638 @@ +// from: https://raw.githubusercontent.com/jquery/jquery/88eb22e0599d546f98f6145c53deb086e1d82857/src/selector.js +import jQuery from "./core.js"; +import nodeName from "./core/nodeName.js"; +import document from "./var/document.js"; +import documentElement from "./var/documentElement.js"; +import indexOf from "./var/indexOf.js"; +import pop from "./var/pop.js"; +import push from "./var/push.js"; +import whitespace from "./selector/var/whitespace.js"; +import rbuggyQSA from "./selector/rbuggyQSA.js"; +import support from "./selector/support.js"; + +// The following utils are attached directly to the jQuery object. +import "./selector/contains.js"; +import "./selector/escapeSelector.js"; +import "./selector/uniqueSort.js"; + +var preferredDoc = document, + matches = documentElement.matches || documentElement.msMatchesSelector; + +( function() { + +var i, + Expr, + outermostContext, + + // Local document vars + document, + documentElement, + documentIsHTML, + + // Instance-specific data + expando = jQuery.expando, + dirruns = 0, + done = 0, + classCache = createCache(), + tokenCache = createCache(), + compilerCache = createCache(), + nonnativeSelectorCache = createCache(), + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" + + "loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram + identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", + + // Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + + whitespace + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + + // 3. anything else (capture 2) + ".*" + + ")\\)|)", + + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter + rwhitespace = new RegExp( whitespace + "+", "g" ), + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), + + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), + rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + + whitespace + "*" ), + rdescend = new RegExp( whitespace + "|>" ), + + rpseudo = new RegExp( pseudos ), + ridentifier = new RegExp( "^" + identifier + "$" ), + + matchExpr = { + ID: new RegExp( "^#(" + identifier + ")" ), + CLASS: new RegExp( "^\\.(" + identifier + ")" ), + TAG: new RegExp( "^(" + identifier + "|[*])" ), + ATTR: new RegExp( "^" + attributes ), + PSEUDO: new RegExp( "^" + pseudos ), + CHILD: new RegExp( + "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), + bool: new RegExp( "^(?:" + booleans + ")$", "i" ), + + // For use in libraries implementing .is() + // We use this for POS matching in `select` + needsContext: new RegExp( "^" + whitespace + + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) + }, + + rinputs = /^(?:input|select|textarea|button)$/i, + rheader = /^h\d$/i, + + // Easily-parseable/retrievable ID or TAG or CLASS selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, + + // CSS escapes + // https://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + + "?|\\\\([^\\r\\n\\f])", "g" ), + funescape = function( escape, nonHex ) { + var high = "0x" + escape.slice( 1 ) - 0x10000; + + if ( nonHex ) { + + // Strip the backslash prefix from a non-hex escape sequence + return nonHex; + } + + // Replace a hexadecimal escape sequence with the encoded Unicode code point + // Support: IE <=11+ + // For values outside the Basic Multilingual Plane (BMP), manually construct a + // surrogate pair + return high < 0 ? + String.fromCharCode( high + 0x10000 ) : + String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); + }, + + // Used for iframes; see `setDocument`. + // Support: IE 9 - 11+, Edge 12 - 18+ + // Removing the function wrapper causes a "Permission Denied" + // error in IE/Edge. + unloadHandler = function() { + setDocument(); + }, + + inDisabledFieldset = addCombinator( + function( elem ) { + return elem.disabled === true && nodeName( elem, "fieldset" ); + }, + { dir: "parentNode", next: "legend" } + ); + +function selectorError( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +} + +function find( selector, context, results, seed ) { + var m, i, elem, nid, match, groups, newSelector, + newContext = context && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or context + if ( typeof selector !== "string" || !selector || + nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { + + return results; + } + + // Try to shortcut find operations (as opposed to filters) in HTML documents + if ( !seed ) { + setDocument( context ); + context = context || document; + + if ( documentIsHTML ) { + + // If the selector is sufficiently simple, try using a "get*By*" DOM method + // (excepting DocumentFragment context, where the methods don't exist) + if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { + + // ID selector + if ( ( m = match[ 1 ] ) ) { + + // Document context + if ( nodeType === 9 ) { + if ( ( elem = context.getElementById( m ) ) ) { + push.call( results, elem ); + } + return results; + + // Element context + } else { + if ( newContext && ( elem = newContext.getElementById( m ) ) && + jQuery.contains( context, elem ) ) { + + push.call( results, elem ); + return results; + } + } + + // Type selector + } else if ( match[ 2 ] ) { + push.apply( results, context.getElementsByTagName( selector ) ); + return results; + + // Class selector + } else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) { + push.apply( results, context.getElementsByClassName( m ) ); + return results; + } + } + + // Take advantage of querySelectorAll + if ( !nonnativeSelectorCache[ selector + " " ] && + ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) { + + newSelector = selector; + newContext = context; + + // qSA considers elements outside a scoping root when evaluating child or + // descendant combinators, which is not what we want. + // In such cases, we work around the behavior by prefixing every selector in the + // list with an ID selector referencing the scope context. + // The technique has to be used as well when a leading combinator is used + // as such selectors are not recognized by querySelectorAll. + // Thanks to Andrew Dupont for this technique. + if ( nodeType === 1 && + ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) { + + // Expand context for sibling selectors + newContext = rsibling.test( selector ) && testContext( context.parentNode ) || + context; + + // We can use :scope instead of the ID hack if the browser + // supports it & if we're not changing the context. + if ( newContext !== context || !support.scope ) { + + // Capture the context ID, setting it first if necessary + if ( ( nid = context.getAttribute( "id" ) ) ) { + nid = jQuery.escapeSelector( nid ); + } else { + context.setAttribute( "id", ( nid = expando ) ); + } + } + + // Prefix every selector in the list + groups = tokenize( selector ); + i = groups.length; + while ( i-- ) { + groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + + toSelector( groups[ i ] ); + } + newSelector = groups.join( "," ); + } + + try { + push.apply( results, + newContext.querySelectorAll( newSelector ) + ); + return results; + } catch ( qsaError ) { + nonnativeSelectorCache( selector, true ); + } finally { + if ( nid === expando ) { + context.removeAttribute( "id" ); + } + } + } + } + } + + // All others + return select( selector.replace( rtrim, "$1" ), context, results, seed ); +} + +/** + * Create key-value caches of limited size + * @returns {function(string, object)} Returns the Object data after storing it on itself with + * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) + * deleting the oldest entry + */ +function createCache() { + var keys = []; + + function cache( key, value ) { + + // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) + if ( keys.push( key + " " ) > Expr.cacheLength ) { + + // Only keep the most recent entries + delete cache[ keys.shift() ]; + } + return ( cache[ key + " " ] = value ); + } + return cache; +} + +/** + * Mark a function for special use by jQuery selector module + * @param {Function} fn The function to mark + */ +function markFunction( fn ) { + fn[ expando ] = true; + return fn; +} + +/** + * Returns a function to use in pseudos for input types + * @param {String} type + */ +function createInputPseudo( type ) { + return function( elem ) { + return nodeName( elem, "input" ) && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for buttons + * @param {String} type + */ +function createButtonPseudo( type ) { + return function( elem ) { + return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) && + elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for :enabled/:disabled + * @param {Boolean} disabled true for :disabled; false for :enabled + */ +function createDisabledPseudo( disabled ) { + + // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable + return function( elem ) { + + // Only certain elements can match :enabled or :disabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled + if ( "form" in elem ) { + + // Check for inherited disabledness on relevant non-disabled elements: + // * listed form-associated elements in a disabled fieldset + // https://html.spec.whatwg.org/multipage/forms.html#category-listed + // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled + // * option elements in a disabled optgroup + // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled + // All such elements have a "form" property. + if ( elem.parentNode && elem.disabled === false ) { + + // Option elements defer to a parent optgroup if present + if ( "label" in elem ) { + if ( "label" in elem.parentNode ) { + return elem.parentNode.disabled === disabled; + } else { + return elem.disabled === disabled; + } + } + + // Support: IE 6 - 11+ + // Use the isDisabled shortcut property to check for disabled fieldset ancestors + return elem.isDisabled === disabled || + + // Where there is no isDisabled, check manually + /* jshint -W018 */ + elem.isDisabled !== !disabled && + inDisabledFieldset( elem ) === disabled; + } + + return elem.disabled === disabled; + + // Try to winnow out elements that can't be disabled before trusting the disabled property. + // Some victims get caught in our net (label, legend, menu, track), but it shouldn't + // even exist on them, let alone have a boolean value. + } else if ( "label" in elem ) { + return elem.disabled === disabled; + } + + // Remaining elements are neither :enabled nor :disabled + return false; + }; +} + +/** + * Returns a function to use in pseudos for positionals + * @param {Function} fn + */ +function createPositionalPseudo( fn ) { + return markFunction( function( argument ) { + argument = +argument; + return markFunction( function( seed, matches ) { + var j, + matchIndexes = fn( [], seed.length, argument ), + i = matchIndexes.length; + + // Match elements found at the specified indexes + while ( i-- ) { + if ( seed[ ( j = matchIndexes[ i ] ) ] ) { + seed[ j ] = !( matches[ j ] = seed[ j ] ); + } + } + } ); + } ); +} + +/** + * Checks a node for validity as a jQuery selector context + * @param {Element|Object=} context + * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value + */ +function testContext( context ) { + return context && typeof context.getElementsByTagName !== "undefined" && context; +} + +/** + * Sets document-related variables once based on the current document + * @param {Element|Object} [node] An element or document object to use to set the document + */ +function setDocument( node ) { + var subWindow, + doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already selected + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( doc == document || doc.nodeType !== 9 ) { + return; + } + + // Update global variables + document = doc; + documentElement = document.documentElement; + documentIsHTML = !jQuery.isXMLDoc( document ); + + // Support: IE 9 - 11+, Edge 12 - 18+ + // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( preferredDoc != document && + ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { + + // Support: IE 9 - 11+, Edge 12 - 18+ + subWindow.addEventListener( "unload", unloadHandler ); + } +} + +find.matches = function( expr, elements ) { + return find( expr, null, null, elements ); +}; + +find.matchesSelector = function( elem, expr ) { + setDocument( elem ); + + if ( documentIsHTML && + !nonnativeSelectorCache[ expr + " " ] && + ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { + + try { + return matches.call( elem, expr ); + } catch ( e ) { + nonnativeSelectorCache( expr, true ); + } + } + + return find( expr, document, null, [ elem ] ).length > 0; +}; + +Expr = jQuery.expr = { + + // Can be adjusted by the user + cacheLength: 50, + + createPseudo: markFunction, + + match: matchExpr, + + find: { + ID: function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var elem = context.getElementById( id ); + return elem ? [ elem ] : []; + } + }, + + TAG: function( tag, context ) { + if ( typeof context.getElementsByTagName !== "undefined" ) { + return context.getElementsByTagName( tag ); + + // DocumentFragment nodes don't have gEBTN + } else { + return context.querySelectorAll( tag ); + } + }, + + CLASS: function( className, context ) { + if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { + return context.getElementsByClassName( className ); + } + } + }, + + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + + preFilter: { + ATTR: function( match ) { + match[ 1 ] = match[ 1 ].replace( runescape, funescape ); + + // Move the given value to match[3] whether quoted or unquoted + match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" ) + .replace( runescape, funescape ); + + if ( match[ 2 ] === "~=" ) { + match[ 3 ] = " " + match[ 3 ] + " "; + } + + return match.slice( 0, 4 ); + }, + + CHILD: function( match ) { + + /* matches from matchExpr["CHILD"] + 1 type (only|nth|...) + 2 what (child|of-type) + 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) + 4 xn-component of xn+y argument ([+-]?\d*n|) + 5 sign of xn-component + 6 x of xn-component + 7 sign of y-component + 8 y of y-component + */ + match[ 1 ] = match[ 1 ].toLowerCase(); + + if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { + + // nth-* requires argument + if ( !match[ 3 ] ) { + selectorError( match[ 0 ] ); + } + + // numeric x and y parameters for Expr.filter.CHILD + // remember that false/true cast respectively to 0/1 + match[ 4 ] = +( match[ 4 ] ? + match[ 5 ] + ( match[ 6 ] || 1 ) : + 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) + ); + match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); + + // other types prohibit arguments + } else if ( match[ 3 ] ) { + selectorError( match[ 0 ] ); + } + + return match; + }, + + PSEUDO: function( match ) { + var excess, + unquoted = !match[ 6 ] && match[ 2 ]; + + if ( matchExpr.CHILD.test( match[ 0 ] ) ) { + return null; + } + + // Accept quoted arguments as-is + if ( match[ 3 ] ) { + match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; + + // Strip excess characters from unquoted arguments + } else if ( unquoted && rpseudo.test( unquoted ) && + + // Get excess from tokenize (recursively) + ( excess = tokenize( unquoted, true ) ) && + + // advance to the next closing parenthesis + ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { + + // excess is a negative index + match[ 0 ] = match[ 0 ].slice( 0, excess ); + match[ 2 ] = unquoted.slice( 0, excess ); + } + + // Return only captures needed by the pseudo filter method (type and argument) + return match.slice( 0, 3 ); + } + }, + + filter: { + ID: function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + return elem.getAttribute( "id" ) === attrId; + }; + }, + + TAG: function( nodeNameSelector ) { + var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); + return nodeNameSelector === "*" ? + function() { + return true; +} : + function( elem ) { + return nodeName( elem, expectedNodeName ); + }; + }, + + CLASS: function( className ) { + var pattern = classCache[ className + " " ]; + + return pattern || + ( pattern = new RegExp( "(^|" + whitespace + ")" + className + + "(" + whitespace + "|$)" ) ) && + classCache( className, function( elem ) { + return pattern.test( + typeof elem.className === "string" && elem.className || + typeof elem.getAttribute !== "undefined" && + elem.getAttribute( "class" ) || + "" + ); + } ); + }, + + ATTR: function( name, operator, check ) { + return function( elem ) { + var result = jQuery.attr( elem, name ); + + if ( result == null ) { + return operator === "!="; + } + if ( !operator ) { + return true; + } + + result += ""; + + if ( operator === "=" ) { + return result === check; + } + if ( operator === "!=" ) { + return result !== check; + } + if ( operator === "^=" ) { + return check && result.indexOf( check ) === 0; + } + if ( operator === "*=" ) { + return check && result.indexOf( check ) > -1; + } + if ( operator === "$=" ) { + return check && result.slice( -check.length ) === check; + } + if ( operator === "~=" ) { + return ( " " + result.replace( rwhitespace, " " ) + " " ) + .indexOf( check ) > -1; + } + if ( operator === "|=" ) { + return result === check || result.slice( 0, check.length + 1 ) === check + "-"; + } + + return false; + }; + }, + + CHILD: function( type, what, _argument, first, last ) { + var simple = type.slice( 0, 3 ) !== "nth", + forward = type.slice( -4 ) !== "last", + ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function( elem ) { + return !!elem.parentNode; + } : + + function( elem, _context, xml ) { + var cache, outerCache, node, nodeIndex, start, + dir = simple !== forward ? "nextSibling" : "previousSibling", + parent = elem.parentNode, + name = ofType && elem.nodeName.toLowerCase(), + useCache = !xml && !ofType, + diff = false; + + if ( parent ) { + + // :(first|last|only)-(child|of-type) + if ( simple ) { + while ( dir ) { + node = elem; + while ( ( node = node[ dir ] ) ) { + if ( ofType ? + nodeName( node, name ) : + node.nodeType === 1 ) { + + return false; + } + } + + // Reverse direction for :only-* (if we haven't yet done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) stores cache data on `parent` + if ( forward && useCache ) { + + // Seek `elem` from a previously-cached index + outerCache = parent[ expando ] || ( parent[ expando ] = {} ); + cache = outerCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex && cache[ 2 ]; + node = nodeIndex && parent.childNodes[ nodeIndex ]; + + while ( ( node = ++nodeIndex && node && node[ dir ] || + + // Fallback to seeking `elem` from the start + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + // When found, cache indexes on `parent` and break + if ( node.nodeType === 1 && ++diff && node === elem ) { + outerCache[ type ] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + + // Use previously-cached element index if available + if ( useCache ) { + outerCache = elem[ expando ] || ( elem[ expando ] = {} ); + cache = outerCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or :nth-last-child(...) or :nth(-last)?-of-type(...) + if ( diff === false ) { + + // Use the same loop as above to seek `elem` from the start + while ( ( node = ++nodeIndex && node && node[ dir ] || + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + if ( ( ofType ? + nodeName( node, name ) : + node.nodeType === 1 ) && + ++diff ) { + + // Cache the index of each encountered element + if ( useCache ) { + outerCache = node[ expando ] || + ( node[ expando ] = {} ); + outerCache[ type ] = [ dirruns, diff ]; + } + + if ( node === elem ) { + break; + } + } + } + } + } + + // Incorporate the offset, then check against cycle size + diff -= last; + return diff === first || ( diff % first === 0 && diff / first >= 0 ); + } + }; + }, + + PSEUDO: function( pseudo, argument ) { + + // pseudo-class names are case-insensitive + // https://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters + // Remember that setFilters inherits from pseudos + var args, + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || + selectorError( "unsupported pseudo: " + pseudo ); + + // The user may use createPseudo to indicate that + // arguments are needed to create the filter function + // just as jQuery does + if ( fn[ expando ] ) { + return fn( argument ); + } + + // But maintain support for old signatures + if ( fn.length > 1 ) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? + markFunction( function( seed, matches ) { + var idx, + matched = fn( seed, argument ), + i = matched.length; + while ( i-- ) { + idx = indexOf.call( seed, matched[ i ] ); + seed[ idx ] = !( matches[ idx ] = matched[ i ] ); + } + } ) : + function( elem ) { + return fn( elem, 0, args ); + }; + } + + return fn; + } + }, + + pseudos: { + + // Potentially complex pseudos + not: markFunction( function( selector ) { + + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], + results = [], + matcher = compile( selector.replace( rtrim, "$1" ) ); + + return matcher[ expando ] ? + markFunction( function( seed, matches, _context, xml ) { + var elem, + unmatched = matcher( seed, null, xml, [] ), + i = seed.length; + + // Match elements unmatched by `matcher` + while ( i-- ) { + if ( ( elem = unmatched[ i ] ) ) { + seed[ i ] = !( matches[ i ] = elem ); + } + } + } ) : + function( elem, _context, xml ) { + input[ 0 ] = elem; + matcher( input, null, xml, results ); + + // Don't keep the element (issue #299) + input[ 0 ] = null; + return !results.pop(); + }; + } ), + + has: markFunction( function( selector ) { + return function( elem ) { + return find( selector, elem ).length > 0; + }; + } ), + + contains: markFunction( function( text ) { + text = text.replace( runescape, funescape ); + return function( elem ) { + return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1; + }; + } ), + + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // https://www.w3.org/TR/selectors/#lang-pseudo + lang: markFunction( function( lang ) { + + // lang value must be a valid identifier + if ( !ridentifier.test( lang || "" ) ) { + selectorError( "unsupported lang: " + lang ); + } + lang = lang.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + var elemLang; + do { + if ( ( elemLang = documentIsHTML ? + elem.lang : + elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; + } + } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); + return false; + }; + } ), + + // Miscellaneous + target: function( elem ) { + var hash = window.location && window.location.hash; + return hash && hash.slice( 1 ) === elem.id; + }, + + root: function( elem ) { + return elem === documentElement; + }, + + focus: function( elem ) { + return elem === document.activeElement && + document.hasFocus() && + !!( elem.type || elem.href || ~elem.tabIndex ); + }, + + // Boolean properties + enabled: createDisabledPseudo( false ), + disabled: createDisabledPseudo( true ), + + checked: function( elem ) { + + // In CSS3, :checked should return both checked and selected elements + // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + return ( nodeName( elem, "input" ) && !!elem.checked ) || + ( nodeName( elem, "option" ) && !!elem.selected ); + }, + + selected: function( elem ) { + + // Support: IE <=11+ + // Accessing the selectedIndex property + // forces the browser to treat the default option as + // selected when in an optgroup. + if ( elem.parentNode ) { + // eslint-disable-next-line no-unused-expressions + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + empty: function( elem ) { + + // https://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), + // but not by others (comment: 8; processing instruction: 7; etc.) + // nodeType < 6 works because attributes (2) do not appear as children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + if ( elem.nodeType < 6 ) { + return false; + } + } + return true; + }, + + parent: function( elem ) { + return !Expr.pseudos.empty( elem ); + }, + + // Element/input types + header: function( elem ) { + return rheader.test( elem.nodeName ); + }, + + input: function( elem ) { + return rinputs.test( elem.nodeName ); + }, + + button: function( elem ) { + return nodeName( elem, "input" ) && elem.type === "button" || + nodeName( elem, "button" ); + }, + + text: function( elem ) { + return nodeName( elem, "input" ) && elem.type === "text"; + }, + + // Position-in-collection + first: createPositionalPseudo( function() { + return [ 0 ]; + } ), + + last: createPositionalPseudo( function( _matchIndexes, length ) { + return [ length - 1 ]; + } ), + + eq: createPositionalPseudo( function( _matchIndexes, length, argument ) { + return [ argument < 0 ? argument + length : argument ]; + } ), + + even: createPositionalPseudo( function( matchIndexes, length ) { + var i = 0; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + odd: createPositionalPseudo( function( matchIndexes, length ) { + var i = 1; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + lt: createPositionalPseudo( function( matchIndexes, length, argument ) { + var i; + + if ( argument < 0 ) { + i = argument + length; + } else if ( argument > length ) { + i = length; + } else { + i = argument; + } + + for ( ; --i >= 0; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + gt: createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; ++i < length; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ) + } +}; + +Expr.pseudos.nth = Expr.pseudos.eq; + +// Add button/input type pseudos +for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { + Expr.pseudos[ i ] = createInputPseudo( i ); +} +for ( i in { submit: true, reset: true } ) { + Expr.pseudos[ i ] = createButtonPseudo( i ); +} + +// Easy API for creating new setFilters +function setFilters() {} +setFilters.prototype = Expr.filters = Expr.pseudos; +Expr.setFilters = new setFilters(); + +function tokenize( selector, parseOnly ) { + var matched, match, tokens, type, + soFar, groups, preFilters, + cached = tokenCache[ selector + " " ]; + + if ( cached ) { + return parseOnly ? 0 : cached.slice( 0 ); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while ( soFar ) { + + // Comma and first run + if ( !matched || ( match = rcomma.exec( soFar ) ) ) { + if ( match ) { + + // Don't consume trailing commas as valid + soFar = soFar.slice( match[ 0 ].length ) || soFar; + } + groups.push( ( tokens = [] ) ); + } + + matched = false; + + // Combinators + if ( ( match = rcombinators.exec( soFar ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + + // Cast descendant combinators to space + type: match[ 0 ].replace( rtrim, " " ) + } ); + soFar = soFar.slice( matched.length ); + } + + // Filters + for ( type in Expr.filter ) { + if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || + ( match = preFilters[ type ]( match ) ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + type: type, + matches: match + } ); + soFar = soFar.slice( matched.length ); + } + } + + if ( !matched ) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + if ( parseOnly ) { + return soFar.length; + } + + return soFar ? + selectorError( selector ) : + + // Cache the tokens + tokenCache( selector, groups ).slice( 0 ); +} + +function toSelector( tokens ) { + var i = 0, + len = tokens.length, + selector = ""; + for ( ; i < len; i++ ) { + selector += tokens[ i ].value; + } + return selector; +} + +function addCombinator( matcher, combinator, base ) { + var dir = combinator.dir, + skip = combinator.next, + key = skip || dir, + checkNonElements = base && key === "parentNode", + doneName = done++; + + return combinator.first ? + + // Check against closest ancestor/preceding element + function( elem, context, xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + return matcher( elem, context, xml ); + } + } + return false; + } : + + // Check against all ancestor/preceding elements + function( elem, context, xml ) { + var oldCache, outerCache, + newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching + if ( xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + if ( matcher( elem, context, xml ) ) { + return true; + } + } + } + } else { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + outerCache = elem[ expando ] || ( elem[ expando ] = {} ); + + if ( skip && nodeName( elem, skip ) ) { + elem = elem[ dir ] || elem; + } else if ( ( oldCache = outerCache[ key ] ) && + oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { + + // Assign to newCache so results back-propagate to previous elements + return ( newCache[ 2 ] = oldCache[ 2 ] ); + } else { + + // Reuse newcache so results back-propagate to previous elements + outerCache[ key ] = newCache; + + // A match means we're done; a fail means we have to keep checking + if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { + return true; + } + } + } + } + } + return false; + }; +} + +function elementMatcher( matchers ) { + return matchers.length > 1 ? + function( elem, context, xml ) { + var i = matchers.length; + while ( i-- ) { + if ( !matchers[ i ]( elem, context, xml ) ) { + return false; + } + } + return true; + } : + matchers[ 0 ]; +} + +function multipleContexts( selector, contexts, results ) { + var i = 0, + len = contexts.length; + for ( ; i < len; i++ ) { + find( selector, contexts[ i ], results ); + } + return results; +} + +function condense( unmatched, map, filter, context, xml ) { + var elem, + newUnmatched = [], + i = 0, + len = unmatched.length, + mapped = map != null; + + for ( ; i < len; i++ ) { + if ( ( elem = unmatched[ i ] ) ) { + if ( !filter || filter( elem, context, xml ) ) { + newUnmatched.push( elem ); + if ( mapped ) { + map.push( i ); + } + } + } + } + + return newUnmatched; +} + +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { + if ( postFilter && !postFilter[ expando ] ) { + postFilter = setMatcher( postFilter ); + } + if ( postFinder && !postFinder[ expando ] ) { + postFinder = setMatcher( postFinder, postSelector ); + } + return markFunction( function( seed, results, context, xml ) { + var temp, i, elem, matcherOut, + preMap = [], + postMap = [], + preexisting = results.length, + + // Get initial elements from seed or context + elems = seed || + multipleContexts( selector || "*", + context.nodeType ? [ context ] : context, [] ), + + // Prefilter to get matcher input, preserving a map for seed-results synchronization + matcherIn = preFilter && ( seed || !selector ) ? + condense( elems, preMap, preFilter, context, xml ) : + elems; + + if ( matcher ) { + + // If we have a postFinder, or filtered seed, or non-seed postFilter + // or preexisting results, + matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results; + + // Find primary matches + matcher( matcherIn, matcherOut, context, xml ); + } else { + matcherOut = matcherIn; + } + + // Apply postFilter + if ( postFilter ) { + temp = condense( matcherOut, postMap ); + postFilter( temp, [], context, xml ); + + // Un-match failing elements by moving them back to matcherIn + i = temp.length; + while ( i-- ) { + if ( ( elem = temp[ i ] ) ) { + matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); + } + } + } + + if ( seed ) { + if ( postFinder || preFilter ) { + if ( postFinder ) { + + // Get the final matcherOut by condensing this intermediate into postFinder contexts + temp = []; + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) ) { + + // Restore matcherIn since elem is not yet a final match + temp.push( ( matcherIn[ i ] = elem ) ); + } + } + postFinder( null, ( matcherOut = [] ), temp, xml ); + } + + // Move matched elements from seed to results to keep them synchronized + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) && + ( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) { + + seed[ temp ] = !( results[ temp ] = elem ); + } + } + } + + // Add elements to results, through postFinder if defined + } else { + matcherOut = condense( + matcherOut === results ? + matcherOut.splice( preexisting, matcherOut.length ) : + matcherOut + ); + if ( postFinder ) { + postFinder( null, results, matcherOut, xml ); + } else { + push.apply( results, matcherOut ); + } + } + } ); +} + +function matcherFromTokens( tokens ) { + var checkContext, matcher, j, + len = tokens.length, + leadingRelative = Expr.relative[ tokens[ 0 ].type ], + implicitRelative = leadingRelative || Expr.relative[ " " ], + i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements are reachable from top-level context(s) + matchContext = addCombinator( function( elem ) { + return elem === checkContext; + }, implicitRelative, true ), + matchAnyContext = addCombinator( function( elem ) { + return indexOf.call( checkContext, elem ) > -1; + }, implicitRelative, true ), + matchers = [ function( elem, context, xml ) { + var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( + ( checkContext = context ).nodeType ? + matchContext( elem, context, xml ) : + matchAnyContext( elem, context, xml ) ); + + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for ( ; i < len; i++ ) { + if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { + matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; + } else { + matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); + + // Return special upon seeing a positional matcher + if ( matcher[ expando ] ) { + + // Find the next relative operator (if any) for proper handling + j = ++i; + for ( ; j < len; j++ ) { + if ( Expr.relative[ tokens[ j ].type ] ) { + break; + } + } + return setMatcher( + i > 1 && elementMatcher( matchers ), + i > 1 && toSelector( + + // If the preceding token was a descendant combinator, insert an implicit any-element `*` + tokens.slice( 0, i - 1 ) + .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) + ).replace( rtrim, "$1" ), + matcher, + i < j && matcherFromTokens( tokens.slice( i, j ) ), + j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), + j < len && toSelector( tokens ) + ); + } + matchers.push( matcher ); + } + } + + return elementMatcher( matchers ); +} + +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { + var bySet = setMatchers.length > 0, + byElement = elementMatchers.length > 0, + superMatcher = function( seed, context, xml, results, outermost ) { + var elem, j, matcher, + matchedCount = 0, + i = "0", + unmatched = seed && [], + setMatched = [], + contextBackup = outermostContext, + + // We must always have either seed elements or outermost context + elems = seed || byElement && Expr.find.TAG( "*", outermost ), + + // Use integer dirruns iff this is the outermost matcher + dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ); + + if ( outermost ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + outermostContext = context == document || context || outermost; + } + + // Add elements passing elementMatchers directly to results + for ( ; ( elem = elems[ i ] ) != null; i++ ) { + if ( byElement && elem ) { + j = 0; + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( !context && elem.ownerDocument != document ) { + setDocument( elem ); + xml = !documentIsHTML; + } + while ( ( matcher = elementMatchers[ j++ ] ) ) { + if ( matcher( elem, context || document, xml ) ) { + push.call( results, elem ); + break; + } + } + if ( outermost ) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if ( bySet ) { + + // They will have gone through all possible matchers + if ( ( elem = !matcher && elem ) ) { + matchedCount--; + } + + // Lengthen the array for every element, matched or not + if ( seed ) { + unmatched.push( elem ); + } + } + } + + // `i` is now the count of elements visited above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that + // case, which will result in a "00" `matchedCount` that differs from `i` but is also + // numerically zero. + if ( bySet && i !== matchedCount ) { + j = 0; + while ( ( matcher = setMatchers[ j++ ] ) ) { + matcher( unmatched, setMatched, context, xml ); + } + + if ( seed ) { + + // Reintegrate element matches to eliminate the need for sorting + if ( matchedCount > 0 ) { + while ( i-- ) { + if ( !( unmatched[ i ] || setMatched[ i ] ) ) { + setMatched[ i ] = pop.call( results ); + } + } + } + + // Discard index placeholder values to get only actual matches + setMatched = condense( setMatched ); + } + + // Add matches to results + push.apply( results, setMatched ); + + // Seedless set matches succeeding multiple successful matchers stipulate sorting + if ( outermost && !seed && setMatched.length > 0 && + ( matchedCount + setMatchers.length ) > 1 ) { + + jQuery.uniqueSort( results ); + } + } + + // Override manipulation of globals by nested matchers + if ( outermost ) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? + markFunction( superMatcher ) : + superMatcher; +} + +function compile( selector, match /* Internal Use Only */ ) { + var i, + setMatchers = [], + elementMatchers = [], + cached = compilerCache[ selector + " " ]; + + if ( !cached ) { + + // Generate a function of recursive functions that can be used to check each element + if ( !match ) { + match = tokenize( selector ); + } + i = match.length; + while ( i-- ) { + cached = matcherFromTokens( match[ i ] ); + if ( cached[ expando ] ) { + setMatchers.push( cached ); + } else { + elementMatchers.push( cached ); + } + } + + // Cache the compiled function + cached = compilerCache( selector, + matcherFromGroupMatchers( elementMatchers, setMatchers ) ); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; +} + +/** + * A low-level selection function that works with jQuery's compiled + * selector functions + * @param {String|Function} selector A selector or a pre-compiled + * selector function built with jQuery selector compile + * @param {Element} context + * @param {Array} [results] + * @param {Array} [seed] A set of elements to match against + */ +function select( selector, context, results, seed ) { + var i, tokens, token, type, find, + compiled = typeof selector === "function" && selector, + match = !seed && tokenize( ( selector = compiled.selector || selector ) ); + + results = results || []; + + // Try to minimize operations if there is only one selector in the list and no seed + // (the latter of which guarantees us context) + if ( match.length === 1 ) { + + // Reduce context if the leading compound selector is an ID + tokens = match[ 0 ] = match[ 0 ].slice( 0 ); + if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && + context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { + + context = ( Expr.find.ID( + token.matches[ 0 ].replace( runescape, funescape ), + context + ) || [] )[ 0 ]; + if ( !context ) { + return results; + + // Precompiled matchers will still verify ancestry, so step up a level + } else if ( compiled ) { + context = context.parentNode; + } + + selector = selector.slice( tokens.shift().value.length ); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length; + while ( i-- ) { + token = tokens[ i ]; + + // Abort if we hit a combinator + if ( Expr.relative[ ( type = token.type ) ] ) { + break; + } + if ( ( find = Expr.find[ type ] ) ) { + + // Search, expanding context for leading sibling combinators + if ( ( seed = find( + token.matches[ 0 ].replace( runescape, funescape ), + rsibling.test( tokens[ 0 ].type ) && + testContext( context.parentNode ) || context + ) ) ) { + + // If seed is empty or no tokens remain, we can return early + tokens.splice( i, 1 ); + selector = seed.length && toSelector( tokens ); + if ( !selector ) { + push.apply( results, seed ); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one is not provided + // Provide `match` to avoid retokenization if we modified the selector above + ( compiled || compile( selector, match ) )( + seed, + context, + !documentIsHTML, + results, + !context || rsibling.test( selector ) && testContext( context.parentNode ) || context + ); + return results; +} + +// Initialize against the default document +setDocument(); + +jQuery.find = find; + +} )(); diff --git a/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.txt b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.txt new file mode 100644 index 0000000000..92588d6387 --- /dev/null +++ b/pmd-javascript/src/test/resources/net/sourceforge/pmd/lang/ecmascript/ast/testdata/jquery-selector.txt @@ -0,0 +1,5219 @@ ++- AstRoot + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- EmptyStatement + +- VariableDeclaration + | +- VariableInitializer + | | +- Name + | | +- Name + | +- VariableInitializer + | +- Name + | +- InfixExpression + | +- PropertyGet + | | +- Name + | | +- Name + | +- PropertyGet + | +- Name + | +- Name + +- ExpressionStatement + +- FunctionCall + +- ParenthesizedExpression + +- FunctionNode + +- Block + +- VariableDeclaration + | +- VariableInitializer + | | +- Name + | +- VariableInitializer + | | +- Name + | +- VariableInitializer + | | +- Name + | +- VariableInitializer + | | +- Name + | +- VariableInitializer + | | +- Name + | +- VariableInitializer + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- NumberLiteral + | +- VariableInitializer + | | +- Name + | | +- NumberLiteral + | +- VariableInitializer + | | +- Name + | | +- FunctionCall + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- FunctionCall + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- FunctionCall + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- FunctionCall + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- InfixExpression + | | +- StringLiteral + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- InfixExpression + | | | | | | | | +- InfixExpression + | | | | | | | | | +- InfixExpression + | | | | | | | | | | +- InfixExpression + | | | | | | | | | | | +- InfixExpression + | | | | | | | | | | | | +- InfixExpression + | | | | | | | | | | | | | +- StringLiteral + | | | | | | | | | | | | | +- Name + | | | | | | | | | | | | +- StringLiteral + | | | | | | | | | | | +- Name + | | | | | | | | | | +- StringLiteral + | | | | | | | | | +- Name + | | | | | | | | +- StringLiteral + | | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- InfixExpression + | | | | | | | | +- InfixExpression + | | | | | | | | | +- StringLiteral + | | | | | | | | | +- Name + | | | | | | | | +- StringLiteral + | | | | | | | +- StringLiteral + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- StringLiteral + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | | +- Name + | | | +- StringLiteral + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- StringLiteral + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Name + | | | +- StringLiteral + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- StringLiteral + | | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | +- Name + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- Name + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- ObjectLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- StringLiteral + | | | | +- Name + | | | +- StringLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- StringLiteral + | | | | +- Name + | | | +- StringLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- StringLiteral + | | | | +- Name + | | | +- StringLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- InfixExpression + | | | | | | | | +- InfixExpression + | | | | | | | | | +- InfixExpression + | | | | | | | | | | +- InfixExpression + | | | | | | | | | | | +- StringLiteral + | | | | | | | | | | | +- Name + | | | | | | | | | | +- StringLiteral + | | | | | | | | | +- Name + | | | | | | | | +- StringLiteral + | | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- StringLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- NewExpression + | | | +- Name + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- StringLiteral + | | +- ObjectProperty + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- InfixExpression + | | | | | | | | +- StringLiteral + | | | | | | | | +- Name + | | | | | | | +- StringLiteral + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Name + | | | +- StringLiteral + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- RegExpLiteral + | +- VariableInitializer + | | +- Name + | | +- RegExpLiteral + | +- VariableInitializer + | | +- Name + | | +- RegExpLiteral + | +- VariableInitializer + | | +- Name + | | +- RegExpLiteral + | +- VariableInitializer + | | +- Name + | | +- NewExpression + | | +- Name + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- StringLiteral + | | | | +- Name + | | | +- StringLiteral + | | +- StringLiteral + | +- VariableInitializer + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- StringLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- NumberLiteral + | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- ReturnStatement + | | | +- Name + | | +- ReturnStatement + | | +- ConditionalExpression + | | +- InfixExpression + | | | +- Name + | | | +- NumberLiteral + | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- NumberLiteral + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- NumberLiteral + | | | +- NumberLiteral + | | +- InfixExpression + | | +- InfixExpression + | | | +- Name + | | | +- NumberLiteral + | | +- NumberLiteral + | +- VariableInitializer + | | +- Name + | | +- FunctionNode + | | +- Block + | | +- ExpressionStatement + | | +- FunctionCall + | | +- Name + | +- VariableInitializer + | +- Name + | +- FunctionCall + | +- Name + | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- KeywordLiteral + | | +- FunctionCall + | | +- Name + | | +- Name + | | +- StringLiteral + | +- ObjectLiteral + | +- ObjectProperty + | | +- Name + | | +- StringLiteral + | +- ObjectProperty + | +- Name + | +- StringLiteral + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ThrowStatement + | +- NewExpression + | +- Name + | +- InfixExpression + | +- StringLiteral + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- ConditionalExpression + | | +- Name + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- NumberLiteral + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- InfixExpression + | | +- Name + | | +- ArrayLiteral + | +- IfStatement + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- StringLiteral + | | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- NumberLiteral + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- NumberLiteral + | | | +- InfixExpression + | | | +- Name + | | | +- NumberLiteral + | | +- Scope + | | +- ReturnStatement + | | +- Name + | +- IfStatement + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- IfStatement + | | +- Name + | | +- Scope + | | +- IfStatement + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Scope + | | | | | +- IfStatement + | | | | | | +- ParenthesizedExpression + | | | | | | | +- Assignment + | | | | | | | +- Name + | | | | | | | +- FunctionCall + | | | | | | | +- PropertyGet + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Scope + | | | | | | +- ExpressionStatement + | | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- ReturnStatement + | | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- Name + | | | | +- ReturnStatement + | | | | +- Name + | | | +- IfStatement + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | | +- ExpressionStatement + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- ReturnStatement + | | | | +- Name + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- Name + | | +- IfStatement + | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- ElementGet + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- ParenthesizedExpression + | | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- Name + | | | +- UnaryExpression + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- ParenthesizedExpression + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- UnaryExpression + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- StringLiteral + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- WhileLoop + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- ParenthesizedExpression + | | | | | | +- ConditionalExpression + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | | +- StringLiteral + | | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- StringLiteral + | | | | +- FunctionCall + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- StringLiteral + | | +- TryStatement + | | +- Scope + | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- Name + | | +- CatchClause + | | | +- Name + | | | +- Block + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- KeywordLiteral + | | +- Scope + | | +- IfStatement + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- StringLiteral + | +- ReturnStatement + | +- FunctionCall + | +- Name + | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | | +- StringLiteral + | +- Name + | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | +- Name + | | +- ArrayLiteral + | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- IfStatement + | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- UnaryExpression + | | | +- ElementGet + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- ParenthesizedExpression + | | +- Assignment + | | +- ElementGet + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- StringLiteral + | | +- Name + | +- ReturnStatement + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ExpressionStatement + | | +- Assignment + | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- KeywordLiteral + | +- ReturnStatement + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- FunctionNode + | +- Name + | +- Block + | +- ReturnStatement + | +- InfixExpression + | +- FunctionCall + | | +- Name + | | +- Name + | | +- StringLiteral + | +- InfixExpression + | +- PropertyGet + | | +- Name + | | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- FunctionNode + | +- Name + | +- Block + | +- ReturnStatement + | +- InfixExpression + | +- ParenthesizedExpression + | | +- InfixExpression + | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- StringLiteral + | | +- FunctionCall + | | +- Name + | | +- Name + | | +- StringLiteral + | +- InfixExpression + | +- PropertyGet + | | +- Name + | | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- FunctionNode + | +- Name + | +- Block + | +- IfStatement + | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- Scope + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- KeywordLiteral + | | | | +- Scope + | | | | +- IfStatement + | | | | | +- InfixExpression + | | | | | | +- StringLiteral + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- IfStatement + | | | | | +- InfixExpression + | | | | | | +- StringLiteral + | | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | | +- ReturnStatement + | | | | | | +- InfixExpression + | | | | | | +- PropertyGet + | | | | | | | +- PropertyGet + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- ReturnStatement + | | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- IfStatement + | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- Scope + | | +- ReturnStatement + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- KeywordLiteral + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- FunctionCall + | +- Name + | +- FunctionNode + | +- Name + | +- Block + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- UnaryExpression + | | +- Name + | +- ReturnStatement + | +- FunctionCall + | +- Name + | +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- ArrayLiteral + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- WhileLoop + | +- UnaryExpression + | | +- Name + | +- Scope + | +- IfStatement + | +- ElementGet + | | +- Name + | | +- ParenthesizedExpression + | | +- Assignment + | | +- Name + | | +- ElementGet + | | +- Name + | | +- Name + | +- Scope + | +- ExpressionStatement + | +- Assignment + | +- ElementGet + | | +- Name + | | +- Name + | +- UnaryExpression + | +- ParenthesizedExpression + | +- Assignment + | +- ElementGet + | | +- Name + | | +- Name + | +- ElementGet + | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- InfixExpression + | +- Name + | +- InfixExpression + | +- InfixExpression + | | +- UnaryExpression + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- StringLiteral + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- ConditionalExpression + | | +- Name + | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Name + | +- IfStatement + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- Scope + | | +- ReturnStatement + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- Name + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- UnaryExpression + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- IfStatement + | +- InfixExpression + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- InfixExpression + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- Scope + | +- ExpressionStatement + | +- FunctionCall + | +- PropertyGet + | | +- Name + | | +- Name + | +- StringLiteral + | +- Name + +- ExpressionStatement + | +- Assignment + | +- PropertyGet + | | +- Name + | | +- Name + | +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- FunctionCall + | +- Name + | +- Name + | +- KeywordLiteral + | +- KeywordLiteral + | +- Name + +- ExpressionStatement + | +- Assignment + | +- PropertyGet + | | +- Name + | | +- Name + | +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ExpressionStatement + | | +- FunctionCall + | | +- Name + | | +- Name + | +- IfStatement + | | +- InfixExpression + | | | +- Name + | | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- ElementGet + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- ParenthesizedExpression + | | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- Name + | | | +- UnaryExpression + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Scope + | | +- TryStatement + | | +- Scope + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- Name + | | +- CatchClause + | | +- Name + | | +- Block + | | +- ExpressionStatement + | | +- FunctionCall + | | +- Name + | | +- Name + | | +- KeywordLiteral + | +- ReturnStatement + | +- InfixExpression + | +- PropertyGet + | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- KeywordLiteral + | | | +- ArrayLiteral + | | | +- Name + | | +- Name + | +- NumberLiteral + +- ExpressionStatement + | +- Assignment + | +- Name + | +- Assignment + | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectLiteral + | +- ObjectProperty + | | +- Name + | | +- NumberLiteral + | +- ObjectProperty + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- ObjectLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Name + | | | +- Block + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- UnaryExpression + | | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Name + | | | +- Scope + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- ConditionalExpression + | | | +- Name + | | | +- ArrayLiteral + | | | | +- Name + | | | +- ArrayLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Name + | | | +- Block + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Scope + | | | | +- ReturnStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Block + | | +- IfStatement + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | +- Scope + | | +- ReturnStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- ObjectLiteral + | | +- ObjectProperty + | | | +- StringLiteral + | | | +- ObjectLiteral + | | | +- ObjectProperty + | | | | +- Name + | | | | +- StringLiteral + | | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | | +- StringLiteral + | | | +- ObjectLiteral + | | | +- ObjectProperty + | | | +- Name + | | | +- StringLiteral + | | +- ObjectProperty + | | | +- StringLiteral + | | | +- ObjectLiteral + | | | +- ObjectProperty + | | | | +- Name + | | | | +- StringLiteral + | | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | +- StringLiteral + | | +- ObjectLiteral + | | +- ObjectProperty + | | +- Name + | | +- StringLiteral + | +- ObjectProperty + | | +- Name + | | +- ObjectLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- ParenthesizedExpression + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- StringLiteral + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- StringLiteral + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | | +- NumberLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- ElementGet + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | | +- NumberLiteral + | | | | | +- StringLiteral + | | | | +- Scope + | | | | | +- IfStatement + | | | | | | +- UnaryExpression + | | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- Scope + | | | | | | +- ExpressionStatement + | | | | | | +- FunctionCall + | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- UnaryExpression + | | | | | | +- ParenthesizedExpression + | | | | | | +- ConditionalExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- InfixExpression + | | | | | | | +- ElementGet + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- ParenthesizedExpression + | | | | | | | +- InfixExpression + | | | | | | | +- ElementGet + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- NumberLiteral + | | | | | | +- InfixExpression + | | | | | | +- NumberLiteral + | | | | | | +- ParenthesizedExpression + | | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- ElementGet + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- StringLiteral + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- StringLiteral + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- UnaryExpression + | | | | | +- ParenthesizedExpression + | | | | | +- InfixExpression + | | | | | +- ParenthesizedExpression + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- InfixExpression + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- StringLiteral + | | | | +- IfStatement + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- ReturnStatement + | | | +- Name + | | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | | +- Name + | | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- ElementGet + | | | +- Name + | | | +- NumberLiteral + | | +- IfStatement + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | +- ReturnStatement + | | | +- KeywordLiteral + | | +- IfStatement + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- StringLiteral + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- Name + | | | | | +- Name + | | | | | +- KeywordLiteral + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Name + | | | | +- NumberLiteral + | | | | +- Name + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | | +- Name + | | +- ReturnStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- NumberLiteral + | | +- NumberLiteral + | +- ObjectProperty + | | +- Name + | | +- ObjectLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- ReturnStatement + | | | +- InfixExpression + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- ConditionalExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- FunctionNode + | | | | +- Block + | | | | +- ReturnStatement + | | | | +- KeywordLiteral + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- ReturnStatement + | | | +- InfixExpression + | | | +- Name + | | | +- InfixExpression + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- NewExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- InfixExpression + | | | | | | | | +- InfixExpression + | | | | | | | | | +- StringLiteral + | | | | | | | | | +- Name + | | | | | | | | +- StringLiteral + | | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- StringLiteral + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- UnaryExpression + | | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- UnaryExpression + | | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- StringLiteral + | | | +- StringLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Block + | | | +- ReturnStatement + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- KeywordLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- IfStatement + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- KeywordLiteral + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- StringLiteral + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- UnaryExpression + | | | | +- NumberLiteral + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- UnaryExpression + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- ParenthesizedExpression + | | | | | | | +- InfixExpression + | | | | | | | +- InfixExpression + | | | | | | | | +- StringLiteral + | | | | | | | | +- FunctionCall + | | | | | | | | +- PropertyGet + | | | | | | | | | +- Name + | | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | | +- StringLiteral + | | | | | | | +- StringLiteral + | | | | | | +- Name + | | | | | +- Name + | | | | +- UnaryExpression + | | | | +- NumberLiteral + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- ReturnStatement + | | | +- KeywordLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | | +- NumberLiteral + | | | | | +- StringLiteral + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- UnaryExpression + | | | | | | +- NumberLiteral + | | | | | +- StringLiteral + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- ReturnStatement + | | | +- ConditionalExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- Name + | | | | +- NumberLiteral + | | | +- FunctionNode + | | | | +- Name + | | | | +- Block + | | | | +- ReturnStatement + | | | | +- UnaryExpression + | | | | +- UnaryExpression + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- ConditionalExpression + | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | | +- StringLiteral + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- UnaryExpression + | | | | | | +- Name + | | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- KeywordLiteral + | | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | | +- Name + | | | | +- Scope + | | | | +- WhileLoop + | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- WhileLoop + | | | | | | +- ParenthesizedExpression + | | | | | | | +- Assignment + | | | | | | | +- Name + | | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Scope + | | | | | | +- IfStatement + | | | | | | +- ConditionalExpression + | | | | | | | +- Name + | | | | | | | +- FunctionCall + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | +- InfixExpression + | | | | | | | +- PropertyGet + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- Scope + | | | | | | +- ReturnStatement + | | | | | | +- KeywordLiteral + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- InfixExpression + | | | | | +- UnaryExpression + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- ReturnStatement + | | | | +- KeywordLiteral + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- ArrayLiteral + | | | | +- ConditionalExpression + | | | | +- Name + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ObjectLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ArrayLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- ElementGet + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- WhileLoop + | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- UnaryExpression + | | | | | | | | +- Name + | | | | | | | +- InfixExpression + | | | | | | | +- Name + | | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- ParenthesizedExpression + | | | | | | | +- Assignment + | | | | | | | +- Name + | | | | | | | +- Assignment + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- IfStatement + | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- PropertyGet + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- InfixExpression + | | | | | | +- UnaryExpression + | | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ArrayLiteral + | | | | | | +- Name + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- BreakStatement + | | | | +- Scope + | | | | +- IfStatement + | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ObjectLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ArrayLiteral + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- InfixExpression + | | | | | | | +- ElementGet + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- Name + | | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- KeywordLiteral + | | | | +- Scope + | | | | +- WhileLoop + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- InfixExpression + | | | | | | +- UnaryExpression + | | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- ParenthesizedExpression + | | | | | | +- ConditionalExpression + | | | | | | +- Name + | | | | | | +- FunctionCall + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ObjectLiteral + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- ArrayLiteral + | | | | | +- Name + | | | | | +- Name + | | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- BreakStatement + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- ParenthesizedExpression + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | | +- Name + | | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- ElementGet + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- ElementGet + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- IfStatement + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- InfixExpression + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- ArrayLiteral + | | | | +- Name + | | | | +- Name + | | | | +- StringLiteral + | | | | +- Name + | | | +- ReturnStatement + | | | +- ConditionalExpression + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | | +- Name + | | | | +- FunctionNode + | | | | +- Name + | | | | +- Name + | | | | +- Block + | | | | +- VariableDeclaration + | | | | | +- VariableInitializer + | | | | | | +- Name + | | | | | +- VariableInitializer + | | | | | | +- Name + | | | | | | +- FunctionCall + | | | | | | +- Name + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- WhileLoop + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- UnaryExpression + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Block + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- NumberLiteral + | | | +- Name + | | +- ReturnStatement + | | +- Name + | +- ObjectProperty + | +- Name + | +- ObjectLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | | +- Name + | | | | +- ArrayLiteral + | | | +- VariableInitializer + | | | | +- Name + | | | | +- ArrayLiteral + | | | +- VariableInitializer + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- StringLiteral + | | +- ReturnStatement + | | +- ConditionalExpression + | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- FunctionCall + | | | +- Name + | | | +- FunctionNode + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Block + | | | +- VariableDeclaration + | | | | +- VariableInitializer + | | | | | +- Name + | | | | +- VariableInitializer + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- Name + | | | | | +- Name + | | | | | +- KeywordLiteral + | | | | | +- Name + | | | | | +- ArrayLiteral + | | | | +- VariableInitializer + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- WhileLoop + | | | +- UnaryExpression + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- UnaryExpression + | | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- ExpressionStatement + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Name + | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- KeywordLiteral + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- KeywordLiteral + | | +- ReturnStatement + | | +- UnaryExpression + | | +- FunctionCall + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- PropertyGet + | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- NumberLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- FunctionCall + | | | +- PropertyGet + | | | | +- ParenthesizedExpression + | | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | +- NumberLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- IfStatement + | | | +- UnaryExpression + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- InfixExpression + | | | +- StringLiteral + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | +- DoLoop + | | | +- Scope + | | | | +- IfStatement + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- ConditionalExpression + | | | | | +- Name + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- StringLiteral + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- NumberLiteral + | | | +- InfixExpression + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- ReturnStatement + | | +- KeywordLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- PropertyGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- InfixExpression + | | +- Name + | | +- InfixExpression + | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- InfixExpression + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- InfixExpression + | | +- FunctionCall + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | +- UnaryExpression + | | +- ParenthesizedExpression + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- KeywordLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- KeywordLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- ParenthesizedExpression + | | | +- InfixExpression + | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | | +- StringLiteral + | | | +- UnaryExpression + | | | +- UnaryExpression + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- ParenthesizedExpression + | | +- InfixExpression + | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- StringLiteral + | | +- UnaryExpression + | | +- UnaryExpression + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- IfStatement + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- PropertyGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- KeywordLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ForLoop + | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | +- ReturnStatement + | | | +- KeywordLiteral + | | +- ReturnStatement + | | +- KeywordLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- UnaryExpression + | | +- FunctionCall + | | +- PropertyGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- InfixExpression + | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | | +- StringLiteral + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- StringLiteral + | | +- FunctionCall + | | +- Name + | | +- Name + | | +- StringLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- InfixExpression + | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- StringLiteral + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- StringLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Block + | | +- ReturnStatement + | | +- ArrayLiteral + | | +- NumberLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- ArrayLiteral + | | +- InfixExpression + | | +- Name + | | +- NumberLiteral + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- ReturnStatement + | | +- ArrayLiteral + | | +- ConditionalExpression + | | +- InfixExpression + | | | +- Name + | | | +- NumberLiteral + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | | +- NumberLiteral + | | +- ForLoop + | | | +- EmptyExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- Assignment + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | | +- NumberLiteral + | | +- ForLoop + | | | +- EmptyExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- Assignment + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- Name + | +- ObjectProperty + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | +- IfStatement + | | | +- InfixExpression + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- Name + | | +- ForLoop + | | | +- EmptyExpression + | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- EmptyExpression + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- Name + | +- ObjectProperty + | +- Name + | +- FunctionCall + | +- Name + | +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | +- Name + | | +- ConditionalExpression + | | +- InfixExpression + | | | +- Name + | | | +- NumberLiteral + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- Name + | +- ForLoop + | | +- EmptyExpression + | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- Name + | | | +- Name + | | +- EmptyExpression + | | +- Scope + | | +- ExpressionStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- Name + +- ExpressionStatement + | +- Assignment + | +- PropertyGet + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- PropertyGet + | +- PropertyGet + | | +- Name + | | +- Name + | +- Name + +- ForInLoop + | +- Name + | +- ObjectLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | +- Name + | | +- KeywordLiteral + | +- Scope + | +- ExpressionStatement + | +- Assignment + | +- ElementGet + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- FunctionCall + | +- Name + | +- Name + +- ForInLoop + | +- Name + | +- ObjectLiteral + | | +- ObjectProperty + | | | +- Name + | | | +- KeywordLiteral + | | +- ObjectProperty + | | +- Name + | | +- KeywordLiteral + | +- Scope + | +- ExpressionStatement + | +- Assignment + | +- ElementGet + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- FunctionCall + | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Block + +- ExpressionStatement + | +- Assignment + | +- PropertyGet + | | +- Name + | | +- Name + | +- Assignment + | +- PropertyGet + | | +- Name + | | +- Name + | +- PropertyGet + | +- Name + | +- Name + +- ExpressionStatement + | +- Assignment + | +- PropertyGet + | | +- Name + | | +- Name + | +- NewExpression + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- ElementGet + | | +- Name + | | +- InfixExpression + | | +- Name + | | +- StringLiteral + | +- IfStatement + | | +- Name + | | +- Scope + | | +- ReturnStatement + | | +- ConditionalExpression + | | +- Name + | | +- NumberLiteral + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- NumberLiteral + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- Name + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- ArrayLiteral + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- WhileLoop + | | +- Name + | | +- Scope + | | +- IfStatement + | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ArrayLiteral + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- KeywordLiteral + | | +- IfStatement + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ObjectLiteral + | | | | +- ObjectProperty + | | | | | +- Name + | | | | | +- Name + | | | | +- ObjectProperty + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Name + | | | | +- Name + | | | | +- StringLiteral + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- ForInLoop + | | | +- Name + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ObjectLiteral + | | | | +- ObjectProperty + | | | | | +- Name + | | | | | +- Name + | | | | +- ObjectProperty + | | | | | +- Name + | | | | | +- Name + | | | | +- ObjectProperty + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- IfStatement + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- BreakStatement + | +- IfStatement + | | +- Name + | | +- Scope + | | +- ReturnStatement + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ReturnStatement + | +- ConditionalExpression + | +- Name + | +- FunctionCall + | | +- Name + | | +- Name + | +- FunctionCall + | +- PropertyGet + | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Name + | +- NumberLiteral + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | | +- NumberLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- StringLiteral + | +- ForLoop + | | +- EmptyExpression + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- PropertyGet + | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- StringLiteral + | | +- VariableInitializer + | | +- Name + | | +- UnaryExpression + | | +- Name + | +- ReturnStatement + | +- ConditionalExpression + | +- PropertyGet + | | +- Name + | | +- Name + | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- WhileLoop + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Name + | | | +- Scope + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- KeywordLiteral + | +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- ArrayLiteral + | | +- Name + | | +- Name + | +- IfStatement + | | +- Name + | | +- Scope + | | | +- WhileLoop + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ReturnStatement + | | | +- KeywordLiteral + | | +- Scope + | | +- WhileLoop + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- InfixExpression + | | | +- InfixExpression + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- InfixExpression + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- ObjectLiteral + | | +- IfStatement + | | +- InfixExpression + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Scope + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- InfixExpression + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- IfStatement + | | +- InfixExpression + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Name + | | | +- InfixExpression + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Name + | | +- Scope + | | | +- ReturnStatement + | | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- ElementGet + | | | +- Name + | | | +- NumberLiteral + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- IfStatement + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ReturnStatement + | | +- KeywordLiteral + | +- ReturnStatement + | +- KeywordLiteral + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- ReturnStatement + | +- ConditionalExpression + | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- NumberLiteral + | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- WhileLoop + | | | +- UnaryExpression + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | +- UnaryExpression + | | | | +- FunctionCall + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ReturnStatement + | | | +- KeywordLiteral + | | +- ReturnStatement + | | +- KeywordLiteral + | +- ElementGet + | +- Name + | +- NumberLiteral + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | | +- NumberLiteral + | | +- VariableInitializer + | | +- Name + | | +- PropertyGet + | | +- Name + | | +- Name + | +- ForLoop + | | +- EmptyExpression + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- FunctionCall + | | +- Name + | | +- Name + | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- ArrayLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- NumberLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- InfixExpression + | | +- Name + | | +- KeywordLiteral + | +- ForLoop + | | +- EmptyExpression + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- InfixExpression + | | | +- UnaryExpression + | | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- IfStatement + | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- IfStatement + | | +- InfixExpression + | | | +- Name + | | | +- UnaryExpression + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- Name + | +- IfStatement + | | +- InfixExpression + | | | +- Name + | | | +- UnaryExpression + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- Name + | | +- Name + | +- ReturnStatement + | +- FunctionCall + | +- Name + | +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- ArrayLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- ArrayLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- InfixExpression + | | | | +- Name + | | | | +- StringLiteral + | | | +- ConditionalExpression + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ArrayLiteral + | | | | | +- Name + | | | | +- Name + | | | +- ArrayLiteral + | | +- VariableInitializer + | | +- Name + | | +- ConditionalExpression + | | +- InfixExpression + | | | +- Name + | | | +- ParenthesizedExpression + | | | +- InfixExpression + | | | +- Name + | | | +- UnaryExpression + | | | +- Name + | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Name + | +- IfStatement + | | +- Name + | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- ConditionalExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- ParenthesizedExpression + | | | | | +- ConditionalExpression + | | | | | +- Name + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- ArrayLiteral + | | | | +- Name + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- Name + | +- IfStatement + | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- ArrayLiteral + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- WhileLoop + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | +- Assignment + | | +- ElementGet + | | | +- Name + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | +- ParenthesizedExpression + | | +- Assignment + | | +- ElementGet + | | | +- Name + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Name + | +- IfStatement + | +- Name + | +- Scope + | | +- IfStatement + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- Scope + | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- ArrayLiteral + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- WhileLoop + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- Name + | | | +- KeywordLiteral + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ArrayLiteral + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- WhileLoop + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- InfixExpression + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- ConditionalExpression + | | | | +- Name + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- UnaryExpression + | | | +- NumberLiteral + | | +- Scope + | | +- ExpressionStatement + | | +- Assignment + | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | +- ParenthesizedExpression + | | +- Assignment + | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- Name + | +- Scope + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- FunctionCall + | | +- Name + | | +- ConditionalExpression + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- IfStatement + | +- Name + | +- Scope + | | +- ExpressionStatement + | | +- FunctionCall + | | +- Name + | | +- KeywordLiteral + | | +- Name + | | +- Name + | | +- Name + | +- Scope + | +- ExpressionStatement + | +- FunctionCall + | +- PropertyGet + | | +- Name + | | +- Name + | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- ElementGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- PropertyGet + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- ElementGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- StringLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- ConditionalExpression + | | | +- Name + | | | +- NumberLiteral + | | | +- NumberLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- FunctionNode + | | | | +- Name + | | | | +- Block + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- KeywordLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- FunctionNode + | | | | +- Name + | | | | +- Block + | | | | +- ReturnStatement + | | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | | +- Name + | | | | +- UnaryExpression + | | | | +- NumberLiteral + | | | +- Name + | | | +- KeywordLiteral + | | +- VariableInitializer + | | +- Name + | | +- ArrayLiteral + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- ParenthesizedExpression + | | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- ParenthesizedExpression + | | | +- ConditionalExpression + | | | +- PropertyGet + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- KeywordLiteral + | | +- ReturnStatement + | | +- Name + | +- ForLoop + | | +- EmptyExpression + | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ElementGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- PropertyGet + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Scope + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- ArrayLiteral + | | | +- FunctionCall + | | | +- Name + | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- ElementGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- KeywordLiteral + | | | +- PropertyGet + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- UnaryExpression + | | | | +- Name + | | | +- ForLoop + | | | | +- EmptyExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | +- ElementGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- BreakStatement + | | | +- ReturnStatement + | | | +- FunctionCall + | | | +- Name + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- FunctionCall + | | | | | | +- Name + | | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- FunctionCall + | | | | | | | | +- PropertyGet + | | | | | | | | | +- Name + | | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | | +- InfixExpression + | | | | | | | | +- Name + | | | | | | | | +- NumberLiteral + | | | | | | | +- Name + | | | | | | +- ObjectLiteral + | | | | | | +- ObjectProperty + | | | | | | +- Name + | | | | | | +- ConditionalExpression + | | | | | | +- InfixExpression + | | | | | | | +- PropertyGet + | | | | | | | | +- ElementGet + | | | | | | | | | +- Name + | | | | | | | | | +- InfixExpression + | | | | | | | | | +- Name + | | | | | | | | | +- NumberLiteral + | | | | | | | | +- Name + | | | | | | | +- StringLiteral + | | | | | | +- StringLiteral + | | | | | | +- StringLiteral + | | | | | +- Name + | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- FunctionCall + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- FunctionCall + | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | +- FunctionCall + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- FunctionCall + | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- VariableInitializer + | | +- Name + | | +- FunctionNode + | | +- Name + | | +- Name + | | +- Name + | | +- Name + | | +- Name + | | +- Block + | | +- VariableDeclaration + | | | +- VariableInitializer + | | | | +- Name + | | | +- VariableInitializer + | | | | +- Name + | | | +- VariableInitializer + | | | | +- Name + | | | +- VariableInitializer + | | | | +- Name + | | | | +- NumberLiteral + | | | +- VariableInitializer + | | | | +- Name + | | | | +- StringLiteral + | | | +- VariableInitializer + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- ArrayLiteral + | | | +- VariableInitializer + | | | | +- Name + | | | | +- ArrayLiteral + | | | +- VariableInitializer + | | | | +- Name + | | | | +- Name + | | | +- VariableInitializer + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- StringLiteral + | | | | +- Name + | | | +- VariableInitializer + | | | +- Name + | | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ConditionalExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- KeywordLiteral + | | | +- NumberLiteral + | | | +- InfixExpression + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- Name + | | | +- Name + | | +- ForLoop + | | | +- EmptyExpression + | | | +- InfixExpression + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- Name + | | | | +- KeywordLiteral + | | | +- UnaryExpression + | | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- IfStatement + | | | | | +- InfixExpression + | | | | | | +- UnaryExpression + | | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- FunctionCall + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- WhileLoop + | | | | | +- ParenthesizedExpression + | | | | | | +- Assignment + | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- UnaryExpression + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- IfStatement + | | | | | +- FunctionCall + | | | | | | +- Name + | | | | | | +- Name + | | | | | | +- InfixExpression + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- BreakStatement + | | | | +- IfStatement + | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- IfStatement + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- InfixExpression + | | | | | +- UnaryExpression + | | | | | | +- Name + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- UnaryExpression + | | | | +- Name + | | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- NumberLiteral + | | | +- WhileLoop + | | | | +- ParenthesizedExpression + | | | | | +- Assignment + | | | | | +- Name + | | | | | +- ElementGet + | | | | | +- Name + | | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | | +- Name + | | | | +- Scope + | | | | +- IfStatement + | | | | | +- InfixExpression + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Scope + | | | | | +- WhileLoop + | | | | | +- UnaryExpression + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- IfStatement + | | | | | +- UnaryExpression + | | | | | | +- ParenthesizedExpression + | | | | | | +- InfixExpression + | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Scope + | | | | | +- ExpressionStatement + | | | | | +- Assignment + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | +- InfixExpression + | | | | +- Name + | | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- ParenthesizedExpression + | | | | | +- InfixExpression + | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- NumberLiteral + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- Name + | | +- ReturnStatement + | | +- Name + | +- ReturnStatement + | +- ConditionalExpression + | +- Name + | +- FunctionCall + | | +- Name + | | +- Name + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- ArrayLiteral + | | +- VariableInitializer + | | | +- Name + | | | +- ArrayLiteral + | | +- VariableInitializer + | | +- Name + | | +- ElementGet + | | +- Name + | | +- InfixExpression + | | +- Name + | | +- StringLiteral + | +- IfStatement + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- IfStatement + | | | +- UnaryExpression + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- WhileLoop + | | | +- UnaryExpression + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- FunctionCall + | | | | +- Name + | | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- IfStatement + | | | +- ElementGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | +- Assignment + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- Name + +- FunctionNode + | +- Name + | +- Name + | +- Name + | +- Name + | +- Name + | +- Block + | +- VariableDeclaration + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | +- VariableInitializer + | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- StringLiteral + | | | +- Name + | | +- VariableInitializer + | | +- Name + | | +- InfixExpression + | | +- UnaryExpression + | | | +- Name + | | +- FunctionCall + | | +- Name + | | +- ParenthesizedExpression + | | +- Assignment + | | +- Name + | | +- InfixExpression + | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ExpressionStatement + | | +- Assignment + | | +- Name + | | +- InfixExpression + | | +- Name + | | +- ArrayLiteral + | +- IfStatement + | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- Assignment + | | | +- ElementGet + | | | | +- Name + | | | | +- NumberLiteral + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Name + | | | +- NumberLiteral + | | +- IfStatement + | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- ParenthesizedExpression + | | | | | | | +- Assignment + | | | | | | | +- Name + | | | | | | | +- ElementGet + | | | | | | | +- Name + | | | | | | | +- NumberLiteral + | | | | | | +- Name + | | | | | +- StringLiteral + | | | | +- InfixExpression + | | | | +- InfixExpression + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- InfixExpression + | | | | +- Name + | | | | +- ElementGet + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- PropertyGet + | | | | +- ElementGet + | | | | | +- Name + | | | | | +- NumberLiteral + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- ElementGet + | | | | +- ParenthesizedExpression + | | | | | +- InfixExpression + | | | | | +- FunctionCall + | | | | | | +- PropertyGet + | | | | | | | +- PropertyGet + | | | | | | | | +- Name + | | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- FunctionCall + | | | | | | | +- PropertyGet + | | | | | | | | +- ElementGet + | | | | | | | | | +- PropertyGet + | | | | | | | | | | +- Name + | | | | | | | | | | +- Name + | | | | | | | | | +- NumberLiteral + | | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- Name + | | | | | +- ArrayLiteral + | | | | +- NumberLiteral + | | | +- IfStatement + | | | | +- UnaryExpression + | | | | | +- Name + | | | | +- Scope + | | | | | +- ReturnStatement + | | | | | +- Name + | | | | +- IfStatement + | | | | +- Name + | | | | +- Scope + | | | | +- ExpressionStatement + | | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- PropertyGet + | | | +- PropertyGet + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- ConditionalExpression + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- NumberLiteral + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- WhileLoop + | | +- UnaryExpression + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- ElementGet + | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- ElementGet + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- ParenthesizedExpression + | | | | +- Assignment + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Scope + | | | +- BreakStatement + | | +- IfStatement + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- ElementGet + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Scope + | | +- IfStatement + | | +- ParenthesizedExpression + | | | +- Assignment + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- PropertyGet + | | | | | | | +- Name + | | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- InfixExpression + | | | +- InfixExpression + | | | | +- FunctionCall + | | | | | +- PropertyGet + | | | | | | +- Name + | | | | | | +- Name + | | | | | +- PropertyGet + | | | | | +- ElementGet + | | | | | | +- Name + | | | | | | +- NumberLiteral + | | | | | +- Name + | | | | +- FunctionCall + | | | | +- Name + | | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | +- Scope + | | +- ExpressionStatement + | | | +- FunctionCall + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- Name + | | | +- NumberLiteral + | | +- ExpressionStatement + | | | +- Assignment + | | | +- Name + | | | +- InfixExpression + | | | +- PropertyGet + | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | +- IfStatement + | | | +- UnaryExpression + | | | | +- Name + | | | +- Scope + | | | +- ExpressionStatement + | | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | | +- Name + | | | +- ReturnStatement + | | | +- Name + | | +- BreakStatement + | +- ExpressionStatement + | | +- FunctionCall + | | +- ParenthesizedExpression + | | | +- InfixExpression + | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- Name + | | | +- Name + | | +- Name + | | +- Name + | | +- UnaryExpression + | | | +- Name + | | +- Name + | | +- InfixExpression + | | +- UnaryExpression + | | | +- Name + | | +- InfixExpression + | | +- InfixExpression + | | | +- FunctionCall + | | | | +- PropertyGet + | | | | | +- Name + | | | | | +- Name + | | | | +- Name + | | | +- FunctionCall + | | | +- Name + | | | +- PropertyGet + | | | +- Name + | | | +- Name + | | +- Name + | +- ReturnStatement + | +- Name + +- ExpressionStatement + | +- FunctionCall + | +- Name + +- ExpressionStatement + +- Assignment + +- PropertyGet + | +- Name + | +- Name + +- Name