@agoric/xsnap 0.14.3-dev-b047af2.0 → 0.14.3-dev-3eb4230.0

package/moddable/xs/sources/xsSyntaxical.c

@@ -1,4193 +0,0 @@
-/*
- * Copyright (c) 2016-2017  Moddable Tech, Inc.
- *
- *   This file is part of the Moddable SDK Runtime.
- * 
- *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- * 
- *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU Lesser General Public License for more details.
- * 
- *   You should have received a copy of the GNU Lesser General Public License
- *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
- *
- * This file incorporates work covered by the following copyright and  
- * permission notice:  
- *
- *       Copyright (C) 2010-2016 Marvell International Ltd.
- *       Copyright (C) 2002-2010 Kinoma, Inc.
- *
- *       Licensed under the Apache License, Version 2.0 (the "License");
- *       you may not use this file except in compliance with the License.
- *       You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- *       Unless required by applicable law or agreed to in writing, software
- *       distributed under the License is distributed on an "AS IS" BASIS,
- *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *       See the License for the specific language governing permissions and
- *       limitations under the License.
- */
-
-#include "xsScript.h"
-
-static txBoolean fxIsKeyword(txParser* parser, txSymbol* keyword);
-static txBoolean fxIsToken(txParser* parser, txToken theToken);
-static void fxMatchToken(txParser* parser, txToken theToken);
-static txNode* fxPopNode(txParser* parser);
-static void fxPushNode(txParser* parser, txNode* node);
-static void fxPushBigIntNode(txParser* parser, txBigInt* value, txInteger line);
-static void fxPushIndexNode(txParser* parser, txIndex value, txInteger line);
-static void fxPushIntegerNode(txParser* parser, txInteger value, txInteger line);
-static void fxPushNodeStruct(txParser* parser, txInteger count, txToken token, txInteger line);
-static void fxPushNodeList(txParser* parser, txInteger count);
-static void fxPushNULL(txParser* parser);
-static void fxPushNumberNode(txParser* parser, txNumber value, txInteger line);
-static void fxPushRawNode(txParser* parser, txInteger length, txString value, txInteger line);
-static void fxPushStringNode(txParser* parser, txInteger length, txString value, txInteger line);
-static void fxPushSymbol(txParser* parser, txSymbol* symbol);
-static void fxSwapNodes(txParser* parser);
-
-static void fxExport(txParser* parser);
-static void fxExportBinding(txParser* parser, txNode* node);
-static void fxImport(txParser* parser);
-static void fxSpecifiers(txParser* parser);
-
-static void fxBody(txParser* parser);
-static void fxStatements(txParser* parser);
-static void fxBlock(txParser* parser);
-static void fxStatement(txParser* parser, txBoolean blockIt);
-static void fxSemicolon(txParser* parser);
-static void fxBreakStatement(txParser* parser);
-static void fxContinueStatement(txParser* parser);
-static void fxDebuggerStatement(txParser* parser);
-static void fxDoStatement(txParser* parser);
-static void fxForStatement(txParser* parser);
-static void fxIfStatement(txParser* parser);
-static void fxReturnStatement(txParser* parser);
-static void fxSwitchStatement(txParser* parser);
-static void fxThrowStatement(txParser* parser);
-static void fxTryStatement(txParser* parser);
-static void fxVariableStatement(txParser* parser, txToken theToken);
-static void fxWhileStatement(txParser* parser);
-static void fxWithStatement(txParser* parser);
-
-static void fxCommaExpression(txParser* parser);
-static void fxAssignmentExpression(txParser* parser);
-static void fxConditionalExpression(txParser* parser);
-static void fxOrExpression(txParser* parser);
-static void fxAndExpression(txParser* parser);
-static void fxCoalesceExpression(txParser* parser);
-static void fxBitOrExpression(txParser* parser);
-static void fxBitXorExpression(txParser* parser);
-static void fxBitAndExpression(txParser* parser);
-static void fxEqualExpression(txParser* parser);
-static void fxRelationalExpression(txParser* parser);
-static void fxShiftExpression(txParser* parser);
-static void fxAdditiveExpression(txParser* parser);
-static void fxMultiplicativeExpression(txParser* parser);
-static void fxExponentiationExpression(txParser* parser);
-static void fxUnaryExpression(txParser* parser);
-static void fxPrefixExpression(txParser* parser);
-static void fxPostfixExpression(txParser* parser);
-static void fxCallExpression(txParser* parser);
-
-static void fxLiteralExpression(txParser* parser, txUnsigned flag);
-static void fxArrayExpression(txParser* parser);
-static void fxArrowExpression(txParser* parser, txUnsigned flag);
-static void fxClassExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol);
-static void fxFunctionExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag);
-static void fxGeneratorExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag);
-static void fxGroupExpression(txParser* parser, txUnsigned flag);
-static void fxObjectExpression(txParser* parser);
-static void fxNewExpression(txParser* parser);
-static void fxTemplateExpression(txParser* parser);
-static void fxYieldExpression(txParser* parser);
-
-static void fxParameters(txParser* parser);
-static void fxPropertyName(txParser* parser, txSymbol** theSymbol, txToken* theToken0, txToken* theToken1, txToken* theToken2, txUnsigned* flag);
-
-static void fxBinding(txParser* parser, txToken theToken, txFlag initializeIt);
-static txNode* fxBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
-static void fxArrayBinding(txParser* parser, txToken theToken);
-static txNode* fxArrayBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
-static txUnsigned fxObjectBinding(txParser* parser, txToken theToken);
-static txNode* fxObjectBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken);
-static void fxParametersBinding(txParser* parser);
-static txNode* fxParametersBindingFromExpressions(txParser* parser, txNode* theNode);
-static void fxRestBinding(txParser* parser, txToken theToken, txUnsigned flag);
-static txNode* fxRestBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken, txUnsigned flag);
-
-static void fxCheckArrowFunction(txParser* parser, txInteger count);
-static txBoolean fxCheckReference(txParser* parser, txToken theToken);
-static void fxCheckStrictBinding(txParser* parser, txNode* node);
-static void fxCheckStrictFunction(txParser* parser, txFunctionNode* function);
-static void fxCheckStrictSymbol(txParser* parser, txSymbol* symbol);
-static void fxCheckUniqueProperty(txParser* parser, txNode* base, txNode* current);
-static void fxCheckUniquePropertyAux(txParser* parser, txNode* baseNode, txNode* currentNode);
-
-static void fxJSONObject(txParser* parser);
-static void fxJSONArray(txParser* parser);
-
-static void fxJSXAttributeName(txParser* parser);
-static void fxJSXAttributeValue(txParser* parser);
-static void fxJSXElement(txParser* parser);
-static void fxJSXElementName(txParser* parser);
-static txBoolean fxJSXMatch(txParser* parser, txNode* opening, txNode* closing);
-static txSymbol* fxJSXNamespace(txParser* parser, txSymbol* namespace, txSymbol* name);
-
-#define XS_TOKEN_BEGIN_STATEMENT 1
-#define XS_TOKEN_BEGIN_EXPRESSION 2
-#define XS_TOKEN_ASSIGN_EXPRESSION 4
-#define XS_TOKEN_EQUAL_EXPRESSION 8
-#define XS_TOKEN_RELATIONAL_EXPRESSION 16
-#define XS_TOKEN_SHIFT_EXPRESSION 32
-#define XS_TOKEN_ADDITIVE_EXPRESSION 64
-#define XS_TOKEN_MULTIPLICATIVE_EXPRESSION 128
-#define XS_TOKEN_EXPONENTIATION_EXPRESSION 256
-#define XS_TOKEN_PREFIX_EXPRESSION 512
-#define XS_TOKEN_POSTFIX_EXPRESSION 1024
-#define XS_TOKEN_END_STATEMENT 2048
-#define XS_TOKEN_REFERENCE_EXPRESSION 4096
-#define XS_TOKEN_BEGIN_BINDING 16384
-#define XS_TOKEN_IDENTIFIER_NAME 32768
-#define XS_TOKEN_UNARY_EXPRESSION 65536
-#define XS_TOKEN_CALL_EXPRESSION 131072
-
-static txTokenFlag gxTokenFlags[XS_TOKEN_COUNT] = {
-	/* XS_NO_TOKEN */ 0,
-	/* XS_TOKEN_ACCESS */ 0,
-	/* XS_TOKEN_ADD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ADDITIVE_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
-	/* XS_TOKEN_ADD_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_AND */ 0,
-	/* XS_TOKEN_AND_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_ARG */ 0,
-	/* XS_TOKEN_ARGUMENTS */ 0,
-	/* XS_TOKEN_ARGUMENTS_SLOPPY */ 0,
-	/* XS_TOKEN_ARGUMENTS_STRICT */ 0,
-	/* XS_TOKEN_ARRAY */ 0,
-	/* XS_TOKEN_ARRAY_BINDING */ 0,
-	/* XS_TOKEN_ARROW */ 0,
-	/* XS_TOKEN_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_AWAIT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_BIGINT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_BINDING */ 0,
-	/* XS_TOKEN_BIT_AND */ 0,
-	/* XS_TOKEN_BIT_AND_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_BIT_NOT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
-	/* XS_TOKEN_BIT_OR */ 0,
-	/* XS_TOKEN_BIT_OR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_BIT_XOR */ 0,
-	/* XS_TOKEN_BIT_XOR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_BLOCK */ 0,
-	/* XS_TOKEN_BODY */ 0,
-	/* XS_TOKEN_BREAK */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_CALL */ 0,
-	/* XS_TOKEN_CASE */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_CATCH */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_CHAIN */ XS_TOKEN_CALL_EXPRESSION,
-	/* XS_TOKEN_CLASS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_COALESCE */ 0,
-	/* XS_TOKEN_COALESCE_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_COLON */ 0,
-	/* XS_TOKEN_COMMA */ XS_TOKEN_END_STATEMENT,
-	/* XS_TOKEN_CONST */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_CONTINUE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_CURRENT */ 0,
-	/* XS_TOKEN_DEBUGGER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_DECREMENT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_PREFIX_EXPRESSION | XS_TOKEN_POSTFIX_EXPRESSION,
-	/* XS_TOKEN_DEFAULT */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_DEFINE */ 0,
-	/* XS_TOKEN_DELEGATE */ 0,
-	/* XS_TOKEN_DELETE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_DIVIDE */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
-	/* XS_TOKEN_DIVIDE_ASSIGN */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_DO */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_DOT */ XS_TOKEN_CALL_EXPRESSION,
-	/* XS_TOKEN_ELISION */ 0,
-	/* XS_TOKEN_ELSE */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_ENUM */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_EOF */ XS_TOKEN_END_STATEMENT,
-	/* XS_TOKEN_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
-	/* XS_TOKEN_EVAL */ 0,
-	/* XS_TOKEN_EXPONENTIATION */ XS_TOKEN_EXPONENTIATION_EXPRESSION,
-	/* XS_TOKEN_EXPONENTIATION_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_EXPORT */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_EXPRESSIONS */ 0,
-	/* XS_TOKEN_EXTENDS */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_FALSE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_FIELD */ 0,
-	/* XS_TOKEN_FINALLY */ XS_TOKEN_IDENTIFIER_NAME | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_FOR */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_FOR_AWAIT_OF */ 0,
-	/* XS_TOKEN_FOR_IN */ 0,
-	/* XS_TOKEN_FOR_OF */ 0,
-	/* XS_TOKEN_FUNCTION */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_GENERATOR */ 0,
-	/* XS_TOKEN_GETTER */ 0,
-	/* XS_TOKEN_HOST */ XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_IDENTIFIER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_IF */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_IMPLEMENTS */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_IMPORT */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_IMPORT_CALL */ 0,
-	/* XS_TOKEN_IMPORT_META */ 0,
-	/* XS_TOKEN_IN */ XS_TOKEN_RELATIONAL_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_INCLUDE */ 0,
-	/* XS_TOKEN_INCREMENT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_PREFIX_EXPRESSION | XS_TOKEN_POSTFIX_EXPRESSION,
-	/* XS_TOKEN_INSTANCEOF */ XS_TOKEN_RELATIONAL_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_INTEGER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_INTERFACE */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_ITEMS */ 0,
-	/* XS_TOKEN_LABEL */ 0,
-	/* XS_TOKEN_LEFT_BRACE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING,
-	/* XS_TOKEN_LEFT_BRACKET */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_BEGIN_BINDING | XS_TOKEN_CALL_EXPRESSION,
-	/* XS_TOKEN_LEFT_PARENTHESIS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
-	/* XS_TOKEN_LEFT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
-	/* XS_TOKEN_LEFT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_LESS */ XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_RELATIONAL_EXPRESSION,
-	/* XS_TOKEN_LESS_EQUAL */ XS_TOKEN_RELATIONAL_EXPRESSION,
-	/* XS_TOKEN_LET */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_MEMBER */ 0,
-	/* XS_TOKEN_MEMBER_AT */ 0,
-	/* XS_TOKEN_MINUS */ 0,
-	/* XS_TOKEN_MODULE */ 0,
-	/* XS_TOKEN_MODULO */ XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
-	/* XS_TOKEN_MODULO_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_MORE */ XS_TOKEN_RELATIONAL_EXPRESSION,
-	/* XS_TOKEN_MORE_EQUAL */ XS_TOKEN_RELATIONAL_EXPRESSION,
-	/* XS_TOKEN_MULTIPLY */ XS_TOKEN_MULTIPLICATIVE_EXPRESSION,
-	/* XS_TOKEN_MULTIPLY_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_NEW */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME, 
-	/* XS_TOKEN_NOT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
-	/* XS_TOKEN_NOT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
-	/* XS_TOKEN_NULL */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME, 
-	/* XS_TOKEN_NUMBER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_OBJECT */ 0,
-	/* XS_TOKEN_OBJECT_BINDING */ 0,
-	/* XS_TOKEN_OPTION */ 0,
-	/* XS_TOKEN_OR */ 0,
-	/* XS_TOKEN_OR_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_PACKAGE */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_PARAMS */ 0,
-	/* XS_TOKEN_PARAMS_BINDING */ 0,
-	/* XS_TOKEN_PLUS */ 0,
-	/* XS_TOKEN_PRIVATE */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_PRIVATE_IDENTIFIER */ XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_PRIVATE_MEMBER */ 0,
-	/* XS_TOKEN_PRIVATE_PROPERTY */ 0,
-	/* XS_TOKEN_PROGRAM */ 0,
-	/* XS_TOKEN_PROPERTY */ 0,
-	/* XS_TOKEN_PROPERTY_AT */ 0,
-	/* XS_TOKEN_PROPERTY_BINDING */ 0,
-	/* XS_TOKEN_PROPERTY_BINDING_AT */ 0,
-	/* XS_TOKEN_PROTECTED */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_PUBLIC */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_QUESTION_MARK */ 0,
-	/* XS_TOKEN_REGEXP */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_REST_BINDING */ 0,
-	/* XS_TOKEN_RETURN */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_RIGHT_BRACE */ XS_TOKEN_END_STATEMENT,
-	/* XS_TOKEN_RIGHT_BRACKET */ 0,
-	/* XS_TOKEN_RIGHT_PARENTHESIS */ 0,
-	/* XS_TOKEN_SEMICOLON */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_END_STATEMENT,
-	/* XS_TOKEN_SETTER */ 0,
-	/* XS_TOKEN_SHORT */ 0,
-	/* XS_TOKEN_SIGNED_RIGHT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
-	/* XS_TOKEN_SIGNED_RIGHT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_SKIP_BINDING */ 0,
-	/* XS_TOKEN_SPECIFIER */ 0,
-	/* XS_TOKEN_SPREAD */ XS_TOKEN_BEGIN_BINDING,
-	/* XS_TOKEN_STATEMENT */ 0,
-	/* XS_TOKEN_STATEMENTS */ 0,
-	/* XS_TOKEN_STATIC */ XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_STRICT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
-	/* XS_TOKEN_STRICT_NOT_EQUAL */ XS_TOKEN_EQUAL_EXPRESSION,
-	/* XS_TOKEN_STRING */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION,
-	/* XS_TOKEN_SUBTRACT */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_ADDITIVE_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION,
-	/* XS_TOKEN_SUBTRACT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_SUPER */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_SWITCH */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_TARGET */ 0,
-	/* XS_TOKEN_TEMPLATE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
-	/* XS_TOKEN_TEMPLATE_HEAD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_CALL_EXPRESSION,
-	/* XS_TOKEN_TEMPLATE_MIDDLE */ 0,
-	/* XS_TOKEN_TEMPLATE_TAIL */ 0,
-	/* XS_TOKEN_THIS */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_THROW */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_TRUE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_TRY */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_TYPEOF */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_UNDEFINED */ 0,
-	/* XS_TOKEN_UNSIGNED_RIGHT_SHIFT */ XS_TOKEN_SHIFT_EXPRESSION,
-	/* XS_TOKEN_UNSIGNED_RIGHT_SHIFT_ASSIGN */ XS_TOKEN_ASSIGN_EXPRESSION,
-	/* XS_TOKEN_VAR */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_VOID */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_UNARY_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_WHILE */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_WITH */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_IDENTIFIER_NAME,
-	/* XS_TOKEN_YIELD */ XS_TOKEN_BEGIN_STATEMENT | XS_TOKEN_BEGIN_EXPRESSION | XS_TOKEN_IDENTIFIER_NAME
-};
-
-static txString const gxTokenNames[XS_TOKEN_COUNT] ICACHE_FLASH_ATTR = {
-	/* XS_NO_TOKEN */ "",
-	/* XS_TOKEN_ACCESS */ "access",
-	/* XS_TOKEN_ADD */ "+",
-	/* XS_TOKEN_ADD_ASSIGN */ "+=",
-	/* XS_TOKEN_AND */ "&&",
-	/* XS_TOKEN_AND_ASSIGN */ "&&=",
-	/* XS_TOKEN_ARG */ "arg",
-	/* XS_TOKEN_ARGUMENTS */ "arguments",
-	/* XS_TOKEN_ARGUMENTS_SLOPPY */ "arguments_sloppy",
-	/* XS_TOKEN_ARGUMENTS_STRICT */ "arguments_strict",
-	/* XS_TOKEN_ARRAY */ "array",
-	/* XS_TOKEN_ARRAY_BINDING */ "array_binding",
-	/* XS_TOKEN_ARROW */ "=>",
-	/* XS_TOKEN_ASSIGN */ "=",
-	/* XS_TOKEN_AWAIT */ "await",
-	/* XS_TOKEN_BIGINT */ "bigint",
-	/* XS_TOKEN_BINDING */ "binding",
-	/* XS_TOKEN_BIT_AND */ "&",
-	/* XS_TOKEN_BIT_AND_ASSIGN */ "&=",
-	/* XS_TOKEN_BIT_NOT */ "~",
-	/* XS_TOKEN_BIT_OR */ "|",
-	/* XS_TOKEN_BIT_OR_ASSIGN */ "|=",
-	/* XS_TOKEN_BIT_XOR */ "^",
-	/* XS_TOKEN_BIT_XOR_ASSIGN */ "^=",
-	/* XS_TOKEN_BLOCK */ "block",
-	/* XS_TOKEN_BODY */ "body",
-	/* XS_TOKEN_BREAK */ "break",
-	/* XS_TOKEN_CALL */ "call",
-	/* XS_TOKEN_CASE */ "case",
-	/* XS_TOKEN_CATCH */ "catch",
-	/* XS_TOKEN_CHAIN */ "?.",
-	/* XS_TOKEN_CLASS */ "class",
-	/* XS_TOKEN_COALESCE */ "??",
-	/* XS_TOKEN_COALESCE_ASSIGN */ "\?\?=",
-	/* XS_TOKEN_COLON */ ":",
-	/* XS_TOKEN_COMMA */ ",",
-	/* XS_TOKEN_CONST */ "const",
-	/* XS_TOKEN_CONTINUE */ "continue",
-	/* XS_TOKEN_CURRENT */ "current",
-	/* XS_TOKEN_DEBUGGER */ "debugger",
-	/* XS_TOKEN_DECREMENT */ "--",
-	/* XS_TOKEN_DEFAULT */ "default",
-	/* XS_TOKEN_DEFINE */ "define",
-	/* XS_TOKEN_DELEGATE */ "delegate",
-	/* XS_TOKEN_DELETE */ "delete",
-	/* XS_TOKEN_DIVIDE */ "/",
-	/* XS_TOKEN_DIVIDE_ASSIGN */ "/=",
-	/* XS_TOKEN_DO */ "do",
-	/* XS_TOKEN_DOT */ ".",
-	/* XS_TOKEN_ELISION */ "elision",
-	/* XS_TOKEN_ELSE */ "else",
-	/* XS_TOKEN_ENUM */ "enum",
-	/* XS_TOKEN_EOF */ "",
-	/* XS_TOKEN_EQUAL */ "==",
-	/* XS_TOKEN_EVAL */ "eval",
-	/* XS_TOKEN_EXPONENTIATION */ "**",
-	/* XS_TOKEN_EXPONENTIATION_ASSIGN */ "**=",
-	/* XS_TOKEN_EXPORT */ "export",
-	/* XS_TOKEN_EXPRESSIONS */ "expressions",
-	/* XS_TOKEN_EXTENDS */ "extends",
-	/* XS_TOKEN_FALSE */ "false",
-	/* XS_TOKEN_FIELD */ "field",
-	/* XS_TOKEN_FINALLY */ "finally",
-	/* XS_TOKEN_FOR */ "for",
-	/* XS_TOKEN_FOR_AWAIT_OF */ "for_await_of",
-	/* XS_TOKEN_FOR_IN */ "for_in",
-	/* XS_TOKEN_FOR_OF */ "for_of",
-	/* XS_TOKEN_FUNCTION */ "function",
-	/* XS_TOKEN_GENERATOR */ "generator",
-	/* XS_TOKEN_GETTER */ "getter",
-	/* XS_TOKEN_HOST */ "host", 
-	/* XS_TOKEN_IDENTIFIER */ "identifier",
-	/* XS_TOKEN_IF */ "if",
-	/* XS_TOKEN_IMPLEMENTS */ "implements",
-	/* XS_TOKEN_IMPORT */ "import",
-	/* XS_TOKEN_IMPORT_CALL */ "import",
-	/* XS_TOKEN_IMPORT_META */ "import.meta",
-	/* XS_TOKEN_IN */ "in",
-	/* XS_TOKEN_INCLUDE */ "include",
-	/* XS_TOKEN_INCREMENT */ "++",
-	/* XS_TOKEN_INSTANCEOF */ "instanceof",
-	/* XS_TOKEN_INTEGER */ "integer",
-	/* XS_TOKEN_INTERFACE */ "interface",
-	/* XS_TOKEN_ITEMS */ "items",
-	/* XS_TOKEN_LABEL */ "label",
-	/* XS_TOKEN_LEFT_BRACE */ "{",
-	/* XS_TOKEN_LEFT_BRACKET */ "[",
-	/* XS_TOKEN_LEFT_PARENTHESIS */ "(",
-	/* XS_TOKEN_LEFT_SHIFT */ "<<",
-	/* XS_TOKEN_LEFT_SHIFT_ASSIGN */ "<<=",
-	/* XS_TOKEN_LESS */ "<",
-	/* XS_TOKEN_LESS_EQUAL */ "<=",
-	/* XS_TOKEN_LET */ "let",
-	/* XS_TOKEN_MEMBER */ "member",
-	/* XS_TOKEN_MEMBER_AT */ "member_at",
-	/* XS_TOKEN_MINUS */ "minus",
-	/* XS_TOKEN_MODULE */ "module",
-	/* XS_TOKEN_MODULO */ "%",
-	/* XS_TOKEN_MODULO_ASSIGN */ "%=",
-	/* XS_TOKEN_MORE */ ">",
-	/* XS_TOKEN_MORE_EQUAL */ ">=",
-	/* XS_TOKEN_MULTIPLY */ "*",
-	/* XS_TOKEN_MULTIPLY_ASSIGN */ "*=",
-	/* XS_TOKEN_NEW */ "new", 
-	/* XS_TOKEN_NOT */ "!",
-	/* XS_TOKEN_NOT_EQUAL */ "!=",
-	/* XS_TOKEN_NULL */ "null", 
-	/* XS_TOKEN_NUMBER */ "number",
-	/* XS_TOKEN_OBJECT */ "object",
-	/* XS_TOKEN_OBJECT_BINDING */ "object_binding",
-	/* XS_TOKEN_OPTION */ "?.",
-	/* XS_TOKEN_OR */ "||",
-	/* XS_TOKEN_OR_ASSIGN */ "||=",
-	/* XS_TOKEN_PACKAGE */ "package",
-	/* XS_TOKEN_PARAMS */ "params",
-	/* XS_TOKEN_PARAMS_BINDING */ "params_binding",
-	/* XS_TOKEN_PLUS */ "plus",
-	/* XS_TOKEN_PRIVATE */ "private",
-	/* XS_TOKEN_PRIVATE_IDENTIFIER */ "private_identifier",
-	/* XS_TOKEN_PRIVATE_MEMBER */ "private_member",
-	/* XS_TOKEN_PRIVATE_PROPERTY */ "private_property",
-	/* XS_TOKEN_PROGRAM */ "program",
-	/* XS_TOKEN_PROPERTY */ "property",
-	/* XS_TOKEN_PROPERTY_AT */ "property_at",
-	/* XS_TOKEN_PROPERTY_BINDING */ "property_binding",
-	/* XS_TOKEN_PROPERTY_BINDING_AT */ "property_binding_at",
-	/* XS_TOKEN_PROTECTED */ "protected",
-	/* XS_TOKEN_PUBLIC */ "public",
-	/* XS_TOKEN_QUESTION_MARK */ "?",
-	/* XS_TOKEN_REGEXP */ "regexp",
-	/* XS_TOKEN_REST_BINDING */ "rest_binding",
-	/* XS_TOKEN_RETURN */ "return",
-	/* XS_TOKEN_RIGHT_BRACE */ "}",
-	/* XS_TOKEN_RIGHT_BRACKET */ "]",
-	/* XS_TOKEN_RIGHT_PARENTHESIS */ ")",
-	/* XS_TOKEN_SEMICOLON */ ";",
-	/* XS_TOKEN_SETTER */ "setter",
-	/* XS_TOKEN_SHORT */ "short",
-	/* XS_TOKEN_SIGNED_RIGHT_SHIFT */ ">>",
-	/* XS_TOKEN_SIGNED_RIGHT_SHIFT_ASSIGN */ ">>=",
-	/* XS_TOKEN_SKIP_BINDING */ "skip_binding",
-	/* XS_TOKEN_SPECIFIER */ "specifier",
-	/* XS_TOKEN_SPREAD */ "...",
-	/* XS_TOKEN_STATEMENT */ "statement",
-	/* XS_TOKEN_STATEMENTS */ "statements",
-	/* XS_TOKEN_STATIC */ "static",
-	/* XS_TOKEN_STRICT_EQUAL */ "===",
-	/* XS_TOKEN_STRICT_NOT_EQUAL */ "!==",
-	/* XS_TOKEN_STRING */ "string",
-	/* XS_TOKEN_SUBTRACT */ "-",
-	/* XS_TOKEN_SUBTRACT_ASSIGN */ "-=",
-	/* XS_TOKEN_SUPER */ "super",
-	/* XS_TOKEN_SWITCH */ "switch",
-	/* XS_TOKEN_TARGET */ "target",
-	/* XS_TOKEN_TEMPLATE */ "template",
-	/* XS_TOKEN_TEMPLATE_HEAD */ "template_head",
-	/* XS_TOKEN_TEMPLATE_MIDDLE */ "template_middle",
-	/* XS_TOKEN_TEMPLATE_TAIL */ "template_tail",
-	/* XS_TOKEN_THIS */ "this",
-	/* XS_TOKEN_THROW */ "throw",
-	/* XS_TOKEN_TRUE */ "true",
-	/* XS_TOKEN_TRY */ "try",
-	/* XS_TOKEN_TYPEOF */ "typeof",
-	/* XS_TOKEN_UNDEFINED */ "undefined",
-	/* XS_TOKEN_UNSIGNED_RIGHT_SHIFT */ ">>>",
-	/* XS_TOKEN_UNSIGNED_RIGHT_SHIFT_ASSIGN */ ">>>=",
-	/* XS_TOKEN_VAR */ "var",
-	/* XS_TOKEN_VOID */ "void",
-	/* XS_TOKEN_WHILE */ "while",
-	/* XS_TOKEN_WITH */ "with",
-	/* XS_TOKEN_YIELD */ "yield",
-};
-
-txBoolean fxIsKeyword(txParser* parser, txSymbol* keyword)
-{
-	txBoolean result = ((parser->token == XS_TOKEN_IDENTIFIER) && (parser->symbol == keyword)) ? 1 : 0;
-	if (result) {
-		if (parser->escaped)
-			fxReportParserError(parser, parser->line, "escaped keyword");
-	}
-	return result;
-}
-
-txBoolean fxIsToken(txParser* parser, txToken theToken)
-{
-	txBoolean result = (parser->token == theToken) ? 1 : 0;
-	if (result) {
-		if (parser->escaped)
-			fxReportParserError(parser, parser->line, "escaped keyword");
-	}
-	return result;
-}
-
-void fxMatchToken(txParser* parser, txToken theToken)
-{
-	if (parser->token == theToken) {
-		if (parser->escaped)
-			fxReportParserError(parser, parser->line, "escaped keyword");
-		fxGetNextToken(parser);
-	}
-	else
-		fxReportParserError(parser, parser->line, "missing %s", gxTokenNames[theToken]);
-}
-
-txNode* fxPopNode(txParser* parser)
-{
-	txNode* node = parser->root;
-	parser->root = node->next;
-	node->next = NULL;
-	parser->nodeCount--;
-	return node;
-}
-
-void fxPushNode(txParser* parser, txNode* node)
-{
-	node->next = parser->root;
-	parser->root = (txNode*)node;
-	parser->nodeCount++;
-}
-
-void fxPushBigIntNode(txParser* parser, txBigInt* value, txInteger line)
-{
-	txBigIntNode* node = fxNewParserChunk(parser, sizeof(txBigIntNode));
-	node->description = &gxTokenDescriptions[XS_TOKEN_BIGINT];
-	node->path = parser->path;
-	node->line = line;
-	node->flags = 0;
-	node->value = *value;
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxPushIndexNode(txParser* parser, txIndex value, txInteger line)
-{
-	if (((txInteger)value) >= 0)
-		fxPushIntegerNode(parser, (txInteger)value, line);
-	else
-		fxPushNumberNode(parser, value, line);
-}
-
-void fxPushIntegerNode(txParser* parser, txInteger value, txInteger line)
-{
-	txIntegerNode* node = fxNewParserChunk(parser, sizeof(txIntegerNode));
-	node->description = &gxTokenDescriptions[XS_TOKEN_INTEGER];
-	node->path = parser->path;
-	node->line = line;
-	node->flags = 0;
-	node->value = value;
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxPushNodeStruct(txParser* parser, txInteger count, txToken token, txInteger line)
-{
-	const txNodeDescription* description = &gxTokenDescriptions[token];
-	txNode* node;
-	if ((count > parser->nodeCount) || ((sizeof(txNode) + (count * sizeof(txNode*))) > (size_t)(description->size))) {
-		fxReportParserError(parser, parser->line, "invalid %s", gxTokenNames[token]);
-	}
-    node = fxNewParserChunkClear(parser, description->size);
-	node->description = description;
-	node->flags |= parser->flags & (mxStrictFlag | mxGeneratorFlag | mxAsyncFlag);
-	node->path = parser->path;
-	node->line = line;
-    parser->nodeCount -= count;
-	if (count) {
-		txNode** dst = (txNode**)&node[1];
-		txNode* src = parser->root;
-		while (count) {
-			txNode* next = src->next;
-			src->next = NULL;
-			count--;
-			if (src->description)
-				dst[count] = src;
-			else if (src->path)
-				dst[count] = (txNode*)(src->path);
-			src = next;
-		}
-		parser->root = src;
-	}
-	fxPushNode(parser, node);
-}
-
-void fxPushNodeList(txParser* parser, txInteger count)
-{
-	txNodeList* list = fxNewParserChunk(parser, sizeof(txNodeList));
-	txNode* previous = NULL;
-	txNode* current = parser->root;
-	txNode* next;
-    parser->nodeCount -= count;
-	list->length = count;
-	while (count) {
-		next = current->next;
-		current->next = previous;
-		previous = current;
-		current = next;
-		count--;
-	}
-	parser->root = current;
-	list->description = &gxTokenDescriptions[XS_NO_TOKEN];
-	list->first = previous;
-	fxPushNode(parser, (txNode*)list);
-}
-
-void fxPushNULL(txParser* parser)
-{
-    txNodeLink* node = fxNewParserChunkClear(parser, sizeof(txNodeLink));
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxPushNumberNode(txParser* parser, txNumber value, txInteger line)
-{
-	txNumberNode* node = fxNewParserChunk(parser, sizeof(txNumberNode));
-	node->description = &gxTokenDescriptions[XS_TOKEN_NUMBER];
-	node->path = parser->path;
-	node->line = line;
-	node->flags = 0;
-	node->value = value;
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxPushRawNode(txParser* parser, txInteger length, txString value, txInteger line)
-{
-	txStringNode* node = fxNewParserChunk(parser, sizeof(txStringNode));
-	node->description = &gxTokenDescriptions[XS_TOKEN_STRING];
-	node->path = parser->path;
-	node->line = line;
-	node->flags = 0;
-	node->length = length;
-	node->value = value;
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxPushStringNode(txParser* parser, txInteger length, txString value, txInteger line)
-{
-	txStringNode* node = fxNewParserChunk(parser, sizeof(txStringNode));
-	node->description = &gxTokenDescriptions[XS_TOKEN_STRING];
-	node->path = parser->path;
-	node->line = line;
-	node->flags = parser->escaped;
-	node->length = length;
-	node->value = value;
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxPushSymbol(txParser* parser, txSymbol* symbol)
-{
-    txNodeLink* node = fxNewParserChunkClear(parser, sizeof(txNodeLink));
-	node->symbol = symbol;	
-	fxPushNode(parser, (txNode*)node);
-}
-
-void fxSwapNodes(txParser* parser)
-{
-	txNode* previous = parser->root;
-	txNode* current = previous->next;
-	previous->next = current->next;
-	current->next = previous;
-	parser->root = current;
-}
-
-void fxModule(txParser* parser)
-{
-	txInteger aCount = parser->nodeCount;
-	txInteger aLine = parser->line;
-	while ((parser->token != XS_TOKEN_EOF)) {
-		if (parser->token == XS_TOKEN_EXPORT)
-			fxExport(parser);
-		else if (parser->token == XS_TOKEN_IMPORT) {
-			fxGetNextToken2(parser);
-			if ((parser->token2 == XS_TOKEN_DOT) || (parser->token2 == XS_TOKEN_LEFT_PARENTHESIS))
-				fxStatement(parser, 1);
-			else
-				fxImport(parser);
-		}
-		else if (parser->token == XS_TOKEN_RETURN) {
-			fxReportParserError(parser, parser->line, "invalid return");
-			fxGetNextToken(parser);
-		}
-		else if (parser->token == XS_TOKEN_YIELD) {
-			fxReportParserError(parser, parser->line, "invalid yield");
-			fxGetNextToken(parser);
-		}
-		else {
-			fxStatement(parser, 1);
-		}
-	}
-	aCount = parser->nodeCount - aCount;
-	if (aCount > 1) {
-		fxPushNodeList(parser, aCount);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
-	}
-	else if (aCount == 0) {
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_MODULE, aLine);
-	parser->root->flags = parser->flags & (mxStrictFlag | mxAwaitingFlag);
-}
-
-void fxExport(txParser* parser)
-{
-	txSymbol* symbol = C_NULL;
-	txInteger count;
-	txInteger line = parser->line;
-	txUnsigned flag = 0;
-	txToken aToken;
-	fxMatchToken(parser, XS_TOKEN_EXPORT);
-	switch (parser->token) {
-	case XS_TOKEN_MULTIPLY:
-		fxPushNULL(parser);
-		fxGetNextToken(parser);
-		if (fxIsKeyword(parser, parser->asSymbol)) {
-			fxGetNextToken(parser);
-			if (gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME) {
-				fxPushSymbol(parser, parser->symbol);
-				fxGetNextToken(parser);
-			}
-			else {
-				fxPushNULL(parser);
-				fxReportParserError(parser, parser->line, "missing identifier");
-			}
-		}
-		else {
-			fxPushNULL(parser);
-		}
-		if (fxIsKeyword(parser, parser->fromSymbol)) {
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_STRING) {
-				fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
-				fxPushNodeList(parser, 1);
-				fxPushStringNode(parser, parser->stringLength, parser->string, line);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_EXPORT, line);
-				fxGetNextToken(parser);
-				fxSemicolon(parser);
-			}
-			else
-				fxReportParserError(parser, parser->line, "missing module");
-		}
-		else
-			fxReportParserError(parser, parser->line, "missing from");
-		break;
-	case XS_TOKEN_DEFAULT:
-		fxMatchToken(parser, XS_TOKEN_DEFAULT);
-		if (parser->flags & mxDefaultFlag)
-			fxReportParserError(parser, parser->line, "invalid default");
-		parser->flags |= mxDefaultFlag;
-		if (parser->token == XS_TOKEN_CLASS) {
-			fxClassExpression(parser, line, &symbol);
-			if (symbol)
-				fxPushSymbol(parser, symbol);
-			else
-				fxPushSymbol(parser, parser->defaultSymbol);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
-			fxSwapNodes(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
-		}
-		else if (parser->token == XS_TOKEN_FUNCTION) {
-	again:
-			fxMatchToken(parser, XS_TOKEN_FUNCTION);
-			if (parser->token == XS_TOKEN_MULTIPLY) {
-				fxGetNextToken(parser);
-				fxGeneratorExpression(parser, line, &symbol, flag);
-			}
-			else
-				fxFunctionExpression(parser, line, &symbol, flag);
-			if (symbol) {
-				txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
-				node->initializer = fxPopNode(parser);
-				fxPushNode(parser, (txNode*)node);
-			}
-			else {
-				txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, parser->defaultSymbol);
-				node->initializer = fxPopNode(parser);
-				fxPushNode(parser, (txNode*)node);
-			}
-		}
-		else {
-			if ((parser->token == XS_TOKEN_IDENTIFIER) && (parser->symbol == parser->asyncSymbol) && (!parser->escaped)) {
-				fxGetNextToken2(parser);
-				if ((!parser->crlf2) && (parser->token2 == XS_TOKEN_FUNCTION)) {
-					fxGetNextToken(parser);
-					flag = mxAsyncFlag;
-					goto again;					
-				}
-			}
-			fxAssignmentExpression(parser);
-			fxSemicolon(parser);
-			fxPushSymbol(parser, parser->defaultSymbol);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_CONST, line);
-			fxSwapNodes(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, line);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
-		}
-		if (symbol) {
-			fxPushSymbol(parser, symbol);
-			fxPushSymbol(parser, parser->defaultSymbol);
-		}
-		else {
-			fxPushSymbol(parser, parser->defaultSymbol);
-			fxPushNULL(parser);
-		}
-		fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
-		fxPushNodeList(parser, 1);
-		fxPushNULL(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_EXPORT, line);
-		break;
-	case XS_TOKEN_CLASS:
-		fxClassExpression(parser, line, &symbol);
-		if (symbol) {
-			fxPushSymbol(parser, symbol);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
-			fxSwapNodes(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
-			
-			fxPushSymbol(parser, symbol);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
-			fxPushNodeList(parser, 1);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_EXPORT, line);
-		}
-		else
-			fxReportParserError(parser, parser->line, "missing identifier");
-		break;
-	case XS_TOKEN_FUNCTION:
-	again2:
-		fxMatchToken(parser, XS_TOKEN_FUNCTION);
-		if (parser->token == XS_TOKEN_MULTIPLY) {
-			fxGetNextToken(parser);
-			fxGeneratorExpression(parser, line, &symbol, flag);
-		}
-		else
-			fxFunctionExpression(parser, line, &symbol, flag);
-		if (symbol) {
-			txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
-			node->initializer = fxPopNode(parser);
-			fxPushNode(parser, (txNode*)node);
-			fxPushSymbol(parser, symbol);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, line);
-			fxPushNodeList(parser, 1);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_EXPORT, line);
-		}
-		else
-			fxReportParserError(parser, parser->line, "missing identifier");
-		break;
-	case XS_TOKEN_CONST:
-	case XS_TOKEN_LET:
-	case XS_TOKEN_VAR:
-		aToken = parser->token;
-		fxVariableStatement(parser, aToken);
-		count = parser->nodeCount;
-		fxExportBinding(parser, parser->root);
-		fxPushNodeList(parser, parser->nodeCount - count);
-		fxPushNULL(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_EXPORT, line);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_LEFT_BRACE:
-		count = parser->nodeCount;
-		fxSpecifiers(parser);
-		fxPushNodeList(parser, parser->nodeCount - count);
-		if (fxIsKeyword(parser, parser->fromSymbol)) {
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_STRING) {
-				fxPushStringNode(parser, parser->stringLength, parser->string, line);
-				fxGetNextToken(parser);
-			}
-			else {
-				fxPushNULL(parser);
-				fxReportParserError(parser, parser->line, "missing module");
-			}
-		}
-		else
-			fxPushNULL(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_EXPORT, line);
-		fxSemicolon(parser);
-		break;
-	default:
-		if ((parser->token == XS_TOKEN_IDENTIFIER) && (parser->symbol == parser->asyncSymbol) && (!parser->escaped)) {
-			fxGetNextToken2(parser);
-			if ((!parser->crlf2) && (parser->token2 == XS_TOKEN_FUNCTION)) {
-				fxGetNextToken(parser);
-				flag = mxAsyncFlag;
-				goto again2;					
-			}
-		}
-		fxReportParserError(parser, parser->line, "invalid export %s", gxTokenNames[parser->token]);
-		fxGetNextToken(parser);
-		break;
-	}
-}
-
-void fxExportBinding(txParser* parser, txNode* node)
-{
-	txToken token = node->description->token;
-	if ((token == XS_TOKEN_CONST) || (token == XS_TOKEN_LET) || (token == XS_TOKEN_VAR)) {
-		fxPushSymbol(parser, ((txDeclareNode*)node)->symbol);
-		fxPushNULL(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, node->line);
-	}
-	else if (token == XS_TOKEN_BINDING) {
-		fxExportBinding(parser, ((txBindingNode*)node)->target);
-	}
-	else if (token == XS_TOKEN_ARRAY_BINDING) {
-		node = ((txArrayBindingNode*)node)->items->first;
-		while (node) {
-			fxExportBinding(parser, node);
-			node = node->next;
-		}
-	}
-	else if (token == XS_TOKEN_OBJECT_BINDING) {
-		node = ((txObjectBindingNode*)node)->items->first;
-		while (node) {
-			fxExportBinding(parser, node);
-			node = node->next;
-		}
-	}
-	else if (token == XS_TOKEN_PROPERTY_BINDING)
-		fxExportBinding(parser, ((txPropertyBindingNode*)node)->binding);
-	else if (token == XS_TOKEN_PROPERTY_BINDING_AT)
-		fxExportBinding(parser, ((txPropertyBindingAtNode*)node)->binding);
-	else if (token == XS_TOKEN_REST_BINDING)
-		fxExportBinding(parser, ((txRestBindingNode*)node)->binding);
-	else if (token == XS_TOKEN_STATEMENTS) {
-		node = ((txStatementsNode*)node)->items->first;
-		while (node) {
-			fxExportBinding(parser, node);
-			node = node->next;
-		}
-	}
-}
-
-
-void fxImport(txParser* parser)
-{
-	txBoolean asFlag = 1;
-	txBoolean fromFlag = 0;
-	txInteger count = parser->nodeCount;
-	fxMatchToken(parser, XS_TOKEN_IMPORT);
-	if (parser->token == XS_TOKEN_IDENTIFIER) {
-		fxPushSymbol(parser, parser->defaultSymbol);
-		fxPushSymbol(parser, parser->symbol);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->line);
-		fxGetNextToken(parser);
-		if (parser->token == XS_TOKEN_COMMA)
-			fxGetNextToken(parser);
-		else
-			asFlag = 0;
-		fromFlag = 1;
-	}
-	if (asFlag) {
-		if (parser->token == XS_TOKEN_MULTIPLY) {
-			fxGetNextToken(parser);
-			if (fxIsKeyword(parser, parser->asSymbol)) {
-				fxGetNextToken(parser);
-				if (parser->token == XS_TOKEN_IDENTIFIER) {
-					fxPushNULL(parser);
-					fxPushSymbol(parser, parser->symbol);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->line);
-					fxGetNextToken(parser);
-				}
-				else {
-					fxReportParserError(parser, parser->line, "missing identifier");
-				}
-			}
-			else {
-				fxReportParserError(parser, parser->line, "missing as");
-			}
-			fromFlag = 1;
-		}
-		else if (parser->token == XS_TOKEN_LEFT_BRACE) {
-			fxSpecifiers(parser);
-			fromFlag = 1;
-		}
-	}
-	fxPushNodeList(parser, parser->nodeCount - count);
-	if (fromFlag) {
-		if (fxIsKeyword(parser, parser->fromSymbol)) {
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_STRING) {
-				fxPushStringNode(parser, parser->stringLength, parser->string, parser->line);
-				fxGetNextToken(parser);
-			}
-			else {
-				fxPushNULL(parser);
-				fxReportParserError(parser, parser->line, "missing module");
-			}
-		}
-		else {
-			fxPushNULL(parser);
-			fxReportParserError(parser, parser->line, "missing from");
-		}
-	}
-	else if (parser->token == XS_TOKEN_STRING) {
-		fxPushStringNode(parser, parser->stringLength, parser->string, parser->line);
-		fxGetNextToken(parser);
-	}
-	else {
-		fxPushNULL(parser);
-		fxReportParserError(parser, parser->line, "missing module");
-	}
-	fxPushNodeStruct(parser, 2, XS_TOKEN_IMPORT, parser->line);
-	fxSemicolon(parser);
-}
-
-void fxSpecifiers(txParser* parser)
-{
-	txInteger aCount = 0;
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-	while (gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME) {
-		fxPushSymbol(parser, parser->symbol);
-		fxGetNextToken(parser);
-		if (fxIsKeyword(parser, parser->asSymbol)) {
-			fxGetNextToken(parser);
-			if (gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME) {
-				fxPushSymbol(parser, parser->symbol);
-				fxGetNextToken(parser);
-			}
-			else {
-				fxPushNULL(parser);
-				fxReportParserError(parser, parser->line, "missing identifier");
-			}
-		}
-		else
-			fxPushNULL(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_SPECIFIER, parser->line);
-		aCount++;
-		if (parser->token != XS_TOKEN_COMMA) 
-			break;
-		fxGetNextToken(parser);
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-}
-
-void fxProgram(txParser* parser)
-{
-	txInteger count = parser->nodeCount;
-	txInteger line = parser->line;
-	txNode* node;
-	while (parser->token != XS_TOKEN_EOF) {
-		fxStatement(parser, 1);
-		node = parser->root;
-		if (!node || !node->description || (node->description->token != XS_TOKEN_STATEMENT))
-			break;
-		node = ((txStatementNode*)node)->expression;
-		if (!node || !node->description || (node->description->token != XS_TOKEN_STRING))
-			break;
-		if (!(node->flags & mxStringEscapeFlag) && (c_strcmp(((txStringNode*)node)->value, "use strict") == 0)) {
-			if (!(parser->flags & mxStrictFlag)) {
-				parser->flags |= mxStrictFlag;
-				if (parser->token == XS_TOKEN_IDENTIFIER)
-					fxCheckStrictKeyword(parser);
-			}
-		}
-	}
-	while (parser->token != XS_TOKEN_EOF) {
-		fxStatement(parser, 1);
-	}
-	count = parser->nodeCount - count;
-	if (count > 1) {
-		fxPushNodeList(parser, count);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
-	}
-	else if (count == 0) {
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_PROGRAM, line);
-	if (parser->flags & mxFieldFlag)
-		if (parser->flags & mxArgumentsFlag)
-			fxReportParserError(parser, parser->line, "invalid arguments");
-	parser->root->flags = parser->flags & mxStrictFlag;
-}
-
-void fxBody(txParser* parser)
-{
-	txInteger count = parser->nodeCount;
-	txInteger line = parser->line;
-	txNode* node;
-    fxCheckParserStack(parser, line);
-	while ((parser->token != XS_TOKEN_EOF) && (parser->token != XS_TOKEN_RIGHT_BRACE)) {
-		fxStatement(parser, 1);
-		node = parser->root;
-		if (!node || !node->description || (node->description->token != XS_TOKEN_STATEMENT))
-			break;
-		node = ((txStatementNode*)node)->expression;
-		if (!node || !node->description || (node->description->token != XS_TOKEN_STRING))
-			break;
-		if (!(node->flags & mxStringEscapeFlag) && (c_strcmp(((txStringNode*)node)->value, "use strict") == 0)) {
-			if (parser->flags & mxNotSimpleParametersFlag)
-				fxReportParserError(parser, parser->line, "invalid directive");
-			if (!(parser->flags & mxStrictFlag)) {
-				parser->flags |= mxStrictFlag;
-				if (parser->token == XS_TOKEN_IDENTIFIER)
-					fxCheckStrictKeyword(parser);
-			}
-		}
-	}
-	while ((parser->token != XS_TOKEN_EOF) && (parser->token != XS_TOKEN_RIGHT_BRACE)) {
-		fxStatement(parser, 1);
-	}
-	count = parser->nodeCount - count;
-	if (count > 1) {
-		fxPushNodeList(parser, count);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
-	}
-	else if (count == 0) {
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
-	}
-}
-
-void fxBlock(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxCheckParserStack(parser, aLine);
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-	fxStatements(parser);
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_BLOCK, aLine);
-}
-
-void fxStatements(txParser* parser)
-{
-	txInteger count = parser->nodeCount;
-	txInteger line = parser->line;
-	while ((parser->token != XS_TOKEN_EOF) && (parser->token != XS_TOKEN_RIGHT_BRACE)) {
-		fxStatement(parser, 1);
-	}
-	count = parser->nodeCount - count;
-	fxPushNodeList(parser, count);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, line);
-}
-
-void fxStatement(txParser* parser, txBoolean blockIt)
-{
-	txInteger line = parser->line;
-	txSymbol* symbol = C_NULL;
-	txUnsigned flag = 0;
-	switch (parser->token) {
-//	case XS_TOKEN_COMMA:
-	case XS_TOKEN_SEMICOLON:
-		fxGetNextToken(parser);
-		if (!blockIt) {
-			fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
-		}
-		break;
-	case XS_TOKEN_BREAK:
-		fxBreakStatement(parser);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_CLASS:
-		if (!blockIt)
-			fxReportParserError(parser, parser->line, "no block");
-		fxClassExpression(parser, line, &symbol);
-		if (symbol) {
-			fxPushSymbol(parser, symbol);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_LET, line);
-			fxSwapNodes(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, line);
-		}
-		else
-			fxReportParserError(parser, parser->line, "missing identifier");
-		break;
-	case XS_TOKEN_CONST:
-		if (!blockIt)
-			fxReportParserError(parser, parser->line, "no block");
-		fxVariableStatement(parser, XS_TOKEN_CONST);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_CONTINUE:
-		fxContinueStatement(parser);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_DEBUGGER:
-		fxDebuggerStatement(parser);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_DO:
-		fxDoStatement(parser);
-		break;
-	case XS_TOKEN_FOR:
-		fxForStatement(parser);
-		break;
-	case XS_TOKEN_FUNCTION:
-		//if ((parser->flags & mxStrictFlag) && !blockIt) BROWSER
-	again:
-		if (!blockIt)
-			fxReportParserError(parser, parser->line, "no block (strict code)");
-		fxMatchToken(parser, XS_TOKEN_FUNCTION);
-		if (parser->token == XS_TOKEN_MULTIPLY) {
-			fxGetNextToken(parser);
-			fxGeneratorExpression(parser, line, &symbol, flag);
-		}
-		else
-			fxFunctionExpression(parser, line, &symbol, flag);
-		if (symbol) {
-			txDefineNode* node = fxDefineNodeNew(parser, XS_TOKEN_DEFINE, symbol);
-			node->initializer = fxPopNode(parser);
-			fxPushNode(parser, (txNode*)node);
-		}
-		else
-			fxReportParserError(parser, parser->line, "missing identifier");
-		break;
-	case XS_TOKEN_IF:
-		fxIfStatement(parser);
-		break;
-	case XS_TOKEN_RETURN:
-		if (!(parser->flags & (mxArrowFlag | mxFunctionFlag | mxGeneratorFlag)))
-			fxReportParserError(parser, parser->line, "invalid return");
-		fxReturnStatement(parser);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_LEFT_BRACE:
-		fxBlock(parser);
-		break;
-	case XS_TOKEN_LET:
-		if (!blockIt)
-			fxReportParserError(parser, parser->line, "no block");
-		fxVariableStatement(parser, XS_TOKEN_LET);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_SWITCH:
-		fxSwitchStatement(parser);
-		break;
-	case XS_TOKEN_THROW:
-		fxThrowStatement(parser);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_TRY:
-		fxTryStatement(parser);
-		break;
-	case XS_TOKEN_VAR:
-		fxVariableStatement(parser, XS_TOKEN_VAR);
-		fxSemicolon(parser);
-		break;
-	case XS_TOKEN_WHILE:
-		fxWhileStatement(parser);
-		break;
-	case XS_TOKEN_WITH:
-		if (parser->flags & mxStrictFlag)
-			fxReportParserError(parser, parser->line, "with (strict code)");
-		fxWithStatement(parser);
-		break;
-	case XS_TOKEN_IDENTIFIER:
-		fxGetNextToken2(parser);
-		if (parser->token2 == XS_TOKEN_COLON) {
-			fxPushSymbol(parser, parser->symbol);
-			fxGetNextToken(parser);
-			fxMatchToken(parser, XS_TOKEN_COLON);
-			//if ((parser->flags & mxStrictFlag) && (parser->token == XS_TOKEN_FUNCTION)) BROWSER
-			//	fxReportParserError(parser, parser->line, "labeled function (strict code)");
-			if (parser->token == XS_TOKEN_FUNCTION)
-				fxReportParserError(parser, parser->line, "labeled function");
-			fxCheckParserStack(parser, line);
-			fxStatement(parser, 0);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, line);
-			break;
-		}
-		if ((parser->symbol == parser->asyncSymbol) && (!parser->escaped) 
-				&& (!parser->crlf2) && (parser->token2 == XS_TOKEN_FUNCTION)) {
-			fxGetNextToken(parser);
-			flag = mxAsyncFlag;
-			goto again;
-		}
-		if ((parser->symbol == parser->letSymbol) && (!parser->escaped) 
-				&& ((gxTokenFlags[parser->token2] & XS_TOKEN_BEGIN_BINDING) || (parser->token2 == XS_TOKEN_AWAIT) || (parser->token2 == XS_TOKEN_YIELD))
-				&& (blockIt || (!parser->crlf2) || (parser->token2 == XS_TOKEN_LEFT_BRACKET))) {
-			parser->token = XS_TOKEN_LET;
-			if (!blockIt)
-				fxReportParserError(parser, parser->line, "no block");
-			fxVariableStatement(parser, XS_TOKEN_LET);
-			fxSemicolon(parser);
-			break;
-		}
-		/* continue */
-	default:
-		if (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION) {
-			fxCommaExpression(parser);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, line);
-			fxSemicolon(parser);
-		}
-		else {
-			fxReportParserError(parser, parser->line, "invalid token %s", gxTokenNames[parser->token]);
-			fxPushNULL(parser);
-			fxGetNextToken(parser);
-		}
-		break;
-	}
-}
-
-void fxSemicolon(txParser* parser)
-{
-	if ((parser->crlf) || (gxTokenFlags[parser->token] & XS_TOKEN_END_STATEMENT)) {
-		if (parser->token == XS_TOKEN_SEMICOLON)
-			fxGetNextToken(parser);
-	}
-	else
-		fxReportParserError(parser, parser->line, "missing ;");
-}
-
-void fxBreakStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_BREAK);
-	if ((!parser->crlf) && (parser->token == XS_TOKEN_IDENTIFIER)) {
-		fxPushSymbol(parser, parser->symbol);
-		fxGetNextToken(parser);
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_BREAK, aLine);
-}
-
-void fxContinueStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_CONTINUE);
-	if ((!parser->crlf) && (parser->token == XS_TOKEN_IDENTIFIER)) {
-		fxPushSymbol(parser, parser->symbol);
-		fxGetNextToken(parser);
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_CONTINUE, aLine);
-}
-
-void fxDebuggerStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_DEBUGGER);
-	fxPushNodeStruct(parser, 0, XS_TOKEN_DEBUGGER, aLine);
-}
-
-void fxDoStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxCheckParserStack(parser, aLine);
-	fxPushNULL(parser);
-	fxMatchToken(parser, XS_TOKEN_DO);
-	fxStatement(parser, 0);
-	fxMatchToken(parser, XS_TOKEN_WHILE);
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	fxCommaExpression(parser);
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	if (parser->token == XS_TOKEN_SEMICOLON)
-		fxGetNextToken(parser);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_DO, aLine);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
-}
-
-void fxForStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	txBoolean awaitFlag = 0;
-	txBoolean expressionFlag = 0;
-	txToken aToken;
-	fxPushNULL(parser);
-	fxMatchToken(parser, XS_TOKEN_FOR);
-	if (parser->token == XS_TOKEN_AWAIT) {
-		awaitFlag = 1;
-		fxMatchToken(parser, XS_TOKEN_AWAIT);
-	}
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	fxGetNextToken2(parser);
-	parser->flags |= mxForFlag;
-	if (parser->token == XS_TOKEN_SEMICOLON) {
-		fxPushNULL(parser);
-	}
-	else if (parser->token == XS_TOKEN_CONST) {
-		fxVariableStatement(parser, XS_TOKEN_CONST);
-	}
-	else if (parser->token == XS_TOKEN_LET) {
-		fxVariableStatement(parser, XS_TOKEN_LET);
-	}
-	else if (fxIsKeyword(parser, parser->letSymbol) && (gxTokenFlags[parser->token2] & XS_TOKEN_BEGIN_BINDING)) {
-		parser->token = XS_TOKEN_LET;
-		fxVariableStatement(parser, XS_TOKEN_LET);
-	}
-	else if (parser->token == XS_TOKEN_VAR) {
-		fxVariableStatement(parser, XS_TOKEN_VAR);
-	}
-	else {
-		fxCommaExpression(parser);
-		expressionFlag = 1;
-	}
-	parser->flags &= ~mxForFlag;
-	if (awaitFlag && !fxIsKeyword(parser, parser->ofSymbol))
-		fxReportParserError(parser, parser->line, "invalid for await");
-	if (fxIsToken(parser, XS_TOKEN_IN) || fxIsKeyword(parser, parser->ofSymbol)) {
-		if (expressionFlag) {
-			if (!fxCheckReference(parser, XS_TOKEN_ASSIGN)) {
-				fxReportParserError(parser, parser->line, "no reference");
-			}
-		}
-		else {
-			aToken = parser->root->description->token;
-			if (aToken == XS_TOKEN_BINDING) {
-				if (((txBindingNode*)(parser->root))->initializer)
-					fxReportParserError(parser, parser->line, "invalid binding initializer");
-			}
-// 			else if (aToken == XS_TOKEN_ARRAY_BINDING) {
-// 				if (((txArrayBindingNode*)(parser->root))->initializer)
-// 					fxReportParserError(parser, parser->line, "invalid array binding initializer");
-// 			}
-// 			else if (aToken == XS_TOKEN_OBJECT_BINDING) {
-// 				if (((txObjectBindingNode*)(parser->root))->initializer)
-// 					fxReportParserError(parser, parser->line, "invalid object binding initializer");
-// 			}
-// 			else
-// 				fxReportParserError(parser, parser->line, "no reference %s", gxTokenNames[aToken]);
-		}
-		aToken = parser->token;
-		fxGetNextToken(parser);
-		if (aToken == XS_TOKEN_IN)
-			fxCommaExpression(parser);
-		else
-			fxAssignmentExpression(parser);
-		fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-		fxStatement(parser, 0);
-		if (awaitFlag)
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_AWAIT_OF, aLine);
-		else if (aToken == XS_TOKEN_IN)
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_IN, aLine);
-		else
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FOR_OF, aLine);
-	}
-	else {
-		if (expressionFlag)
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
-		fxMatchToken(parser, XS_TOKEN_SEMICOLON);
-		if (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION) {
-			fxCommaExpression(parser);
-		}
-		else {
-			fxPushNULL(parser);
-		}
-		fxMatchToken(parser, XS_TOKEN_SEMICOLON);
-		if (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION) {
-			fxCommaExpression(parser);
-		}
-		else {
-			fxPushNULL(parser);
-		}
-		fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-		fxCheckParserStack(parser, aLine);
-		fxStatement(parser, 0);
-		fxPushNodeStruct(parser, 4, XS_TOKEN_FOR, aLine);
-	}
-	fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
-}
-
-void fxIfStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_IF);
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	fxCommaExpression(parser);
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	fxStatement(parser, 0);
-	if (parser->token == XS_TOKEN_ELSE) {
-		fxMatchToken(parser, XS_TOKEN_ELSE);
-		fxStatement(parser, 0);
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	fxPushNodeStruct(parser, 3, XS_TOKEN_IF, aLine);
-}
-
-void fxReturnStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_RETURN);
-	if ((!parser->crlf) && (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION)) {
-		fxCommaExpression(parser);
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_RETURN, aLine);
-}
-
-void fxSwitchStatement(txParser* parser)
-{
-	txInteger aCount = 0;
-	txBoolean aDefaultFlag = 0;
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_SWITCH);
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	fxCommaExpression(parser);
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-	while ((parser->token == XS_TOKEN_CASE) || (parser->token == XS_TOKEN_DEFAULT)) {
-		txInteger aCaseCount;
-		txInteger aCaseLine = parser->line;
-		if (parser->token == XS_TOKEN_CASE) {
-			fxMatchToken(parser, XS_TOKEN_CASE);
-			fxCommaExpression(parser);
-			fxMatchToken(parser, XS_TOKEN_COLON);
-			aCaseCount = parser->nodeCount;
-			while (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_STATEMENT)
-				fxStatement(parser, 1);
-			aCaseCount = parser->nodeCount - aCaseCount;
-			if (aCaseCount > 1) {
-				fxPushNodeList(parser, aCaseCount);
-				fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aCaseLine);
-			}
-			else if (aCaseCount == 0) {
-				fxPushNULL(parser);
-			}
-			fxPushNodeStruct(parser, 2, XS_TOKEN_CASE, aCaseLine);
-		}
-		else {
-			fxMatchToken(parser, XS_TOKEN_DEFAULT);
-			if (aDefaultFlag) 
-				fxReportParserError(parser, parser->line, "invalid default");
-			fxPushNULL(parser);
-			fxMatchToken(parser, XS_TOKEN_COLON);
-			aCaseCount = parser->nodeCount;
-			while (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_STATEMENT)
-				fxStatement(parser, 1);
-			aCaseCount = parser->nodeCount - aCaseCount;
-			if (aCaseCount > 1) {
-				fxPushNodeList(parser, aCaseCount);
-				fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
-			}
-			else if (aCaseCount == 0) {
-				fxPushNULL(parser);
-			}
-			fxPushNodeStruct(parser, 2, XS_TOKEN_CASE, aCaseLine);
-			aDefaultFlag = 1;
-		}
-		aCount++;
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_SWITCH, aLine);
-}
-
-void fxThrowStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_THROW);
-	if ((!parser->crlf) && (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION)) {
-		fxCommaExpression(parser);
-	}
-	else {
-		fxReportParserError(parser, parser->line, "missing expression");
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_THROW, aLine);
-}
-
-void fxTryStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_TRY);
-	fxBlock(parser);
-	if (parser->token == XS_TOKEN_CATCH) {
-		txInteger aCatchLine = parser->line;
-		fxMatchToken(parser, XS_TOKEN_CATCH);
-		if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-			fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-			fxBinding(parser, XS_TOKEN_LET, 1);
-			fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-		}
-		else
-			fxPushNULL(parser);
-		fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-		fxStatements(parser);
-		fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_CATCH, aCatchLine);
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	if (parser->token == XS_TOKEN_FINALLY) {
-		fxMatchToken(parser, XS_TOKEN_FINALLY);
-		fxBlock(parser);
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	fxPushNodeStruct(parser, 3, XS_TOKEN_TRY, aLine);
-}
-
-void fxVariableStatement(txParser* parser, txToken theToken)
-{
-	txBoolean commaFlag = 0;
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, theToken);
-	while (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_BINDING) {
-		commaFlag = 0;
-		fxBinding(parser, theToken, 1);
-// 		if (parser->token == XS_TOKEN_ASSIGN) {
-// 			parser->flags &= ~mxForFlag;
-// 			fxGetNextToken(parser);
-// 			fxAssignmentExpression(parser);
-// 			fxPushNodeStruct(parser, 2, XS_TOKEN_ASSIGN, aLine);
-// 			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
-// 		}
-		aCount++;
-		if (parser->token == XS_TOKEN_COMMA) {
-			parser->flags &= ~mxForFlag;
-			fxGetNextToken(parser);
-			commaFlag = 1;
-		}
-		else
-			break;
-	}
-    if ((aCount == 0) || commaFlag) {
-		fxPushNULL(parser);
-		fxPushNULL(parser);
-		fxPushNodeStruct(parser, 2, theToken, aLine);
-		fxReportParserError(parser, parser->line, "missing identifier");
-	}
-	if (aCount > 1) {
-		fxPushNodeList(parser, aCount);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
-	}
-}
-
-void fxWhileStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxPushNULL(parser);
-	fxMatchToken(parser, XS_TOKEN_WHILE);
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	fxCommaExpression(parser);
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	fxStatement(parser, 0);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_WHILE, aLine);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_LABEL, aLine);
-}
-
-void fxWithStatement(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_WITH);
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	fxCommaExpression(parser);
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	fxStatement(parser, 0);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_WITH, aLine);
-}
-
-void fxCommaExpression(txParser* parser)
-{
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	if (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION) {
-		fxAssignmentExpression(parser);
-		aCount++;
-		while (parser->token == XS_TOKEN_COMMA) {
-			fxGetNextToken(parser);
-			fxAssignmentExpression(parser);
-			aCount++;
-		}
-	}
-	if (aCount > 1) {
-		fxPushNodeList(parser, aCount);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
-	}
-	else if (aCount == 0) {
-		fxPushNULL(parser);
-		fxReportParserError(parser, parser->line, "missing expression");
-	}
-}
-
-void fxAssignmentExpression(txParser* parser)
-{
-	if (parser->token == XS_TOKEN_YIELD)
-		fxYieldExpression(parser);
-	else {
-		fxConditionalExpression(parser);
-		while (gxTokenFlags[parser->token] & XS_TOKEN_ASSIGN_EXPRESSION) {
-			txToken aToken = parser->token;
-			txInteger aLine = parser->line;
-			if (!fxCheckReference(parser, aToken)) 
-				fxReportParserError(parser, parser->line, "no reference");
-			fxGetNextToken(parser);
-			fxAssignmentExpression(parser);
-			fxPushNodeStruct(parser, 2, aToken, aLine);
-		}
-	}
-}
-
-void fxConditionalExpression(txParser* parser)
-{
-	fxCoalesceExpression(parser);
-	if (parser->token == XS_TOKEN_QUESTION_MARK) {
-		txInteger aLine = parser->line;
-		txUnsigned flags;
-		fxCheckArrowFunction(parser, 1);
-		fxGetNextToken(parser);
-		flags = parser->flags & mxForFlag;
-		parser->flags &= ~mxForFlag;
-		fxAssignmentExpression(parser);
-		parser->flags |= flags;
-		fxMatchToken(parser, XS_TOKEN_COLON);
-		fxAssignmentExpression(parser);
-		fxPushNodeStruct(parser, 3, XS_TOKEN_QUESTION_MARK, aLine);
-	}
-}
-
-void fxCoalesceExpression(txParser* parser)
-{
-	fxOrExpression(parser);
-	while (parser->token == XS_TOKEN_COALESCE) {
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxOrExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_COALESCE, aLine);
-	}
-}
-
-void fxOrExpression(txParser* parser)
-{
-	fxAndExpression(parser);
-	while (parser->token == XS_TOKEN_OR) {
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxAndExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_OR, aLine);
-	}
-}
-
-void fxAndExpression(txParser* parser)
-{
-	fxBitOrExpression(parser);
-	while (parser->token == XS_TOKEN_AND) {
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxBitOrExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_AND, aLine);
-	}
-}
-
-void fxBitOrExpression(txParser* parser)
-{
-	fxBitXorExpression(parser);
-	while (parser->token == XS_TOKEN_BIT_OR) {
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxBitXorExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_OR, aLine);
-	}
-}
-
-void fxBitXorExpression(txParser* parser)
-{
-	fxBitAndExpression(parser);
-	while (parser->token == XS_TOKEN_BIT_XOR) {
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxBitAndExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_XOR, aLine);
-	}
-}
-
-void fxBitAndExpression(txParser* parser)
-{
-	fxEqualExpression(parser);
-	while (parser->token == XS_TOKEN_BIT_AND) {
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxEqualExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_BIT_AND, aLine);
-	}
-}
-
-void fxEqualExpression(txParser* parser)
-{
-	fxRelationalExpression(parser);
-	while (gxTokenFlags[parser->token] & XS_TOKEN_EQUAL_EXPRESSION) {
-		txToken aToken = parser->token;
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxRelationalExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, aToken, aLine);
-	}
-}
-
-void fxRelationalExpression(txParser* parser)
-{
-	if (parser->token == XS_TOKEN_PRIVATE_IDENTIFIER) {
-		txInteger aLine = parser->line;
-		fxPushSymbol(parser, parser->symbol);
-		fxGetNextToken(parser);
-		fxMatchToken(parser, XS_TOKEN_IN);
-		if (parser->flags & mxForFlag)
-			fxReportParserError(parser, parser->line, "invalid %s", gxTokenNames[XS_TOKEN_IN]);
-		fxShiftExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_IDENTIFIER, aLine);
-	}
-	else {
-		fxShiftExpression(parser);
-		if ((parser->flags & mxForFlag) && ((parser->token == XS_TOKEN_IN) || fxIsKeyword(parser, parser->ofSymbol)))
-			return;
-		while (gxTokenFlags[parser->token] & XS_TOKEN_RELATIONAL_EXPRESSION) {
-			txToken aToken = parser->token;
-			txInteger aLine = parser->line;
-			fxMatchToken(parser, aToken);
-			fxShiftExpression(parser);
-			fxCheckArrowFunction(parser, 2);
-			fxPushNodeStruct(parser, 2, aToken, aLine);
-		}
-	}
-}
-
-void fxShiftExpression(txParser* parser)
-{
-	fxAdditiveExpression(parser);
-	while (gxTokenFlags[parser->token] & XS_TOKEN_SHIFT_EXPRESSION) {
-		txToken aToken = parser->token;
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxAdditiveExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, aToken, aLine);
-	}
-}
-
-void fxAdditiveExpression(txParser* parser)
-{
-	fxMultiplicativeExpression(parser);
-	while (gxTokenFlags[parser->token] & XS_TOKEN_ADDITIVE_EXPRESSION) {
-		txToken aToken = parser->token;
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxMultiplicativeExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, aToken, aLine);
-	}
-}
-
-void fxMultiplicativeExpression(txParser* parser)
-{
-	fxExponentiationExpression(parser);
-	while (gxTokenFlags[parser->token] & XS_TOKEN_MULTIPLICATIVE_EXPRESSION) {
-		txToken aToken = parser->token;
-		txInteger aLine = parser->line;
-		fxGetNextToken(parser);
-		fxExponentiationExpression(parser);
-		fxCheckArrowFunction(parser, 2);
-		fxPushNodeStruct(parser, 2, aToken, aLine);
-	}
-}
-
-void fxExponentiationExpression(txParser* parser)
-{
-	if (gxTokenFlags[parser->token] & XS_TOKEN_UNARY_EXPRESSION)
-		fxUnaryExpression(parser);
-	else {
-		fxPrefixExpression(parser);
-		if (gxTokenFlags[parser->token] & XS_TOKEN_EXPONENTIATION_EXPRESSION) {
-			txToken aToken = parser->token;
-			txInteger aLine = parser->line;
-			fxGetNextToken(parser);
-            fxExponentiationExpression(parser);
-			fxCheckArrowFunction(parser, 2);
-			fxPushNodeStruct(parser, 2, aToken, aLine);
-		}
-	}
-}
-
-void fxUnaryExpression(txParser* parser)
-{
-	if (gxTokenFlags[parser->token] & XS_TOKEN_UNARY_EXPRESSION) {
-		txToken aToken = parser->token;
-		txInteger aLine = parser->line;
-		fxCheckParserStack(parser, aLine);
-		fxMatchToken(parser, aToken);
-		fxUnaryExpression(parser);
-		fxCheckArrowFunction(parser, 1);
-		if (aToken == XS_TOKEN_ADD)
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PLUS, aLine);
-		else if (aToken == XS_TOKEN_SUBTRACT)
-			fxPushNodeStruct(parser, 1, XS_TOKEN_MINUS, aLine);
-		else if (aToken == XS_TOKEN_DELETE) {
-			//if ((parser->flags & mxStrictFlag) && (parser->root->description->token == XS_TOKEN_ACCESS)) {
-			//	fxReportParserError(parser, parser->line, "no reference (strict mode)");
-			//}
-			if (!fxCheckReference(parser, aToken)) 
-				fxReportParserError(parser, parser->line, "no reference");
-			fxPushNodeStruct(parser, 1, aToken, aLine);
-		}
-		else if (aToken == XS_TOKEN_AWAIT) {
-			if ((parser->flags & mxGeneratorFlag) && !(parser->flags & mxYieldFlag))
-				fxReportParserError(parser, parser->line, "invalid await");
-			else
-				parser->flags |= mxAwaitingFlag;
-			fxPushNodeStruct(parser, 1, aToken, aLine);
-		}
-		else
-			fxPushNodeStruct(parser, 1, aToken, aLine);
-			
-	}
-	else
-		fxPrefixExpression(parser);
-}
-
-void fxPrefixExpression(txParser* parser)
-{
-	if (gxTokenFlags[parser->token] & XS_TOKEN_PREFIX_EXPRESSION) {
-		txToken aToken = parser->token;
-		txInteger aLine = parser->line;
-		fxCheckParserStack(parser, aLine);
-		fxGetNextToken(parser);
-		fxPrefixExpression(parser);
-		fxCheckArrowFunction(parser, 1);
-		if (!fxCheckReference(parser, aToken)) 
-			fxReportParserError(parser, parser->line, "no reference");
-		fxPushNodeStruct(parser, 1, aToken, aLine);
-		parser->root->flags = mxExpressionNoValue;
-	}
-	else
-		fxPostfixExpression(parser);
-}
-
-void fxPostfixExpression(txParser* parser)
-{
-	fxCallExpression(parser);
-	if ((!parser->crlf) && (gxTokenFlags[parser->token] & XS_TOKEN_POSTFIX_EXPRESSION)) {
-		fxCheckArrowFunction(parser, 1);
-		if (!fxCheckReference(parser, parser->token)) 
-			fxReportParserError(parser, parser->line, "no reference");
-		fxPushNodeStruct(parser, 1, parser->token, parser->line);
-		fxGetNextToken(parser);
-	}
-}
-
-void fxCallExpression(txParser* parser)
-{
-	txInteger chainLine = parser->line;
-	fxLiteralExpression(parser, 0);
-	if (gxTokenFlags[parser->token] & XS_TOKEN_CALL_EXPRESSION) {
-		txBoolean chainFlag = 0;
-		fxCheckArrowFunction(parser, 1);
-		for (;;) {
-			txInteger aLine = parser->line;
-			if (parser->token == XS_TOKEN_DOT) {
-				fxGetNextToken(parser);
-				if (parser->token == XS_TOKEN_IDENTIFIER) {
-					fxPushSymbol(parser, parser->symbol);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aLine);
-					fxGetNextToken(parser);
-				}
-				else if (parser->token == XS_TOKEN_PRIVATE_IDENTIFIER) {
-					if (parser->root->flags & mxSuperFlag)
-						fxReportParserError(parser, parser->line, "invalid super");
-					fxPushSymbol(parser, parser->symbol);
-					fxSwapNodes(parser);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aLine);
-					fxGetNextToken(parser);
-				}
-				else
-					fxReportParserError(parser, parser->line, "missing property");
-			}
-			//else if (parser->crlf)
-			//	break;
-			else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-				fxGetNextToken(parser);
-				fxCommaExpression(parser);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aLine);
-				fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
-			}
-			else if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-				if (parser->root->description && (parser->root->description->token == XS_TOKEN_ACCESS)) {
-					txAccessNode* access = (txAccessNode*)parser->root;
-					if (access->symbol == parser->evalSymbol) {
-						parser->flags |= mxEvalFlag;
-					}
-				}
-				fxParameters(parser);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
-			}
-			else if (parser->token == XS_TOKEN_TEMPLATE) {
-				if (chainFlag)
-					fxReportParserError(parser, parser->line, "invalid template");
-				fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-				fxPushRawNode(parser, parser->rawLength, parser->raw, aLine);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
-				fxGetNextToken(parser);
-				fxPushNodeList(parser, 1);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
-			}
-			else if (parser->token == XS_TOKEN_TEMPLATE_HEAD) {
-				if (chainFlag)
-					fxReportParserError(parser, parser->line, "invalid template");
-				fxTemplateExpression(parser);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
-			}
-			else if (parser->token == XS_TOKEN_CHAIN) {
-				fxGetNextToken(parser);
-				chainFlag = 1;
-				if (parser->token == XS_TOKEN_IDENTIFIER) {
-					fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
-					fxPushSymbol(parser, parser->symbol);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aLine);
-					fxGetNextToken(parser);
-				}
-				else if (parser->token == XS_TOKEN_PRIVATE_IDENTIFIER) {
-					fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
-					fxPushSymbol(parser, parser->symbol);
-					fxSwapNodes(parser);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aLine);
-					fxGetNextToken(parser);
-				}
-				else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-					fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
-					fxGetNextToken(parser);
-					fxCommaExpression(parser);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aLine);
-					fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
-				}
-				else if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-					fxPushNodeStruct(parser, 1, XS_TOKEN_OPTION, aLine);
-					fxParameters(parser);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
-				}
-				else
-					fxReportParserError(parser, parser->line, "invalid ?.");
-			}
-			else
-				break;
-		} 
-		if (chainFlag)
-			fxPushNodeStruct(parser, 1, XS_TOKEN_CHAIN, chainLine);
-	} 
-}
-
-void fxLiteralExpression(txParser* parser, txUnsigned flag)
-{
-	int escaped;
-	txSymbol* aSymbol;
-	txInteger aLine = parser->line;
-	txUnsigned flags = 0;
-	char c = 0;
-	fxCheckParserStack(parser, aLine);
-	switch (parser->token) {
-	case XS_TOKEN_NULL:
-	case XS_TOKEN_TRUE:
-	case XS_TOKEN_FALSE:
-		fxPushNodeStruct(parser, 0, parser->token, aLine);
-		fxMatchToken(parser, parser->token);
-		break;
-	case XS_TOKEN_IMPORT:
-		fxMatchToken(parser, XS_TOKEN_IMPORT);
-		if (!flag && (parser->token == XS_TOKEN_LEFT_PARENTHESIS)) {
-			fxGetNextToken(parser);
-			fxAssignmentExpression(parser);
-			fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_IMPORT_CALL, aLine);
-		}
-		else if (parser->token == XS_TOKEN_DOT) {
-			fxGetNextToken(parser);
-			if ((parser->token == XS_TOKEN_IDENTIFIER) && (parser->symbol == parser->metaSymbol) && (!parser->escaped)) {	
-				fxGetNextToken(parser);
-				if (parser->flags & mxProgramFlag)
-					fxReportParserError(parser, parser->line, "invalid import.meta");
-				else
-					fxPushNodeStruct(parser, 0, XS_TOKEN_IMPORT_META, aLine);
-			}
-			else
-				fxReportParserError(parser, parser->line, "invalid import.");
-		}
-		else
-			fxReportParserError(parser, parser->line, "invalid import");
-		break;
-	case XS_TOKEN_SUPER:
-		fxMatchToken(parser, XS_TOKEN_SUPER);
-		if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-			if (parser->flags & mxDerivedFlag) {
-				fxParameters(parser);
-				fxPushNodeStruct(parser, 1, XS_TOKEN_SUPER, aLine);
-			}
-			else {
-				fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-				fxReportParserError(parser, parser->line, "invalid super");
-			}
-		}
-		else if ((parser->token == XS_TOKEN_DOT) || (parser->token == XS_TOKEN_LEFT_BRACKET)) {
-			if (parser->flags & mxSuperFlag) {
-				fxPushNodeStruct(parser, 0, XS_TOKEN_THIS, aLine);
-				parser->root->flags |= parser->flags & (mxDerivedFlag | mxSuperFlag);
-			}
-			else {
-				fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-				fxReportParserError(parser, parser->line, "invalid super");
-			}
-		}
-		else
-			fxReportParserError(parser, parser->line, "invalid super");
-		parser->flags |= mxSuperFlag;
-		break;
-	case XS_TOKEN_THIS:
-		fxPushNodeStruct(parser, 0, parser->token, aLine);
-		parser->root->flags |= parser->flags & mxDerivedFlag;
-		fxMatchToken(parser, XS_TOKEN_THIS);
-		break;
-	case XS_TOKEN_INTEGER:
-		fxPushIntegerNode(parser, parser->integer, aLine);
-		fxGetNextToken(parser);
-		break;
-	case XS_TOKEN_NUMBER:
-		fxPushNumberNode(parser, parser->number, aLine);
-		fxGetNextToken(parser);
-		break;
-	case XS_TOKEN_BIGINT:
-		fxPushBigIntNode(parser, &parser->bigint, aLine);
-		fxGetNextToken(parser);
-		break;
-	case XS_TOKEN_DIVIDE_ASSIGN:
-		c = '=';
-		// continue
-	case XS_TOKEN_DIVIDE:
-		fxGetNextRegExp(parser, c);
-		fxPushStringNode(parser, parser->modifierLength, parser->modifier, aLine);
-		fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_REGEXP, aLine);
-		fxGetNextToken(parser);
-		break;
-	case XS_TOKEN_STRING:
-		fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-		fxGetNextToken(parser);
-		break;
-	case XS_TOKEN_IDENTIFIER:
-		escaped = parser->escaped;
-		aSymbol = parser->symbol;
-		fxGetNextToken(parser);
-		if (aSymbol == parser->undefinedSymbol) {
-			fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-			break;
-		}
-		flags = 0;
-		if ((aSymbol == parser->asyncSymbol) && (!escaped) && (!parser->crlf)) {
-			if (parser->token == XS_TOKEN_FUNCTION) {
-				fxMatchToken(parser, XS_TOKEN_FUNCTION);
-				if (parser->token == XS_TOKEN_MULTIPLY) {
-					fxGetNextToken(parser);
-					fxGeneratorExpression(parser, aLine, C_NULL, mxAsyncFlag);
-				}
-				else
-					fxFunctionExpression(parser, aLine, C_NULL, mxAsyncFlag);
-				break;
-			}
-			if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-				fxGroupExpression(parser, mxAsyncFlag);
-				break;
-			}
-			if (parser->token == XS_TOKEN_IDENTIFIER) {
-// 				if (!(parser->flags & mxForFlag) || !fxIsKeyword(parser, parser->ofSymbol)) {
-					aSymbol = parser->symbol;
-					fxGetNextToken(parser);
-					flags = mxAsyncFlag;
-// 				}
-			}
-		}
-		if (aSymbol == parser->awaitSymbol)
-			parser->flags |= mxAwaitingFlag;
-		if ((!parser->crlf) && (parser->token == XS_TOKEN_ARROW)) {
-			fxCheckStrictSymbol(parser, aSymbol);
-			if (flags && (aSymbol == parser->awaitSymbol))
-				fxReportParserError(parser, parser->line, "invalid await");
-			fxPushSymbol(parser, aSymbol);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_ARG, aLine);
-			fxPushNodeList(parser, 1);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
-			fxArrowExpression(parser, flags);
-			break;
-		}
-		if (aSymbol == parser->argumentsSymbol)
-			parser->flags |= mxArgumentsFlag;
-		fxPushSymbol(parser, aSymbol);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
-		break;
-	case XS_TOKEN_CLASS:
-		flags = parser->flags & mxForFlag;
-		parser->flags &= ~mxForFlag;
-		fxClassExpression(parser, aLine, C_NULL);
-		parser->flags |= flags;
-		break;
-	case XS_TOKEN_FUNCTION:
-		fxMatchToken(parser, XS_TOKEN_FUNCTION);
-		if (parser->token == XS_TOKEN_MULTIPLY) {
-			fxGetNextToken(parser);
-			fxGeneratorExpression(parser, aLine, C_NULL, 0);
-		}
-		else
-			fxFunctionExpression(parser, aLine, C_NULL, 0);
-		break;
-	case XS_TOKEN_NEW:
-		fxNewExpression(parser);
-		break;
-	case XS_TOKEN_LEFT_BRACE:
-		flags = parser->flags & mxForFlag;
-		parser->flags &= ~mxForFlag;
-		fxObjectExpression(parser);
-		parser->flags |= flags;
-		break;
-	case XS_TOKEN_LEFT_BRACKET:
-		flags = parser->flags & mxForFlag;
-		parser->flags &= ~mxForFlag;
-		fxArrayExpression(parser);
-		parser->flags |= flags;
-		break;
-	case XS_TOKEN_LEFT_PARENTHESIS:
-		fxGroupExpression(parser, 0);
-		break;
-	case XS_TOKEN_TEMPLATE:
-		fxPushNULL(parser);
-		fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-		fxPushRawNode(parser, parser->rawLength, parser->raw, aLine);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
-		fxGetNextToken(parser);
-		fxPushNodeList(parser, 1);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
-		break;
-	case XS_TOKEN_TEMPLATE_HEAD:
-		fxPushNULL(parser);
-		fxTemplateExpression(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
-		break;
-	case XS_TOKEN_HOST:
-		fxGetNextToken(parser);
-		fxPushNULL(parser);
-		fxPushNULL(parser);
-		if (parser->token == XS_TOKEN_STRING) {
-			fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-			fxGetNextToken(parser);
-		}
-		else {
-			fxReportParserError(parser, parser->line, "invalid host object");
-			fxPushNULL(parser);
-		}
-		fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
-		break;
-	case XS_TOKEN_LESS:
-		fxGetNextToken(parser);
-		fxJSXElement(parser);
-		fxGetNextToken(parser);
-		break;
-	default:
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-		fxReportParserError(parser, parser->line, "missing expression");
-		break;
-	}
-}
-
-void fxArrayExpression(txParser* parser)
-{
-	txInteger aCount = 0;
-	int elision = 1;
-	txInteger aLine = parser->line;
-	txBoolean aSpreadFlag = 0;
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACKET);
-	while ((parser->token == XS_TOKEN_COMMA) || (parser->token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION)) {
-		txInteger anItemLine = parser->line;
-		if (parser->token == XS_TOKEN_COMMA) {
-			fxGetNextToken(parser);
-			if (elision) {
-				fxPushNodeStruct(parser, 0, XS_TOKEN_ELISION, anItemLine);
-				aCount++;
-			}
-			else
-				elision = 1;
-		}
-		else if (parser->token == XS_TOKEN_SPREAD) {
-			fxGetNextToken(parser);
-			if (!elision)
-				fxReportParserError(parser, parser->line, "missing ,");
-			fxAssignmentExpression(parser);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, anItemLine);
-			aCount++;
-			elision = 0;
-			aSpreadFlag = 1;
-		}
-		else {
-			if (!elision)
-				fxReportParserError(parser, parser->line, "missing ,");
-			fxAssignmentExpression(parser);
-			aCount++;
-			elision = 0;
-		}
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY, aLine);
-	if (aCount && elision)
-		parser->root->flags |= mxElisionFlag;
-	if (aSpreadFlag)
-		parser->root->flags |= mxSpreadFlag;
-}
-
-void fxArrowExpression(txParser* parser, txUnsigned flag)
-{
-	txInteger aLine = parser->line;
-	txUnsigned flags = parser->flags;
-	parser->flags &= ~mxAsyncFlag;
-	parser->flags |= mxArrowFlag | flag;
-	fxMatchToken(parser, XS_TOKEN_ARROW);
-	fxPushNULL(parser);
-	fxSwapNodes(parser);	
-	if (parser->token == XS_TOKEN_LEFT_BRACE) {
-		fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-		fxBody(parser);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
-		fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	}
-	else {
-		fxAssignmentExpression(parser);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_RETURN, aLine);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
-	}
-	fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
-	parser->root->flags = parser->flags & (mxStrictFlag | mxFieldFlag | mxNotSimpleParametersFlag | mxArrowFlag | mxSuperFlag | flag);
-	if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
-		fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
-	parser->flags = flags | (parser->flags & (mxArgumentsFlag | mxEvalFlag));
-}
-
-void fxClassExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol)
-{
-	txBoolean heritageFlag = 0;
-//	txBoolean hostFlag = 0;
-	txNode* constructor = NULL;
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	txUnsigned flags = parser->flags;
-	txInteger constructorInitCount = 0;
-	txInteger instanceInitCount = 0;
-	parser->flags |= mxStrictFlag;
-	fxMatchToken(parser, XS_TOKEN_CLASS);
-	if (parser->token == XS_TOKEN_IDENTIFIER) {
-		fxPushSymbol(parser, parser->symbol);
-		if (theSymbol)
-			*theSymbol = parser->symbol;
-		fxGetNextToken(parser);
-	}
-	else
-		fxPushNULL(parser);
-	if (parser->token == XS_TOKEN_EXTENDS) {
-		fxMatchToken(parser, XS_TOKEN_EXTENDS);
-		fxCallExpression(parser);
-		fxCheckArrowFunction(parser, 1);
-		flags |= parser->flags & mxAwaitingFlag;
-		heritageFlag = 1;
-	}
-	else if (parser->token == XS_TOKEN_HOST) {
-		fxGetNextToken(parser);
-		fxPushNULL(parser);
-		fxPushNULL(parser);
-		if (parser->token == XS_TOKEN_STRING) {
-			fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-			fxGetNextToken(parser);
-		}
-		else {
-			fxReportParserError(parser, parser->line, "invalid host class");
-			fxPushNULL(parser);
-		}
-		fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, aLine);
-//		hostFlag = 1;
-	}
-	else {
-		fxPushNULL(parser);
-	}
-	if (parser->token == XS_TOKEN_LEFT_BRACE) {
-		fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-		for (;;) {
-			txBoolean aStaticFlag;
-			txInteger aPropertyLine = parser->line;
-			txSymbol* aSymbol;
-			txToken aToken0;
-			txToken aToken1;
-			txToken aToken2;
-			txUnsigned flag;
-			while (parser->token == XS_TOKEN_SEMICOLON)
-				fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_RIGHT_BRACE)
-				break;
-			aStaticFlag = 0;
-			if ((parser->token == XS_TOKEN_STATIC) && (!parser->escaped)) {
-				fxGetNextToken(parser);
-				if ((parser->token == XS_TOKEN_ASSIGN) || parser->token == XS_TOKEN_SEMICOLON) {
-					fxPushSymbol(parser, parser->staticSymbol);
-					aToken1 = XS_TOKEN_PROPERTY;
-					goto field;
-				}
-				if (parser->token == XS_TOKEN_LEFT_BRACE) {
-					txUnsigned flags = parser->flags;
-					parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxSuperFlag | mxTargetFlag | mxFieldFlag | mxAsyncFlag;
-					fxCheckParserStack(parser, aPropertyLine);
-					fxGetNextToken(parser);
-					fxStatements(parser);
-					fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-					fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aPropertyLine);
-					if (parser->flags & mxArgumentsFlag)
-						fxReportParserError(parser, parser->line, "invalid arguments");
-					if (parser->flags & mxAwaitingFlag)
-						fxReportParserError(parser, parser->line, "invalid await");
-					parser->flags = flags;
-					parser->root->flags |= mxStaticFlag;
-					constructorInitCount++;
-					aCount++;
-					continue;
-				}
-				aStaticFlag = 1;
-			}
-			fxPropertyName(parser, &aSymbol, &aToken0, &aToken1, &aToken2, &flag);
-			if ((aStaticFlag == 0) && (aSymbol == parser->constructorSymbol)) {
-				fxPopNode(parser); // symbol
-				if (constructor || (aToken2 == XS_TOKEN_GENERATOR) || (aToken2 == XS_TOKEN_GETTER) || (aToken2 == XS_TOKEN_SETTER) || (flag & mxAsyncFlag)) 
-					fxReportParserError(parser, parser->line, "invalid constructor");
-				fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | ((heritageFlag) ? mxDerivedFlag : mxBaseFlag));
-				constructor = fxPopNode(parser);
-			}
-			else if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-				if ((aToken1 == XS_TOKEN_PRIVATE_PROPERTY) && (aSymbol == parser->privateConstructorSymbol))
-					fxReportParserError(parser, parser->line, "invalid method: #constructor");
-				if (aStaticFlag && (aSymbol == parser->prototypeSymbol))
-					fxReportParserError(parser, parser->line, "invalid static method: prototype");
-				if (aStaticFlag)
-					flag |= mxStaticFlag;
-				if (aToken2 == XS_TOKEN_GETTER) 
-					flag |= mxGetterFlag;
-				else if (aToken2 == XS_TOKEN_SETTER) 
-					flag |= mxSetterFlag;
-				else
-					flag |= mxMethodFlag;
-				if (aToken2 == XS_TOKEN_GENERATOR)
-					fxGeneratorExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flag);
-				else
-					fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flag);
-				fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
-				parser->root->flags |= flag & (mxStaticFlag | mxGetterFlag | mxSetterFlag | mxMethodFlag);
-				if (aToken1 == XS_TOKEN_PRIVATE_PROPERTY) {
-					if (aStaticFlag)
-						constructorInitCount++;
-					else
-						instanceInitCount++;
-				}
-				aCount++;
-			}
-			else {
-				if ((aToken1 == XS_TOKEN_PRIVATE_PROPERTY) && (aSymbol == parser->privateConstructorSymbol))
-					fxReportParserError(parser, parser->line, "invalid field: #constructor");
-				if (aSymbol == parser->constructorSymbol)
-					fxReportParserError(parser, parser->line, "invalid field: constructor");
-				if (aSymbol == parser->prototypeSymbol)
-					fxReportParserError(parser, parser->line, "invalid field: prototype");
-			field:
-				if (parser->token == XS_TOKEN_ASSIGN) {
-					txUnsigned flags = parser->flags;
-					parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxSuperFlag | mxTargetFlag | mxFieldFlag;
-					fxGetNextToken(parser);
-					fxAssignmentExpression(parser);
-					if (parser->flags & mxArgumentsFlag)
-						fxReportParserError(parser, parser->line, "invalid arguments");
-					parser->flags = flags;
-				}
-				else {
-					fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-				}
-				fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
-				if (aStaticFlag) {
-					parser->root->flags |= mxStaticFlag;
-					constructorInitCount++;
-				}
-				else
-					instanceInitCount++;
-				fxSemicolon(parser);
-				aCount++;
-			}
-		}
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	fxPushNodeList(parser, aCount);
-	
-	if (constructorInitCount || instanceInitCount) {
-		txNodeList* itemsList = (txNodeList*)(parser->root);
-		txNodeList* constructorInitList = C_NULL;
-		txNode** constructorInitAddress = C_NULL;
-		txNodeList* instanceInitList = C_NULL;
-		txNode** instanceInitAddress = C_NULL;
-		txNode** address;
-		txNode* item;
-		if (constructorInitCount) {
-			fxPushNULL(parser);
-			fxPushNodeList(parser, 0);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
-			fxPushNodeList(parser, 0);
-			constructorInitList = (txNodeList*)(parser->root);
-			constructorInitList->length = constructorInitCount;
-			constructorInitAddress = &(((txNodeList*)(parser->root))->first);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
-			parser->root->flags = mxStrictFlag | mxSuperFlag | mxFieldFlag;
-		}
-		else 
-			fxPushNULL(parser);
-		if (instanceInitCount) {
-			fxPushNULL(parser);
-			fxPushNodeList(parser, 0);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
-			fxPushNodeList(parser, 0);
-			instanceInitList = (txNodeList*)(parser->root);
-			instanceInitList->length = instanceInitCount;
-			instanceInitAddress = &(((txNodeList*)(parser->root))->first);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENTS, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
-			parser->root->flags = mxStrictFlag | mxSuperFlag | mxFieldFlag;
-		}
-		else 
-			fxPushNULL(parser);
-		address = &(itemsList->first);
-		while ((item = *address)) {
-			if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
-				if (item->description->token == XS_TOKEN_PRIVATE_PROPERTY) {
-					txFieldNode* field = fxFieldNodeNew(parser, XS_TOKEN_FIELD);
-					field->item = item;
-					if (item->flags & mxStaticFlag) {
-						*constructorInitAddress = (txNode*)field;
-						constructorInitAddress = &field->next;
-					}
-					else {
-						*instanceInitAddress = (txNode*)field;
-						instanceInitAddress = &field->next;
-					}
-				}
-			}
-			address = &(item->next);
-		}
-		address = &(itemsList->first);
-		while ((item = *address)) {
-			if (item->description->token == XS_TOKEN_BODY) {
-				*address = item->next;
-				item->next = C_NULL;
-				itemsList->length--;
-				*constructorInitAddress = (txNode*)item;
-				constructorInitAddress = &item->next;
-			}
-			else if (item->flags & (mxMethodFlag | mxGetterFlag | mxSetterFlag)) {
-				address = &(item->next);
-			}
-			else {
-				txFieldNode* field = fxFieldNodeNew(parser, XS_TOKEN_FIELD);
-				field->item = item;
-				if (item->description->token == XS_TOKEN_PROPERTY) {
-					field->value = ((txPropertyNode*)item)->value;
-					((txPropertyNode*)item)->value = C_NULL;
-				}
-				else if (item->description->token == XS_TOKEN_PROPERTY_AT) {
-					field->value = ((txPropertyAtNode*)item)->value;
-					((txPropertyAtNode*)item)->value = C_NULL;
-				}
-				else {
-					field->value = ((txPrivatePropertyNode*)item)->value;
-					((txPrivatePropertyNode*)item)->value = C_NULL;
-				}
-				if (item->flags & mxStaticFlag) {
-					*constructorInitAddress = (txNode*)field;
-					constructorInitAddress = &field->next;
-				}
-				else {
-					*instanceInitAddress = (txNode*)field;
-					instanceInitAddress = &field->next;
-				}
-				address = &(item->next);
-			}
-		}
-	}
-	else {
-		fxPushNULL(parser);
-		fxPushNULL(parser);
-	}
-	if (constructor) {
-		fxPushNode(parser, constructor);
-	}
-	else {
-		if (heritageFlag) {
-			fxPushNULL(parser);
-		
-			fxPushSymbol(parser, parser->argsSymbol);
-			fxPushNULL(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_ARG, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_REST_BINDING, aLine);
-			fxPushNodeList(parser, 1);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
-			
-			fxPushSymbol(parser, parser->argsSymbol);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aLine);
-			fxPushNodeList(parser, 1);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
-			parser->root->flags |= mxSpreadFlag;
-			fxPushNodeStruct(parser, 1, XS_TOKEN_SUPER, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
-			
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
-			parser->root->flags = mxStrictFlag | mxDerivedFlag | mxMethodFlag | mxTargetFlag | mxSuperFlag;
-		}
-		else {
-			fxPushNULL(parser);
-		
-			fxPushNodeList(parser, 0);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
-			
-			fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_STATEMENT, aLine);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, aLine);
-			
-			fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, aLine);
-			parser->root->flags = mxStrictFlag | mxBaseFlag | mxMethodFlag | mxTargetFlag;
-		}
-	}
-	fxPushNodeStruct(parser, 6, XS_TOKEN_CLASS, aLine);
-	parser->flags = flags | (parser->flags & (mxArgumentsFlag));
-}
-
-void fxFunctionExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag)
-{
-	txUnsigned flags = parser->flags;
-	parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxFunctionFlag | mxTargetFlag | flag;
-	if ((parser->token == XS_TOKEN_IDENTIFIER)
-			|| ((flags & mxGeneratorFlag) && !(flags & mxStrictFlag) && (parser->token == XS_TOKEN_YIELD))
-			|| ((theSymbol == C_NULL) && (parser->token == XS_TOKEN_AWAIT))) {
-		fxPushSymbol(parser, parser->symbol);
-		if (theSymbol)
-			*theSymbol = parser->symbol;
-		fxCheckStrictSymbol(parser, parser->symbol);
-		fxGetNextToken(parser);
-	}
-	else
-		fxPushNULL(parser);
-	fxParametersBinding(parser);
-	if (parser->token == XS_TOKEN_HOST) {
-		fxGetNextToken(parser);
-		if (parser->token == XS_TOKEN_STRING) {
-			fxPushStringNode(parser, parser->stringLength, parser->string, theLine);
-			fxGetNextToken(parser);
-		}
-		else {
-			fxReportParserError(parser, parser->line, "invalid host function");
-			fxPushNULL(parser);
-		}
-		fxPushNodeStruct(parser, 3, XS_TOKEN_HOST, theLine);
-        parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxTargetFlag | mxArgumentsFlag | mxEvalFlag | flag);
-        if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
-            fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
-        parser->flags = flags;
-	}
-	else {
-		fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-		fxBody(parser);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, theLine);
-		fxPushNodeStruct(parser, 3, XS_TOKEN_FUNCTION, theLine);
-        parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxTargetFlag | mxArgumentsFlag | mxEvalFlag | flag);
-        if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
-            fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
-        parser->flags = flags;
-        fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	}
-}
-
-void fxGeneratorExpression(txParser* parser, txInteger theLine, txSymbol** theSymbol, txUnsigned flag)
-{
-	txUnsigned flags = parser->flags;
-	parser->flags = (flags & (mxParserFlags | mxStrictFlag)) | mxGeneratorFlag | mxTargetFlag | flag;
-	if ((parser->token == XS_TOKEN_IDENTIFIER)
-			|| ((theSymbol == C_NULL) && (parser->token == XS_TOKEN_AWAIT))) {
-		fxPushSymbol(parser, parser->symbol);
-		if (theSymbol)
-			*theSymbol = parser->symbol;
-		else if (parser->symbol == parser->yieldSymbol)
- 			fxReportParserError(parser, parser->line, "invalid yield");
-		else if ((parser->flags & mxAsyncFlag) && (parser->symbol == parser->awaitSymbol))
- 			fxReportParserError(parser, parser->line, "invalid await");
-		fxCheckStrictSymbol(parser, parser->symbol);
-		fxGetNextToken(parser);
-	}
-	else
-		fxPushNULL(parser);
-	fxParametersBinding(parser);
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-	parser->flags |= mxYieldFlag;
-    fxBody(parser);
-	parser->flags &= ~mxYieldFlag;
-	fxPushNodeStruct(parser, 1, XS_TOKEN_BODY, theLine);
-	fxPushNodeStruct(parser, 3, XS_TOKEN_GENERATOR, theLine);
-	parser->root->flags = parser->flags & (mxStrictFlag | mxNotSimpleParametersFlag | mxGeneratorFlag | mxArgumentsFlag | mxEvalFlag | flag);
-	if (!(flags & mxStrictFlag) && (parser->flags & mxStrictFlag))
-		fxCheckStrictFunction(parser, (txFunctionNode*)parser->root);
-	parser->flags = flags;
-    fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-}
-
-void fxGroupExpression(txParser* parser, txUnsigned flag)
-{
-	txBoolean commaFlag = 0;
-	txBoolean spreadFlag = 0;
-	txInteger aCount = 0;
-	txInteger aLine;
-	txUnsigned formerAwaitingYieldingFlags = parser->flags & (mxAwaitingFlag | mxYieldingFlag);
-	parser->flags &= ~(mxAwaitingFlag | mxYieldingFlag);
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	while ((parser->token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION)) {
-		aLine = parser->line;
-		commaFlag = 0;
-		if (parser->token == XS_TOKEN_SPREAD) {
-			fxGetNextToken(parser);
-			fxAssignmentExpression(parser);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aLine);
-			spreadFlag = 1;
-		}
-		else
-			fxAssignmentExpression(parser);
-		aCount++;
-		if (parser->token != XS_TOKEN_COMMA) 
-			break;
-		fxGetNextToken(parser);
-		commaFlag = 1;
-	}
-	aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	if ((!parser->crlf) && (parser->token == XS_TOKEN_ARROW)) {
-		fxPushNodeList(parser, aCount);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
-		if (commaFlag && spreadFlag)
-			fxReportParserError(parser, parser->line, "invalid parameters");
-		if (!fxParametersBindingFromExpressions(parser, parser->root))
-			fxReportParserError(parser, parser->line, "no parameters");
-		fxCheckStrictBinding(parser, parser->root);
-		parser->root->flags |= flag;
-		if (parser->flags & mxAwaitingFlag) {
-			if (flag || (parser->flags & mxAsyncFlag))
-				fxReportParserError(parser, parser->line, "invalid await");
-			else
-				formerAwaitingYieldingFlags |= mxAwaitingFlag;
-		}
-		if (parser->flags & mxYieldingFlag)
-			fxReportParserError(parser, parser->line, "invalid yield");
-		fxArrowExpression(parser, flag);
-	}
-	else if (flag) {
-		fxPushNodeList(parser, aCount);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
-		if (spreadFlag)
-			parser->root->flags |= mxSpreadFlag;
-		
-		fxPushSymbol(parser, parser->asyncSymbol);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aLine);
-		fxSwapNodes(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, aLine);
-	}
-	else {
-        if ((aCount == 0) || commaFlag) {
-            fxPushNULL(parser);
-			fxReportParserError(parser, parser->line, "missing expression");
-        }
-		else /*if (aCount > 1)*/ {
-			fxPushNodeList(parser, aCount);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_EXPRESSIONS, aLine);
-		}
-	}
-	parser->flags |= formerAwaitingYieldingFlags;
-}
-
-void fxNewExpression(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_NEW);
-	if (parser->token == XS_TOKEN_DOT) {
-		fxGetNextToken(parser);
-		if (fxIsKeyword(parser, parser->targetSymbol)) {
-			if (!(parser->flags & mxTargetFlag))
-				fxReportParserError(parser, parser->line, "invalid new.target");
-			fxGetNextToken(parser);
-			fxPushNodeStruct(parser, 0, XS_TOKEN_TARGET, aLine);
-		}
-		else
-			fxReportParserError(parser, parser->line, "missing target");
-		return;
-	}
-	fxLiteralExpression(parser, 1);
-	fxCheckArrowFunction(parser, 1);
-	for (;;) {
-		txInteger aMemberLine = parser->line;
-		if (parser->token == XS_TOKEN_DOT) {
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_IDENTIFIER) {
-				fxPushSymbol(parser, parser->symbol);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, aMemberLine);
-				fxGetNextToken(parser);
-			}
-			else if (parser->token == XS_TOKEN_PRIVATE_IDENTIFIER) {
-				fxPushSymbol(parser, parser->symbol);
-				fxSwapNodes(parser);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_PRIVATE_MEMBER, aMemberLine);
-				fxGetNextToken(parser);
-			}
-			else
-				fxReportParserError(parser, parser->line, "missing property");
-		}
-		else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-			fxGetNextToken(parser);
-			fxCommaExpression(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER_AT, aMemberLine);
-			fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
-		}
-		else if (parser->token == XS_TOKEN_TEMPLATE) {
-			fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-			fxPushRawNode(parser, parser->rawLength, parser->raw, aLine);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
-			fxGetNextToken(parser);
-			fxPushNodeList(parser, 1);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
-		}
-		else if (parser->token == XS_TOKEN_TEMPLATE_HEAD) {
-			fxTemplateExpression(parser);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE, aLine);
-		}
-		else
-			break;
-	} 
-	if (parser->token == XS_TOKEN_LEFT_PARENTHESIS)
-		fxParameters(parser);
-	else {
-		fxPushNodeList(parser, 0);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
-	}
-	fxPushNodeStruct(parser, 2, XS_TOKEN_NEW, aLine);
-}
-
-void fxObjectExpression(txParser* parser)
-{
-	txInteger aCount = 0;
-	txSymbol* aSymbol;
-	txToken aToken0;
-	txToken aToken1;
-	txToken aToken2;
-	txInteger aLine = parser->line;
-	txNode* base = parser->root;
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-	for (;;) {
-		txInteger aPropertyLine = parser->line;
-		txUnsigned flags = 0;
-        if (parser->token == XS_TOKEN_RIGHT_BRACE)
-            break;
-        if (parser->token == XS_TOKEN_SPREAD) {
-			fxGetNextToken(parser);
-			fxAssignmentExpression(parser);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aPropertyLine);
-        }
-        else {
-			fxPropertyName(parser, &aSymbol, &aToken0, &aToken1, &aToken2, &flags);
-			if (aToken1 == XS_TOKEN_PRIVATE_PROPERTY) {
-				fxReportParserError(parser, parser->line, "invalid private property");
-			}
-			else if ((aToken2 == XS_TOKEN_GETTER) || (aToken2 == XS_TOKEN_SETTER)) {
-				flags |= mxShorthandFlag;
-				if (aToken2 == XS_TOKEN_GETTER)
-					flags |= mxGetterFlag;
-				else if (aToken2 == XS_TOKEN_SETTER)
-					flags |= mxSetterFlag;
-				if (parser->token == XS_TOKEN_LEFT_PARENTHESIS)
-					fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag);
-				else
-					fxReportParserError(parser, parser->line, "missing (");
-			}
-			else if (aToken2 == XS_TOKEN_GENERATOR) {
-				flags |= mxShorthandFlag | mxMethodFlag;
-				if (parser->token == XS_TOKEN_LEFT_PARENTHESIS)
-					fxGeneratorExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
-				else
-					fxReportParserError(parser, parser->line, "missing (");
-			}
-			else if (aToken2 == XS_TOKEN_FUNCTION) {
-				flags |= mxShorthandFlag | mxMethodFlag;
-				if (parser->token == XS_TOKEN_LEFT_PARENTHESIS)
-					fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
-				else
-					fxReportParserError(parser, parser->line, "missing (");
-			}
-			else if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-				flags |= mxShorthandFlag | mxMethodFlag;
-				fxFunctionExpression(parser, aPropertyLine, C_NULL, mxSuperFlag | flags);
-			}
-			else if (parser->token == XS_TOKEN_COLON) {
-				fxGetNextToken(parser);
-				fxAssignmentExpression(parser);
-			}
-			else if (aToken1 == XS_TOKEN_PROPERTY) {
-				flags |= mxShorthandFlag;
-				fxPushSymbol(parser, aSymbol);
-				if (parser->token == XS_TOKEN_ASSIGN) {
-					fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aPropertyLine);
-					fxGetNextToken(parser);
-					fxAssignmentExpression(parser);
-					fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, aPropertyLine);
-				}
-				else if (aToken0 == XS_TOKEN_IDENTIFIER) {
-					fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, aPropertyLine);
-				}
-				else {
-					fxReportParserError(parser, parser->line, "invalid identifier");
-					fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aPropertyLine);
-				}
-			}
-			else {
-				fxReportParserError(parser, parser->line, "missing :");
-				fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aPropertyLine);
-			}
-			fxPushNodeStruct(parser, 2, aToken1, aPropertyLine);
-			parser->root->flags |= flags;
-			fxCheckUniqueProperty(parser, base, parser->root); 
-		}
-		aCount++;
-        if (parser->token == XS_TOKEN_RIGHT_BRACE)
-            break;
-		fxMatchToken(parser, XS_TOKEN_COMMA);
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, aLine);
-}
-
-void fxTemplateExpression(txParser* parser)
-{
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-	fxPushRawNode(parser, parser->rawLength, parser->raw, aLine);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
-	aCount++;
-	for (;;) {
-		fxGetNextToken(parser);
-        if (parser->token != XS_TOKEN_RIGHT_BRACE) {
-            fxCommaExpression(parser);
-            aCount++;
-        }
-		if (parser->token != XS_TOKEN_RIGHT_BRACE) {
-			fxReportParserError(parser, parser->line, "missing }");
-		}
-		fxGetNextTokenTemplate(parser);
-		fxPushStringNode(parser, parser->stringLength, parser->string, aLine);
-		fxPushRawNode(parser, parser->rawLength, parser->raw, aLine);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_TEMPLATE_MIDDLE, aLine);
-		aCount++;
-		if (parser->token == XS_TOKEN_TEMPLATE_TAIL) {
-			fxGetNextToken(parser);
-			break;
-		}
-	}
-	fxPushNodeList(parser, aCount);
-}
-
-void fxYieldExpression(txParser* parser)
-{
-	txInteger aLine = parser->line;
-	if (!(parser->flags & mxYieldFlag))
-		fxReportParserError(parser, parser->line, "invalid yield");
-	else
-		parser->flags |= mxYieldingFlag;
-	fxMatchToken(parser, XS_TOKEN_YIELD);
-	if ((!parser->crlf) && (parser->token == XS_TOKEN_MULTIPLY)) {
-		fxGetNextToken(parser);
-		fxAssignmentExpression(parser);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_DELEGATE, aLine);
-		return;
-	}
-	if ((!parser->crlf) && (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION)) {
-		fxAssignmentExpression(parser);
-	}
-	else {
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, aLine);
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_YIELD, aLine);
-}
-
-void fxParameters(txParser* parser)
-{
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	txBoolean aSpreadFlag = 0;
-	fxMatchToken(parser, XS_TOKEN_LEFT_PARENTHESIS);
-	while ((parser->token == XS_TOKEN_SPREAD) || (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_EXPRESSION)) {
-		txInteger aParamLine = parser->line;
-		if (parser->token == XS_TOKEN_SPREAD) {
-			fxGetNextToken(parser);
-			fxAssignmentExpression(parser);
-			fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, aParamLine);
-			aSpreadFlag = 1;
-		}
-		else
-			fxAssignmentExpression(parser);
-		aCount++;
-		if (parser->token != XS_TOKEN_RIGHT_PARENTHESIS)
-			fxMatchToken(parser, XS_TOKEN_COMMA);
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, aLine);
-	if (aSpreadFlag)
-		parser->root->flags |= mxSpreadFlag;
-}
-
-void fxPropertyName(txParser* parser, txSymbol** theSymbol, txToken* theToken0, txToken* theToken1, txToken* theToken2, txUnsigned* flag)
-{
-	txSymbol* aSymbol = C_NULL;
-	txToken aToken0 = XS_NO_TOKEN;
-	txToken aToken1 = XS_NO_TOKEN;
-	txToken aToken2 = XS_NO_TOKEN;
-	txInteger aLine = parser->line;
-	txIndex index;
-	*flag = 0;
-	fxGetNextToken2(parser);
-	aToken0 = parser->token;
-	if ((gxTokenFlags[aToken0] & XS_TOKEN_IDENTIFIER_NAME)) {
-		aSymbol = parser->symbol;
-		if (parser->token2 == XS_TOKEN_COLON) {
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-		}
-		else if (fxIsKeyword(parser, parser->asyncSymbol) && (!parser->crlf2)) {
-			*flag = mxAsyncFlag;
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_MULTIPLY) {
-				aToken2 = XS_TOKEN_GENERATOR;
-				fxGetNextToken(parser);
-			}
-			else
-				aToken2 = XS_TOKEN_FUNCTION;
-		}
-		else if (fxIsKeyword(parser, parser->getSymbol)) {
-			aToken2 = XS_TOKEN_GETTER;
-			fxGetNextToken(parser);
-		}
-		else if (fxIsKeyword(parser, parser->setSymbol)) {
-			aToken2 = XS_TOKEN_SETTER;
-			fxGetNextToken(parser);
-		}
-		else {
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-		}
-	}
-	else if (parser->token == XS_TOKEN_MULTIPLY) {
-		aToken2 = XS_TOKEN_GENERATOR;
-		fxGetNextToken(parser);
-	}
-	else if (parser->token == XS_TOKEN_PRIVATE_IDENTIFIER) {
-		aSymbol = parser->symbol;
-		fxPushSymbol(parser, aSymbol);
-		aToken1 = XS_TOKEN_PRIVATE_PROPERTY;
-	}
-	else if (parser->token == XS_TOKEN_INTEGER) {
-		if (fxIntegerToIndex(parser->dtoa, parser->integer, &index)) {
-			fxPushIndexNode(parser, index, aLine);
-			aToken1 = XS_TOKEN_PROPERTY_AT;
-		}
-		else {
-			aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->dtoa, parser->integer, parser->buffer, parser->bufferSize));
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-		}
-	}
-	else if (parser->token == XS_TOKEN_NUMBER) {
-		if (fxNumberToIndex(parser->dtoa, parser->number, &index)) {
-			fxPushIndexNode(parser, index, aLine);
-			aToken1 = XS_TOKEN_PROPERTY_AT;
-		}
-		else {
-			aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->dtoa, parser->number, parser->buffer, parser->bufferSize, 0, 0));
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-		}
-	}
-	else if (parser->token == XS_TOKEN_STRING) {
-		if (fxStringToIndex(parser->dtoa, parser->string, &index)) {
-			fxPushIndexNode(parser, index, aLine);
-			aToken1 = XS_TOKEN_PROPERTY_AT;
-		}
-		else {
-			aSymbol = fxNewParserSymbol(parser, parser->string);
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-		}
-	}
-	else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-		fxGetNextToken(parser);
-		fxCommaExpression(parser);
-		if (parser->token != XS_TOKEN_RIGHT_BRACKET) {
-			fxReportParserError(parser, parser->line, "missing ]");
-		}
-		aToken1 = XS_TOKEN_PROPERTY_AT;
-	}
-	else {
-		fxReportParserError(parser, parser->line, "missing identifier");
-		fxPushNULL(parser);
-	}
-	if (aToken2 != XS_NO_TOKEN) {
-		if ((gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME)) {
-			aSymbol = parser->symbol;
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-			fxGetNextToken(parser);
-		}
-		else if (parser->token == XS_TOKEN_PRIVATE_IDENTIFIER) {
-			aSymbol = parser->symbol;
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PRIVATE_PROPERTY;
-			fxGetNextToken(parser);
-		}
-		else if (parser->token == XS_TOKEN_INTEGER) {
-			if (fxIntegerToIndex(parser->dtoa, parser->integer, &index)) {
-				fxPushIndexNode(parser, index, aLine);
-				aToken1 = XS_TOKEN_PROPERTY_AT;
-			}
-			else {
-				aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->dtoa, parser->integer, parser->buffer, parser->bufferSize));
-				fxPushSymbol(parser, aSymbol);
-				aToken1 = XS_TOKEN_PROPERTY;
-			}
-			fxGetNextToken(parser);
-		}
-		else if (parser->token == XS_TOKEN_NUMBER) {
-			if (fxNumberToIndex(parser->dtoa, parser->number, &index)) {
-				fxPushIndexNode(parser, index, aLine);
-				aToken1 = XS_TOKEN_PROPERTY_AT;
-			}
-			else {
-				aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->dtoa, parser->number, parser->buffer, parser->bufferSize, 0, 0));
-				fxPushSymbol(parser, aSymbol);
-				aToken1 = XS_TOKEN_PROPERTY;
-			}
-			fxGetNextToken(parser);
-		}
-		else if (parser->token == XS_TOKEN_STRING) {
-			if (fxStringToIndex(parser->dtoa, parser->string, &index)) {
-				fxPushIndexNode(parser, index, aLine);
-				aToken1 = XS_TOKEN_PROPERTY_AT;
-			}
-			else {
-				aSymbol = fxNewParserSymbol(parser, parser->string);
-				fxPushSymbol(parser, aSymbol);
-				aToken1 = XS_TOKEN_PROPERTY;
-			}
-			fxGetNextToken(parser);
-		}
-		else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-			fxGetNextToken(parser);
-			fxCommaExpression(parser);
-			if (parser->token != XS_TOKEN_RIGHT_BRACKET) {
-				fxReportParserError(parser, parser->line, "missing ]");
-			}
-			aToken1 = XS_TOKEN_PROPERTY_AT;
-			fxGetNextToken(parser);
-		}
-		else if (aToken2 == XS_TOKEN_GETTER) {
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-			aToken2 = XS_NO_TOKEN;
-		}
-		else if (aToken2 == XS_TOKEN_SETTER) {
-			fxPushSymbol(parser, aSymbol);
-			aToken1 = XS_TOKEN_PROPERTY;
-			aToken2 = XS_NO_TOKEN;
-		}
-		else {
-			fxReportParserError(parser, parser->line, "missing identifier");
-			fxPushNULL(parser);
-		}
-	}
-	else
-		fxGetNextToken(parser);
-	*theSymbol = aSymbol;
-	*theToken0 = aToken0;
-	*theToken1 = aToken1;
-	*theToken2 = aToken2;
-}
-
-void fxBinding(txParser* parser, txToken theToken, txFlag initializeIt)
-{
-	txInteger aLine = parser->line;
-	fxCheckParserStack(parser, aLine);
-	if (parser->token == XS_TOKEN_IDENTIFIER) {
-		fxCheckStrictSymbol(parser, parser->symbol);
-		if (((theToken == XS_TOKEN_CONST) || (theToken == XS_TOKEN_LET)) && (parser->symbol == parser->letSymbol))
-			fxReportParserError(parser, parser->line, "invalid identifier");
-		fxPushSymbol(parser, parser->symbol);
-		fxPushNodeStruct(parser, 1, theToken, aLine);
-		fxGetNextToken(parser);
-	}
-	else if (parser->token == XS_TOKEN_LEFT_BRACE) {
-		fxObjectBinding(parser, theToken);
-	}
-	else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-		fxArrayBinding(parser, theToken);
-	}
-	else {
-		fxReportParserError(parser, parser->line, "missing identifier");
-		fxPushNULL(parser);
-	}
-	if (initializeIt && (parser->token == XS_TOKEN_ASSIGN)) {
-		parser->flags &= ~mxForFlag;
-		fxGetNextToken(parser);
-		fxAssignmentExpression(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_BINDING, aLine);
-	}
-}
-
-txNode* fxBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
-{
-	txToken aToken = (theNode && theNode->description) ? theNode->description->token : XS_NO_TOKEN;
-	txNode* binding;
-again:
-	if (aToken == XS_TOKEN_EXPRESSIONS) {
-		txNode* item = ((txExpressionsNode*)theNode)->items->first;
-		if (item && !item->next) {
-			aToken = item->description->token;
-			if ((aToken == XS_TOKEN_ACCESS) || (aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
-				item->next = theNode->next;
-				theNode = item;
-			}
-			else if (aToken == XS_TOKEN_EXPRESSIONS) {
-				item->next = theNode->next;
-				theNode = item;
-				goto again;
-			}
-			else
-				return NULL;
-		}
-	}
-	if (aToken == XS_TOKEN_BINDING) {
-		binding = fxBindingFromExpression(parser, ((txBindingNode*)theNode)->target, theToken);
-		((txBindingNode*)theNode)->target = binding;
-// 		fxCheckStrictBinding(parser, theNode);
-// 		fxCheckStrictSymbol(parser, ((txBindingNode*)theNode)->symbol);
-// 		theNode->description = &gxTokenDescriptions[theToken];
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_ARRAY_BINDING) {
-		txNodeList* list = ((txArrayBindingNode*)theNode)->items;
-		txNode** address = &(list->first);
-		txNode* item;
-		while ((item = *address)) {
-			txNode* binding = *address = fxBindingFromExpression(parser, item, theToken);
-			binding->next = item->next;
-			address = &(binding->next);
-		}
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_OBJECT_BINDING) {
-		txNodeList* list = ((txObjectBindingNode*)theNode)->items;
-		txNode** address = &(list->first);
-		txNode* item;
-		while ((item = *address)) {
-			txNode* binding = *address = fxBindingFromExpression(parser, item, theToken);
-			binding->next = item->next;
-			address = &(binding->next);
-		}
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_PROPERTY_BINDING) {
-		((txPropertyBindingNode*)theNode)->binding = fxBindingFromExpression(parser, ((txPropertyBindingNode*)theNode)->binding, theToken);
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_PROPERTY_BINDING_AT) {
-		((txPropertyBindingAtNode*)theNode)->binding = fxBindingFromExpression(parser, ((txPropertyBindingAtNode*)theNode)->binding, theToken);
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_REST_BINDING) {
-		((txRestBindingNode*)theNode)->binding = fxBindingFromExpression(parser, ((txRestBindingNode*)theNode)->binding, theToken);
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_SKIP_BINDING)
-		return theNode;
-	
-	if (aToken == XS_TOKEN_ACCESS) {
-		fxCheckStrictSymbol(parser, ((txAccessNode*)theNode)->symbol);
-		if (theToken == XS_TOKEN_ACCESS)
-			return theNode;
-		fxPushSymbol(parser, ((txAccessNode*)theNode)->symbol);
-		fxPushNodeStruct(parser, 1, theToken, ((txAccessNode*)theNode)->line);
-		return fxPopNode(parser);
-	}
-	if ((aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
-		return theNode;
-	}
-	if (aToken == XS_TOKEN_ASSIGN) {
-		binding = fxBindingFromExpression(parser, ((txAssignNode*)theNode)->reference, theToken);
-		if (!binding)
-			return NULL;
-		((txBindingNode*)theNode)->description = &gxTokenDescriptions[XS_TOKEN_BINDING];
-		((txBindingNode*)theNode)->target = binding;
-		((txBindingNode*)theNode)->initializer = ((txAssignNode*)theNode)->value;
-		return theNode;
-	}
-	
-	if (aToken == XS_TOKEN_ARRAY)
-		return fxArrayBindingFromExpression(parser, theNode, theToken);
-	if (aToken == XS_TOKEN_OBJECT)
-		return fxObjectBindingFromExpression(parser, theNode, theToken);
-	return NULL;
-}
-
-void fxArrayBinding(txParser* parser, txToken theToken)
-{
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	int elision = 1;
-	fxCheckParserStack(parser, aLine);
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACKET);
-	while ((parser->token == XS_TOKEN_COMMA) || (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_BINDING)) {
-		txInteger anItemLine = parser->line;
-		if (parser->token == XS_TOKEN_COMMA) {
-			fxGetNextToken(parser);
-			if (elision) {
-				fxPushNodeStruct(parser, 0, XS_TOKEN_SKIP_BINDING, anItemLine);
-				aCount++;
-			}
-			else
-				elision = 1;
-		}
-		else {
-			if (!elision)
-				fxReportParserError(parser, parser->line, "missing ,");
-			if (parser->token == XS_TOKEN_SPREAD) {
-				fxRestBinding(parser, theToken, 0);
-				aCount++;
-				break;
-			}
-			fxBinding(parser, theToken, 1);
-			aCount++;
-			elision = 0;
-		}
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACKET);
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY_BINDING, aLine);
-}
-
-txNode* fxArrayBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
-{
-	txNodeList* list = ((txArrayNode*)theNode)->items;
-	txNode** address = &(list->first);
-	txNode* item;
-	txNode* binding;
-	while ((item = *address)) {
-        if (!item->description) {
-            parser->errorSymbol = parser->SyntaxErrorSymbol;
-            return NULL;
-        }
-		if (item->description->token == XS_TOKEN_SPREAD) {
-			if (theNode->flags & mxElisionFlag) {
-				parser->errorSymbol = parser->SyntaxErrorSymbol;
-				return NULL;
-			}
-			binding = fxRestBindingFromExpression(parser, item, theToken, 0);
-			if (!binding) {
-				parser->errorSymbol = parser->SyntaxErrorSymbol;
-				return NULL;
-			}
-			break;
-		}
-		if (item->description->token == XS_TOKEN_ELISION) {
-			item->description = &gxTokenDescriptions[XS_TOKEN_SKIP_BINDING];
-		}
-		else {
-// 			if ((theToken == XS_TOKEN_BINDING) && ((item->description->token== XS_TOKEN_MEMBER) || (item->description->token == XS_TOKEN_MEMBER_AT)))
-// 				binding = item;
-// 			else {			
-				binding = fxBindingFromExpression(parser, item, theToken);
-				if (!binding) {
-					parser->errorSymbol = parser->SyntaxErrorSymbol;
-					return NULL;
-				}
-				binding->next = item->next;
-				item = *address = binding;
-// 			}
-		}
-		address = &(item->next);
-	}
-	fxPushNode(parser, (txNode*)list);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY_BINDING, theNode->line);
-	return fxPopNode(parser);
-}
-
-txUnsigned fxObjectBinding(txParser* parser, txToken theToken)
-{
-	txUnsigned flags = 0;
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	txSymbol* aSymbol;
-	txToken aToken;
-	txIndex index;
-	fxMatchToken(parser, XS_TOKEN_LEFT_BRACE);
-	for (;;) {
-		txInteger aPropertyLine = parser->line;
-		if (parser->token == XS_TOKEN_RIGHT_BRACE)
-			break;
-		aSymbol = NULL;
-		aToken = XS_TOKEN_PROPERTY_BINDING;
-		if ((gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME)) {
-			aSymbol = parser->symbol;
-			fxPushSymbol(parser, aSymbol);
-			aToken = XS_TOKEN_PROPERTY_BINDING;
-		}
-		else if (parser->token == XS_TOKEN_INTEGER) {
-			if (fxIntegerToIndex(parser->dtoa, parser->integer, &index)) {
-				fxPushIndexNode(parser, index, aPropertyLine);
-				aToken = XS_TOKEN_PROPERTY_BINDING_AT;
-			}
-			else {
-				aSymbol = fxNewParserSymbol(parser, fxIntegerToString(parser->dtoa, parser->integer, parser->buffer, parser->bufferSize));
-				fxPushSymbol(parser, aSymbol);
-				aToken = XS_TOKEN_PROPERTY_BINDING;
-			}
-		}
-		else if (parser->token == XS_TOKEN_NUMBER) {
-			if (fxNumberToIndex(parser->dtoa, parser->number, &index)) {
-				fxPushIndexNode(parser, index, aPropertyLine);
-				aToken = XS_TOKEN_PROPERTY_BINDING_AT;
-			}
-			else {
-				aSymbol = fxNewParserSymbol(parser, fxNumberToString(parser->dtoa, parser->number, parser->buffer, parser->bufferSize, 0, 0));
-				fxPushSymbol(parser, aSymbol);
-				aToken = XS_TOKEN_PROPERTY_BINDING;
-			}
-		}
-		else if (parser->token == XS_TOKEN_STRING) {
-			if (fxStringToIndex(parser->dtoa, parser->string, &index)) {
-				fxPushIndexNode(parser, index, aPropertyLine);
-				aToken = XS_TOKEN_PROPERTY_BINDING_AT;
-			}
-			else {
-				aSymbol = fxNewParserSymbol(parser, parser->string);
-				fxPushSymbol(parser, aSymbol);
-				aToken = XS_TOKEN_PROPERTY_BINDING;
-			}
-		}
-		else if (parser->token == XS_TOKEN_LEFT_BRACKET) {
-			fxGetNextToken(parser);
-			fxCommaExpression(parser);
-			if (parser->token != XS_TOKEN_RIGHT_BRACKET) {
-				fxReportParserError(parser, parser->line, "missing ]");
-			}
-			aToken = XS_TOKEN_PROPERTY_BINDING_AT;
-		}
-		else if (parser->token == XS_TOKEN_SPREAD) {
-			flags |= mxSpreadFlag;
-			fxRestBinding(parser, theToken, 1);
-			aCount++;
-            break;
-		}
-		else {
-			fxReportParserError(parser, parser->line, "missing identifier");
-			fxPushNULL(parser);
-		}
-		fxGetNextToken2(parser);
-		if (parser->token2 == XS_TOKEN_COLON) {
-			fxGetNextToken(parser);
-			fxGetNextToken(parser);
-			fxBinding(parser, theToken, 1);
-		}
-		else if (aSymbol) {
-			fxBinding(parser, theToken, 1);
-		}
-		else {
-			fxReportParserError(parser, parser->line, "missing :");
-			fxPushNULL(parser);
-		}
-		fxPushNodeStruct(parser, 2, aToken, aPropertyLine);
-		aCount++;
-        if (parser->token == XS_TOKEN_RIGHT_BRACE)
-            break;
-		if (parser->token == XS_TOKEN_COMMA)
-			fxGetNextToken(parser);
-		else
-            break;
-	}
-	fxMatchToken(parser, XS_TOKEN_RIGHT_BRACE);
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT_BINDING, aLine);
-	parser->root->flags |= flags;
-	return flags;
-}
-
-txNode* fxObjectBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken)
-{
-	txNodeList* list = ((txObjectNode*)theNode)->items;
-	txNode* property = list->first;
-	txNode* binding;
-	txUnsigned flags = 0;
-	while (property) {
-		if (!property->description) {
-			parser->errorSymbol = parser->SyntaxErrorSymbol;
-			return NULL;
-		}
-		if (property->description->token == XS_TOKEN_PROPERTY) {
-			binding = fxBindingFromExpression(parser, ((txPropertyNode*)property)->value, theToken);
-			if (!binding) {
-				parser->errorSymbol = parser->SyntaxErrorSymbol;
-				return NULL;
-			}
-			property->description = &gxTokenDescriptions[XS_TOKEN_PROPERTY_BINDING];
-			((txPropertyBindingNode*)property)->binding = binding;
-		}
-		else if (property->description->token == XS_TOKEN_PROPERTY_AT) {
-			binding = fxBindingFromExpression(parser, ((txPropertyAtNode*)property)->value, theToken);
-			if (!binding) {
-				parser->errorSymbol = parser->SyntaxErrorSymbol;
-				return NULL;
-			}
-			property->description = &gxTokenDescriptions[XS_TOKEN_PROPERTY_BINDING_AT];
-			((txPropertyBindingAtNode*)property)->binding = binding;
-		}
-		else if (property->description->token == XS_TOKEN_SPREAD) {
-			binding = fxRestBindingFromExpression(parser, property, theToken, 1);
-			if (!binding) {
-				parser->errorSymbol = parser->SyntaxErrorSymbol;
-				return NULL;
-			}
-			flags |= mxSpreadFlag;
-			break;
-		}
-		property = property->next;
-	}
-	fxPushNode(parser, (txNode*)list);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT_BINDING, theNode->line);
-	parser->root->flags |= flags;
-	return fxPopNode(parser);
-}
-
-void fxParametersBinding(txParser* parser)
-{
-	txInteger aCount = 0;
-	txInteger aLine = parser->line;
-	txBindingNode* binding;
-	if (parser->token == XS_TOKEN_LEFT_PARENTHESIS) {
-		fxGetNextToken(parser);
-		while (gxTokenFlags[parser->token] & XS_TOKEN_BEGIN_BINDING) {
-			if (parser->token == XS_TOKEN_SPREAD) {
-				parser->flags |= mxNotSimpleParametersFlag;
-				fxRestBinding(parser, XS_TOKEN_ARG, 0);
-				aCount++;
-				break;
-			}
-			fxBinding(parser, XS_TOKEN_ARG, 1);
-			binding = (txBindingNode*)parser->root;
-			if (binding->description->token != XS_TOKEN_ARG)
-				parser->flags |= mxNotSimpleParametersFlag;
-			aCount++;
-			if (parser->token != XS_TOKEN_RIGHT_PARENTHESIS)
-				fxMatchToken(parser, XS_TOKEN_COMMA);
-		}
-		fxMatchToken(parser, XS_TOKEN_RIGHT_PARENTHESIS);
-	}
-	else
-		fxReportParserError(parser, parser->line, "missing (");
-	fxPushNodeList(parser, aCount);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS_BINDING, aLine);
-}
-
-txNode* fxParametersBindingFromExpressions(txParser* parser, txNode* theNode)
-{
-	txNodeList* list = ((txParamsNode*)theNode)->items;
-	txNode** address = &(list->first);
-	txNode* item;
-	txBindingNode* binding;
-	while ((item = *address)) {
-		txToken aToken = (item && item->description) ? item->description->token : XS_NO_TOKEN;
-		if (aToken == XS_TOKEN_SPREAD) {
-			binding = (txBindingNode*)fxRestBindingFromExpression(parser, item, XS_TOKEN_ARG, 0);
-			if (!binding)
-				return NULL;
-			parser->flags |= mxNotSimpleParametersFlag;
-			break;
-		}
-		binding = (txBindingNode*)fxBindingFromExpression(parser, item, XS_TOKEN_ARG);
-		if (!binding)
-			return NULL;
-		if (binding->description->token != XS_TOKEN_ARG)
-			parser->flags |= mxNotSimpleParametersFlag;
-		binding->next = item->next;
-		item = *address = (txNode*)binding;
-		address = &(item->next);
-	}
-	theNode->description = &gxTokenDescriptions[XS_TOKEN_PARAMS_BINDING];
-	return theNode;
-}
-
-void fxRestBinding(txParser* parser, txToken theToken, txUnsigned flag)
-{
-	txInteger aLine = parser->line;
-	fxMatchToken(parser, XS_TOKEN_SPREAD);
-	fxBinding(parser, theToken, 0);
-	if (flag && ((parser->root->description->token == XS_TOKEN_ARRAY_BINDING) || (parser->root->description->token == XS_TOKEN_OBJECT_BINDING))) {
-		fxReportParserError(parser, parser->line, "invalid rest");
-	}
-	fxPushNodeStruct(parser, 1, XS_TOKEN_REST_BINDING, aLine);
-}
-
-txNode* fxRestBindingFromExpression(txParser* parser, txNode* theNode, txToken theToken, txUnsigned flag)
-{
-	txNode* expression = ((txSpreadNode*)theNode)->expression;
-	txNode* binding;
-	if (theNode->next) {
-		parser->errorSymbol = parser->SyntaxErrorSymbol;
-		return NULL;
-	}
-	if (!expression)
-		return NULL;
-// 	if ((theToken == XS_TOKEN_BINDING) && ((expression->description->token == XS_TOKEN_MEMBER) || (expression->description->token == XS_TOKEN_MEMBER_AT)))
-// 		binding = expression;
-// 	else {			
-		binding = fxBindingFromExpression(parser, expression, theToken);
-		if (!binding) {
-			parser->errorSymbol = parser->SyntaxErrorSymbol;
-			return NULL;
-		}
-		if (binding->description->token == XS_TOKEN_BINDING) {
-			fxReportParserError(parser, parser->line, "invalid rest");
-			return NULL;
-		}
-		if (flag && ((binding->description->token == XS_TOKEN_ARRAY_BINDING) || (binding->description->token == XS_TOKEN_OBJECT_BINDING))) {
-			fxReportParserError(parser, parser->line, "invalid rest");
-			return NULL;
-		}
-// 	}
-	theNode->description = &gxTokenDescriptions[XS_TOKEN_REST_BINDING];
-	((txRestBindingNode*)theNode)->binding = binding;
-	return theNode;
-}
-
-void fxCheckArrowFunction(txParser* parser, txInteger count)
-{
-	txNode* node = parser->root;
-	while (count) {
-		if (node->flags & mxArrowFlag)
-			fxReportParserError(parser, parser->line, "invalid arrow function");
-		count--;
-		node = node->next;
-	}
-}
-
-txBoolean fxCheckReference(txParser* parser, txToken theToken)
-{
-	txNode* node = parser->root;
-	txToken aToken = (node && node->description) ? node->description->token : XS_NO_TOKEN;
-	if (aToken == XS_TOKEN_EXPRESSIONS) {
-		txNode* item = ((txExpressionsNode*)node)->items->first;
-		if (item && !item->next) {
-			aToken = (item->description) ? item->description->token : XS_NO_TOKEN;
-			if ((aToken == XS_TOKEN_ACCESS) || (aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED)) {
-				item->next = node->next;
-				node = parser->root = item;
-			}
-			else
-				aToken = XS_TOKEN_EXPRESSIONS;
-		}
-	}
-	if (aToken == XS_TOKEN_ACCESS) {
-		fxCheckStrictSymbol(parser, ((txAccessNode*)node)->symbol);
-		return 1;
-	}
-	if ((aToken == XS_TOKEN_MEMBER) || (aToken == XS_TOKEN_MEMBER_AT) || (aToken == XS_TOKEN_PRIVATE_MEMBER) || (aToken == XS_TOKEN_UNDEFINED))
-		return 1;
-		
-	if (theToken == XS_TOKEN_ASSIGN) {
-		if (aToken == XS_TOKEN_ARRAY) {
-			txNode* binding = fxArrayBindingFromExpression(parser, node, XS_TOKEN_ACCESS);
-            if (binding) {
-                binding->next = node->next;
-                parser->root = binding;
- 				return 1;
-           }
-       	}
-		else if (aToken == XS_TOKEN_OBJECT) {
-			txNode* binding = fxObjectBindingFromExpression(parser, node, XS_TOKEN_ACCESS);
-            if (binding) {
-                binding->next = node->next;
-                parser->root = binding;
- 				return 1;
-            }
-        }
-	}
-	else if (theToken == XS_TOKEN_DELETE)
-		return 1;
-	return 0;
-}
-
-void fxCheckStrictBinding(txParser* parser, txNode* node)
-{
-	if (node && node->description) {
-		if (node->description->token == XS_TOKEN_ACCESS) {
-			fxCheckStrictSymbol(parser, ((txAccessNode*)node)->symbol);
-		}
-		else if (node->description->token == XS_TOKEN_ARG) {
-			fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
-		}
-		else if (node->description->token == XS_TOKEN_CONST) {
-			fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
-		}
-		else if (node->description->token == XS_TOKEN_LET) {
-			fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
-		}
-		else if (node->description->token == XS_TOKEN_VAR) {
-			fxCheckStrictSymbol(parser, ((txDeclareNode*)node)->symbol);
-		}
-		else if (node->description->token == XS_TOKEN_BINDING) {
-			fxCheckStrictBinding(parser, ((txBindingNode*)node)->target);
-		}
-		else if (node->description->token == XS_TOKEN_ARRAY_BINDING) {
-			node = ((txArrayBindingNode*)node)->items->first;
-			while (node) {
-				fxCheckStrictBinding(parser, node);
-				node = node->next;
-			}
-		}
-		else if (node->description->token == XS_TOKEN_OBJECT_BINDING) {
-			node = ((txObjectBindingNode*)node)->items->first;
-			while (node) {
-				fxCheckStrictBinding(parser, node);
-				node = node->next;
-			}
-		}
-		else if (node->description->token == XS_TOKEN_PARAMS_BINDING) {
-			node = ((txParamsBindingNode*)node)->items->first;
-			while (node) {
-				fxCheckStrictBinding(parser, node);
-				node = node->next;
-			}
-		}
-		else if (node->description->token == XS_TOKEN_PROPERTY_BINDING)
-			fxCheckStrictBinding(parser, ((txPropertyBindingNode*)node)->binding);
-		else if (node->description->token == XS_TOKEN_PROPERTY_BINDING_AT)
-			fxCheckStrictBinding(parser, ((txPropertyBindingAtNode*)node)->binding);
-		else if (node->description->token == XS_TOKEN_REST_BINDING)
-			fxCheckStrictBinding(parser, ((txRestBindingNode*)node)->binding);
-	}
-}
-
-void fxCheckStrictFunction(txParser* parser, txFunctionNode* function)
-{
-	parser->line = function->line;
-	fxCheckStrictSymbol(parser, function->symbol);
-	fxCheckStrictBinding(parser, function->params);
-}
-
-void fxCheckStrictSymbol(txParser* parser, txSymbol* symbol)
-{
-	if (parser->flags & mxStrictFlag) {
-		if (symbol == parser->argumentsSymbol)
-			fxReportParserError(parser, parser->line, "invalid arguments (strict mode)");
-		else if (symbol == parser->evalSymbol)
-			fxReportParserError(parser, parser->line, "invalid eval (strict mode)");
-		else if (symbol == parser->yieldSymbol)
-			fxReportParserError(parser, parser->line, "invalid yield (strict mode)");
-	}
-	else if (parser->flags & mxYieldFlag) {
-		if (symbol == parser->yieldSymbol)
-			fxReportParserError(parser, parser->line, "invalid yield");
-	}
-}
-
-void fxCheckUniqueProperty(txParser* parser, txNode* base, txNode* current)
-{
-	return; // no more!
-	if (current->description->token == XS_TOKEN_PROPERTY) {
-		txPropertyNode* currentNode = (txPropertyNode*)current;
-		while (base != current) {
-			txPropertyNode* baseNode = (txPropertyNode*)base;
-			if (baseNode->description->token == XS_TOKEN_PROPERTY) {
-				if (baseNode->symbol == currentNode->symbol) {
-					fxCheckUniquePropertyAux(parser, (txNode*)baseNode, (txNode*)currentNode);			
-				}
-			}
-			base = base->next;
-		}
-	}
-	else {
-		txPropertyAtNode* currentNode = (txPropertyAtNode*)current;
-		txIntegerNode* currentAt = (txIntegerNode*)(currentNode->at);
-		if (currentAt->description->token == XS_TOKEN_INTEGER) {
-			while (base != current) {
-				txPropertyAtNode* baseNode = (txPropertyAtNode*)base;
-				if (baseNode->description->token == XS_TOKEN_PROPERTY_AT) {
-					txIntegerNode* baseAt = (txIntegerNode*)(baseNode->at);
-					if (baseAt->description->token == XS_TOKEN_INTEGER) {
-						if (baseAt->value == currentAt->value) {
-							fxCheckUniquePropertyAux(parser, (txNode*)baseNode, (txNode*)currentNode);			
-						}
-					}
-				}
-				base = base->next;
-			}
-		}
-	}
-}
-
-void fxCheckUniquePropertyAux(txParser* parser, txNode* baseNode, txNode* currentNode)
-{
-	if (currentNode->flags & mxGetterFlag) {
-		if (baseNode->flags & mxGetterFlag)
-			fxReportParserError(parser, parser->line, "getter already defined");
-		else if (!(baseNode->flags & mxSetterFlag))
-			fxReportParserError(parser, parser->line, "property already defined");
-	}
-	else if (currentNode->flags & mxSetterFlag) {
-		if (baseNode->flags & mxSetterFlag)
-			fxReportParserError(parser, parser->line, "setter already defined");
-		else if (!(baseNode->flags & mxGetterFlag))
-			fxReportParserError(parser, parser->line, "property already defined");
-	}
-	else {
-		if (baseNode->flags & mxGetterFlag)
-			fxReportParserError(parser, parser->line, "getter already defined");
-		else if (baseNode->flags & mxSetterFlag)
-			fxReportParserError(parser, parser->line, "setter already defined");
-		else if (parser->flags & mxStrictFlag)
-			fxReportParserError(parser, parser->line, "property already defined (strict mode)");
-	}
-}
-
-
-void fxJSONValue(txParser* parser)
-{
-	switch (parser->token) {
-	case XS_TOKEN_FALSE:
-		fxPushNodeStruct(parser, 0, parser->token, parser->line);
-		fxGetNextTokenJSON(parser);
-		break;
-	case XS_TOKEN_TRUE:
-		fxPushNodeStruct(parser, 0, parser->token, parser->line);
-		fxGetNextTokenJSON(parser);
-		break;
-	case XS_TOKEN_NULL:
-		fxPushNodeStruct(parser, 0, parser->token, parser->line);
-		fxGetNextTokenJSON(parser);
-		break;
-	case XS_TOKEN_INTEGER:
-		fxPushIntegerNode(parser, parser->integer, parser->line);
-		fxGetNextTokenJSON(parser);
-		break;
-	case XS_TOKEN_NUMBER:
-		fxPushNumberNode(parser, parser->number, parser->line);
-		fxGetNextTokenJSON(parser);
-		break;
-	case XS_TOKEN_STRING:
-		fxPushStringNode(parser, parser->stringLength, parser->string, parser->line);
-		fxGetNextTokenJSON(parser);
-		break;
-	case XS_TOKEN_LEFT_BRACE:
-		fxJSONObject(parser);
-		break;
-	case XS_TOKEN_LEFT_BRACKET:
-		fxJSONArray(parser);
-		break;
-	default:
-		fxPushNULL(parser);
-		fxReportParserError(parser, parser->line, "invalid value");
-		break;
-	}
-}
-
-void fxJSONObject(txParser* parser)
-{
-	txIndex aLength = 0;
-	txInteger aLine = parser->line;
-	fxGetNextTokenJSON(parser);
-	for (;;) {
-		if (parser->token == XS_TOKEN_RIGHT_BRACE)
-			break;
-		if (parser->token != XS_TOKEN_STRING) {
-			fxReportParserError(parser, parser->line, "missing name");
-			break;
-		}
-		fxPushStringNode(parser, parser->stringLength, parser->string, parser->line);
-		fxGetNextTokenJSON(parser);
-		if (parser->token != XS_TOKEN_COLON) {
-			fxReportParserError(parser, parser->line, "missing :");
-			break;
-		}
-		fxGetNextTokenJSON(parser);
-		fxJSONValue(parser);
-		fxPushNodeStruct(parser, 2, XS_TOKEN_PROPERTY_AT, parser->line);
-		aLength++;
-		if (parser->token != XS_TOKEN_COMMA)
-			break;
-		fxGetNextTokenJSON(parser);
-	}
-	if (parser->token != XS_TOKEN_RIGHT_BRACE)
-		fxReportParserError(parser, parser->line, "missing }");
-	fxGetNextTokenJSON(parser);
-	fxPushNodeList(parser, aLength);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, aLine);
-}
-
-void fxJSONArray(txParser* parser)
-{
-	txIndex aLength = 0;
-	txInteger aLine = parser->line;
-	fxGetNextTokenJSON(parser);
-	for (;;) {
-		if (parser->token == XS_TOKEN_RIGHT_BRACKET)
-			break;
-		fxJSONValue(parser);
-		aLength++;
-		if (parser->token != XS_TOKEN_COMMA)
-			break;
-		fxGetNextTokenJSON(parser);
-	}
-	if (parser->token != XS_TOKEN_RIGHT_BRACKET)
-		fxReportParserError(parser, parser->line, "missing ]");
-	fxGetNextTokenJSON(parser);
-	fxPushNodeList(parser, aLength);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_ARRAY, aLine);
-}
-
-void fxJSXAttributeName(txParser* parser)
-{
-	txSymbol* symbol = parser->symbol;
-	fxGetNextToken(parser);
-	if (parser->token == XS_TOKEN_COLON) {
-		fxGetNextToken(parser);
-		if (gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME)
-			symbol = fxJSXNamespace(parser, symbol, parser->symbol);
-		else
-			fxReportParserError(parser, parser->line, "missing name");
-	}
-	fxPushSymbol(parser, symbol);
-}
-
-void fxJSXAttributeValue(txParser* parser)
-{
-	txInteger line = parser->line;
-	fxGetNextTokenJSXAttribute(parser);
-	if (parser->token == XS_TOKEN_STRING) {
-		fxPushStringNode(parser, parser->stringLength, parser->string, line);
-		fxGetNextToken(parser);
-	}
-	else if (parser->token == XS_TOKEN_LEFT_BRACE) {
-		fxGetNextToken(parser);
-		if (parser->token == XS_TOKEN_RIGHT_BRACE) {
-			fxGetNextToken(parser);
-			fxReportParserError(parser, parser->line, "missing expression");
-			fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
-		}
-		else {
-			fxAssignmentExpression(parser);
-			if (parser->token == XS_TOKEN_RIGHT_BRACE)
-				fxGetNextToken(parser);
-			else
-				fxReportParserError(parser, parser->line, "missing }");
-		}
-	}
-	else {
-		fxReportParserError(parser, parser->line, "invalid %s", gxTokenNames[parser->token]);
-		fxPushNodeStruct(parser, 0, XS_TOKEN_UNDEFINED, line);
-	}
-}
-
-void fxJSXElement(txParser* parser)
-{
-	txBoolean closed = 0;
-	txInteger line = parser->line;
-	txNode* name = NULL;
-	txInteger nodeCount = parser->nodeCount;
-	txInteger propertyCount = 0;
-	fxPushSymbol(parser, parser->__jsx__Symbol);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, parser->line);
-	if (parser->token == XS_TOKEN_IDENTIFIER) {
-		fxJSXElementName(parser);
-		name = parser->root;
-	}
-	else {
-		fxReportParserError(parser, parser->line, "missing identifier");
-		fxPushNULL(parser);
-	}
-	for (;;) {
-		if (parser->token == XS_TOKEN_MORE)
-			break;
-		if (parser->token == XS_TOKEN_DIVIDE) {
-			fxGetNextToken(parser);
-			if (parser->token != XS_TOKEN_MORE)
-				fxReportParserError(parser, parser->line, "missing >");
-			closed = 1;
-			break;
-		}
-		if (gxTokenFlags[parser->token] & XS_TOKEN_IDENTIFIER_NAME) {
-			fxJSXAttributeName(parser);
-			if (parser->token == XS_TOKEN_ASSIGN)
-				fxJSXAttributeValue(parser);
-			else
-				fxPushNodeStruct(parser, 0, XS_TOKEN_TRUE, parser->line);
-			fxPushNodeStruct(parser, 2, XS_TOKEN_PROPERTY, parser->line);
-			propertyCount++;
-		}
-		else if (parser->token == XS_TOKEN_LEFT_BRACE) {
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_SPREAD) {
-				fxGetNextToken(parser);
-				fxAssignmentExpression(parser);
-				if (parser->token == XS_TOKEN_RIGHT_BRACE)
-					fxGetNextToken(parser);
-				else
-					fxReportParserError(parser, parser->line, "missing }");
-				fxPushNodeStruct(parser, 1, XS_TOKEN_SPREAD, parser->line);
-				propertyCount++;
-			}
-			else
-				fxReportParserError(parser, parser->line, "invalid %s", gxTokenNames[parser->token]);
-		}
-		else {
-			fxReportParserError(parser, parser->line, "invalid %s", gxTokenNames[parser->token]);
-			break;
-		}
-	}
-	if (propertyCount > 0) {
-		fxPushNodeList(parser, propertyCount);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_OBJECT, parser->line);
-	}
-	else
-		fxPushNodeStruct(parser, 0, XS_TOKEN_NULL, parser->line);
-	if (!closed) {
-		for (;;) {
-			fxGetNextTokenJSXChild(parser);
-			if (parser->stringLength)
-				fxPushStringNode(parser, parser->stringLength, parser->string, parser->line);
-			if (parser->token == XS_TOKEN_LEFT_BRACE) {
-				fxGetNextToken(parser);
-				if (parser->token == XS_TOKEN_RIGHT_BRACE)
-					fxGetNextToken(parser);
-				else {
-					fxAssignmentExpression(parser);
-					if (parser->token != XS_TOKEN_RIGHT_BRACE)
-						fxReportParserError(parser, parser->line, "missing }");
-				}
-			}
-			else if (parser->token == XS_TOKEN_LESS) {
-				fxGetNextToken(parser);
-				if (parser->token == XS_TOKEN_DIVIDE) {
-					fxGetNextToken(parser);
-					if (parser->token == XS_TOKEN_IDENTIFIER) {
-						fxJSXElementName(parser);
-						if (!fxJSXMatch(parser, name, parser->root)) {
-							fxReportParserError(parser, parser->line, "invalid element");
-							fxPushNULL(parser);
-						}
-					}
-					else {
-						fxReportParserError(parser, parser->line, "missing identifier");
-						fxPushNULL(parser);
-					}
-					if (parser->token != XS_TOKEN_MORE)
-						fxReportParserError(parser, parser->line, "missing >");
-					fxPopNode(parser);
-					break;
-				}
-				else
-					fxJSXElement(parser);
-			}
-			else {
-				fxReportParserError(parser, parser->line, "invalid %s", gxTokenNames[parser->token]);
-				break;
-			}
-		}
-	}
-	fxPushNodeList(parser, parser->nodeCount - nodeCount - 1);
-	fxPushNodeStruct(parser, 1, XS_TOKEN_PARAMS, line);
-	fxPushNodeStruct(parser, 2, XS_TOKEN_CALL, line);
-}
-
-void fxJSXElementName(txParser* parser)
-{
-	txInteger line = parser->line;
-	txSymbol* symbol = parser->symbol;
-	fxGetNextToken(parser);
-	if (parser->token == XS_TOKEN_COLON) {
-		fxGetNextToken(parser);
-		if (parser->token == XS_TOKEN_IDENTIFIER)
-			symbol = fxJSXNamespace(parser, symbol, parser->symbol);
-		else
-			fxReportParserError(parser, parser->line, "missing name");
-		fxPushSymbol(parser, symbol);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, line);
-		fxGetNextToken(parser);
-	}
-	else {
-		fxPushSymbol(parser, symbol);
-		fxPushNodeStruct(parser, 1, XS_TOKEN_ACCESS, line);
-		while (parser->token == XS_TOKEN_DOT) {
-			fxGetNextToken(parser);
-			if (parser->token == XS_TOKEN_IDENTIFIER) {
-				fxPushSymbol(parser, parser->symbol);
-				fxPushNodeStruct(parser, 2, XS_TOKEN_MEMBER, parser->line);
-				fxGetNextToken(parser);
-			}
-			else
-				fxReportParserError(parser, parser->line, "missing property");
-		}
-	}
-}
-
-txBoolean fxJSXMatch(txParser* parser, txNode* opening, txNode* closing)
-{
-	if (opening && closing) {
-		while (opening->description->token == XS_TOKEN_MEMBER) {
-			if (closing->description->token != XS_TOKEN_MEMBER)
-				return 0;
-			if (((txMemberNode*)opening)->symbol != ((txMemberNode*)closing)->symbol)
-				return 0;
-			opening = ((txMemberNode*)opening)->reference;
-			closing = ((txMemberNode*)closing)->reference;
-		}
-		if (opening->description->token == XS_TOKEN_ACCESS) {
-			if (closing->description->token != XS_TOKEN_ACCESS)
-				return 0;
-			if (((txAccessNode*)opening)->symbol != ((txAccessNode*)closing)->symbol)
-				return 0;
-			return 1;
-		}
-	}
-	return 0;
-}
-
-txSymbol* fxJSXNamespace(txParser* parser, txSymbol* namespace, txSymbol* name)
-{
-	txSize namespaceLength = namespace->length;
-	txSize nameLength = name->length;
-	txSize length = namespaceLength + 1 + nameLength + 1;
-	txString string = fxNewParserChunk(parser, length);
-	snprintf(string, length, "%s:%s", namespace->string, name->string);
-	return fxNewParserSymbol(parser, string);
-}