{"version":3,"sources":["../lib/utils.js","../lib/parse.js","../lib/ast.js","../lib/transform.js","../lib/output.js","../lib/scope.js","../lib/compress/index.js","../tools/domprops.js","../lib/propmangle.js","../lib/minify.js","../lib/mozilla-ast.js","../lib/sourcemap.js"],"names":["characters","str","split","member","name","array","includes","find_if","func","i","n","length","configure_error_stack","fn","Object","defineProperty","prototype","get","err","Error","this","message","e","stack","DefaultsError","msg","defs","defaults","args","croak","ret","HOP","merge","obj","ext","count","noop","return_false","return_true","return_this","return_null","create","constructor","MAP","a","f","backwards","top","doit","val","is_last","Last","v","AtTop","Splice","push","apply","slice","reverse","skip","Array","concat","at_top","splice","last","push_uniq","el","string_template","text","props","replace","p","remove","mergeSort","cmp","_ms","m","Math","floor","left","right","b","r","ai","bi","makePredicate","words","cats","out","j","quote","word","JSON","stringify","s","compareTo","arr","sort","cat","Function","all","predicate","Dictionary","_values","_size","prop","hasOwnProperty","call","first_in_statement","node","parent","AST_Statement","body","AST_Sequence","expressions","TYPE","expression","AST_Dot","AST_Sub","AST_Conditional","condition","AST_Binary","AST_UnaryPostfix","keep_name","keep_setting","RegExp","test","set","key","has","add","del","each","substr","size","map","clone","toObject","fromObject","dict","KEYWORDS","KEYWORDS_ATOM","RESERVED_WORDS","KEYWORDS_BEFORE_EXPRESSION","OPERATOR_CHARS","RE_NUM_LITERAL","RE_HEX_NUMBER","RE_OCT_NUMBER","RE_ES6_OCT_NUMBER","RE_BIN_NUMBER","RE_DEC_NUMBER","OPERATORS","WHITESPACE_CHARS","NEWLINE_CHARS","PUNC_AFTER_EXPRESSION","PUNC_BEFORE_EXPRESSION","PUNC_CHARS","UNICODE","ID_Start","ID_Continue","get_full_char","pos","char","charAt","is_surrogate_pair_head","next","is_surrogate_pair_tail","prev","code","charCodeAt","is_digit","is_identifier","is_identifier_start","ch","is_identifier_char","is_identifier_string","JS_Parse_Error","filename","line","col","js_error","is_token","token","type","value","EX_EOF","tokenizer","$TEXT","html5_comments","shebang","S","tokpos","tokline","tokcol","newline_before","regex_allowed","brace_counter","template_braces","comments_before","directives","directive_stack","peek","signal_eof","in_string","forward","looking_at","find","what","indexOf","start_token","prev_was_dot","previous_token","is_comment","UNARY_POSTFIX","endline","endcol","endpos","nlb","file","raw","substring","comments_after","AST_Token","skip_whitespace","parse_error","read_num","prefix","has_e","after_e","has_x","has_dot","num","pred","read_while","next_token","has_directive","valid","parseInt","parseFloat","parse_js_number","isNaN","read_escaped_char","strict_hex","template_string","String","fromCharCode","hex_bytes","result","strict_octal","read_octal_escape_sequence","digit","read_string","with_eof_error","quote_char","tok","read_template_characters","begin","content","end","tmp","pop","skip_line_comment","find_eol","skip_multiline_comment","surrogates","get_full_char_length","read_name","escaped","read_escaped_identifier_char","read_regexp","source","prev_backslash","in_class","mods","regexp","raw_source","read_operator","grow","op","bigger","handle_slash","eof_error","cont","x","ex","force_regexp","context","nc","add_directive","directive","undefined","push_directives_stack","pop_directives_stack","UNARY_PREFIX","ASSIGNMENT","PRECEDENCE","ATOMIC_START_TOKEN","parse","options","bare_returns","ecma","module","strict","toplevel","input","peeked","in_function","in_async","in_generator","in_directives","in_loop","labels","is","ctx","token_error","unexpected","expect_token","expect","punc","has_newline_before","comment","can_insert_semicolon","is_in_generator","is_in_async","semicolon","optional","parenthesised","exp","embed_tokens","parser","start","expr","arguments","handle_regexp","statement","is_export_default","is_for_body","is_if_body","dir","stat","simple_statement","AST_String","AST_Directive","function_","AST_Defun","imported_name","imported_names","as_symbol","AST_SymbolImport","map_names","mod_str","AST_Import","module_name","import_","label","AST_Label","l","AST_IterationStatement","references","forEach","ref","AST_Continue","AST_LabeledStatement","labeled_statement","AST_BlockStatement","block_","AST_EmptyStatement","break_cont","AST_Break","AST_Debugger","AST_Do","AST_While","for_await_error","await_tok","init","var_","let_","const_","is_in","is_of","AST_Definitions","definitions","is_assignable","to_destructuring","AST_Destructuring","AST_ForIn","object","for_in","is_await","lhs","AST_ForOf","await","for_of","step","AST_For","regular_for","for_","class_","AST_DefClass","cond","belse","AST_If","alternative","if_","AST_Return","AST_Switch","switch_body_","AST_Throw","bcatch","bfinally","parameter","AST_SymbolCatch","AST_Catch","argname","AST_Finally","AST_Try","try_","AST_With","is_default","exported_names","exported_value","exported_definition","AST_Export","AST_Lambda","AST_SimpleStatement","export_","ldef","AST_LabelRef","thedef","arrow_function","argnames","is_async","_function_body","AST_Arrow","async","ctor","is_generator_property","in_statement","is_generator","AST_SymbolDefun","AST_SymbolLambda","AST_Function","AST_Accessor","AST_SymbolDeclaration","track_used_binding_identifiers","is_parameter","parameters","duplicate","default_assignment","spread","strict_mode","tracker","add_parameter","check_strict","mark_default_assignment","mark_spread","mark_strict_mode","is_strict","used_parameters","symbol_type","param","expand","binding_element","AST_DefaultAssign","operator","AST_Expansion","expand_token","elements","first","is_expand","first_token","AST_SymbolFunarg","AST_Hole","names","is_array","AST_ObjectKeyVal","property_token","property","as_property_name","block","generator","loop","current_generator","current_async","params","_verify_symbol","cur","branch","AST_Case","AST_Default","vardefs","no_in","kind","def","sym_type","AST_SymbolVar","AST_SymbolConst","AST_SymbolLet","AST_VarDef","AST_Var","AST_Let","AST_Const","as_atom_node","_make_symbol","AST_SymbolRef","AST_Number","AST_RegExp","AST_False","AST_True","AST_Null","to_fun_args","_","__","default_seen_above","insert_default","default_value","AST_Object","properties","AST_Array","AST_Assign","expr_atom","allow_calls","allow_arrows","subscripts","AST_NewTarget","newexp","expr_list","AST_New","mark_pure","new_","exprs","maybe_sequence","spread_token","invalid_sequence","trailing_comma","params_or_seq_","AST_Call","len","unshift","comments_before_length","array_","object_or_destructuring_","cls","AST_ClassExpression","tagged","segments","AST_TemplateSegment","AST_TemplateString","closing","allow_trailing_comma","allow_empty","create_accessor","concise","concise_method_or_getset","AST_Node","KindOfClass","method","class_name","extends_","AST_SymbolDefClass","AST_SymbolClass","extends","is_class","get_ast","AST_SymbolMethod","is_static","AST_ConciseMethod","static","AST_ObjectGetter","AST_ObjectSetter","map_name","is_import","make_symbol","foreign_name","foreign_type","AST_SymbolImportForeign","AST_SymbolExportForeign","AST_SymbolExport","AST_NameMapping","map_nameAsterisk","AST_This","AST_Super","sym","noerror","comments","pure","call_args","AST_PrefixedTemplateString","maybe_unary","AST_Await","make_unary","AST_UnaryPrefix","expr_op","min_prec","prec","maybe_conditional","expr_ops","yes","consequent","AST_PropAccess","AST_ObjectProperty","maybe_assign","star","has_expression","AST_Yield","is_star","_yield_expression","commas","AST_Toplevel","DEFNODE","methods","base","self_props","PROPS","proto","initialize","BASE","SUBCLASSES","CTOR","SELF_PROPS","DEFMETHOD","_clone","deep","self","transform","TreeTransformer","$documentation","$propdoc","_walk","visitor","_visit","walk","warn_function","warn","txt","walk_body","clone_block_scope","block_scope","AST_Block","AST_StatementWithBody","TreeWalker","AST_LoopControl","AST_DWLoop","AST_Scope","variables","functions","uses_with","uses_eval","parent_scope","enclosed","cname","get_defun_scope","is_block_scope","pinned","globals","wrap_commonjs","wrapped_tl","wrap_enclose","args_values","index","join","uses_arguments","args_as_names","all_symbols","AST_Symbol","seg","AST_Jump","AST_Exit","AST_SwitchBranch","name_import","name_export","AST_Unary","AST_Class","scope","AST_SymbolBlockDeclaration","AST_Constant","getValue","literal","AST_Atom","AST_NaN","AST_Undefined","AST_Infinity","AST_Boolean","callback","visit","before","after","descend","getPrototypeOf","find_parent","st","loopcontrol_target","tw","in_list","y","do_list","list","EXPECT_DIRECTIVE","is_some_comments","OutputStream","readonly","ascii_only","beautify","braces","ie8","indent_level","indent_start","inline_script","keep_quoted_props","max_line_len","preamble","quote_keys","quote_style","safari10","semicolons","shorthand","source_map","webkit","width","wrap_iife","comment_filter","regex_pos","lastIndexOf","indentation","current_col","current_line","current_pos","OUTPUT","to_utf8","identifier","toString","encode_string","dq","sq","quote_single","quote_double","make_string","make_indent","back","repeat_string","d","mapping_token","mapping_name","has_parens","might_need_space","might_need_semicolon","might_add_newline","need_newline_indented","need_space","newline_insert","mappings","do_add_mapping","mapping","cline","ccol","ensure_line_len","delta","requireSemicolonChars","print","indent","space","half","with_indent","next_indent","save_indentation","newline","force_semicolon","has_nlb","current_width","should_break","comma","colon","print_name","make_name","print_string","escape_directive","encoded","print_template_string_chars","with_block","with_parens","with_square","add_mapping","option","opt","prepend_comments","_dumped","shift","filter","last_nlb","c","append_comments","tail","insert","push_node","pop_node","SymbolDef","orig","eliminated","replaced","global","export","mangled_name","undeclared","id","next_id","DEFPRINT","nodetype","in_directive","active_scope","use_asm","PARENS","isArray","display_body","is_toplevel","output","allow_directives","stmt","print_braced_empty","print_braced","parenthesize_for_noin","noin","parens","print_property_name","make_num","force_statement","make_block","need_constructor_parens","toLowerCase","exec","best","best_of","DEFMAP","stream","force_parens","_codegen","add_source_map","needs_parens","po","pp","so","sp","p1","_do_print_body","nokeyword","arg","_do_print","tag","parenthesize_tag","is_tagged","make_then","definition","get_name","allowShortHand","_print_getter_setter","MASK_EXPORT_DONT_MANGLE","MASK_EXPORT_WANT_MANGLE","next_mangled","base54","reserved","unmangleable","eval","keep_fnames","keep_classnames","mangle","cache","redefined","defun","in_destructuring","for_scopes","save_scope","init_scope_vars","save_defun","save_labels","def_function","mark_export","def_variable","destructuring","mark_enclosed","find_variable","reference","level","exported","def_global","refs","g","symbol","mangled_names","tricky_def","tricky_name","_default_mangler_options","lname","to_mangle","Set","collect","save_nesting","avoid","to_avoid","add_def","reset","find_colliding_names","rename","next_name","_print","consider","skip_string","tail_node","print_to_string","chars","frequency","leading","digits","compare","Compressor","false_by_default","arrows","booleans","booleans_as_integers","collapse_vars","comparisons","computed_props","conditionals","dead_code","drop_console","drop_debugger","evaluate","global_defs","hoist_funs","hoist_props","hoist_vars","if_return","inline","join_vars","keep_fargs","keep_infinity","loops","negate_iife","passes","pure_getters","pure_funcs","reduce_funcs","reduce_vars","sequences","side_effects","switches","top_retain","typeofs","unsafe","unsafe_arrows","unsafe_comps","unsafe_Function","unsafe_math","unsafe_methods","unsafe_proto","unsafe_regexp","unsafe_undefined","unused","warnings","funcs","vars","sequences_limit","warnings_produced","exposed","in_boolean_context","compress","resolve_defines","process_expression","min_count","stopping","pass","figure_out_scope","reset_opt_flags","info","clear_warnings","_squeezed","was_scope","hoist_properties","hoist_declarations","optimize","drop_unused","def_optimize","optimizer","compressor","_optimized","read_property","get_value","make_node_from_constant","fixed_value","is_modified","immutable","is_lhs","is_expr_pure","contains_this","is_func_expr","is_lhs_read_only","is_immutable","is_ref_of","make_node","make_sequence","reduce","merge_sequence","isFinite","maintain_this_binding","as_statement_array","thing","is_empty","can_be_evicted_from_block","loop_body","is_iife_call","is_undeclared_ref","tt","drop_side_effect_free","def_reduce_vars","reset_def","assignments","chained","direct_access","fixed","recursive_refs","should_replace","single_use","reset_variables","safe_ids","mark","loop_ids","reset_block_variables","safe","safe_to_read","safe_to_assign","mark_escaped","depth","is_constant","is_constant_expression","lazy_op","suppressor","mark_def_node","inlined","save_ids","mark_func_expr","iife","eq","saved_loop","has_break_or_continue","recursive_ref","ref_once","_top","global_names","def_is_boolean","unary_bool","binary_bool","def_is_string","identifier_atom","is_identifier_atom","tighten_body","statements","in_try","find_loop_scope_try","CHANGED","max_iter","eliminate_spurious_blocks","eliminate_dead_code","handle_if_return","sequencesize","sequencesize_2","join_consecutive_vars","collapse","candidates","stat_index","scanner","abort","hit","hit_stack","hit_index","handle_custom_scan_order","stop_after","find_stop","write_only","lvalues","equivalent_to","replace_all","is_declared","stop_if_hit","lhs_local","can_replace","value_def","candidate","funarg","may_modify","may_throw_on_access","may_throw","has_side_effects","side_effects_external","multi_replacer","extract_args","extract_candidates","get_lhs","get_lvalues","is_lhs_local","value_has_side_effects","replace_all_symbols","remove_candidate","has_overlapping_symbol","fn_strict","found","scan_this","referenced","var_def","mangleable_var","get_rvalue","min","seen_dirs","multiple_if_returns","has_multiple_if_returns","in_lambda","next_index","ab","can_merge_flow","aborts","negate","as_statement_array_with_return","extract_functions","prev_index","lct","declarations_only","has_quit","extract_declarations_from_unreachable_code","seq","push_seq","to_simple_statement","decls","cons_seq","alt","join_object_assignments","defn","trimmed","diff","extract_object_assignments","target","remove_initializers","is_undefined","def_dot_throw","_dot_throw","is_boolean","def_is_number","unary","binary","is_number","is_string","unary_side_effects","best_of_expression","ast1","ast2","convert_to_predicate","def_find_defs","_find_defs","child","suffix","defines","to_node","object_fns","native_fns","Boolean","Number","static_fns","def_eval","_eval","unaryPrefix","element","non_converting_unary","non_converting_binary","pow","global_objs","static_values","aa","first_arg","def_negate","basic_negation","negated","global_pure_fns","fns","def_has_side_effects","any","is_call_pure","def_may_throw","def_is_constant_expression","all_refs_local","scope_def","block_aborts","opt_AST_Lambda","drop_funcs","drop_vars","assign_as_unused","in_use","in_use_ids","fixed_ids","var_defs_by_id","initializations","destructuring_value","node_def","in_export","destructuring_cache","scan_ref_scoped","trim","__unused","unreferenced","template","drop_block","head","is_destructure","var_defs","assign","dirs","hoisted","vars_found","var_decl","to_assignments","varNames","var_names","_var_names","isParentScopeAvailable","defs_by_id","make_sym","new_var","make_var_name","def_drop_side_effect_free","nodes","changed","values","pure_prop_access_globals","retain_top_func","if_break_in_loop","is_break","drop_it","rest","self_condition_length","negated_length","negated_is_best","default_branch","exact_match","decl","eliminate_branch","default_index","has_break","varDef","inline_array_like_spread","simple_args","is_func","EXIT","separator","consts","ast","fun","comp","compute_char_frequency","mangle_names","is_regular_func","can_inline","return_value","can_flatten_body","block_scoped","variable","safe_to_inject","can_inject_vars","can_inject_args","is_reachable","can_inject_symbols","append_var","flatten_args","lines","flatten_vars","flatten_fn","ev","trim_right_for_undefined","lift_sequences","commutativeOperators","is_atomic","reachable","find_ref","scan_scope","reversible","is_strict_comparison","combined","ll","rr","truthy","falsy","lr","associative","reversed","within_array_or_object_literal","defun_def","lambda_def","value_length","has_symbol_ref","name_length","overhead","undef","ASSIGN_OPS","ASSIGN_OPS_COMMUTATIVE","safe_to_flatten","literals_in_boolean_context","lift_key","evaluateRight","arg_index","single_arg_diff","in_bool","is_true","is_false","booleanize","OPT_ARGUMENTS","sub","flatten_object","retValue","FLATTEN","flatten","k","optimized","has_special_symbol","segment","arrow","ancestors","is_destructuring_export_decl","keep","elem","should_retain","domprops","reserve_quoted_keys","addStrings","mangle_properties","reserved_option","builtins","debug","keep_quoted","only_cache","regex","objects","global_ref","new_global","Date","Symbol","ArrayBuffer","DataView","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","EvalError","Float32Array","Float64Array","Int8Array","Int16Array","Int32Array","Map","Promise","Proxy","RangeError","ReferenceError","Reflect","SyntaxError","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","URIError","WeakMap","WeakSet","getOwnPropertyNames","find_builtins","debug_name_suffix","names_to_mangle","root","mangleStrings","can_mangle","should_mangle","mangled","debug_mangled","to_ascii","atob","b64","Buffer","from","to_base64","btoa","set_shorthand","keys","init_cache","to_json","normalize_directives","MOZ_TO_ME","Program","M","my_start_token","my_end_token","from_moz","ArrayPattern","elm","ObjectPattern","AssignmentPattern","SpreadElement","argument","RestElement","TemplateElement","cooked","TemplateLiteral","quasis","TaggedTemplateExpression","quasi","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ExpressionStatement","TryStatement","handlers","handler","guardedHandlers","finalizer","Property","computed","MethodDefinition","ArrayExpression","ObjectExpression","SequenceExpression","MemberExpression","SwitchCase","VariableDeclaration","declarations","ImportDeclaration","specifiers","specifier","imported","local","ExportAllDeclaration","ExportNamedDeclaration","declaration","ExportDefaultDeclaration","Literal","rx","pattern","flags","MetaProperty","meta","Identifier","FROM_MOZ_STACK","raw_token","moznode","loc","range","column","moztype","mytype","propmap","moz_to_me","me_to_moz","moz","how","my","to_moz","to_moz_block","to_moz_scope","def_to_moz","UpdateExpression","UnaryExpression","ClassDeclaration","ClassExpression","superClass","to_moz_in_destructuring","guard","name_mapping","isComputed","string_or_num","match","to_mozilla_ast","mynode","from_mozilla_ast","save_stack","TO_MOZ_STACK","files","quoted_props","timings","enclose","nameCache","sourceMap","wrap","now","includeSources","url","warning","orig_line_diff","dest_line_diff","MOZ_SourceMap","SourceMapGenerator","sourceRoot","orig_map","SourceMapConsumer","sources","sourceContent","sourceContentFor","setSourceContent","gen_line","gen_col","orig_line","orig_col","originalPositionFor","addMapping","generated","original","toJSON","SourceMap","total","error"],"mappings":"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YACA,OACA,wBACA,iBACA,cACA,eACA,OACA,oBACA,UACA,WACA,iBACA,kBACA,oBACA,mBACA,OACA,YACA,UACA,kBACA,MACA,eACA,qBACA,SACA,eACA,WACA,gBACA,QACA,SACA,UACA,oBACA,mBACA,oBACA,kBACA,eACA,iBACA,gCACA,gCACA,gCACA,+BACA,6BACA,aACA,iBACA,iBACA,iBACA,qBACA,eACA,qBACA,MACA,iBACA,iBACA,mBACA,sBACA,kBACA,2BACA,kBACA,gBACA,kBACA,mBACA,eACA,qBACA,mBACA,cACA,oBACA,UACA,cACA,sBACA,eACA,gBACA,kBACA,iBACA,WACA,eACA,0BACA,mBACA,kBACA,WACA,SACA,cACA,aACA,UACA,gBACA,UACA,UACA,kBACA,wBACA,sBACA,oBACA,yBACA,uBACA,wBACA,oBACA,qBACA,uBACA,sBACA,mBACA,WACA,SACA,YACA,SACA,cACA,UACA,aACA,eACA,SACA,SACA,aACA,SACA,iBACA,kBACA,sBACA,SACA,SACA,UACA,WACA,eACA,aACA,eACA,cACA,cACA,cACA,QACA,YACA,cACA,aACA,aACA,aACA,WACA,YACA,YACA,aACA,gBACA,kBACA,iBACA,iBACA,iBACA,cACA,UACA,iBACA,SACA,WACA,WACA,SACA,YACA,iBACA,kBACA,wBACA,SACA,KACA,iBACA,gBACA,2BACA,gBACA,oBACA,sBACA,gBACA,aACA,iBACA,YACA,iBACA,aACA,WACA,eACA,UACA,mBACA,UACA,cACA,gBACA,UACA,SACA,YACA,cACA,eACA,iBACA,WACA,WACA,OACA,YACA,gBACA,mBACA,aACA,mBACA,oBACA,kBACA,oBACA,aACA,cACA,gBACA,2BACA,aACA,kBACA,iBACA,iBACA,kBACA,eACA,WACA,uBACA,SACA,yBACA,gBACA,iCACA,6BACA,iCACA,8BACA,4CACA,8BACA,qBACA,YACA,WACA,eACA,oBACA,sBACA,YACA,oBACA,YACA,WACA,mBACA,UACA,UACA,cACA,kBACA,aACA,qBACA,uBACA,gBACA,eACA,eACA,sBACA,iBACA,iBACA,kBACA,wBACA,+BACA,uBACA,4BACA,8BACA,0BACA,yBACA,0BACA,2BACA,yBACA,4BACA,wBACA,0BACA,0BACA,yBACA,4BACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,gBACA,aACA,aACA,eACA,mBACA,kBACA,YACA,cACA,WACA,mBACA,oBACA,oBACA,oBACA,WACA,gBACA,mBACA,oBACA,eACA,uBACA,6BACA,qBACA,eACA,eACA,sBACA,iBACA,iBACA,eACA,cACA,WACA,iBACA,gBACA,gBACA,gBACA,sBACA,cACA,WACA,cACA,aACA,eACA,gBACA,eACA,gBACA,qBACA,iBACA,eACA,WACA,YACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,YACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,YACA,aACA,aACA,aACA,aACA,aACA,aACA,aACA,YACA,YACA,YACA,YACA,YACA,YACA,eACA,eACA,WACA,sBACA,WACA,gBACA,eACA,cACA,cACA,mBACA,cACA,sBACA,WACA,gBACA,WACA,eACA,WACA,cACA,eACA,WACA,cACA,kBACA,mBACA,WACA,cACA,oBACA,kBACA,WACA,oBACA,iBACA,iBACA,iBACA,iBACA,iBACA,iBACA,iBACA,iBACA,iBACA,iBACA,kBACA,WACA,eACA,iBACA,eACA,eACA,eACA,eACA,eACA,eACA,eACA,mBACA,mBACA,oBACA,kBACA,sBACA,4BACA,oBACA,WACA,aACA,kBACA,gBACA,mBACA,iBACA,eACA,iBACA,gBACA,cACA,cACA,cACA,eACA,qBACA,oBACA,oBACA,WACA,uBACA,eACA,WACA,cACA,gBACA,eACA,WACA,qBACA,gBACA,mBACA,mBACA,eACA,eACA,eACA,eACA,kBACA,WACA,aACA,eACA,WACA,oBACA,cACA,iBACA,YACA,WACA,qBACA,qBACA,mBACA,WACA,aACA,gBACA,oBACA,uBACA,sBACA,sBACA,sBACA,yBACA,uBACA,sBACA,uBACA,sBACA,wBACA,0BACA,yBACA,4BACA,yBACA,4BACA,sBACA,qBACA,qBACA,qBACA,uBACA,wBACA,WACA,6BACA,iCACA,kCACA,kCACA,8BACA,mCACA,4BACA,2BACA,2BACA,4BACA,2BACA,2BACA,mCACA,kCACA,6BACA,6BACA,6BACA,2BACA,qBACA,qBACA,6BACA,wBACA,qBACA,0BACA,qBACA,kCACA,2BACA,yBACA,mBACA,sBACA,0BACA,gCACA,qBACA,oBACA,4BACA,wBACA,0BACA,oBACA,sBACA,sBACA,yBACA,0BACA,wBACA,wBACA,2BACA,8BACA,qBACA,mBACA,sBACA,0BACA,wBACA,0BACA,0BACA,wBACA,oCACA,kCACA,iCACA,wBACA,wBACA,wBACA,wBACA,wBACA,wBACA,wBACA,wBACA,wBACA,wBACA,yBACA,yBACA,yBACA,yBACA,yBACA,yBACA,2BACA,wBACA,qBACA,6BACA,uBACA,wBACA,qBACA,wBACA,wBACA,0BACA,oCACA,kCACA,sBACA,4BACA,yBACA,oBACA,qBACA,4BACA,qBACA,yBACA,uBACA,sBACA,sBACA,yBACA,2BACA,0BACA,oBACA,wBACA,uBACA,sBACA,4BACA,6BACA,0BACA,+BACA,4BACA,4BACA,qBACA,6BACA,6BACA,4BACA,0BACA,uBACA,qBACA,qBACA,sBACA,6BACA,wBACA,sBACA,qBACA,yBACA,wBACA,wBACA,0BACA,yBACA,qBACA,sBACA,yBACA,2BACA,uBACA,wBACA,wBACA,wBACA,oBACA,4BACA,sBACA,qBACA,wBACA,wBACA,6BACA,qBACA,qBACA,oBACA,qBACA,uBACA,wBACA,yBACA,WACA,WACA,cACA,OACA,YACA,cACA,WACA,YACA,YACA,eACA,cACA,eACA,mBACA,uBACA,WACA,OACA,iBACA,YACA,sBACA,4BACA,mBACA,oBACA,yBACA,uBACA,gBACA,2BACA,WACA,mBACA,eACA,YACA,yBACA,IACA,uBACA,+BACA,eACA,QACA,eACA,QACA,aACA,eACA,cACA,wBACA,UACA,QACA,aACA,QACA,uBACA,UACA,eACA,SACA,kBACA,QACA,aACA,YACA,QACA,iBACA,cACA,cACA,WACA,UACA,UACA,gBACA,mBACA,gBACA,cACA,iBACA,0BACA,QACA,aACA,aACA,aACA,aACA,aACA,aACA,QACA,iBACA,2BACA,kBACA,sCACA,cACA,qCACA,qCACA,+CACA,uCACA,sBACA,uBACA,oCACA,oCACA,4CACA,0BACA,QACA,iBACA,aACA,WACA,wBACA,gBACA,OACA,YACA,OACA,YACA,WACA,aACA,aACA,eACA,eACA,aACA,WACA,WACA,WACA,uBACA,SACA,UACA,aACA,WACA,UACA,gBACA,eACA,eACA,oBACA,mBACA,mBACA,gBACA,eACA,mBACA,SACA,wBACA,WACA,YACA,aACA,WACA,aACA,kBACA,OACA,oBACA,oBACA,oBACA,kBACA,mBACA,gBACA,kBACA,sBACA,wBACA,kBACA,oBACA,oBACA,iBACA,qBACA,qBACA,mBACA,kBACA,sBACA,qBACA,oBACA,uBACA,iBACA,eACA,cACA,mBACA,sBACA,kBACA,6BACA,kBACA,mBACA,sBACA,gBACA,kBACA,qBACA,kBACA,oBACA,mBACA,mBACA,qBACA,oBACA,gBACA,mBACA,oBACA,kBACA,iBACA,qBACA,mBACA,kBACA,sBACA,kBACA,mBACA,iBACA,mBACA,oBACA,sBACA,oBACA,wBACA,oBACA,uBACA,mBACA,qBACA,iBACA,sBACA,2BACA,mBACA,oBACA,oBACA,oBACA,oBACA,kBACA,mBACA,0BACA,uBACA,sBACA,mBACA,sBACA,0BACA,sBACA,sBACA,kBACA,mBACA,mBACA,mBACA,qBACA,mBACA,kBACA,UACA,UACA,eACA,aACA,gBACA,gBACA,aACA,gBACA,cACA,YACA,qBACA,cACA,uBACA,aACA,gBACA,iBACA,WACA,cACA,iBACA,iBACA,mBACA,aACA,iBACA,wBACA,OACA,mCACA,iCACA,cACA,OACA,YACA,iBACA,MACA,WACA,WACA,WACA,sBACA,qBACA,wBACA,eACA,yBACA,gCACA,2BACA,wBACA,oBACA,oBACA,gBACA,mBACA,SACA,eACA,QACA,cACA,YACA,WACA,aACA,qBACA,iBACA,aACA,aACA,YACA,SACA,gBACA,OACA,4BACA,WACA,OACA,OACA,UACA,iBACA,gBACA,WACA,QACA,WACA,gBACA,uBACA,gCACA,uBACA,SACA,OACA,SACA,kBACA,uBACA,wBACA,QACA,YACA,aACA,aACA,cACA,OACA,OACA,MACA,SACA,UACA,SACA,QACA,UACA,WACA,YACA,UACA,cACA,iBACA,YACA,kBACA,mBACA,WACA,mCACA,4BACA,+BACA,wBACA,mBACA,0BACA,iCACA,mBACA,YACA,sBACA,qBACA,iCACA,6BACA,oBACA,oBACA,mBACA,sBACA,oBACA,8BACA,sBACA,sBACA,8BACA,sBACA,uBACA,uBACA,aACA,eACA,aACA,YACA,mBACA,YACA,kBACA,oBACA,mBACA,eACA,YACA,YACA,YACA,WACA,YACA,UACA,qBACA,oBACA,oBACA,oBACA,sBACA,mBACA,iBACA,mBACA,qBACA,uBACA,wBACA,qBACA,yBACA,sBACA,uBACA,qBACA,uBACA,2CACA,kCACA,qCACA,iCACA,gCACA,8BACA,2BACA,6BACA,+BACA,kCACA,kCACA,iCACA,gCACA,kCACA,kCACA,gCACA,yBACA,yBACA,yBACA,iCACA,yBACA,0BACA,0BACA,MACA,OACA,kBACA,eACA,8BACA,sBACA,aACA,gBACA,gBACA,uBACA,sBACA,kBACA,oBACA,uBACA,YACA,YACA,iBACA,sBACA,gBACA,cACA,cACA,kCACA,6BACA,mBACA,mBACA,wBACA,iBACA,eACA,cACA,UACA,WACA,gBACA,aACA,mBACA,eACA,oBACA,wBACA,uBACA,uBACA,6BACA,mBACA,wBACA,6BACA,gBACA,wBACA,aACA,wBACA,eACA,oBACA,oBACA,oBACA,iBACA,sBACA,uBACA,iBACA,sBACA,sBACA,sBACA,qBACA,cACA,kBACA,aACA,qBACA,eACA,aACA,eACA,qBACA,sBACA,iBACA,gBACA,eACA,gBACA,qBACA,qBACA,qBACA,iBACA,aACA,wBACA,eACA,yBACA,0BACA,0BACA,aACA,iBACA,eACA,iBACA,cACA,gBACA,yBACA,sBACA,YACA,mBACA,6BACA,8BACA,0BACA,2BACA,gBACA,kBACA,iBACA,uBACA,kBACA,mBACA,cACA,gBACA,iBACA,aACA,mBACA,yBACA,wBACA,yBACA,oBACA,eACA,qBACA,oBACA,gBACA,qBACA,wBACA,wBACA,8BACA,eACA,eACA,gBACA,gBACA,oBACA,kBACA,gBACA,mBACA,iBACA,gBACA,iBACA,UACA,wBACA,yBACA,oBACA,gBACA,cACA,eACA,iBACA,kBACA,oBACA,QACA,MACA,OACA,oBACA,SACA,aACA,cACA,wBACA,cACA,OACA,oBACA,gBACA,QACA,WACA,kBACA,gBACA,mBACA,oBACA,sBACA,SACA,WACA,8BACA,cACA,iCACA,MACA,eACA,YACA,cACA,qBACA,OACA,aACA,eACA,WACA,WACA,eACA,mBACA,SACA,eACA,WACA,MACA,2BACA,2BACA,sBACA,sBACA,sBACA,sBACA,OACA,SACA,UACA,6BACA,6BACA,gBACA,SACA,8BACA,sBACA,sBACA,SACA,iBACA,gBACA,iBACA,YACA,YACA,kBACA,kBACA,oBACA,4BACA,4BACA,mCACA,mCACA,gCACA,gCACA,uCACA,uCACA,qBACA,gCACA,gCACA,qBACA,8BACA,8BACA,qBACA,qBACA,kBACA,kBACA,UACA,oBACA,aACA,KACA,gBACA,SACA,wBACA,sBACA,uBACA,uBACA,oBACA,OACA,oBACA,8BACA,kBACA,sBACA,eACA,mBACA,aACA,SACA,cACA,mBACA,kBACA,qBACA,wBACA,4BACA,oBACA,eACA,SACA,cACA,gBACA,oBACA,wBACA,gBACA,UACA,mBACA,QACA,cACA,mBACA,IACA,YACA,qBACA,iBACA,YACA,gBACA,aACA,WACA,UACA,eACA,0BACA,uBACA,yBACA,0BACA,0BACA,sBACA,+BACA,wBACA,4BACA,qBACA,WACA,yCACA,wBACA,8BACA,yCACA,8BACA,2BACA,SACA,UACA,MACA,SACA,UACA,OACA,QACA,WACA,qBACA,4BACA,sBACA,kBACA,4BACA,iBACA,eACA,wBACA,iBACA,gBACA,QACA,aACA,iBACA,mBACA,OACA,iBACA,SACA,UACA,WACA,aACA,eACA,UACA,2BACA,iBACA,kBACA,yBACA,wBACA,WACA,kBACA,cACA,eACA,mBACA,iBACA,aACA,YACA,eACA,eACA,SACA,gBACA,iBACA,uBACA,mBACA,kBACA,cACA,2BACA,aACA,QACA,UACA,WACA,iBACA,qBACA,eACA,gBACA,yBACA,qBACA,eACA,cACA,wBACA,gBACA,8BACA,YACA,OACA,aACA,eACA,UACA,QACA,SACA,YACA,qBACA,YACA,eACA,iBACA,cACA,qBACA,oBACA,oBACA,+BACA,+BACA,mBACA,0BACA,yBACA,eACA,qBACA,sBACA,eACA,eACA,gBACA,iBACA,0BACA,0BACA,cACA,eACA,qBACA,oBACA,cACA,cACA,aACA,gBACA,gBACA,cACA,wBACA,qBACA,yBACA,WACA,yBACA,oBACA,0BACA,6BACA,mBACA,qBACA,yBACA,qBACA,oBACA,wBACA,oBACA,wBACA,iCACA,kBACA,oBACA,2BACA,sBACA,mBACA,qBACA,WACA,sCACA,mBACA,iBACA,iBACA,oBACA,cACA,aACA,qBACA,yBACA,oBACA,eACA,oBACA,0BACA,gCACA,wBACA,6BACA,8BACA,8BACA,2BACA,yBACA,oBACA,oBACA,oBACA,oBACA,oBACA,2BACA,oBACA,oBACA,wBACA,yBACA,qBACA,yBACA,+BACA,wBACA,mBACA,yBACA,mBACA,iBACA,qBACA,2BACA,yBACA,wBACA,wBACA,0BACA,cACA,qBACA,kBACA,qBACA,qBACA,qBACA,kBACA,kBACA,YACA,gBACA,iBACA,2BACA,kBACA,mBACA,iBACA,YACA,qBACA,yBACA,YACA,gBACA,WACA,iBACA,aACA,mBACA,mBACA,sBACA,4BACA,4BACA,kCACA,kCACA,gCACA,gCACA,sCACA,sCACA,sBACA,gCACA,gCACA,sBACA,8BACA,8BACA,iBACA,sBACA,sBACA,oBACA,WACA,eACA,oBACA,qBACA,yBACA,2BACA,UACA,iBACA,qBACA,gBACA,mBACA,gBACA,iBACA,gBACA,kBACA,mBACA,mBACA,iBACA,kBACA,wBACA,iBACA,qBACA,4BACA,kBACA,eACA,mBACA,eACA,gBACA,kBACA,iBACA,cACA,gBACA,eACA,oBACA,qBACA,oBACA,wBACA,4BACA,gBACA,gBACA,gBACA,gBACA,sBACA,6BACA,yBACA,kCACA,wBACA,yBACA,oBACA,uBACA,oBACA,yBACA,8BACA,+BACA,0BACA,8BACA,6BACA,8BACA,uBACA,2BACA,8BACA,4BACA,0BACA,2BACA,8BACA,0BACA,8BACA,2BACA,mCACA,0CACA,gCACA,kCACA,iCACA,wCACA,qCACA,wCACA,sCACA,qCACA,uCACA,sCACA,gCACA,8BACA,+BACA,gCACA,mCACA,+BACA,wBACA,oBACA,qBACA,qBACA,oBACA,oBACA,wBACA,oBACA,4BACA,oBACA,oBACA,yBACA,8BACA,0BACA,iCACA,0BACA,yBACA,4BACA,qBACA,yBACA,4BACA,uBACA,wBACA,0BACA,iCACA,gCACA,kCACA,6BACA,qBACA,yBACA,kCACA,wBACA,oBACA,iCACA,yBACA,6BACA,sCACA,+BACA,kCACA,mCACA,mCACA,mCACA,mCACA,mCACA,mCACA,mCACA,mCACA,mCACA,uBACA,2BACA,0BACA,2BACA,0BACA,wBACA,yBACA,uBACA,uBACA,sBACA,sBACA,sBACA,0BACA,wBACA,mCACA,iCACA,8BACA,kCACA,wBACA,+BACA,qBACA,yBACA,yBACA,yBACA,aACA,aACA,SACA,oBACA,SACA,sBACA,kBACA,+BACA,YACA,gBACA,yBACA,4BACA,qBACA,MACA,aACA,eACA,qBACA,uBACA,2BACA,gBACA,UACA,eACA,SACA,aACA,iBACA,eACA,SACA,cACA,YACA,4BACA,8BACA,8BACA,4BACA,6BACA,+BACA,UACA,WACA,WACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,WACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,YACA,WACA,YACA,YACA,WACA,WACA,WACA,WACA,WACA,WACA,aACA,qBACA,2BACA,mBACA,8BACA,8BACA,8BACA,8BACA,8BACA,8BACA,qBACA,6BACA,qBACA,iBACA,iBACA,YACA,UACA,cACA,gBACA,2BACA,WACA,YACA,eACA,iBACA,oBACA,WACA,oBACA,gBACA,cACA,gBACA,OACA,cACA,cACA,YACA,cACA,YACA,eACA,mBACA,gBACA,YACA,aACA,QACA,aACA,YACA,aACA,kBACA,aACA,YACA,UACA,WACA,cACA,eACA,0BACA,wBACA,+BACA,+BACA,mBACA,qCACA,sBACA,iCACA,oBACA,SACA,gBACA,eACA,iBACA,yBACA,yBACA,uBACA,6BACA,cACA,WACA,MACA,kBACA,eACA,mBACA,MACA,cACA,cACA,aACA,oBACA,qBACA,+BACA,qBACA,kBACA,iBACA,iBACA,SACA,UACA,iBACA,cACA,qCACA,oCACA,8BACA,iCACA,8BACA,2BACA,6BACA,2BACA,gBACA,WACA,gBACA,UACA,WACA,gBACA,SACA,YACA,gBACA,mBACA,qBACA,wBACA,uBACA,qBACA,qBACA,iBACA,UACA,UACA,kBACA,cACA,oBACA,mBACA,eACA,oBACA,wBACA,cACA,6BACA,eACA,uBACA,mBACA,uBACA,oBACA,sBACA,uBACA,wBACA,yBACA,kBACA,sBACA,0BACA,gBACA,gBACA,sBACA,6BACA,wBACA,kBACA,oBACA,yBACA,kBACA,wCACA,cACA,mBACA,qBACA,yBACA,wBACA,YACA,aACA,SACA,SACA,cACA,iBACA,4BACA,0BACA,8BACA,uBACA,gBACA,qCACA,iBACA,iBACA,kBACA,kBACA,cACA,gBACA,OACA,SACA,SACA,mBACA,mBACA,mBACA,mBACA,UACA,YACA,gBACA,IACA,QACA,OACA,QACA,MACA,WACA,eACA,+BACA,cACA,SACA,gBACA,aACA,YACA,iBACA,WACA,OACA,QACA,SACA,YACA,SACA,aACA,gBACA,sBACA,oBACA,gBACA,MACA,cACA,eACA,eACA,SACA,aACA,mBACA,YACA,gBACA,aACA,kBACA,YACA,cACA,WACA,cACA,UACA,aACA,WACA,YACA,UACA,kBACA,kBACA,YACA,eACA,WACA,sBACA,aACA,iBACA,kBACA,SACA,YACA,MACA,UACA,QACA,YACA,QACA,gBACA,cACA,aACA,eACA,aACA,YACA,oBACA,aACA,MACA,kBACA,oBACA,QACA,MACA,cACA,UACA,SACA,UACA,WACA,mBACA,YACA,kBACA,SACA,aACA,eACA,UACA,QACA,UACA,UACA,uBACA,gCACA,sBACA,iBACA,YACA,kBACA,sBACA,qBACA,sBACA,4BACA,iBACA,uBACA,4BACA,iBACA,qBACA,oBACA,oBACA,0BACA,gBACA,qBACA,qBACA,0BACA,mBACA,cACA,MACA,cACA,kBACA,UACA,mBACA,aACA,SACA,eACA,cACA,aACA,aACA,eACA,cACA,aACA,eACA,kBACA,oBACA,UACA,mBACA,QACA,eACA,MACA,QACA,UACA,QACA,YACA,cACA,OACA,QACA,SACA,SACA,QACA,QACA,OACA,QACA,QACA,OACA,cACA,eACA,cACA,SACA,aACA,WACA,gBACA,qBACA,aACA,cACA,gBACA,aACA,iBACA,eACA,cACA,YACA,WACA,cACA,YACA,WACA,aACA,eACA,YACA,WACA,OACA,OACA,UACA,IACA,OACA,sBACA,qBACA,aACA,wBACA,wBACA,kBACA,mBACA,mBACA,oBACA,sBACA,oBACA,kBACA,uBACA,sBACA,iBACA,kBACA,kBACA,mBACA,qBACA,sBACA,sBACA,mBACA,iBACA,WACA,UACA,iBACA,iBACA,WACA,aACA,UACA,UACA,gBACA,UACA,OACA,eACA,iBACA,YACA,WACA,iBACA,eACA,eACA,OACA,gBACA,UACA,eACA,OACA,MACA,aACA,OACA,qBACA,aACA,kBACA,mBACA,cACA,aACA,gBACA,wBACA,YACA,oBACA,QACA,OACA,iBACA,OACA,OACA,OACA,WACA,OACA,YACA,eACA,SACA,gBACA,sBACA,4BACA,6BACA,sBACA,sBACA,kBACA,eACA,eACA,sBACA,sBACA,qBACA,sBACA,qBACA,cACA,oBACA,oBACA,oBACA,gBACA,eACA,qBACA,qBACA,qBACA,iBACA,eACA,aACA,mBACA,yBACA,0BACA,mBACA,mBACA,eACA,eACA,oBACA,yBACA,0BACA,oBACA,oBACA,iBACA,cACA,kBACA,mBACA,cACA,oBACA,oBACA,mBACA,oBACA,mBACA,aACA,kBACA,kBACA,kBACA,eACA,cACA,mBACA,mBACA,mBACA,gBACA,cACA,YACA,iBACA,sBACA,uBACA,iBACA,iBACA,cACA,SACA,eACA,QACA,gBACA,qBACA,iBACA,eACA,cACA,gBACA,SACA,uBACA,aACA,aACA,qBACA,YACA,YACA,aACA,cACA,cACA,kBACA,OACA,UACA,SACA,aACA,cACA,aACA,gBACA,WACA,iBACA,UACA,cACA,SACA,WACA,UACA,aACA,aACA,IACA,OACA,SACA,iBACA,eACA,cACA,kBACA,cACA,cACA,SACA,uBACA,eACA,wBACA,aACA,YACA,SACA,UACA,eACA,cACA,gBACA,oBACA,yBACA,sBACA,OACA,QACA,WACA,OACA,KACA,OACA,YACA,cACA,cACA,QACA,KACA,QACA,QACA,YACA,iBACA,UACA,eACA,mBACA,wBACA,OACA,SACA,WACA,aACA,YACA,eACA,WACA,eACA,UACA,iBACA,yBACA,oBACA,gBACA,UACA,oBACA,aACA,WACA,SACA,aACA,OACA,YACA,YACA,UACA,QACA,kBACA,aACA,YACA,aACA,iBACA,gBACA,aACA,gBACA,kBACA,YACA,uBACA,cACA,eACA,eACA,aACA,QACA,aACA,eACA,oBACA,aACA,aACA,cACA,YACA,cACA,UACA,UACA,OACA,YACA,YACA,aACA,WACA,WACA,gBACA,YACA,WACA,UACA,gBACA,QACA,gBACA,YACA,aACA,QACA,YACA,SACA,UACA,MACA,QACA,MACA,OACA,WACA,cACA,WACA,UACA,WACA,gBACA,kBACA,YACA,UACA,QACA,QACA,sBACA,8BACA,aACA,qBACA,4BACA,YACA,YACA,OACA,cACA,aACA,YACA,eACA,aACA,kBACA,kBACA,kBACA,aACA,cACA,UACA,UACA,oBACA,0BACA,UACA,wBACA,0BACA,mBACA,cACA,eACA,aACA,aACA,UACA,gBACA,WACA,qBACA,uBACA,yBACA,uBACA,0BACA,SACA,gBACA,iBACA,iBACA,gBACA,UACA,qBACA,uCACA,kCACA,UACA,aACA,eACA,YACA,aACA,kBACA,UACA,cACA,qBACA,cACA,YACA,WACA,eACA,UACA,kBACA,kBACA,kBACA,oBACA,mBACA,cACA,gBACA,UACA,cACA,cACA,WACA,aACA,UACA,aACA,WACA,0BACA,SACA,gBACA,SACA,kBACA,iBACA,oBACA,gBACA,aACA,uBACA,0BACA,MACA,OACA,QACA,oBACA,gBACA,mBACA,eACA,WACA,kBACA,SACA,iBACA,eACA,kBACA,oBACA,qBACA,eACA,qBACA,qBACA,sBACA,gBACA,sBACA,wBACA,gBACA,2BACA,qBACA,kBACA,mBACA,oBACA,cACA,kBACA,iBACA,yBACA,qBACA,2BACA,gBACA,kBACA,wBACA,cACA,oBACA,mBACA,oBACA,iBACA,aACA,iBACA,qBACA,oBACA,kBACA,cACA,uBACA,uBACA,2BACA,kBACA,+BACA,0BACA,oBACA,mBACA,qBACA,qBACA,oBACA,kBACA,cACA,mBACA,eACA,gBACA,qBACA,cACA,8BACA,gBACA,uBACA,cACA,wBACA,qBACA,iBACA,kBACA,kBACA,kBACA,yBACA,yBACA,4BACA,kCACA,kCACA,wCACA,wCACA,sCACA,sCACA,4CACA,4CACA,4BACA,sCACA,sCACA,4BACA,oCACA,oCACA,4BACA,4BACA,iBACA,gBACA,qBACA,+BACA,wBACA,gBACA,eACA,mBACA,qBACA,mBACA,cACA,cACA,cACA,iBACA,kBACA,gBACA,cACA,kBACA,mBACA,mBACA,eACA,cACA,SACA,MACA,WACA,WACA,UACA,eACA,UACA,WACA,OACA,WACA,cACA,cACA,eACA,gBACA,aACA,eACA,eACA,gBACA,cACA,mBACA,cACA,SACA,QACA,cACA,KACA,KACA,IACA,OACA,UACA,eACA,eACA,UACA,eACA,WACA,UACA,WACA,KACA,QACA,kBACA,UACA,SACA,kBACA,eACA,YACA,qBACA,UACA,UACA,iBACA,iBACA,eACA,sBACA,mBACA,kBACA,gBACA,aACA,eACA,cACA,gBACA,QACA,sBACA,sBACA,mBACA,iBACA,YACA,SACA,eACA,gBACA,aACA,iBACA,aACA,iBACA,oBACA,qBACA,cACA,eACA,oBACA,gBACA,qBACA,YACA,aACA,eACA,cACA,cACA,gBACA,uBACA,WACA,eACA,iBACA,oBACA,QACA,YACA,SACA,SACA,SACA,YACA,YACA,aACA,aACA,YACA,cACA,cACA,aACA,cACA,iBACA,SACA,cACA,eACA,SACA,SACA,mBACA,aACA,aACA,kBACA,SACA,aACA,MACA,UACA,YACA,SACA,UACA,2BACA,WACA,kBACA,aACA,gBACA,UACA,gBACA,UACA,SACA,WACA,WACA,aACA,WACA,UACA,WACA,kBACA,eACA,cACA,UACA,oBACA,cACA,cACA,cACA,2BACA,6BACA,iBACA,aACA,SACA,kBACA,oBACA,oBACA,mBACA,OACA,gBACA,WACA,WACA,YACA,aACA,2BACA,sBACA,eACA,6BACA,oBACA,YACA,oBACA,sBACA,sBACA,qBACA,aACA,qBACA,WACA,OACA,YACA,WACA,SACA,QACA,KACA,KACA,SACA,IACA,WACA,gBACA,cACA,mBACA,WACA,YACA,UACA,QACA,SACA,QACA,cACA,aACA,SACA,mBACA,0BACA,0BACA,UACA,gBACA,SACA,YACA,qBACA,WACA,UACA,UACA,MACA,eACA,aACA,eACA,cACA,YACA,UACA,QACA,WACA,WACA,UACA,YACA,YACA,oBACA,QACA,YACA,SACA,OACA,WACA,QACA,aACA,QACA,YACA,OACA,cACA,sBACA,aACA,iBACA,kBACA,MACA,SACA,yBACA,UACA,YACA,aACA,yBACA,QACA,WACA,+BACA,YACA,SACA,aACA,aACA,eACA,WACA,4BACA,kBACA,cACA,IACA,OACA,eACA,WACA,aACA,0BACA,WACA,QACA,QACA,aACA,UACA,UACA,kBACA,aACA,mBACA,WACA,WACA,kBACA,WACA,QACA,OACA,eACA,YACA,cACA,WACA,WACA,YACA,WACA,SACA,aACA,aACA,cACA,UACA,UACA,OACA,YACA,WACA,WACA,SACA,YACA,aACA,oBACA,YACA,QACA,OACA,aACA,iBACA,YACA,YACA,cACA,YACA,YACA,gBACA,WACA,WACA,aACA,WACA,QACA,QACA,QACA,cACA,gBACA,aACA,eACA,QACA,QACA,QACA,YACA,cACA,OACA,cACA,wBACA,eACA,yBACA,YACA,mBACA,eACA,aACA,iBACA,eACA,0BACA,oBACA,0BACA,yBACA,uBACA,wBACA,cACA,aACA,sBACA,cACA,uBACA,WACA,iBACA,uBACA,cACA,YACA,gBACA,cACA,wBACA,kBACA,uBACA,uBACA,qBACA,sBACA,aACA,YACA,QACA,WACA,MACA,UACA,cACA,OACA,aACA,cACA,aACA,iBACA,aACA,SACA,QACA,UACA,KACA,QACA,cACA,eACA,eACA,0BACA,uBACA,SACA,YACA,SACA,YACA,oBACA,OACA,eACA,gBACA,cACA,YACA,SACA,aACA,oBACA,oBACA,KACA,KACA,OACA,UACA,QACA,iBACA,cACA,iBACA,kBACA,cACA,gBACA,MACA,kBACA,mBACA,kBACA,SACA,wBACA,YACA,cACA,qBACA,oBACA,eACA,iBACA,mBACA,qBACA,iBACA,UACA,aACA,UACA,cACA,wBACA,qBACA,uBACA,wBACA,sBACA,SACA,+BACA,iBACA,uBACA,gBACA,iBACA,6BACA,mBACA,wBACA,mBACA,aACA,uBACA,kBACA,eACA,aACA,qBACA,iBACA,UACA,mBACA,UACA,SACA,0BACA,gCACA,sBACA,cACA,iBACA,yBACA,oBACA,uBACA,yBACA,mBACA,uBACA,aACA,mBACA,mBACA,WACA,eACA,kBACA,aACA,UACA,aACA,aACA,wBACA,yBACA,gBACA,oCACA,uBACA,cACA,cACA,WACA,eACA,WACA,WACA,UACA,sBACA,UACA,WACA,SACA,cACA,kBACA,WACA,qBACA,cACA,cACA,kBACA,aACA,mBACA,WACA,eACA,iBACA,cACA,mBACA,mCACA,mBACA,2BACA,sBACA,wBACA,eACA,qBACA,mBACA,gBACA,uBACA,2BACA,oBACA,oBACA,sBACA,sBACA,sBACA,uBACA,mBACA,iBACA,mBACA,kBACA,aACA,eACA,eACA,kBACA,mBACA,2BACA,oBACA,UACA,oBACA,iBACA,eACA,aACA,eACA,aACA,mBACA,qBACA,2BACA,kBACA,oBACA,eACA,aACA,2BACA,yBACA,eACA,WACA,oBACA,gBACA,iBACA,qBACA,kBACA,yBACA,kBACA,UACA,oBACA,iBACA,eACA,YACA,wBACA,aACA,YACA,iBACA,cACA,qBACA,gBACA,cACA,gBACA,YACA,YACA,WACA,aACA,qBACA,eACA,YACA,aACA,mBACA,kBACA,wBACA,0BACA,iBACA,mBACA,UACA,YACA,SACA,cACA,2BACA,6BACA,2BACA,WACA,KACA,oBACA,gBACA,WACA,QACA,QACA,iBACA,WACA,sBACA,MACA,eACA,iBACA,gBACA,gBACA,iBACA,eACA,aACA,WACA,YACA,iBACA,OACA,OACA,UACA,UACA,SACA,SACA,OACA,YACA,OACA,OACA,UACA,kBACA,kBACA,qBACA,OACA,WACA,OACA,WACA,SACA,wBACA,UACA,WACA,YACA,cACA,QACA,QACA,qBACA,oBACA,OACA,KACA,aACA,WACA,YACA,aACA,oBACA,kBACA,mBACA,iBACA,SACA,WACA,UACA,iBACA,YACA,aACA,mBACA,UACA,OACA,OACA,MACA,MACA,kCACA,UACA,WACA,cACA,gBACA,QACA,aACA,UACA,YACA,sBACA,sBACA,OACA,OACA,qBACA,sBACA,qBACA,iBACA,mBACA,uBACA,kBACA,WACA,wBACA,6BACA,gBACA,iBACA,YACA,iBACA,mBACA,sBACA,eACA,oBACA,0BACA,mBACA,iBACA,uBACA,sBACA,oBACA,mBACA,oBACA,gBACA,0BACA,mBACA,oBACA,oBACA,sBACA,yBACA,mBACA,gBACA,gBACA,iBACA,sBACA,cACA,2BACA,4BACA,uBACA,iBACA,cACA,aACA,gBACA,QACA,YACA,cACA,YACA,aACA,QACA,cACA,gBACA,cACA,wBACA,qBACA,qBACA,eACA,aACA,aACA,mBACA,aACA,YACA,aACA,eACA,YACA,iBACA,iBACA,iBACA,WACA,uBACA,UACA,aACA,KACA,OACA,cACA,UACA,6BACA,WACA,2BACA,SACA,cACA,cACA,oBACA,6BACA,gBACA,qBACA,aACA,YACA,UACA,cACA,eACA,WACA,gBACA,WACA,cACA,OACA,aACA,YACA,QACA,cACA,QACA,SACA,gBACA,gBACA,iBACA,kBACA,kBACA,YACA,YACA,qBACA,8BACA,gBACA,iBACA,gBACA,aACA,WACA,WACA,cACA,aACA,YACA,YACA,kBACA,SACA,YACA,UACA,OACA,SACA,WACA,UACA,YACA,WACA,YACA,cACA,WACA,cACA,WACA,OACA,OACA,kBACA,iBACA,KACA,KACA,KACA,KACA,eACA,oBACA,oBACA,UACA,MACA,UACA,SACA,gBACA,kBACA,cACA,UACA,YACA,UACA,WACA,OACA,UACA,OACA,OACA,QACA,SACA,OACA,WACA,YACA,eACA,YACA,mBACA,cACA,YACA,cACA,YACA,qBACA,kBACA,eACA,mBACA,WACA,YACA,YACA,oBACA,WACA,SACA,SACA,aACA,aACA,iBACA,iBACA,iBACA,iBACA,SACA,OACA,cACA,aACA,SACA,eACA,mBACA,iBACA,gBACA,QACA,iBACA,gBACA,oBACA,OACA,cACA,YACA,YACA,UACA,iBACA,aACA,WACA,aACA,SACA,YACA,0BACA,SACA,OACA,YACA,cACA,QACA,OACA,aACA,mBACA,sBACA,kBACA,YACA,iBACA,oBACA,gBACA,WACA,OACA,eACA,iBACA,YACA,SACA,mBACA,YACA,eACA,SACA,gBACA,WACA,cACA,OACA,aACA,MACA,QACA,QACA,OACA,cACA,cACA,WACA,YACA,qBACA,eACA,OACA,UACA,YACA,UACA,MACA,QACA,aACA,YACA,SACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,WACA,MACA,UACA,SACA,gBACA,cACA,eACA,aACA,eACA,eACA,aACA,cACA,YACA,cACA,OACA,SACA,aACA,aACA,gBACA,eACA,YACA,eACA,YACA,eACA,cACA,cACA,cACA,QACA,OACA,YACA,mBACA,WACA,YACA,QACA,aACA,cACA,UACA,SACA,kBACA,MACA,aACA,YACA,kBACA,kBACA,0BACA,cACA,cACA,YACA,YACA,iBACA,WACA,WACA,UACA,cACA,QACA,oBACA,eACA,eACA,aACA,YACA,YACA,cACA,SACA,UACA,kBACA,UACA,eACA,kBACA,UACA,SACA,WACA,YACA,MACA,aACA,YACA,cACA,YACA,WACA,WACA,aACA,iBACA,eACA,OACA,SACA,QACA,OACA,SACA,UACA,YACA,gBACA,gBACA,iBACA,cACA,WACA,UACA,YACA,SACA,iBACA,oBACA,cACA,SACA,wBACA,UACA,UACA,mBACA,sBACA,qBACA,0BACA,sBACA,iCACA,mBACA,6BACA,iBACA,aACA,cACA,sBACA,sBACA,6BACA,YACA,UACA,gBACA,mBACA,qBACA,cACA,iBACA,gBACA,gBACA,uBACA,uBACA,YACA,gBACA,eACA,eACA,iBACA,kBACA,cACA,aACA,YACA,2BACA,eACA,kBACA,kBACA,iBACA,iBACA,UACA,eACA,WACA,YACA,qBACA,qBACA,eACA,eACA,YACA,iBACA,gBACA,mBACA,kBACA,SACA,wBACA,qBACA,oBACA,cACA,mBACA,qBACA,uBACA,2BACA,YACA,2BACA,uBACA,wBACA,eACA,qBACA,gBACA,eACA,YACA,eACA,eACA,aACA,uBACA,mBACA,qBACA,cACA,mBACA,uBACA,sBACA,sBACA,4BACA,kBACA,uBACA,uBACA,4BACA,uBACA,qBACA,6BACA,YACA,mBACA,gCACA,uBACA,mBACA,UACA,wBACA,sBACA,qBACA,wBACA,wBACA,oBACA,0BACA,wBACA,mBACA,eACA,WACA,eACA,sBACA,qBACA,mBACA,iBACA,aACA,eACA,SACA,cACA,kBACA,aACA,kBACA,iBACA,iBACA,cACA,aACA,iBACA,sBACA,aACA,aACA,aACA,wBACA,sBACA,sBACA,oBACA,qBACA,2BACA,wBACA,eACA,oBACA,mBACA,gBACA,YACA,iBACA,gBACA,aACA,WACA,uBACA,wBACA,wBACA,uBACA,YACA,0BACA,aACA,cACA,sBACA,iBACA,cACA,SACA,cACA,oBACA,6BACA,eACA,oBACA,mBACA,gBACA,kBACA,gBACA,sBACA,mBACA,6BACA,kBACA,mBACA,mBACA,0BACA,0BACA,sBACA,aACA,mBACA,mBACA,gBACA,oBACA,oBACA,oBACA,oBACA,gBACA,sBACA,sBACA,mBACA,gBACA,gBACA,sBACA,iBACA,iBACA,sBACA,0BACA,mBACA,WACA,gBACA,gBACA,gCACA,+BACA,iCACA,gCACA,cACA,oBACA,mBACA,eACA,oBACA,uBACA,uBACA,6BACA,sBACA,gCACA,eACA,oBACA,aACA,eACA,gBACA,sBACA,SACA,WACA,KACA,aACA,oBACA,YACA,WACA,WACA,eACA,cACA,QACA,IACA,OACA,WACA,YACA,iBACA,QACA,eACA,aACA,gBACA,eACA,WACA,aACA,iBACA,kBACA,YACA,OACA,yBACA,WACA,WACA,eACA,WACA,eACA,SACA,WACA,yBACA,aACA,UACA,OACA,qBACA,WACA,WACA,cACA,WACA,SACA,WACA,UACA,aACA,SACA,WACA,WACA,YACA,YACA,wBACA,eACA,YACA,OACA,cACA,UACA,SACA,MACA,aACA,SACA,mBACA,iBACA,gBACA,kBACA,cACA,mBACA,SACA,aACA,kBACA,YACA,iBACA,cACA,mBACA,UACA,KACA,qBACA,SACA,eACA,aACA,aACA,eACA,YACA,cACA,UACA,UACA,KACA,SACA,WACA,aACA,kBACA,SACA,UACA,aACA,WACA,cACA,aACA,eACA,uBACA,gBACA,aACA,iBACA,eACA,iBACA,sBACA,mBACA,eACA,cACA,qBACA,oBACA,gBACA,gBACA,wBACA,iBACA,iBACA,YACA,SACA,WACA,aACA,WACA,WACA,wBACA,wBACA,0BACA,YACA,mBACA,eACA,WACA,mBACA,uBACA,aACA,UACA,UACA,4BACA,aACA,gBACA,kBACA,SACA,cACA,QACA,kBACA,gBACA,mBACA,oBACA,aACA,eACA,gBACA,iBACA,sBACA,oBACA,0BACA,YACA,gBACA,SACA,YACA,cACA,cACA,aACA,cACA,SACA,mBACA,YACA,cACA,QACA,UACA,UACA,UACA,gBACA,SACA,iBACA,WACA,UACA,YACA,aACA,qBACA,oBACA,kBACA,eACA,iBACA,sBACA,eACA,SACA,iBACA,6BACA,aACA,UACA,YACA,YACA,aACA,UACA,mBACA,mBACA,gBACA,SACA,eACA,mBACA,YACA,cACA,gBACA,uBACA,OACA,SACA,YACA,cACA,eACA,eACA,cACA,aACA,cACA,YACA,eACA,SACA,YACA,cACA,wBACA,uBACA,yBACA,yBACA,wBACA,kBACA,uBACA,sBACA,oBACA,uBACA,iBACA,kBACA,mBACA,iBACA,wBACA,mBACA,yBACA,+BACA,cACA,wBACA,oBACA,kBACA,mBACA,mBACA,mBACA,kBACA,iBACA,kBACA,gBACA,kCACA,qBACA,sBACA,YACA,aACA,aACA,YACA,WACA,SACA,sBACA,eACA,aACA,aACA,UACA,UACA,SACA,YACA,sBACA,kBACA,gBACA,iBACA,iBACA,sBACA,qBACA,gBACA,eACA,gBACA,cACA,aACA,aACA,mBACA,eACA,qBACA,iBACA,gBACA,UACA,WACA,cACA,gBACA,6BACA,WACA,WACA,aACA,YACA,eACA,iBACA,WACA,WACA,WACA,YACA,WACA,oBACA,gBACA,SACA,yBACA,aACA,eACA,cACA,gBACA,YACA,UACA,gBACA,SACA,YACA,kBACA,WACA,YACA,YACA,cACA,YACA,eACA,WACA,gBACA,aACA,cACA,eACA,kBACA,WACA,gBACA,kBACA,kBACA,kBACA,kBACA,iBACA,YACA,YACA,uBACA,6BACA,yBACA,iDACA,2BACA,0BACA,mBACA,mBACA,qBACA,kBACA,4BACA,4CACA,4BACA,2BACA,mCACA,wBACA,UACA,SACA,UACA,OACA,aACA,eACA,gBACA,SACA,QACA,gBACA,WACA,MACA,UACA,UACA,QACA,SACA,SACA,UACA,MACA,SACA,cACA,aACA,cACA,SACA,iBACA,UACA,QACA,YACA,cACA,YACA,aACA,UACA,gBACA,iBACA,gBACA,gBACA,eACA,gBACA,eACA,eACA,eACA,WACA,aACA,aACA,YACA,YACA,mBACA,aACA,gBACA,eACA,YACA,YACA,kBACA,gBACA,KACA,KACA,KACA,KACA,MACA,UACA,iBACA,eACA,gBACA,cACA,gBACA,cACA,eACA,aACA,OACA,mBACA,oBACA,oBACA,iBACA,kBACA,kBACA,YACA,QACA,cACA,QACA,cACA,QACA,cACA,aACA,gBACA,YACA,UACA,eACA,SACA,gBACA,aACA,aACA,mBACA,iBACA,eACA,QACA,aACA,kBACA,WACA,eACA,WACA,YACA,OACA,aACA,cACA,cACA,sBACA,WACA,UACA,sBACA,kBACA,mBACA,eACA,QACA,kBACA,cACA,SACA,UACA,cACA,aACA,YACA,cACA,cACA,qBACA,oBACA,qBACA,oBACA,QACA,OACA,QACA,cACA,aACA,cACA,YACA,aACA,cACA,WACA,yBACA,yBACA,aACA,cACA,WACA,OACA,eACA,gBACA,eACA,SACA,UACA,cACA,QACA,iBACA,6BACA,iBACA,gBACA,YACA,qBACA,cACA,SACA,YACA,YACA,YACA,gBACA,MACA,sBACA,kBACA,iBACA,OACA,QACA,QACA,QACA,YACA,YACA,UACA,WACA,SACA,WACA,WACA,gBACA,YACA,cACA,SACA,MACA,WACA,kBACA,YACA,yBACA,yBACA,SACA,UACA,gBACA,sBACA,4BACA,UACA,WACA,YACA,iBACA,oBACA,yBACA,eACA,eACA,gBACA,kBACA,oBACA,aACA,gBACA,iBACA,aACA,QACA,aACA,0BACA,UACA,oBACA,UACA,aACA,UACA,aACA,WACA,SACA,aACA,uBACA,eACA,WACA,eACA,YACA,cACA,gBACA,WACA,YACA,YACA,OACA,mBACA,YACA,MACA,eACA,mBACA,YACA,sBACA,uBACA,oBACA,wBACA,mBACA,oBACA,gBACA,mBACA,QACA,SACA,IACA,KACA,KACA,OACA,aACA,UACA,UACA,SACA,QACA,aACA,WACA,WACA,cACA,gBACA,cACA,iBACA,OACA,QACA,MACA,OACA,oBACA,qBACA,aACA,gBACA,aACA,WACA,aACA,sBACA,aACA,SACA,SACA,WACA,YACA,eACA,YACA,OACA,MACA,gBACA,cACA,gBACA,SACA,cACA,YACA,cACA,OACA,OACA,gBACA,WACA,UACA,SACA,gBACA,gBACA,WACA,UACA,WACA,yBACA,kBACA,0BACA,SACA,MACA,UACA,cACA,gBACA,UACA,iBACA,gBACA,wBACA,wBACA,WACA,SACA,iBACA,oBACA,SACA,kBACA,kBACA,oBACA,sBACA,iBACA,cACA,YACA,sBACA,eACA,eACA,aACA,iBACA,kBACA,oBACA,aACA,kBACA,iBACA,cACA,eACA,aACA,sCACA,qBACA,eACA,cACA,iBACA,yBACA,iCACA,eACA,sBACA,iBACA,gBACA,SACA,UACA,sBACA,eACA,cACA,YACA,cACA,cACA,eACA,eACA,mBACA,iBACA,wBACA,sBACA,cACA,oBACA,8BACA,oBACA,qBACA,eACA,mBACA,WACA,qBACA,mBACA,QACA,iBACA,SACA,WACA,WACA,UACA,WACA,eACA,cACA,gBACA,eACA,eACA,cACA,cACA,UACA,SACA,aACA,SACA,cACA,MACA,UACA,WACA,YACA,kBACA,WACA,QACA,eACA,cACA,gBACA,OACA,cACA,SACA,kBACA,sBACA,mBACA,uBACA,aACA,WACA,eACA,QACA,WACA,UACA,OACA,YACA,eACA,eACA,QACA,UACA,eACA,KACA,KACA,SACA,iBACA,aACA,UACA,OACA,QACA,UACA,cACA,kBACA,sBACA,YACA,SACA,UACA,QACA,YACA,SACA,SACA,mBACA,gBACA,aACA,2BACA,2BACA,YACA,UACA,UACA,UACA,SACA,kBACA,eACA,iBACA,WACA,gBACA,gBACA,cACA,eACA,iBACA,yBACA,aACA,gBACA,aACA,aACA,WACA,YACA,eACA,cACA,UACA,UACA,wBACA,sBACA,qBACA,2BACA,qBACA,0BACA,uBACA,sBACA,aACA,YACA,MACA,gBACA,SACA,OACA,SACA,YACA,uBACA,eACA,kBACA,wBACA,WACA,OACA,WACA,UACA,SACA,oBACA,aACA,qBACA,cACA,mBACA,kBACA,WACA,gBACA,kBACA,wBACA,wBACA,YACA,qBACA,eACA,iBACA,WACA,eACA,OACA,OACA,eACA,aACA,SACA,gBACA,YACA,oBACA,gBACA,YACA,iBACA,MACA,YACA,WACA,eACA,iBACA,mBACA,qBACA,mBACA,8BACA,aACA,WACA,wBACA,iBACA,oBACA,UACA,UACA,eACA,SACA,cACA,eACA,cACA,eACA,eACA,aACA,aACA,gBACA,cACA,WACA,eACA,WACA,WACA,UACA,cACA,UACA,aACA,cACA,cACA,eACA,sBACA,YACA,iBACA,eACA,kBACA,aACA,gBACA,WACA,eACA,iBACA,2BACA,mBACA,kBACA,iBACA,mCACA,WACA,eACA,kBACA,oBACA,cACA,gBACA,cACA,iBACA,cACA,sBACA,YACA,eACA,uBACA,mBACA,eACA,8BACA,YACA,WACA,aACA,oBACA,uBACA,YACA,WACA,WACA,WACA,gBACA,iBACA,kBACA,iBACA,iBACA,mBACA,kBACA,uBACA,UACA,aACA,eACA,eACA,aACA,iBACA,cACA,qBACA,gBACA,cACA,gBACA,YACA,YACA,WACA,SACA,iBACA,sBACA,cACA,cACA,aACA,UACA,cACA,eACA,MACA,eACA,aACA,cACA,gBACA,gBACA,aACA,QACA,kBACA,iBACA,QACA,QACA,WACA,YACA,OACA,WACA,YACA,kBACA,qBACA,mBACA,UACA,OACA,iBACA,MACA,kBACA,OACA,OACA,gBACA,QACA,QACA,YACA,QACA,YACA,QACA,QACA,QACA,SACA,OACA,wBACA,cACA,eACA,iBACA,OACA,OACA,SACA,eACA,gBACA,cACA,UACA,OACA,UACA,WACA,YACA,mBACA,mBACA,kBACA,QACA,eACA,aACA,SACA,QACA,YACA,eACA,OACA,MACA,aACA,YACA,SACA,SACA,UACA,SACA,QACA,kBACA,aACA,aACA,UACA,QACA,iBACA,WACA,cACA,iBACA,YACA,aACA,QACA,SACA,gBACA,aACA,YACA,gBACA,gBACA,cACA,sBACA,cACA,sBACA,YACA,oBACA,OACA,WACA,eACA,SACA,SACA,cACA,OACA,aACA,eACA,YACA,2BACA,cACA,kBACA,cACA,cACA,gBACA,qCACA,gCACA,aACA,SACA,SACA,cACA,YACA,SACA,mBACA,oBACA,iBACA,kBACA,oBACA,iBACA,eACA,kBACA,mBACA,gBACA,iBACA,mBACA,gBACA,aACA,cACA,aACA,cACA,QACA,aACA,aACA,aACA,iBACA,cACA,MACA,WACA,UACA,SACA,YACA,SACA,YACA,gBACA,SACA,SACA,WACA,UACA,MACA,WACA,eACA,mBACA,UACA,gBACA,YACA,WACA,YACA,UACA,SACA,aACA,WACA,iBACA,aACA,aACA,UACA,QACA,QACA,WACA,QACA,eACA,cACA,cACA,MACA,UACA,SACA,OACA,eACA,cACA,MACA,OACA,SACA,gBACA,gBACA,UACA,UACA,MACA,YACA,OACA,aACA,gBACA,gBACA,gBACA,OACA,aACA,cACA,kBACA,wBACA,uBACA,wBACA,cACA,gBACA,iBACA,cACA,iBACA,YACA,gBACA,aACA,gBACA,eACA,cACA,iBACA,sBACA,sBACA,qBACA,4BACA,qBACA,yBACA,sBACA,0BACA,aACA,cACA,kBACA,cACA,mBACA,aACA,eACA,gBACA,aACA,aACA,gBACA,wBACA,OACA,WACA,YACA,QACA,QACA,OACA,UACA,YACA,UACA,YACA,kBACA,SACA,QACA,UACA,SACA,YACA,eACA,YACA,gBACA,UACA,iBACA,iBACA,cACA,cACA,SACA,qBACA,iBACA,oBACA,iBACA,qBACA,oBACA,cACA,WACA,cACA,QACA,WACA,eACA,WACA,cACA,eACA,cACA,cACA,SACA,yBACA,UACA,UACA,MACA,YACA,QACA,kBACA,mBACA,cACA,UACA,QACA,QACA,cACA,eACA,YACA,mBACA,kBACA,kBACA,iBACA,kBACA,iBACA,sBACA,sBACA,aACA,mBACA,sBACA,sBACA,6BACA,kBACA,qBACA,qBACA,2BACA,YACA,gBACA,eACA,eACA,OACA,WACA,YACA,YACA,QACA,WACA,OACA,aACA,eACA,gBACA,QACA,SACA,YACA,WACA,SACA,eACA,cACA,YACA,aACA,YACA,aACA,YACA,aACA,YACA,aACA,YACA,aACA,YACA,aACA,YACA,aACA,YACA,aACA,mBACA,mBACA,mBACA,SACA,WACA,eACA,WACA,QACA,iBACA,mBACA,SACA,UACA,YACA,UACA,oBACA,cACA,aACA,2BACA,4BACA,cACA,eACA,UACA,cACA,kBACA,qBACA,UACA,YACA,SACA,iBACA,YACA,iBACA,iBACA,UACA,WACA,SACA,QACA,aACA,YACA,MACA,MACA,MACA,OACA,SACA,iBACA,SACA,aACA,YACA,YACA,eACA,WACA,kBACA,SACA,QACA,QACA,kBACA,oBACA,WACA,QACA,cACA,gBACA,gBACA,wBACA,eACA,UACA,YACA,YACA,SACA,gBACA,eACA,kBACA,oBACA,YACA,YACA,SACA,YACA,SACA,UACA,iBACA,kBACA,iBACA,kBACA,iBACA,kBACA,iBACA,kBACA,2BACA,sBACA,WACA,iBACA,gBACA,mBACA,UACA,cACA,cACA,aACA,OACA,UACA,gBACA,aACA,mBACA,WACA,kBACA,kBACA,kBACA,aACA,kBACA,UACA,aACA,QACA,SACA,OACA,SACA,IACA,OACA,OACA,WACA,QACA,gBACA,YACA,eACA,kBACA,uBACA,2BACA,0BACA,0BACA,gCACA,sBACA,2BACA,gCACA,mBACA,qBACA,8BACA,wBACA,2BACA,mBACA,6BACA,uBACA,wBACA,wBACA,yBACA,2BACA,4BACA,4BACA,yBACA,uBACA,+BACA,oBACA,0BACA,0BACA,yBACA,0BACA,yBACA,iBACA,qBACA,gBACA,wBACA,kBACA,gBACA,kBACA,6BACA,yBACA,yBACA,oCACA,6BACA,8BACA,mCACA,mCACA,yBACA,iCACA,wCACA,oCACA,6BACA,wBACA,wBACA,uBACA,uBACA,wBACA,uCACA,0BACA,0BACA,2BACA,mBACA,yBACA,mBACA,yBACA,yBACA,sBACA,oBACA,uBACA,sBACA,4BACA,qBACA,0BACA,eACA,kBACA,oBACA,yBACA,6BACA,mBACA,iBACA,oBACA,uBACA,mBACA,uBACA,8BACA,kBACA,yBACA,qBACA,aACA,uBACA,wBACA,wBACA,oBACA,sBACA,4BACA,oBACA,yBACA,0BACA,2BACA,oBACA,uBACA,uBACA,0BACA,sBACA,8BACA,0BACA,0BACA,0BACA,2BACA,kCACA,qBACA,oCACA,mBACA,iCACA,cACA,sBACA,0BACA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","sourcesContent":["/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    AST_Binary,\n    AST_Conditional,\n    AST_Dot,\n    AST_Sequence,\n    AST_Statement,\n    AST_Sub,\n    AST_UnaryPostfix,\n} from \"./ast.js\";\n\nfunction characters(str) {\n    return str.split(\"\");\n}\n\nfunction member(name, array) {\n    return array.includes(name);\n}\n\nfunction find_if(func, array) {\n    for (var i = 0, n = array.length; i < n; ++i) {\n        if (func(array[i]))\n            return array[i];\n    }\n}\n\nfunction repeat_string(str, i) {\n    if (i <= 0) return \"\";\n    if (i == 1) return str;\n    var d = repeat_string(str, i >> 1);\n    d += d;\n    if (i & 1) d += str;\n    return d;\n}\n\nfunction configure_error_stack(fn) {\n    Object.defineProperty(fn.prototype, \"stack\", {\n        get: function() {\n            var err = new Error(this.message);\n            err.name = this.name;\n            try {\n                throw err;\n            } catch(e) {\n                return e.stack;\n            }\n        }\n    });\n}\n\nfunction DefaultsError(msg, defs) {\n    this.message = msg;\n    this.defs = defs;\n}\nDefaultsError.prototype = Object.create(Error.prototype);\nDefaultsError.prototype.constructor = DefaultsError;\nDefaultsError.prototype.name = \"DefaultsError\";\nconfigure_error_stack(DefaultsError);\n\nDefaultsError.croak = function(msg, defs) {\n    throw new DefaultsError(msg, defs);\n};\n\nfunction defaults(args, defs, croak) {\n    if (args === true)\n        args = {};\n    var ret = args || {};\n    if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i))\n        DefaultsError.croak(\"`\" + i + \"` is not a supported option\", defs);\n    for (var i in defs) if (HOP(defs, i)) {\n        ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];\n    }\n    return ret;\n}\n\nfunction merge(obj, ext) {\n    var count = 0;\n    for (var i in ext) if (HOP(ext, i)) {\n        obj[i] = ext[i];\n        count++;\n    }\n    return count;\n}\n\nfunction noop() {}\nfunction return_false() { return false; }\nfunction return_true() { return true; }\nfunction return_this() { return this; }\nfunction return_null() { return null; }\n\nvar MAP = (function() {\n    function MAP(a, f, backwards) {\n        var ret = [], top = [], i;\n        function doit() {\n            var val = f(a[i], i);\n            var is_last = val instanceof Last;\n            if (is_last) val = val.v;\n            if (val instanceof AtTop) {\n                val = val.v;\n                if (val instanceof Splice) {\n                    top.push.apply(top, backwards ? val.v.slice().reverse() : val.v);\n                } else {\n                    top.push(val);\n                }\n            } else if (val !== skip) {\n                if (val instanceof Splice) {\n                    ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v);\n                } else {\n                    ret.push(val);\n                }\n            }\n            return is_last;\n        }\n        if (a instanceof Array) {\n            if (backwards) {\n                for (i = a.length; --i >= 0;) if (doit()) break;\n                ret.reverse();\n                top.reverse();\n            } else {\n                for (i = 0; i < a.length; ++i) if (doit()) break;\n            }\n        } else {\n            for (i in a) if (HOP(a, i)) if (doit()) break;\n        }\n        return top.concat(ret);\n    }\n    MAP.at_top = function(val) { return new AtTop(val); };\n    MAP.splice = function(val) { return new Splice(val); };\n    MAP.last = function(val) { return new Last(val); };\n    var skip = MAP.skip = {};\n    function AtTop(val) { this.v = val; }\n    function Splice(val) { this.v = val; }\n    function Last(val) { this.v = val; }\n    return MAP;\n})();\n\nfunction push_uniq(array, el) {\n    if (!array.includes(el))\n        array.push(el);\n}\n\nfunction string_template(text, props) {\n    return text.replace(/{(.+?)}/g, function(str, p) {\n        return props && props[p];\n    });\n}\n\nfunction remove(array, el) {\n    for (var i = array.length; --i >= 0;) {\n        if (array[i] === el) array.splice(i, 1);\n    }\n}\n\nfunction mergeSort(array, cmp) {\n    if (array.length < 2) return array.slice();\n    function merge(a, b) {\n        var r = [], ai = 0, bi = 0, i = 0;\n        while (ai < a.length && bi < b.length) {\n            cmp(a[ai], b[bi]) <= 0\n                ? r[i++] = a[ai++]\n                : r[i++] = b[bi++];\n        }\n        if (ai < a.length) r.push.apply(r, a.slice(ai));\n        if (bi < b.length) r.push.apply(r, b.slice(bi));\n        return r;\n    }\n    function _ms(a) {\n        if (a.length <= 1)\n            return a;\n        var m = Math.floor(a.length / 2), left = a.slice(0, m), right = a.slice(m);\n        left = _ms(left);\n        right = _ms(right);\n        return merge(left, right);\n    }\n    return _ms(array);\n}\n\n// this function is taken from Acorn [1], written by Marijn Haverbeke\n// [1] https://github.com/marijnh/acorn\nfunction makePredicate(words) {\n    if (!(words instanceof Array)) words = words.split(\" \");\n    var f = \"\", cats = [];\n    out: for (var i = 0; i < words.length; ++i) {\n        for (var j = 0; j < cats.length; ++j)\n            if (cats[j][0].length == words[i].length) {\n                cats[j].push(words[i]);\n                continue out;\n            }\n        cats.push([words[i]]);\n    }\n    function quote(word) {\n        return JSON.stringify(word).replace(/[\\u2028\\u2029]/g, function(s) {\n            switch (s) {\n                case \"\\u2028\": return \"\\\\u2028\";\n                case \"\\u2029\": return \"\\\\u2029\";\n            }\n            return s;\n        });\n    }\n    function compareTo(arr) {\n        if (arr.length == 1) return f += \"return str === \" + quote(arr[0]) + \";\";\n        f += \"switch(str){\";\n        for (var i = 0; i < arr.length; ++i) f += \"case \" + quote(arr[i]) + \":\";\n        f += \"return true}return false;\";\n    }\n    // When there are more than three length categories, an outer\n    // switch first dispatches on the lengths, to save on comparisons.\n    if (cats.length > 3) {\n        cats.sort(function(a, b) {return b.length - a.length;});\n        f += \"switch(str.length){\";\n        for (var i = 0; i < cats.length; ++i) {\n            var cat = cats[i];\n            f += \"case \" + cat[0].length + \":\";\n            compareTo(cat);\n        }\n        f += \"}\";\n        // Otherwise, simply generate a flat `switch` statement.\n    } else {\n        compareTo(words);\n    }\n    return new Function(\"str\", f);\n}\n\nfunction all(array, predicate) {\n    for (var i = array.length; --i >= 0;)\n        if (!predicate(array[i]))\n            return false;\n    return true;\n}\n\nfunction Dictionary() {\n    this._values = Object.create(null);\n    this._size = 0;\n}\nDictionary.prototype = {\n    set: function(key, val) {\n        if (!this.has(key)) ++this._size;\n        this._values[\"$\" + key] = val;\n        return this;\n    },\n    add: function(key, val) {\n        if (this.has(key)) {\n            this.get(key).push(val);\n        } else {\n            this.set(key, [ val ]);\n        }\n        return this;\n    },\n    get: function(key) { return this._values[\"$\" + key]; },\n    del: function(key) {\n        if (this.has(key)) {\n            --this._size;\n            delete this._values[\"$\" + key];\n        }\n        return this;\n    },\n    has: function(key) { return (\"$\" + key) in this._values; },\n    each: function(f) {\n        for (var i in this._values)\n            f(this._values[i], i.substr(1));\n    },\n    size: function() {\n        return this._size;\n    },\n    map: function(f) {\n        var ret = [];\n        for (var i in this._values)\n            ret.push(f(this._values[i], i.substr(1)));\n        return ret;\n    },\n    clone: function() {\n        var ret = new Dictionary();\n        for (var i in this._values)\n            ret._values[i] = this._values[i];\n        ret._size = this._size;\n        return ret;\n    },\n    toObject: function() { return this._values; }\n};\nDictionary.fromObject = function(obj) {\n    var dict = new Dictionary();\n    dict._size = merge(dict._values, obj);\n    return dict;\n};\n\nfunction HOP(obj, prop) {\n    return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\n// return true if the node at the top of the stack (that means the\n// innermost node in the current output) is lexically the first in\n// a statement.\nfunction first_in_statement(stack) {\n    var node = stack.parent(-1);\n    for (var i = 0, p; p = stack.parent(i); i++) {\n        if (p instanceof AST_Statement && p.body === node)\n            return true;\n        if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||\n            (p.TYPE == \"Call\"               && p.expression === node ) ||\n            (p instanceof AST_Dot           && p.expression === node ) ||\n            (p instanceof AST_Sub           && p.expression === node ) ||\n            (p instanceof AST_Conditional   && p.condition === node  ) ||\n            (p instanceof AST_Binary        && p.left === node       ) ||\n            (p instanceof AST_UnaryPostfix  && p.expression === node )\n        ) {\n            node = p;\n        } else {\n            return false;\n        }\n    }\n}\n\nfunction keep_name(keep_setting, name) {\n    return keep_setting === true\n        || (keep_setting instanceof RegExp && keep_setting.test(name));\n}\n\nexport {\n    all,\n    characters,\n    configure_error_stack,\n    defaults,\n    Dictionary,\n    find_if,\n    first_in_statement,\n    HOP,\n    keep_name,\n    makePredicate,\n    MAP,\n    member,\n    merge,\n    mergeSort,\n    noop,\n    push_uniq,\n    remove,\n    repeat_string,\n    return_false,\n    return_null,\n    return_this,\n    return_true,\n    string_template,\n};\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n    Parser based on parse-js (http://marijn.haverbeke.nl/parse-js/).\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    all,\n    characters,\n    configure_error_stack,\n    defaults,\n    find_if,\n    HOP,\n    makePredicate,\n} from \"./utils.js\";\nimport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Await,\n    AST_Binary,\n    AST_BlockStatement,\n    AST_Break,\n    AST_Call,\n    AST_Case,\n    AST_Catch,\n    AST_ClassExpression,\n    AST_ConciseMethod,\n    AST_Conditional,\n    AST_Const,\n    AST_Continue,\n    AST_Debugger,\n    AST_Default,\n    AST_DefaultAssign,\n    AST_DefClass,\n    AST_Definitions,\n    AST_Defun,\n    AST_Destructuring,\n    AST_Directive,\n    AST_Do,\n    AST_Dot,\n    AST_EmptyStatement,\n    AST_Expansion,\n    AST_Export,\n    AST_False,\n    AST_Finally,\n    AST_For,\n    AST_ForIn,\n    AST_ForOf,\n    AST_Function,\n    AST_Hole,\n    AST_If,\n    AST_Import,\n    AST_IterationStatement,\n    AST_Label,\n    AST_LabeledStatement,\n    AST_LabelRef,\n    AST_Lambda,\n    AST_Let,\n    AST_NameMapping,\n    AST_New,\n    AST_NewTarget,\n    AST_Node,\n    AST_Null,\n    AST_Number,\n    AST_Object,\n    AST_ObjectGetter,\n    AST_ObjectKeyVal,\n    AST_ObjectProperty,\n    AST_ObjectSetter,\n    AST_PrefixedTemplateString,\n    AST_PropAccess,\n    AST_RegExp,\n    AST_Return,\n    AST_Sequence,\n    AST_SimpleStatement,\n    AST_String,\n    AST_Sub,\n    AST_Super,\n    AST_Switch,\n    AST_SymbolCatch,\n    AST_SymbolClass,\n    AST_SymbolConst,\n    AST_SymbolDeclaration,\n    AST_SymbolDefClass,\n    AST_SymbolDefun,\n    AST_SymbolExport,\n    AST_SymbolExportForeign,\n    AST_SymbolFunarg,\n    AST_SymbolImport,\n    AST_SymbolImportForeign,\n    AST_SymbolLambda,\n    AST_SymbolLet,\n    AST_SymbolMethod,\n    AST_SymbolRef,\n    AST_SymbolVar,\n    AST_TemplateSegment,\n    AST_TemplateString,\n    AST_This,\n    AST_Throw,\n    AST_Token,\n    AST_Toplevel,\n    AST_True,\n    AST_Try,\n    AST_UnaryPostfix,\n    AST_UnaryPrefix,\n    AST_Var,\n    AST_VarDef,\n    AST_While,\n    AST_With,\n    AST_Yield,\n} from \"./ast.js\";\n\nvar KEYWORDS = \"break case catch class const continue debugger default delete do else export extends finally for function if in instanceof let new return switch throw try typeof var void while with\";\nvar KEYWORDS_ATOM = \"false null true\";\nvar RESERVED_WORDS = \"enum implements import interface package private protected public static super this \" + KEYWORDS_ATOM + \" \" + KEYWORDS;\nvar KEYWORDS_BEFORE_EXPRESSION = \"return new delete throw else case yield await\";\n\nKEYWORDS = makePredicate(KEYWORDS);\nRESERVED_WORDS = makePredicate(RESERVED_WORDS);\nKEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);\nKEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);\n\nvar OPERATOR_CHARS = makePredicate(characters(\"+-*&%=<>!?|~^\"));\n\nvar RE_NUM_LITERAL = /[0-9a-f]/i;\nvar RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;\nvar RE_OCT_NUMBER = /^0[0-7]+$/;\nvar RE_ES6_OCT_NUMBER = /^0o[0-7]+$/i;\nvar RE_BIN_NUMBER = /^0b[01]+$/i;\nvar RE_DEC_NUMBER = /^\\d*\\.?\\d*(?:e[+-]?\\d*(?:\\d\\.?|\\.?\\d)\\d*)?$/i;\n\nvar OPERATORS = makePredicate([\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"new\",\n    \"void\",\n    \"delete\",\n    \"++\",\n    \"--\",\n    \"+\",\n    \"-\",\n    \"!\",\n    \"~\",\n    \"&\",\n    \"|\",\n    \"^\",\n    \"*\",\n    \"**\",\n    \"/\",\n    \"%\",\n    \">>\",\n    \"<<\",\n    \">>>\",\n    \"<\",\n    \">\",\n    \"<=\",\n    \">=\",\n    \"==\",\n    \"===\",\n    \"!=\",\n    \"!==\",\n    \"?\",\n    \"=\",\n    \"+=\",\n    \"-=\",\n    \"/=\",\n    \"*=\",\n    \"**=\",\n    \"%=\",\n    \">>=\",\n    \"<<=\",\n    \">>>=\",\n    \"|=\",\n    \"^=\",\n    \"&=\",\n    \"&&\",\n    \"||\"\n]);\n\nvar WHITESPACE_CHARS = makePredicate(characters(\" \\u00a0\\n\\r\\t\\f\\u000b\\u200b\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\uFEFF\"));\n\nvar NEWLINE_CHARS = makePredicate(characters(\"\\n\\r\\u2028\\u2029\"));\n\nvar PUNC_AFTER_EXPRESSION = makePredicate(characters(\";]),:\"));\n\nvar PUNC_BEFORE_EXPRESSION = makePredicate(characters(\"[{(,;:\"));\n\nvar PUNC_CHARS = makePredicate(characters(\"[]{}(),;:\"));\n\n/* -----[ Tokenizer ]----- */\n\n// surrogate safe regexps adapted from https://github.com/mathiasbynens/unicode-8.0.0/tree/89b412d8a71ecca9ed593d9e9fa073ab64acfebe/Binary_Property\nvar UNICODE = {\n    ID_Start: /[A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AD\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]/,\n    ID_Continue: /[0-9A-Z_a-z\\xAA\\xB5\\xB7\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0-\\u08B4\\u08E3-\\u0963\\u0966-\\u096F\\u0971-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AF9\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58-\\u0C5A\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C81-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D01-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D57\\u0D5F-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1369-\\u1371\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19DA\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1AB0-\\u1ABD\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1CF8\\u1CF9\\u1D00-\\u1DF5\\u1DFC-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AD\\uA7B0-\\uA7B7\\uA7F7-\\uA827\\uA840-\\uA873\\uA880-\\uA8C4\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA8FD\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uA9E0-\\uA9FE\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDDFD\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDEE0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF7A\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCA0-\\uDCA9\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE38-\\uDE3A\\uDE3F\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE6\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC00-\\uDC46\\uDC66-\\uDC6F\\uDC7F-\\uDCBA\\uDCD0-\\uDCE8\\uDCF0-\\uDCF9\\uDD00-\\uDD34\\uDD36-\\uDD3F\\uDD50-\\uDD73\\uDD76\\uDD80-\\uDDC4\\uDDCA-\\uDDCC\\uDDD0-\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE37\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEEA\\uDEF0-\\uDEF9\\uDF00-\\uDF03\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3C-\\uDF44\\uDF47\\uDF48\\uDF4B-\\uDF4D\\uDF50\\uDF57\\uDF5D-\\uDF63\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC80-\\uDCC5\\uDCC7\\uDCD0-\\uDCD9\\uDD80-\\uDDB5\\uDDB8-\\uDDC0\\uDDD8-\\uDDDD\\uDE00-\\uDE40\\uDE44\\uDE50-\\uDE59\\uDE80-\\uDEB7\\uDEC0-\\uDEC9\\uDF00-\\uDF19\\uDF1D-\\uDF2B\\uDF30-\\uDF39]|\\uD806[\\uDCA0-\\uDCE9\\uDCFF\\uDEC0-\\uDEF8]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDE60-\\uDE69\\uDED0-\\uDEED\\uDEF0-\\uDEF4\\uDF00-\\uDF36\\uDF40-\\uDF43\\uDF50-\\uDF59\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50-\\uDF7E\\uDF8F-\\uDF9F]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99\\uDC9D\\uDC9E]|\\uD834[\\uDD65-\\uDD69\\uDD6D-\\uDD72\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB\\uDFCE-\\uDFFF]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD83A[\\uDC00-\\uDCC4\\uDCD0-\\uDCD6]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]|\\uDB40[\\uDD00-\\uDDEF]/,\n};\n\nfunction get_full_char(str, pos) {\n    var char = str.charAt(pos);\n    if (is_surrogate_pair_head(char)) {\n        var next = str.charAt(pos + 1);\n        if (is_surrogate_pair_tail(next)) {\n            return char + next;\n        }\n    }\n    if (is_surrogate_pair_tail(char)) {\n        var prev = str.charAt(pos - 1);\n        if (is_surrogate_pair_head(prev)) {\n            return prev + char;\n        }\n    }\n    return char;\n}\n\nfunction get_full_char_code(str, pos) {\n    // https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates\n    if (is_surrogate_pair_head(str.charAt(pos))) {\n        return 0x10000 + (str.charCodeAt(pos) - 0xd800 << 10) + str.charCodeAt(pos + 1) - 0xdc00;\n    }\n    return str.charCodeAt(pos);\n}\n\nfunction get_full_char_length(str) {\n    var surrogates = 0;\n\n    for (var i = 0; i < str.length; i++) {\n        if (is_surrogate_pair_head(str.charCodeAt(i))) {\n            if (is_surrogate_pair_tail(str.charCodeAt(i + 1))) {\n                surrogates++;\n                i++;\n            }\n        }\n    }\n\n    return str.length - surrogates;\n}\n\nfunction from_char_code(code) {\n    // Based on https://github.com/mathiasbynens/String.fromCodePoint/blob/master/fromcodepoint.js\n    if (code > 0xFFFF) {\n        code -= 0x10000;\n        return (String.fromCharCode((code >> 10) + 0xD800) +\n            String.fromCharCode((code % 0x400) + 0xDC00));\n    }\n    return String.fromCharCode(code);\n}\n\nfunction is_surrogate_pair_head(code) {\n    if (typeof code === \"string\")\n        code = code.charCodeAt(0);\n\n    return code >= 0xd800 && code <= 0xdbff;\n}\n\nfunction is_surrogate_pair_tail(code) {\n    if (typeof code === \"string\")\n        code = code.charCodeAt(0);\n    return code >= 0xdc00 && code <= 0xdfff;\n}\n\nfunction is_digit(code) {\n    return code >= 48 && code <= 57;\n}\n\nfunction is_identifier(name) {\n    return typeof name === \"string\" && !RESERVED_WORDS(name);\n}\n\nfunction is_identifier_start(ch) {\n    var code = ch.charCodeAt(0);\n    return UNICODE.ID_Start.test(ch) || code == 36 || code == 95;\n}\n\nfunction is_identifier_char(ch) {\n    var code = ch.charCodeAt(0);\n    return UNICODE.ID_Continue.test(ch)\n        || code == 36\n        || code == 95\n        || code == 8204 // \\u200c: zero-width non-joiner <ZWNJ>\n        || code == 8205 // \\u200d: zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)\n    ;\n}\n\nfunction is_identifier_string(str) {\n    return /^[a-z_$][a-z0-9_$]*$/i.test(str);\n}\n\nfunction parse_js_number(num) {\n    if (RE_HEX_NUMBER.test(num)) {\n        return parseInt(num.substr(2), 16);\n    } else if (RE_OCT_NUMBER.test(num)) {\n        return parseInt(num.substr(1), 8);\n    } else if (RE_ES6_OCT_NUMBER.test(num)) {\n        return parseInt(num.substr(2), 8);\n    } else if (RE_BIN_NUMBER.test(num)) {\n        return parseInt(num.substr(2), 2);\n    } else if (RE_DEC_NUMBER.test(num)) {\n        return parseFloat(num);\n    } else {\n        var val = parseFloat(num);\n        if (val == num) return val;\n    }\n}\n\nfunction JS_Parse_Error(message, filename, line, col, pos) {\n    this.message = message;\n    this.filename = filename;\n    this.line = line;\n    this.col = col;\n    this.pos = pos;\n}\nJS_Parse_Error.prototype = Object.create(Error.prototype);\nJS_Parse_Error.prototype.constructor = JS_Parse_Error;\nJS_Parse_Error.prototype.name = \"SyntaxError\";\nconfigure_error_stack(JS_Parse_Error);\n\nfunction js_error(message, filename, line, col, pos) {\n    throw new JS_Parse_Error(message, filename, line, col, pos);\n}\n\nfunction is_token(token, type, val) {\n    return token.type == type && (val == null || token.value == val);\n}\n\nvar EX_EOF = {};\n\nfunction tokenizer($TEXT, filename, html5_comments, shebang) {\n\n    var S = {\n        text            : $TEXT,\n        filename        : filename,\n        pos             : 0,\n        tokpos          : 0,\n        line            : 1,\n        tokline         : 0,\n        col             : 0,\n        tokcol          : 0,\n        newline_before  : false,\n        regex_allowed   : false,\n        brace_counter   : 0,\n        template_braces : [],\n        comments_before : [],\n        directives      : {},\n        directive_stack : []\n    };\n\n    function peek() { return get_full_char(S.text, S.pos); }\n\n    function next(signal_eof, in_string) {\n        var ch = get_full_char(S.text, S.pos++);\n        if (signal_eof && !ch)\n            throw EX_EOF;\n        if (NEWLINE_CHARS(ch)) {\n            S.newline_before = S.newline_before || !in_string;\n            ++S.line;\n            S.col = 0;\n            if (!in_string && ch == \"\\r\" && peek() == \"\\n\") {\n                // treat a \\r\\n sequence as a single \\n\n                ++S.pos;\n                ch = \"\\n\";\n            }\n        } else {\n            if (ch.length > 1) {\n                ++S.pos;\n                ++S.col;\n            }\n            ++S.col;\n        }\n        return ch;\n    }\n\n    function forward(i) {\n        while (i-- > 0) next();\n    }\n\n    function looking_at(str) {\n        return S.text.substr(S.pos, str.length) == str;\n    }\n\n    function find_eol() {\n        var text = S.text;\n        for (var i = S.pos, n = S.text.length; i < n; ++i) {\n            var ch = text[i];\n            if (NEWLINE_CHARS(ch))\n                return i;\n        }\n        return -1;\n    }\n\n    function find(what, signal_eof) {\n        var pos = S.text.indexOf(what, S.pos);\n        if (signal_eof && pos == -1) throw EX_EOF;\n        return pos;\n    }\n\n    function start_token() {\n        S.tokline = S.line;\n        S.tokcol = S.col;\n        S.tokpos = S.pos;\n    }\n\n    var prev_was_dot = false;\n    var previous_token = null;\n    function token(type, value, is_comment) {\n        S.regex_allowed = ((type == \"operator\" && !UNARY_POSTFIX(value)) ||\n                           (type == \"keyword\" && KEYWORDS_BEFORE_EXPRESSION(value)) ||\n                           (type == \"punc\" && PUNC_BEFORE_EXPRESSION(value))) ||\n                           (type == \"arrow\");\n        if (type == \"punc\" && value == \".\") {\n            prev_was_dot = true;\n        } else if (!is_comment) {\n            prev_was_dot = false;\n        }\n        var ret = {\n            type    : type,\n            value   : value,\n            line    : S.tokline,\n            col     : S.tokcol,\n            pos     : S.tokpos,\n            endline : S.line,\n            endcol  : S.col,\n            endpos  : S.pos,\n            nlb     : S.newline_before,\n            file    : filename\n        };\n        if (/^(?:num|string|regexp)$/i.test(type)) {\n            ret.raw = $TEXT.substring(ret.pos, ret.endpos);\n        }\n        if (!is_comment) {\n            ret.comments_before = S.comments_before;\n            ret.comments_after = S.comments_before = [];\n        }\n        S.newline_before = false;\n        ret = new AST_Token(ret);\n        if (!is_comment) previous_token = ret;\n        return ret;\n    }\n\n    function skip_whitespace() {\n        while (WHITESPACE_CHARS(peek()))\n            next();\n    }\n\n    function read_while(pred) {\n        var ret = \"\", ch, i = 0;\n        while ((ch = peek()) && pred(ch, i++))\n            ret += next();\n        return ret;\n    }\n\n    function parse_error(err) {\n        js_error(err, filename, S.tokline, S.tokcol, S.tokpos);\n    }\n\n    function read_num(prefix) {\n        var has_e = false, after_e = false, has_x = false, has_dot = prefix == \".\";\n        var num = read_while(function(ch, i) {\n            var code = ch.charCodeAt(0);\n            switch (code) {\n              case 98: case 66: // bB\n                return (has_x = true); // Can occur in hex sequence, don't return false yet\n              case 111: case 79: // oO\n              case 120: case 88: // xX\n                return has_x ? false : (has_x = true);\n              case 101: case 69: // eE\n                return has_x ? true : has_e ? false : (has_e = after_e = true);\n              case 45: // -\n                return after_e || (i == 0 && !prefix);\n              case 43: // +\n                return after_e;\n              case (after_e = false, 46): // .\n                return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;\n            }\n            return RE_NUM_LITERAL.test(ch);\n        });\n        if (prefix) num = prefix + num;\n        if (RE_OCT_NUMBER.test(num) && next_token.has_directive(\"use strict\")) {\n            parse_error(\"Legacy octal literals are not allowed in strict mode\");\n        }\n        var valid = parse_js_number(num);\n        if (!isNaN(valid)) {\n            return token(\"num\", valid);\n        } else {\n            parse_error(\"Invalid syntax: \" + num);\n        }\n    }\n\n    function read_escaped_char(in_string, strict_hex, template_string) {\n        var ch = next(true, in_string);\n        switch (ch.charCodeAt(0)) {\n          case 110 : return \"\\n\";\n          case 114 : return \"\\r\";\n          case 116 : return \"\\t\";\n          case 98  : return \"\\b\";\n          case 118 : return \"\\u000b\"; // \\v\n          case 102 : return \"\\f\";\n          case 120 : return String.fromCharCode(hex_bytes(2, strict_hex)); // \\x\n          case 117 : // \\u\n            if (peek() == \"{\") {\n                next(true);\n                if (peek() === \"}\")\n                    parse_error(\"Expecting hex-character between {}\");\n                while (peek() == \"0\") next(true); // No significance\n                var result, length = find(\"}\", true) - S.pos;\n                // Avoid 32 bit integer overflow (1 << 32 === 1)\n                // We know first character isn't 0 and thus out of range anyway\n                if (length > 6 || (result = hex_bytes(length, strict_hex)) > 0x10FFFF) {\n                    parse_error(\"Unicode reference out of bounds\");\n                }\n                next(true);\n                return from_char_code(result);\n            }\n            return String.fromCharCode(hex_bytes(4, strict_hex));\n          case 10  : return \"\"; // newline\n          case 13  :            // \\r\n            if (peek() == \"\\n\") { // DOS newline\n                next(true, in_string);\n                return \"\";\n            }\n        }\n        if (ch >= \"0\" && ch <= \"7\") {\n            if (template_string && strict_hex) {\n                parse_error(\"Octal escape sequences are not allowed in template strings\");\n            }\n            return read_octal_escape_sequence(ch, strict_hex);\n        }\n        return ch;\n    }\n\n    function read_octal_escape_sequence(ch, strict_octal) {\n        // Read\n        var p = peek();\n        if (p >= \"0\" && p <= \"7\") {\n            ch += next(true);\n            if (ch[0] <= \"3\" && (p = peek()) >= \"0\" && p <= \"7\")\n                ch += next(true);\n        }\n\n        // Parse\n        if (ch === \"0\") return \"\\0\";\n        if (ch.length > 0 && next_token.has_directive(\"use strict\") && strict_octal)\n            parse_error(\"Legacy octal escape sequences are not allowed in strict mode\");\n        return String.fromCharCode(parseInt(ch, 8));\n    }\n\n    function hex_bytes(n, strict_hex) {\n        var num = 0;\n        for (; n > 0; --n) {\n            if (!strict_hex && isNaN(parseInt(peek(), 16))) {\n                return parseInt(num, 16) || \"\";\n            }\n            var digit = next(true);\n            if (isNaN(parseInt(digit, 16)))\n                parse_error(\"Invalid hex-character pattern in string\");\n            num += digit;\n        }\n        return parseInt(num, 16);\n    }\n\n    var read_string = with_eof_error(\"Unterminated string constant\", function(quote_char) {\n        var quote = next(), ret = \"\";\n        for (;;) {\n            var ch = next(true, true);\n            if (ch == \"\\\\\") ch = read_escaped_char(true, true);\n            else if (NEWLINE_CHARS(ch)) parse_error(\"Unterminated string constant\");\n            else if (ch == quote) break;\n            ret += ch;\n        }\n        var tok = token(\"string\", ret);\n        tok.quote = quote_char;\n        return tok;\n    });\n\n    var read_template_characters = with_eof_error(\"Unterminated template\", function(begin) {\n        if (begin) {\n            S.template_braces.push(S.brace_counter);\n        }\n        var content = \"\", raw = \"\", ch, tok;\n        next(true, true);\n        while ((ch = next(true, true)) != \"`\") {\n            if (ch == \"\\r\") {\n                if (peek() == \"\\n\") ++S.pos;\n                ch = \"\\n\";\n            } else if (ch == \"$\" && peek() == \"{\") {\n                next(true, true);\n                S.brace_counter++;\n                tok = token(begin ? \"template_head\" : \"template_substitution\", content);\n                tok.begin = begin;\n                tok.raw = raw;\n                tok.end = false;\n                return tok;\n            }\n\n            raw += ch;\n            if (ch == \"\\\\\") {\n                var tmp = S.pos;\n                var prev_is_tag = previous_token && (previous_token.type === \"name\" || previous_token.type === \"punc\" && (previous_token.value === \")\" || previous_token.value === \"]\"));\n                ch = read_escaped_char(true, !prev_is_tag, true);\n                raw += S.text.substr(tmp, S.pos - tmp);\n            }\n\n            content += ch;\n        }\n        S.template_braces.pop();\n        tok = token(begin ? \"template_head\" : \"template_substitution\", content);\n        tok.begin = begin;\n        tok.raw = raw;\n        tok.end = true;\n        return tok;\n    });\n\n    function skip_line_comment(type) {\n        var regex_allowed = S.regex_allowed;\n        var i = find_eol(), ret;\n        if (i == -1) {\n            ret = S.text.substr(S.pos);\n            S.pos = S.text.length;\n        } else {\n            ret = S.text.substring(S.pos, i);\n            S.pos = i;\n        }\n        S.col = S.tokcol + (S.pos - S.tokpos);\n        S.comments_before.push(token(type, ret, true));\n        S.regex_allowed = regex_allowed;\n        return next_token;\n    }\n\n    var skip_multiline_comment = with_eof_error(\"Unterminated multiline comment\", function() {\n        var regex_allowed = S.regex_allowed;\n        var i = find(\"*/\", true);\n        var text = S.text.substring(S.pos, i).replace(/\\r\\n|\\r|\\u2028|\\u2029/g, \"\\n\");\n        // update stream position\n        forward(get_full_char_length(text) /* text length doesn't count \\r\\n as 2 char while S.pos - i does */ + 2);\n        S.comments_before.push(token(\"comment2\", text, true));\n        S.newline_before = S.newline_before || text.includes(\"\\n\");\n        S.regex_allowed = regex_allowed;\n        return next_token;\n    });\n\n    var read_name = with_eof_error(\"Unterminated identifier name\", function() {\n        var name = \"\", ch, escaped = false, hex;\n        var read_escaped_identifier_char = function() {\n            escaped = true;\n            next();\n            if (peek() !== \"u\") {\n                parse_error(\"Expecting UnicodeEscapeSequence -- uXXXX or u{XXXX}\");\n            }\n            return read_escaped_char(false, true);\n        };\n\n        // Read first character (ID_Start)\n        if ((name = peek()) === \"\\\\\") {\n            name = read_escaped_identifier_char();\n            if (!is_identifier_start(name)) {\n                parse_error(\"First identifier char is an invalid identifier char\");\n            }\n        } else if (is_identifier_start(name)) {\n            next();\n        } else {\n            return \"\";\n        }\n\n        // Read ID_Continue\n        while ((ch = peek()) != null) {\n            if ((ch = peek()) === \"\\\\\") {\n                ch = read_escaped_identifier_char();\n                if (!is_identifier_char(ch)) {\n                    parse_error(\"Invalid escaped identifier char\");\n                }\n            } else {\n                if (!is_identifier_char(ch)) {\n                    break;\n                }\n                next();\n            }\n            name += ch;\n        }\n        if (RESERVED_WORDS(name) && escaped) {\n            parse_error(\"Escaped characters are not allowed in keywords\");\n        }\n        return name;\n    });\n\n    var read_regexp = with_eof_error(\"Unterminated regular expression\", function(source) {\n        var prev_backslash = false, ch, in_class = false;\n        while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {\n            parse_error(\"Unexpected line terminator\");\n        } else if (prev_backslash) {\n            source += \"\\\\\" + ch;\n            prev_backslash = false;\n        } else if (ch == \"[\") {\n            in_class = true;\n            source += ch;\n        } else if (ch == \"]\" && in_class) {\n            in_class = false;\n            source += ch;\n        } else if (ch == \"/\" && !in_class) {\n            break;\n        } else if (ch == \"\\\\\") {\n            prev_backslash = true;\n        } else {\n            source += ch;\n        }\n        var mods = read_name();\n        try {\n            var regexp = new RegExp(source, mods);\n            regexp.raw_source = \"/\" + source + \"/\" + mods;\n            return token(\"regexp\", regexp);\n        } catch(e) {\n            parse_error(e.message);\n        }\n    });\n\n    function read_operator(prefix) {\n        function grow(op) {\n            if (!peek()) return op;\n            var bigger = op + peek();\n            if (OPERATORS(bigger)) {\n                next();\n                return grow(bigger);\n            } else {\n                return op;\n            }\n        }\n        return token(\"operator\", grow(prefix || next()));\n    }\n\n    function handle_slash() {\n        next();\n        switch (peek()) {\n          case \"/\":\n            next();\n            return skip_line_comment(\"comment1\");\n          case \"*\":\n            next();\n            return skip_multiline_comment();\n        }\n        return S.regex_allowed ? read_regexp(\"\") : read_operator(\"/\");\n    }\n\n    function handle_eq_sign() {\n        next();\n        if (peek() === \">\") {\n            next();\n            return token(\"arrow\", \"=>\");\n        } else {\n            return read_operator(\"=\");\n        }\n    }\n\n    function handle_dot() {\n        next();\n        if (is_digit(peek().charCodeAt(0))) {\n            return read_num(\".\");\n        }\n        if (peek() === \".\") {\n            next();  // Consume second dot\n            next();  // Consume third dot\n            return token(\"expand\", \"...\");\n        }\n\n        return token(\"punc\", \".\");\n    }\n\n    function read_word() {\n        var word = read_name();\n        if (prev_was_dot) return token(\"name\", word);\n        return KEYWORDS_ATOM(word) ? token(\"atom\", word)\n            : !KEYWORDS(word) ? token(\"name\", word)\n            : OPERATORS(word) ? token(\"operator\", word)\n            : token(\"keyword\", word);\n    }\n\n    function with_eof_error(eof_error, cont) {\n        return function(x) {\n            try {\n                return cont(x);\n            } catch(ex) {\n                if (ex === EX_EOF) parse_error(eof_error);\n                else throw ex;\n            }\n        };\n    }\n\n    function next_token(force_regexp) {\n        if (force_regexp != null)\n            return read_regexp(force_regexp);\n        if (shebang && S.pos == 0 && looking_at(\"#!\")) {\n            start_token();\n            forward(2);\n            skip_line_comment(\"comment5\");\n        }\n        for (;;) {\n            skip_whitespace();\n            start_token();\n            if (html5_comments) {\n                if (looking_at(\"<!--\")) {\n                    forward(4);\n                    skip_line_comment(\"comment3\");\n                    continue;\n                }\n                if (looking_at(\"-->\") && S.newline_before) {\n                    forward(3);\n                    skip_line_comment(\"comment4\");\n                    continue;\n                }\n            }\n            var ch = peek();\n            if (!ch) return token(\"eof\");\n            var code = ch.charCodeAt(0);\n            switch (code) {\n              case 34: case 39: return read_string(ch);\n              case 46: return handle_dot();\n              case 47: {\n                  var tok = handle_slash();\n                  if (tok === next_token) continue;\n                  return tok;\n              }\n              case 61: return handle_eq_sign();\n              case 96: return read_template_characters(true);\n              case 123:\n                S.brace_counter++;\n                break;\n              case 125:\n                S.brace_counter--;\n                if (S.template_braces.length > 0\n                    && S.template_braces[S.template_braces.length - 1] === S.brace_counter)\n                    return read_template_characters(false);\n                break;\n            }\n            if (is_digit(code)) return read_num();\n            if (PUNC_CHARS(ch)) return token(\"punc\", next());\n            if (OPERATOR_CHARS(ch)) return read_operator();\n            if (code == 92 || is_identifier_start(ch)) return read_word();\n            break;\n        }\n        parse_error(\"Unexpected character '\" + ch + \"'\");\n    }\n\n    next_token.next = next;\n    next_token.peek = peek;\n\n    next_token.context = function(nc) {\n        if (nc) S = nc;\n        return S;\n    };\n\n    next_token.add_directive = function(directive) {\n        S.directive_stack[S.directive_stack.length - 1].push(directive);\n\n        if (S.directives[directive] === undefined) {\n            S.directives[directive] = 1;\n        } else {\n            S.directives[directive]++;\n        }\n    };\n\n    next_token.push_directives_stack = function() {\n        S.directive_stack.push([]);\n    };\n\n    next_token.pop_directives_stack = function() {\n        var directives = S.directive_stack[S.directive_stack.length - 1];\n\n        for (var i = 0; i < directives.length; i++) {\n            S.directives[directives[i]]--;\n        }\n\n        S.directive_stack.pop();\n    };\n\n    next_token.has_directive = function(directive) {\n        return S.directives[directive] > 0;\n    };\n\n    return next_token;\n\n}\n\n/* -----[ Parser (constants) ]----- */\n\nvar UNARY_PREFIX = makePredicate([\n    \"typeof\",\n    \"void\",\n    \"delete\",\n    \"--\",\n    \"++\",\n    \"!\",\n    \"~\",\n    \"-\",\n    \"+\"\n]);\n\nvar UNARY_POSTFIX = makePredicate([ \"--\", \"++\" ]);\n\nvar ASSIGNMENT = makePredicate([ \"=\", \"+=\", \"-=\", \"/=\", \"*=\", \"**=\", \"%=\", \">>=\", \"<<=\", \">>>=\", \"|=\", \"^=\", \"&=\" ]);\n\nvar PRECEDENCE = (function(a, ret) {\n    for (var i = 0; i < a.length; ++i) {\n        var b = a[i];\n        for (var j = 0; j < b.length; ++j) {\n            ret[b[j]] = i + 1;\n        }\n    }\n    return ret;\n})(\n    [\n        [\"||\"],\n        [\"&&\"],\n        [\"|\"],\n        [\"^\"],\n        [\"&\"],\n        [\"==\", \"===\", \"!=\", \"!==\"],\n        [\"<\", \">\", \"<=\", \">=\", \"in\", \"instanceof\"],\n        [\">>\", \"<<\", \">>>\"],\n        [\"+\", \"-\"],\n        [\"*\", \"/\", \"%\"],\n        [\"**\"]\n    ],\n    {}\n);\n\nvar ATOMIC_START_TOKEN = makePredicate([ \"atom\", \"num\", \"string\", \"regexp\", \"name\" ]);\n\n/* -----[ Parser ]----- */\n\nfunction parse($TEXT, options) {\n\n    options = defaults(options, {\n        bare_returns   : false,\n        ecma           : 8,\n        expression     : false,\n        filename       : null,\n        html5_comments : true,\n        module         : false,\n        shebang        : true,\n        strict         : false,\n        toplevel       : null,\n    }, true);\n\n    var S = {\n        input         : (typeof $TEXT == \"string\"\n                         ? tokenizer($TEXT, options.filename,\n                                     options.html5_comments, options.shebang)\n                         : $TEXT),\n        token         : null,\n        prev          : null,\n        peeked        : null,\n        in_function   : 0,\n        in_async      : -1,\n        in_generator  : -1,\n        in_directives : true,\n        in_loop       : 0,\n        labels        : []\n    };\n\n    S.token = next();\n\n    function is(type, value) {\n        return is_token(S.token, type, value);\n    }\n\n    function peek() { return S.peeked || (S.peeked = S.input()); }\n\n    function next() {\n        S.prev = S.token;\n\n        if (!S.peeked) peek();\n        S.token = S.peeked;\n        S.peeked = null;\n        S.in_directives = S.in_directives && (\n            S.token.type == \"string\" || is(\"punc\", \";\")\n        );\n        return S.token;\n    }\n\n    function prev() {\n        return S.prev;\n    }\n\n    function croak(msg, line, col, pos) {\n        var ctx = S.input.context();\n        js_error(msg,\n                 ctx.filename,\n                 line != null ? line : ctx.tokline,\n                 col != null ? col : ctx.tokcol,\n                 pos != null ? pos : ctx.tokpos);\n    }\n\n    function token_error(token, msg) {\n        croak(msg, token.line, token.col);\n    }\n\n    function unexpected(token) {\n        if (token == null)\n            token = S.token;\n        token_error(token, \"Unexpected token: \" + token.type + \" (\" + token.value + \")\");\n    }\n\n    function expect_token(type, val) {\n        if (is(type, val)) {\n            return next();\n        }\n        token_error(S.token, \"Unexpected token \" + S.token.type + \" «\" + S.token.value + \"»\" + \", expected \" + type + \" «\" + val + \"»\");\n    }\n\n    function expect(punc) { return expect_token(\"punc\", punc); }\n\n    function has_newline_before(token) {\n        return token.nlb || !all(token.comments_before, function(comment) {\n            return !comment.nlb;\n        });\n    }\n\n    function can_insert_semicolon() {\n        return !options.strict\n            && (is(\"eof\") || is(\"punc\", \"}\") || has_newline_before(S.token));\n    }\n\n    function is_in_generator() {\n        return S.in_generator === S.in_function;\n    }\n\n    function is_in_async() {\n        return S.in_async === S.in_function;\n    }\n\n    function semicolon(optional) {\n        if (is(\"punc\", \";\")) next();\n        else if (!optional && !can_insert_semicolon()) unexpected();\n    }\n\n    function parenthesised() {\n        expect(\"(\");\n        var exp = expression(true);\n        expect(\")\");\n        return exp;\n    }\n\n    function embed_tokens(parser) {\n        return function() {\n            var start = S.token;\n            var expr = parser.apply(null, arguments);\n            var end = prev();\n            expr.start = start;\n            expr.end = end;\n            return expr;\n        };\n    }\n\n    function handle_regexp() {\n        if (is(\"operator\", \"/\") || is(\"operator\", \"/=\")) {\n            S.peeked = null;\n            S.token = S.input(S.token.value.substr(1)); // force regexp\n        }\n    }\n\n    var statement = embed_tokens(function(is_export_default, is_for_body, is_if_body) {\n        handle_regexp();\n        switch (S.token.type) {\n          case \"string\":\n            if (S.in_directives) {\n                var token = peek();\n                if (!S.token.raw.includes(\"\\\\\")\n                    && (is_token(token, \"punc\", \";\")\n                        || is_token(token, \"punc\", \"}\")\n                        || has_newline_before(token)\n                        || is_token(token, \"eof\"))) {\n                    S.input.add_directive(S.token.value);\n                } else {\n                    S.in_directives = false;\n                }\n            }\n            var dir = S.in_directives, stat = simple_statement();\n            return dir && stat.body instanceof AST_String ? new AST_Directive(stat.body) : stat;\n          case \"template_head\":\n          case \"num\":\n          case \"regexp\":\n          case \"operator\":\n          case \"atom\":\n            return simple_statement();\n\n          case \"name\":\n            if (S.token.value == \"async\" && is_token(peek(), \"keyword\", \"function\")) {\n                next();\n                next();\n                if (is_for_body) {\n                    croak(\"functions are not allowed as the body of a loop\");\n                }\n                return function_(AST_Defun, false, true, is_export_default);\n            }\n            if (S.token.value == \"import\" && !is_token(peek(), \"punc\", \"(\")) {\n                next();\n                var node = import_();\n                semicolon();\n                return node;\n            }\n            return is_token(peek(), \"punc\", \":\")\n                ? labeled_statement()\n                : simple_statement();\n\n          case \"punc\":\n            switch (S.token.value) {\n              case \"{\":\n                return new AST_BlockStatement({\n                    start : S.token,\n                    body  : block_(),\n                    end   : prev()\n                });\n              case \"[\":\n              case \"(\":\n                return simple_statement();\n              case \";\":\n                S.in_directives = false;\n                next();\n                return new AST_EmptyStatement();\n              default:\n                unexpected();\n            }\n\n          case \"keyword\":\n            switch (S.token.value) {\n              case \"break\":\n                next();\n                return break_cont(AST_Break);\n\n              case \"continue\":\n                next();\n                return break_cont(AST_Continue);\n\n              case \"debugger\":\n                next();\n                semicolon();\n                return new AST_Debugger();\n\n              case \"do\":\n                next();\n                var body = in_loop(statement);\n                expect_token(\"keyword\", \"while\");\n                var condition = parenthesised();\n                semicolon(true);\n                return new AST_Do({\n                    body      : body,\n                    condition : condition\n                });\n\n              case \"while\":\n                next();\n                return new AST_While({\n                    condition : parenthesised(),\n                    body      : in_loop(function() { return statement(false, true); })\n                });\n\n              case \"for\":\n                next();\n                return for_();\n\n              case \"class\":\n                next();\n                if (is_for_body) {\n                    croak(\"classes are not allowed as the body of a loop\");\n                }\n                if (is_if_body) {\n                    croak(\"classes are not allowed as the body of an if\");\n                }\n                return class_(AST_DefClass);\n\n              case \"function\":\n                next();\n                if (is_for_body) {\n                    croak(\"functions are not allowed as the body of a loop\");\n                }\n                return function_(AST_Defun, false, false, is_export_default);\n\n              case \"if\":\n                next();\n                return if_();\n\n              case \"return\":\n                if (S.in_function == 0 && !options.bare_returns)\n                    croak(\"'return' outside of function\");\n                next();\n                var value = null;\n                if (is(\"punc\", \";\")) {\n                    next();\n                } else if (!can_insert_semicolon()) {\n                    value = expression(true);\n                    semicolon();\n                }\n                return new AST_Return({\n                    value: value\n                });\n\n              case \"switch\":\n                next();\n                return new AST_Switch({\n                    expression : parenthesised(),\n                    body       : in_loop(switch_body_)\n                });\n\n              case \"throw\":\n                next();\n                if (has_newline_before(S.token))\n                    croak(\"Illegal newline after 'throw'\");\n                var value = expression(true);\n                semicolon();\n                return new AST_Throw({\n                    value: value\n                });\n\n              case \"try\":\n                next();\n                return try_();\n\n              case \"var\":\n                next();\n                var node = var_();\n                semicolon();\n                return node;\n\n              case \"let\":\n                next();\n                var node = let_();\n                semicolon();\n                return node;\n\n              case \"const\":\n                next();\n                var node = const_();\n                semicolon();\n                return node;\n\n              case \"with\":\n                if (S.input.has_directive(\"use strict\")) {\n                    croak(\"Strict mode may not include a with statement\");\n                }\n                next();\n                return new AST_With({\n                    expression : parenthesised(),\n                    body       : statement()\n                });\n\n              case \"export\":\n                if (!is_token(peek(), \"punc\", \"(\")) {\n                    next();\n                    var node = export_();\n                    if (is(\"punc\", \";\")) semicolon();\n                    return node;\n                }\n            }\n        }\n        unexpected();\n    });\n\n    function labeled_statement() {\n        var label = as_symbol(AST_Label);\n        if (label.name === \"await\" && is_in_async()) {\n            token_error(S.prev, \"await cannot be used as label inside async function\");\n        }\n        if (find_if(function(l) { return l.name == label.name; }, S.labels)) {\n            // ECMA-262, 12.12: An ECMAScript program is considered\n            // syntactically incorrect if it contains a\n            // LabelledStatement that is enclosed by a\n            // LabelledStatement with the same Identifier as label.\n            croak(\"Label \" + label.name + \" defined twice\");\n        }\n        expect(\":\");\n        S.labels.push(label);\n        var stat = statement();\n        S.labels.pop();\n        if (!(stat instanceof AST_IterationStatement)) {\n            // check for `continue` that refers to this label.\n            // those should be reported as syntax errors.\n            // https://github.com/mishoo/UglifyJS2/issues/287\n            label.references.forEach(function(ref) {\n                if (ref instanceof AST_Continue) {\n                    ref = ref.label.start;\n                    croak(\"Continue label `\" + label.name + \"` refers to non-IterationStatement.\",\n                          ref.line, ref.col, ref.pos);\n                }\n            });\n        }\n        return new AST_LabeledStatement({ body: stat, label: label });\n    }\n\n    function simple_statement(tmp) {\n        return new AST_SimpleStatement({ body: (tmp = expression(true), semicolon(), tmp) });\n    }\n\n    function break_cont(type) {\n        var label = null, ldef;\n        if (!can_insert_semicolon()) {\n            label = as_symbol(AST_LabelRef, true);\n        }\n        if (label != null) {\n            ldef = find_if(function(l) { return l.name == label.name; }, S.labels);\n            if (!ldef)\n                croak(\"Undefined label \" + label.name);\n            label.thedef = ldef;\n        } else if (S.in_loop == 0)\n            croak(type.TYPE + \" not inside a loop or switch\");\n        semicolon();\n        var stat = new type({ label: label });\n        if (ldef) ldef.references.push(stat);\n        return stat;\n    }\n\n    function for_() {\n        var for_await_error = \"`for await` invalid in this context\";\n        var await_tok = S.token;\n        if (await_tok.type == \"name\" && await_tok.value == \"await\") {\n            if (!is_in_async()) {\n                token_error(await_tok, for_await_error);\n            }\n            next();\n        } else {\n            await_tok = false;\n        }\n        expect(\"(\");\n        var init = null;\n        if (!is(\"punc\", \";\")) {\n            init =\n                is(\"keyword\", \"var\") ? (next(), var_(true)) :\n                is(\"keyword\", \"let\") ? (next(), let_(true)) :\n                is(\"keyword\", \"const\") ? (next(), const_(true)) :\n                                       expression(true, true);\n            var is_in = is(\"operator\", \"in\");\n            var is_of = is(\"name\", \"of\");\n            if (await_tok && !is_of) {\n                token_error(await_tok, for_await_error);\n            }\n            if (is_in || is_of) {\n                if (init instanceof AST_Definitions) {\n                    if (init.definitions.length > 1)\n                        token_error(init.start, \"Only one variable declaration allowed in for..in loop\");\n                } else if (!(is_assignable(init) || (init = to_destructuring(init)) instanceof AST_Destructuring)) {\n                    token_error(init.start, \"Invalid left-hand side in for..in loop\");\n                }\n                next();\n                if (is_in) {\n                    return for_in(init);\n                } else {\n                    return for_of(init, !!await_tok);\n                }\n            }\n        } else if (await_tok) {\n            token_error(await_tok, for_await_error);\n        }\n        return regular_for(init);\n    }\n\n    function regular_for(init) {\n        expect(\";\");\n        var test = is(\"punc\", \";\") ? null : expression(true);\n        expect(\";\");\n        var step = is(\"punc\", \")\") ? null : expression(true);\n        expect(\")\");\n        return new AST_For({\n            init      : init,\n            condition : test,\n            step      : step,\n            body      : in_loop(function() { return statement(false, true); })\n        });\n    }\n\n    function for_of(init, is_await) {\n        var lhs = init instanceof AST_Definitions ? init.definitions[0].name : null;\n        var obj = expression(true);\n        expect(\")\");\n        return new AST_ForOf({\n            await  : is_await,\n            init   : init,\n            name   : lhs,\n            object : obj,\n            body   : in_loop(function() { return statement(false, true); })\n        });\n    }\n\n    function for_in(init) {\n        var obj = expression(true);\n        expect(\")\");\n        return new AST_ForIn({\n            init   : init,\n            object : obj,\n            body   : in_loop(function() { return statement(false, true); })\n        });\n    }\n\n    var arrow_function = function(start, argnames, is_async) {\n        if (has_newline_before(S.token)) {\n            croak(\"Unexpected newline before arrow (=>)\");\n        }\n\n        expect_token(\"arrow\", \"=>\");\n\n        var body = _function_body(is(\"punc\", \"{\"), false, is_async);\n\n        var end =\n            body instanceof Array && body.length ? body[body.length - 1].end :\n            body instanceof Array ? start :\n                body.end;\n\n        return new AST_Arrow({\n            start    : start,\n            end      : end,\n            async    : is_async,\n            argnames : argnames,\n            body     : body\n        });\n    };\n\n    var function_ = function(ctor, is_generator_property, is_async, is_export_default) {\n        var start = S.token;\n\n        var in_statement = ctor === AST_Defun;\n        var is_generator = is(\"operator\", \"*\");\n        if (is_generator) {\n            next();\n        }\n\n        var name = is(\"name\") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;\n        if (in_statement && !name) {\n            if (is_export_default) {\n                ctor = AST_Function;\n            } else {\n                unexpected();\n            }\n        }\n\n        if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))\n            unexpected(prev());\n\n        var args = [];\n        var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);\n        return new ctor({\n            start : args.start,\n            end   : body.end,\n            is_generator: is_generator,\n            async : is_async,\n            name  : name,\n            argnames: args,\n            body  : body\n        });\n    };\n\n    function track_used_binding_identifiers(is_parameter, strict) {\n        var parameters = {};\n        var duplicate = false;\n        var default_assignment = false;\n        var spread = false;\n        var strict_mode = !!strict;\n        var tracker = {\n            add_parameter: function(token) {\n                if (parameters[\"$\" + token.value] !== undefined) {\n                    if (duplicate === false) {\n                        duplicate = token;\n                    }\n                    tracker.check_strict();\n                } else {\n                    parameters[\"$\" + token.value] = true;\n                    if (is_parameter) {\n                        switch (token.value) {\n                          case \"arguments\":\n                          case \"eval\":\n                          case \"yield\":\n                            if (strict_mode) {\n                                token_error(token, \"Unexpected \" + token.value + \" identifier as parameter inside strict mode\");\n                            }\n                            break;\n                          default:\n                            if (RESERVED_WORDS(token.value)) {\n                                unexpected();\n                            }\n                        }\n                    }\n                }\n            },\n            mark_default_assignment: function(token) {\n                if (default_assignment === false) {\n                    default_assignment = token;\n                }\n            },\n            mark_spread: function(token) {\n                if (spread === false) {\n                    spread = token;\n                }\n            },\n            mark_strict_mode: function() {\n                strict_mode = true;\n            },\n            is_strict: function() {\n                return default_assignment !== false || spread !== false || strict_mode;\n            },\n            check_strict: function() {\n                if (tracker.is_strict() && duplicate !== false) {\n                    token_error(duplicate, \"Parameter \" + duplicate.value + \" was used already\");\n                }\n            }\n        };\n\n        return tracker;\n    }\n\n    function parameters(params) {\n        var start = S.token;\n        var used_parameters = track_used_binding_identifiers(true, S.input.has_directive(\"use strict\"));\n\n        expect(\"(\");\n\n        while (!is(\"punc\", \")\")) {\n            var param = parameter(used_parameters);\n            params.push(param);\n\n            if (!is(\"punc\", \")\")) {\n                expect(\",\");\n                if (is(\"punc\", \")\") && options.ecma < 8) unexpected();\n            }\n\n            if (param instanceof AST_Expansion) {\n                break;\n            }\n        }\n\n        next();\n    }\n\n    function parameter(used_parameters, symbol_type) {\n        var param;\n        var expand = false;\n        if (used_parameters === undefined) {\n            used_parameters = track_used_binding_identifiers(true, S.input.has_directive(\"use strict\"));\n        }\n        if (is(\"expand\", \"...\")) {\n            expand = S.token;\n            used_parameters.mark_spread(S.token);\n            next();\n        }\n        param = binding_element(used_parameters, symbol_type);\n\n        if (is(\"operator\", \"=\") && expand === false) {\n            used_parameters.mark_default_assignment(S.token);\n            next();\n            param = new AST_DefaultAssign({\n                start: param.start,\n                left: param,\n                operator: \"=\",\n                right: expression(false),\n                end: S.token\n            });\n        }\n\n        if (expand !== false) {\n            if (!is(\"punc\", \")\")) {\n                unexpected();\n            }\n            param = new AST_Expansion({\n                start: expand,\n                expression: param,\n                end: expand\n            });\n        }\n        used_parameters.check_strict();\n\n        return param;\n    }\n\n    function binding_element(used_parameters, symbol_type) {\n        var elements = [];\n        var first = true;\n        var is_expand = false;\n        var expand_token;\n        var first_token = S.token;\n        if (used_parameters === undefined) {\n            used_parameters = track_used_binding_identifiers(false, S.input.has_directive(\"use strict\"));\n        }\n        symbol_type = symbol_type === undefined ? AST_SymbolFunarg : symbol_type;\n        if (is(\"punc\", \"[\")) {\n            next();\n            while (!is(\"punc\", \"]\")) {\n                if (first) {\n                    first = false;\n                } else {\n                    expect(\",\");\n                }\n\n                if (is(\"expand\", \"...\")) {\n                    is_expand = true;\n                    expand_token = S.token;\n                    used_parameters.mark_spread(S.token);\n                    next();\n                }\n                if (is(\"punc\")) {\n                    switch (S.token.value) {\n                      case \",\":\n                        elements.push(new AST_Hole({\n                            start: S.token,\n                            end: S.token\n                        }));\n                        continue;\n                      case \"]\": // Trailing comma after last element\n                        break;\n                      case \"[\":\n                      case \"{\":\n                        elements.push(binding_element(used_parameters, symbol_type));\n                        break;\n                      default:\n                        unexpected();\n                    }\n                } else if (is(\"name\")) {\n                    used_parameters.add_parameter(S.token);\n                    elements.push(as_symbol(symbol_type));\n                } else {\n                    croak(\"Invalid function parameter\");\n                }\n                if (is(\"operator\", \"=\") && is_expand === false) {\n                    used_parameters.mark_default_assignment(S.token);\n                    next();\n                    elements[elements.length - 1] = new AST_DefaultAssign({\n                        start: elements[elements.length - 1].start,\n                        left: elements[elements.length - 1],\n                        operator: \"=\",\n                        right: expression(false),\n                        end: S.token\n                    });\n                }\n                if (is_expand) {\n                    if (!is(\"punc\", \"]\")) {\n                        croak(\"Rest element must be last element\");\n                    }\n                    elements[elements.length - 1] = new AST_Expansion({\n                        start: expand_token,\n                        expression: elements[elements.length - 1],\n                        end: expand_token\n                    });\n                }\n            }\n            expect(\"]\");\n            used_parameters.check_strict();\n            return new AST_Destructuring({\n                start: first_token,\n                names: elements,\n                is_array: true,\n                end: prev()\n            });\n        } else if (is(\"punc\", \"{\")) {\n            next();\n            while (!is(\"punc\", \"}\")) {\n                if (first) {\n                    first = false;\n                } else {\n                    expect(\",\");\n                }\n                if (is(\"expand\", \"...\")) {\n                    is_expand = true;\n                    expand_token = S.token;\n                    used_parameters.mark_spread(S.token);\n                    next();\n                }\n                if (is(\"name\") && (is_token(peek(), \"punc\") || is_token(peek(), \"operator\")) && [\",\", \"}\", \"=\"].includes(peek().value)) {\n                    used_parameters.add_parameter(S.token);\n                    var start = prev();\n                    var value = as_symbol(symbol_type);\n                    if (is_expand) {\n                        elements.push(new AST_Expansion({\n                            start: expand_token,\n                            expression: value,\n                            end: value.end,\n                        }));\n                    } else {\n                        elements.push(new AST_ObjectKeyVal({\n                            start: start,\n                            key: value.name,\n                            value: value,\n                            end: value.end,\n                        }));\n                    }\n                } else if (is(\"punc\", \"}\")) {\n                    continue; // Allow trailing hole\n                } else {\n                    var property_token = S.token;\n                    var property = as_property_name();\n                    if (property === null) {\n                        unexpected(prev());\n                    } else if (prev().type === \"name\" && !is(\"punc\", \":\")) {\n                        elements.push(new AST_ObjectKeyVal({\n                            start: prev(),\n                            key: property,\n                            value: new symbol_type({\n                                start: prev(),\n                                name: property,\n                                end: prev()\n                            }),\n                            end: prev()\n                        }));\n                    } else {\n                        expect(\":\");\n                        elements.push(new AST_ObjectKeyVal({\n                            start: property_token,\n                            quote: property_token.quote,\n                            key: property,\n                            value: binding_element(used_parameters, symbol_type),\n                            end: prev()\n                        }));\n                    }\n                }\n                if (is_expand) {\n                    if (!is(\"punc\", \"}\")) {\n                        croak(\"Rest element must be last element\");\n                    }\n                } else if (is(\"operator\", \"=\")) {\n                    used_parameters.mark_default_assignment(S.token);\n                    next();\n                    elements[elements.length - 1].value = new AST_DefaultAssign({\n                        start: elements[elements.length - 1].value.start,\n                        left: elements[elements.length - 1].value,\n                        operator: \"=\",\n                        right: expression(false),\n                        end: S.token\n                    });\n                }\n            }\n            expect(\"}\");\n            used_parameters.check_strict();\n            return new AST_Destructuring({\n                start: first_token,\n                names: elements,\n                is_array: false,\n                end: prev()\n            });\n        } else if (is(\"name\")) {\n            used_parameters.add_parameter(S.token);\n            return as_symbol(symbol_type);\n        } else {\n            croak(\"Invalid function parameter\");\n        }\n    }\n\n    function params_or_seq_(allow_arrows, maybe_sequence) {\n        var spread_token;\n        var invalid_sequence;\n        var trailing_comma;\n        var a = [];\n        expect(\"(\");\n        while (!is(\"punc\", \")\")) {\n            if (spread_token) unexpected(spread_token);\n            if (is(\"expand\", \"...\")) {\n                spread_token = S.token;\n                if (maybe_sequence) invalid_sequence = S.token;\n                next();\n                a.push(new AST_Expansion({\n                    start: prev(),\n                    expression: expression(),\n                    end: S.token,\n                }));\n            } else {\n                a.push(expression());\n            }\n            if (!is(\"punc\", \")\")) {\n                expect(\",\");\n                if (is(\"punc\", \")\")) {\n                    if (options.ecma < 8) unexpected();\n                    trailing_comma = prev();\n                    if (maybe_sequence) invalid_sequence = trailing_comma;\n                }\n            }\n        }\n        expect(\")\");\n        if (allow_arrows && is(\"arrow\", \"=>\")) {\n            if (spread_token && trailing_comma) unexpected(trailing_comma);\n        } else if (invalid_sequence) {\n            unexpected(invalid_sequence);\n        }\n        return a;\n    }\n\n    function _function_body(block, generator, is_async, name, args) {\n        var loop = S.in_loop;\n        var labels = S.labels;\n        var current_generator = S.in_generator;\n        var current_async = S.in_async;\n        ++S.in_function;\n        if (generator)\n            S.in_generator = S.in_function;\n        if (is_async)\n            S.in_async = S.in_function;\n        if (args) parameters(args);\n        if (block)\n            S.in_directives = true;\n        S.in_loop = 0;\n        S.labels = [];\n        if (block) {\n            S.input.push_directives_stack();\n            var a = block_();\n            if (name) _verify_symbol(name);\n            if (args) args.forEach(_verify_symbol);\n            S.input.pop_directives_stack();\n        } else {\n            var a = expression(false);\n        }\n        --S.in_function;\n        S.in_loop = loop;\n        S.labels = labels;\n        S.in_generator = current_generator;\n        S.in_async = current_async;\n        return a;\n    }\n\n    function _await_expression() {\n        // Previous token must be \"await\" and not be interpreted as an identifier\n        if (!is_in_async()) {\n            croak(\"Unexpected await expression outside async function\",\n                S.prev.line, S.prev.col, S.prev.pos);\n        }\n        // the await expression is parsed as a unary expression in Babel\n        return new AST_Await({\n            start: prev(),\n            end: S.token,\n            expression : maybe_unary(true),\n        });\n    }\n\n    function _yield_expression() {\n        // Previous token must be keyword yield and not be interpret as an identifier\n        if (!is_in_generator()) {\n            croak(\"Unexpected yield expression outside generator function\",\n                S.prev.line, S.prev.col, S.prev.pos);\n        }\n        var start = S.token;\n        var star = false;\n        var has_expression = true;\n\n        // Attempt to get expression or star (and then the mandatory expression)\n        // behind yield on the same line.\n        //\n        // If nothing follows on the same line of the yieldExpression,\n        // it should default to the value `undefined` for yield to return.\n        // In that case, the `undefined` stored as `null` in ast.\n        //\n        // Note 1: It isn't allowed for yield* to close without an expression\n        // Note 2: If there is a nlb between yield and star, it is interpret as\n        //         yield <explicit undefined> <inserted automatic semicolon> *\n        if (can_insert_semicolon() ||\n            (is(\"punc\") && PUNC_AFTER_EXPRESSION(S.token.value))) {\n            has_expression = false;\n\n        } else if (is(\"operator\", \"*\")) {\n            star = true;\n            next();\n        }\n\n        return new AST_Yield({\n            start      : start,\n            is_star    : star,\n            expression : has_expression ? expression() : null,\n            end        : prev()\n        });\n    }\n\n    function if_() {\n        var cond = parenthesised(), body = statement(false, false, true), belse = null;\n        if (is(\"keyword\", \"else\")) {\n            next();\n            belse = statement(false, false, true);\n        }\n        return new AST_If({\n            condition   : cond,\n            body        : body,\n            alternative : belse\n        });\n    }\n\n    function block_() {\n        expect(\"{\");\n        var a = [];\n        while (!is(\"punc\", \"}\")) {\n            if (is(\"eof\")) unexpected();\n            a.push(statement());\n        }\n        next();\n        return a;\n    }\n\n    function switch_body_() {\n        expect(\"{\");\n        var a = [], cur = null, branch = null, tmp;\n        while (!is(\"punc\", \"}\")) {\n            if (is(\"eof\")) unexpected();\n            if (is(\"keyword\", \"case\")) {\n                if (branch) branch.end = prev();\n                cur = [];\n                branch = new AST_Case({\n                    start      : (tmp = S.token, next(), tmp),\n                    expression : expression(true),\n                    body       : cur\n                });\n                a.push(branch);\n                expect(\":\");\n            } else if (is(\"keyword\", \"default\")) {\n                if (branch) branch.end = prev();\n                cur = [];\n                branch = new AST_Default({\n                    start : (tmp = S.token, next(), expect(\":\"), tmp),\n                    body  : cur\n                });\n                a.push(branch);\n            } else {\n                if (!cur) unexpected();\n                cur.push(statement());\n            }\n        }\n        if (branch) branch.end = prev();\n        next();\n        return a;\n    }\n\n    function try_() {\n        var body = block_(), bcatch = null, bfinally = null;\n        if (is(\"keyword\", \"catch\")) {\n            var start = S.token;\n            next();\n            if (is(\"punc\", \"{\")) {\n                var name = null;\n            } else {\n                expect(\"(\");\n                var name = parameter(undefined, AST_SymbolCatch);\n                expect(\")\");\n            }\n            bcatch = new AST_Catch({\n                start   : start,\n                argname : name,\n                body    : block_(),\n                end     : prev()\n            });\n        }\n        if (is(\"keyword\", \"finally\")) {\n            var start = S.token;\n            next();\n            bfinally = new AST_Finally({\n                start : start,\n                body  : block_(),\n                end   : prev()\n            });\n        }\n        if (!bcatch && !bfinally)\n            croak(\"Missing catch/finally blocks\");\n        return new AST_Try({\n            body     : body,\n            bcatch   : bcatch,\n            bfinally : bfinally\n        });\n    }\n\n    function vardefs(no_in, kind) {\n        var a = [];\n        var def;\n        for (;;) {\n            var sym_type =\n                kind === \"var\" ? AST_SymbolVar :\n                kind === \"const\" ? AST_SymbolConst :\n                kind === \"let\" ? AST_SymbolLet : null;\n            if (is(\"punc\", \"{\") || is(\"punc\", \"[\")) {\n                def = new AST_VarDef({\n                    start: S.token,\n                    name: binding_element(undefined ,sym_type),\n                    value: is(\"operator\", \"=\") ? (expect_token(\"operator\", \"=\"), expression(false, no_in)) : null,\n                    end: prev()\n                });\n            } else {\n                def = new AST_VarDef({\n                    start : S.token,\n                    name  : as_symbol(sym_type),\n                    value : is(\"operator\", \"=\")\n                        ? (next(), expression(false, no_in))\n                        : !no_in && kind === \"const\"\n                            ? croak(\"Missing initializer in const declaration\") : null,\n                    end   : prev()\n                });\n                if (def.name.name == \"import\") croak(\"Unexpected token: import\");\n            }\n            a.push(def);\n            if (!is(\"punc\", \",\"))\n                break;\n            next();\n        }\n        return a;\n    }\n\n    var var_ = function(no_in) {\n        return new AST_Var({\n            start       : prev(),\n            definitions : vardefs(no_in, \"var\"),\n            end         : prev()\n        });\n    };\n\n    var let_ = function(no_in) {\n        return new AST_Let({\n            start       : prev(),\n            definitions : vardefs(no_in, \"let\"),\n            end         : prev()\n        });\n    };\n\n    var const_ = function(no_in) {\n        return new AST_Const({\n            start       : prev(),\n            definitions : vardefs(no_in, \"const\"),\n            end         : prev()\n        });\n    };\n\n    var new_ = function(allow_calls) {\n        var start = S.token;\n        expect_token(\"operator\", \"new\");\n        if (is(\"punc\", \".\")) {\n            next();\n            expect_token(\"name\", \"target\");\n            return subscripts(new AST_NewTarget({\n                start : start,\n                end   : prev()\n            }), allow_calls);\n        }\n        var newexp = expr_atom(false), args;\n        if (is(\"punc\", \"(\")) {\n            next();\n            args = expr_list(\")\", options.ecma >= 8);\n        } else {\n            args = [];\n        }\n        var call = new AST_New({\n            start      : start,\n            expression : newexp,\n            args       : args,\n            end        : prev()\n        });\n        mark_pure(call);\n        return subscripts(call, allow_calls);\n    };\n\n    function as_atom_node() {\n        var tok = S.token, ret;\n        switch (tok.type) {\n          case \"name\":\n            ret = _make_symbol(AST_SymbolRef);\n            break;\n          case \"num\":\n            ret = new AST_Number({ start: tok, end: tok, value: tok.value });\n            break;\n          case \"string\":\n            ret = new AST_String({\n                start : tok,\n                end   : tok,\n                value : tok.value,\n                quote : tok.quote\n            });\n            break;\n          case \"regexp\":\n            ret = new AST_RegExp({ start: tok, end: tok, value: tok.value });\n            break;\n          case \"atom\":\n            switch (tok.value) {\n              case \"false\":\n                ret = new AST_False({ start: tok, end: tok });\n                break;\n              case \"true\":\n                ret = new AST_True({ start: tok, end: tok });\n                break;\n              case \"null\":\n                ret = new AST_Null({ start: tok, end: tok });\n                break;\n            }\n            break;\n        }\n        next();\n        return ret;\n    }\n\n    function to_fun_args(ex, _, __, default_seen_above) {\n        var insert_default = function(ex, default_value) {\n            if (default_value) {\n                return new AST_DefaultAssign({\n                    start: ex.start,\n                    left: ex,\n                    operator: \"=\",\n                    right: default_value,\n                    end: default_value.end\n                });\n            }\n            return ex;\n        };\n        if (ex instanceof AST_Object) {\n            return insert_default(new AST_Destructuring({\n                start: ex.start,\n                end: ex.end,\n                is_array: false,\n                names: ex.properties.map(to_fun_args)\n            }), default_seen_above);\n        } else if (ex instanceof AST_ObjectKeyVal) {\n            ex.value = to_fun_args(ex.value, 0, [ex.key]);\n            return insert_default(ex, default_seen_above);\n        } else if (ex instanceof AST_Hole) {\n            return ex;\n        } else if (ex instanceof AST_Destructuring) {\n            ex.names = ex.names.map(to_fun_args);\n            return insert_default(ex, default_seen_above);\n        } else if (ex instanceof AST_SymbolRef) {\n            return insert_default(new AST_SymbolFunarg({\n                name: ex.name,\n                start: ex.start,\n                end: ex.end\n            }), default_seen_above);\n        } else if (ex instanceof AST_Expansion) {\n            ex.expression = to_fun_args(ex.expression);\n            return insert_default(ex, default_seen_above);\n        } else if (ex instanceof AST_Array) {\n            return insert_default(new AST_Destructuring({\n                start: ex.start,\n                end: ex.end,\n                is_array: true,\n                names: ex.elements.map(to_fun_args)\n            }), default_seen_above);\n        } else if (ex instanceof AST_Assign) {\n            return insert_default(to_fun_args(ex.left, undefined, undefined, ex.right), default_seen_above);\n        } else if (ex instanceof AST_DefaultAssign) {\n            ex.left = to_fun_args(ex.left, 0, [ex.left]);\n            return ex;\n        } else {\n            croak(\"Invalid function parameter\", ex.start.line, ex.start.col);\n        }\n    }\n\n    var expr_atom = function(allow_calls, allow_arrows) {\n        if (is(\"operator\", \"new\")) {\n            return new_(allow_calls);\n        }\n        var start = S.token;\n        var peeked;\n        var async = is(\"name\", \"async\")\n            && (peeked = peek()).value != \"[\"\n            && peeked.type != \"arrow\"\n            && as_atom_node();\n        if (is(\"punc\")) {\n            switch (S.token.value) {\n              case \"(\":\n                if (async && !allow_calls) break;\n                var exprs = params_or_seq_(allow_arrows, !async);\n                if (allow_arrows && is(\"arrow\", \"=>\")) {\n                    return arrow_function(start, exprs.map(to_fun_args), !!async);\n                }\n                var ex = async ? new AST_Call({\n                    expression: async,\n                    args: exprs\n                }) : exprs.length == 1 ? exprs[0] : new AST_Sequence({\n                    expressions: exprs\n                });\n                if (ex.start) {\n                    var len = start.comments_before.length;\n                    [].unshift.apply(ex.start.comments_before, start.comments_before);\n                    start.comments_before = ex.start.comments_before;\n                    start.comments_before_length = len;\n                    if (len == 0 && start.comments_before.length > 0) {\n                        var comment = start.comments_before[0];\n                        if (!comment.nlb) {\n                            comment.nlb = start.nlb;\n                            start.nlb = false;\n                        }\n                    }\n                    start.comments_after = ex.start.comments_after;\n                }\n                ex.start = start;\n                var end = prev();\n                if (ex.end) {\n                    end.comments_before = ex.end.comments_before;\n                    [].push.apply(ex.end.comments_after, end.comments_after);\n                    end.comments_after = ex.end.comments_after;\n                }\n                ex.end = end;\n                if (ex instanceof AST_Call) mark_pure(ex);\n                return subscripts(ex, allow_calls);\n              case \"[\":\n                return subscripts(array_(), allow_calls);\n              case \"{\":\n                return subscripts(object_or_destructuring_(), allow_calls);\n            }\n            if (!async) unexpected();\n        }\n        if (allow_arrows && is(\"name\") && is_token(peek(), \"arrow\")) {\n            var param = new AST_SymbolFunarg({\n                name: S.token.value,\n                start: start,\n                end: start,\n            });\n            next();\n            return arrow_function(start, [param], !!async);\n        }\n        if (is(\"keyword\", \"function\")) {\n            next();\n            var func = function_(AST_Function, false, !!async);\n            func.start = start;\n            func.end = prev();\n            return subscripts(func, allow_calls);\n        }\n        if (async) return subscripts(async, allow_calls);\n        if (is(\"keyword\", \"class\")) {\n            next();\n            var cls = class_(AST_ClassExpression);\n            cls.start = start;\n            cls.end = prev();\n            return subscripts(cls, allow_calls);\n        }\n        if (is(\"template_head\")) {\n            return subscripts(template_string(false), allow_calls);\n        }\n        if (ATOMIC_START_TOKEN(S.token.type)) {\n            return subscripts(as_atom_node(), allow_calls);\n        }\n        unexpected();\n    };\n\n    function template_string(tagged) {\n        var segments = [], start = S.token;\n\n        segments.push(new AST_TemplateSegment({\n            start: S.token,\n            raw: S.token.raw,\n            value: S.token.value,\n            end: S.token\n        }));\n        while (S.token.end === false) {\n            next();\n            handle_regexp();\n            segments.push(expression(true));\n\n            if (!is_token(\"template_substitution\")) {\n                unexpected();\n            }\n\n            segments.push(new AST_TemplateSegment({\n                start: S.token,\n                raw: S.token.raw,\n                value: S.token.value,\n                end: S.token\n            }));\n        }\n        next();\n\n        return new AST_TemplateString({\n            start: start,\n            segments: segments,\n            end: S.token\n        });\n    }\n\n    function expr_list(closing, allow_trailing_comma, allow_empty) {\n        var first = true, a = [];\n        while (!is(\"punc\", closing)) {\n            if (first) first = false; else expect(\",\");\n            if (allow_trailing_comma && is(\"punc\", closing)) break;\n            if (is(\"punc\", \",\") && allow_empty) {\n                a.push(new AST_Hole({ start: S.token, end: S.token }));\n            } else if (is(\"expand\", \"...\")) {\n                next();\n                a.push(new AST_Expansion({start: prev(), expression: expression(),end: S.token}));\n            } else {\n                a.push(expression(false));\n            }\n        }\n        next();\n        return a;\n    }\n\n    var array_ = embed_tokens(function() {\n        expect(\"[\");\n        return new AST_Array({\n            elements: expr_list(\"]\", !options.strict, true)\n        });\n    });\n\n    var create_accessor = embed_tokens(function(is_generator, is_async) {\n        return function_(AST_Accessor, is_generator, is_async);\n    });\n\n    var object_or_destructuring_ = embed_tokens(function object_or_destructuring_() {\n        var start = S.token, first = true, a = [];\n        expect(\"{\");\n        while (!is(\"punc\", \"}\")) {\n            if (first) first = false; else expect(\",\");\n            if (!options.strict && is(\"punc\", \"}\"))\n                // allow trailing comma\n                break;\n\n            start = S.token;\n            if (start.type == \"expand\") {\n                next();\n                a.push(new AST_Expansion({\n                    start: start,\n                    expression: expression(false),\n                    end: prev(),\n                }));\n                continue;\n            }\n\n            var name = as_property_name();\n            var value;\n\n            // Check property and fetch value\n            if (!is(\"punc\", \":\")) {\n                var concise = concise_method_or_getset(name, start);\n                if (concise) {\n                    a.push(concise);\n                    continue;\n                }\n\n                value = new AST_SymbolRef({\n                    start: prev(),\n                    name: name,\n                    end: prev()\n                });\n            } else if (name === null) {\n                unexpected(prev());\n            } else {\n                next(); // `:` - see first condition\n                value = expression(false);\n            }\n\n            // Check for default value and alter value accordingly if necessary\n            if (is(\"operator\", \"=\")) {\n                next();\n                value = new AST_Assign({\n                    start: start,\n                    left: value,\n                    operator: \"=\",\n                    right: expression(false),\n                    end: prev()\n                });\n            }\n\n            // Create property\n            a.push(new AST_ObjectKeyVal({\n                start: start,\n                quote: start.quote,\n                key: name instanceof AST_Node ? name : \"\" + name,\n                value: value,\n                end: prev()\n            }));\n        }\n        next();\n        return new AST_Object({ properties: a });\n    });\n\n    function class_(KindOfClass) {\n        var start, method, class_name, extends_, a = [];\n\n        S.input.push_directives_stack(); // Push directive stack, but not scope stack\n        S.input.add_directive(\"use strict\");\n\n        if (S.token.type == \"name\" && S.token.value != \"extends\") {\n            class_name = as_symbol(KindOfClass === AST_DefClass ? AST_SymbolDefClass : AST_SymbolClass);\n        }\n\n        if (KindOfClass === AST_DefClass && !class_name) {\n            unexpected();\n        }\n\n        if (S.token.value == \"extends\") {\n            next();\n            extends_ = expression(true);\n        }\n\n        expect(\"{\");\n\n        if (is(\"punc\", \";\")) { next(); }  // Leading semicolons are okay in class bodies.\n        while (!is(\"punc\", \"}\")) {\n            start = S.token;\n            method = concise_method_or_getset(as_property_name(), start, true);\n            if (!method) { unexpected(); }\n            a.push(method);\n            if (is(\"punc\", \";\")) { next(); }\n        }\n\n        S.input.pop_directives_stack();\n\n        next();\n\n        return new KindOfClass({\n            start: start,\n            name: class_name,\n            extends: extends_,\n            properties: a,\n            end: prev(),\n        });\n    }\n\n    function concise_method_or_getset(name, start, is_class) {\n        var get_ast = function(name, token) {\n            if (typeof name === \"string\" || typeof name === \"number\") {\n                return new AST_SymbolMethod({\n                    start: token,\n                    name: \"\" + name,\n                    end: prev()\n                });\n            } else if (name === null) {\n                unexpected();\n            }\n            return name;\n        };\n        var is_async = false;\n        var is_static = false;\n        var is_generator = false;\n        var property_token = start;\n        if (is_class && name === \"static\" && !is(\"punc\", \"(\")) {\n            is_static = true;\n            property_token = S.token;\n            name = as_property_name();\n        }\n        if (name === \"async\" && !is(\"punc\", \"(\") && !is(\"punc\", \",\") && !is(\"punc\", \"}\")) {\n            is_async = true;\n            property_token = S.token;\n            name = as_property_name();\n        }\n        if (name === null) {\n            is_generator = true;\n            property_token = S.token;\n            name = as_property_name();\n            if (name === null) {\n                unexpected();\n            }\n        }\n        if (is(\"punc\", \"(\")) {\n            name = get_ast(name, start);\n            var node = new AST_ConciseMethod({\n                start       : start,\n                static      : is_static,\n                is_generator: is_generator,\n                async       : is_async,\n                key         : name,\n                quote       : name instanceof AST_SymbolMethod ?\n                              property_token.quote : undefined,\n                value       : create_accessor(is_generator, is_async),\n                end         : prev()\n            });\n            return node;\n        }\n        property_token = S.token;\n        if (name == \"get\") {\n            if (!is(\"punc\") || is(\"punc\", \"[\")) {\n                name = get_ast(as_property_name(), start);\n                return new AST_ObjectGetter({\n                    start : start,\n                    static: is_static,\n                    key   : name,\n                    quote : name instanceof AST_SymbolMethod ?\n                            property_token.quote : undefined,\n                    value : create_accessor(),\n                    end   : prev()\n                });\n            }\n        } else if (name == \"set\") {\n            if (!is(\"punc\") || is(\"punc\", \"[\")) {\n                name = get_ast(as_property_name(), start);\n                return new AST_ObjectSetter({\n                    start : start,\n                    static: is_static,\n                    key   : name,\n                    quote : name instanceof AST_SymbolMethod ?\n                            property_token.quote : undefined,\n                    value : create_accessor(),\n                    end   : prev()\n                });\n            }\n        }\n    }\n\n    function import_() {\n        var start = prev();\n        var imported_name;\n        var imported_names;\n        if (is(\"name\")) {\n            imported_name = as_symbol(AST_SymbolImport);\n        }\n\n        if (is(\"punc\", \",\")) {\n            next();\n        }\n\n        imported_names = map_names(true);\n\n        if (imported_names || imported_name) {\n            expect_token(\"name\", \"from\");\n        }\n        var mod_str = S.token;\n        if (mod_str.type !== \"string\") {\n            unexpected();\n        }\n        next();\n        return new AST_Import({\n            start: start,\n            imported_name: imported_name,\n            imported_names: imported_names,\n            module_name: new AST_String({\n                start: mod_str,\n                value: mod_str.value,\n                quote: mod_str.quote,\n                end: mod_str,\n            }),\n            end: S.token,\n        });\n    }\n\n    function map_name(is_import) {\n        function make_symbol(type) {\n            return new type({\n                name: as_property_name(),\n                start: prev(),\n                end: prev()\n            });\n        }\n\n        var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;\n        var type = is_import ? AST_SymbolImport : AST_SymbolExport;\n        var start = S.token;\n        var foreign_name;\n        var name;\n\n        if (is_import) {\n            foreign_name = make_symbol(foreign_type);\n        } else {\n            name = make_symbol(type);\n        }\n        if (is(\"name\", \"as\")) {\n            next();  // The \"as\" word\n            if (is_import) {\n                name = make_symbol(type);\n            } else {\n                foreign_name = make_symbol(foreign_type);\n            }\n        } else if (is_import) {\n            name = new type(foreign_name);\n        } else {\n            foreign_name = new foreign_type(name);\n        }\n\n        return new AST_NameMapping({\n            start: start,\n            foreign_name: foreign_name,\n            name: name,\n            end: prev(),\n        });\n    }\n\n    function map_nameAsterisk(is_import, name) {\n        var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;\n        var type = is_import ? AST_SymbolImport : AST_SymbolExport;\n        var start = S.token;\n        var foreign_name;\n        var end = prev();\n\n        name = name || new type({\n            name: \"*\",\n            start: start,\n            end: end,\n        });\n\n        foreign_name = new foreign_type({\n            name: \"*\",\n            start: start,\n            end: end,\n        });\n\n        return new AST_NameMapping({\n            start: start,\n            foreign_name: foreign_name,\n            name: name,\n            end: end,\n        });\n    }\n\n    function map_names(is_import) {\n        var names;\n        if (is(\"punc\", \"{\")) {\n            next();\n            names = [];\n            while (!is(\"punc\", \"}\")) {\n                names.push(map_name(is_import));\n                if (is(\"punc\", \",\")) {\n                    next();\n                }\n            }\n            next();\n        } else if (is(\"operator\", \"*\")) {\n            var name;\n            next();\n            if (is_import && is(\"name\", \"as\")) {\n                next();  // The \"as\" word\n                name = as_symbol(is_import ? AST_SymbolImport : AST_SymbolExportForeign);\n            }\n            names = [map_nameAsterisk(is_import, name)];\n        }\n        return names;\n    }\n\n    function export_() {\n        var start = S.token;\n        var is_default;\n        var exported_names;\n\n        if (is(\"keyword\", \"default\")) {\n            is_default = true;\n            next();\n        } else if (exported_names = map_names(false)) {\n            if (is(\"name\", \"from\")) {\n                next();\n\n                var mod_str = S.token;\n                if (mod_str.type !== \"string\") {\n                    unexpected();\n                }\n                next();\n\n                return new AST_Export({\n                    start: start,\n                    is_default: is_default,\n                    exported_names: exported_names,\n                    module_name: new AST_String({\n                        start: mod_str,\n                        value: mod_str.value,\n                        quote: mod_str.quote,\n                        end: mod_str,\n                    }),\n                    end: prev(),\n                });\n            } else {\n                return new AST_Export({\n                    start: start,\n                    is_default: is_default,\n                    exported_names: exported_names,\n                    end: prev(),\n                });\n            }\n        }\n\n        var node;\n        var exported_value;\n        var exported_definition;\n        if (is(\"punc\", \"{\")\n            || is_default\n                && (is(\"keyword\", \"class\") || is(\"keyword\", \"function\"))\n                && is_token(peek(), \"punc\")) {\n            exported_value = expression(false);\n            semicolon();\n        } else if ((node = statement(is_default)) instanceof AST_Definitions && is_default) {\n            unexpected(node.start);\n        } else if (node instanceof AST_Definitions || node instanceof AST_Lambda || node instanceof AST_DefClass) {\n            exported_definition = node;\n        } else if (node instanceof AST_SimpleStatement) {\n            exported_value = node.body;\n        } else {\n            unexpected(node.start);\n        }\n\n        return new AST_Export({\n            start: start,\n            is_default: is_default,\n            exported_value: exported_value,\n            exported_definition: exported_definition,\n            end: prev(),\n        });\n    }\n\n    function as_property_name() {\n        var tmp = S.token;\n        switch (tmp.type) {\n          case \"punc\":\n            if (tmp.value === \"[\") {\n                next();\n                var ex = expression(false);\n                expect(\"]\");\n                return ex;\n            } else unexpected(tmp);\n          case \"operator\":\n            if (tmp.value === \"*\") {\n                next();\n                return null;\n            }\n            if (![\"delete\", \"in\", \"instanceof\", \"new\", \"typeof\", \"void\"].includes(tmp.value)) {\n                unexpected(tmp);\n            }\n          case \"name\":\n            if (tmp.value == \"yield\") {\n                if (is_in_generator()) {\n                    token_error(tmp, \"Yield cannot be used as identifier inside generators\");\n                } else if (!is_token(peek(), \"punc\", \":\")\n                    && !is_token(peek(), \"punc\", \"(\")\n                    && S.input.has_directive(\"use strict\")) {\n                    token_error(tmp, \"Unexpected yield identifier inside strict mode\");\n                }\n            }\n          case \"string\":\n          case \"num\":\n          case \"keyword\":\n          case \"atom\":\n            next();\n            return tmp.value;\n          default:\n            unexpected(tmp);\n        }\n    }\n\n    function as_name() {\n        var tmp = S.token;\n        if (tmp.type != \"name\") unexpected();\n        next();\n        return tmp.value;\n    }\n\n    function _make_symbol(type) {\n        var name = S.token.value;\n        return new (name == \"this\" ? AST_This :\n                    name == \"super\" ? AST_Super :\n                    type)({\n            name  : String(name),\n            start : S.token,\n            end   : S.token\n        });\n    }\n\n    function _verify_symbol(sym) {\n        var name = sym.name;\n        if (is_in_generator() && name == \"yield\") {\n            token_error(sym.start, \"Yield cannot be used as identifier inside generators\");\n        }\n        if (S.input.has_directive(\"use strict\")) {\n            if (name == \"yield\") {\n                token_error(sym.start, \"Unexpected yield identifier inside strict mode\");\n            }\n            if (sym instanceof AST_SymbolDeclaration && (name == \"arguments\" || name == \"eval\")) {\n                token_error(sym.start, \"Unexpected \" + name + \" in strict mode\");\n            }\n        }\n    }\n\n    function as_symbol(type, noerror) {\n        if (!is(\"name\")) {\n            if (!noerror) croak(\"Name expected\");\n            return null;\n        }\n        var sym = _make_symbol(type);\n        _verify_symbol(sym);\n        next();\n        return sym;\n    }\n\n    function mark_pure(call) {\n        var start = call.start;\n        var comments = start.comments_before;\n        var i = HOP(start, \"comments_before_length\") ? start.comments_before_length : comments.length;\n        while (--i >= 0) {\n            var comment = comments[i];\n            if (/[@#]__PURE__/.test(comment.value)) {\n                call.pure = comment;\n                break;\n            }\n        }\n    }\n\n    var subscripts = function(expr, allow_calls) {\n        var start = expr.start;\n        if (is(\"punc\", \".\")) {\n            next();\n            return subscripts(new AST_Dot({\n                start      : start,\n                expression : expr,\n                property   : as_name(),\n                end        : prev()\n            }), allow_calls);\n        }\n        if (is(\"punc\", \"[\")) {\n            next();\n            var prop = expression(true);\n            expect(\"]\");\n            return subscripts(new AST_Sub({\n                start      : start,\n                expression : expr,\n                property   : prop,\n                end        : prev()\n            }), allow_calls);\n        }\n        if (allow_calls && is(\"punc\", \"(\")) {\n            next();\n            var call = new AST_Call({\n                start      : start,\n                expression : expr,\n                args       : call_args(),\n                end        : prev()\n            });\n            mark_pure(call);\n            return subscripts(call, true);\n        }\n        if (is(\"template_head\")) {\n            return subscripts(new AST_PrefixedTemplateString({\n                start: start,\n                prefix: expr,\n                template_string: template_string(true),\n                end: prev()\n            }), allow_calls);\n        }\n        return expr;\n    };\n\n    var call_args = embed_tokens(function _call_args() {\n        var args = [];\n        while (!is(\"punc\", \")\")) {\n            if (is(\"expand\", \"...\")) {\n                next();\n                args.push(new AST_Expansion({\n                    start: prev(),\n                    expression: expression(false),\n                    end: prev()\n                }));\n            } else {\n                args.push(expression(false));\n            }\n            if (!is(\"punc\", \")\")) {\n                expect(\",\");\n                if (is(\"punc\", \")\") && options.ecma < 8) unexpected();\n            }\n        }\n        next();\n        return args;\n    });\n\n    var maybe_unary = function(allow_calls, allow_arrows) {\n        var start = S.token;\n        if (start.type == \"name\" && start.value == \"await\") {\n            if (is_in_async()) {\n                next();\n                return _await_expression();\n            } else if (S.input.has_directive(\"use strict\")) {\n                token_error(S.token, \"Unexpected await identifier inside strict mode\");\n            }\n        }\n        if (is(\"operator\") && UNARY_PREFIX(start.value)) {\n            next();\n            handle_regexp();\n            var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(allow_calls));\n            ex.start = start;\n            ex.end = prev();\n            return ex;\n        }\n        var val = expr_atom(allow_calls, allow_arrows);\n        while (is(\"operator\") && UNARY_POSTFIX(S.token.value) && !has_newline_before(S.token)) {\n            if (val instanceof AST_Arrow) unexpected();\n            val = make_unary(AST_UnaryPostfix, S.token, val);\n            val.start = start;\n            val.end = S.token;\n            next();\n        }\n        return val;\n    };\n\n    function make_unary(ctor, token, expr) {\n        var op = token.value;\n        switch (op) {\n          case \"++\":\n          case \"--\":\n            if (!is_assignable(expr))\n                croak(\"Invalid use of \" + op + \" operator\", token.line, token.col, token.pos);\n            break;\n          case \"delete\":\n            if (expr instanceof AST_SymbolRef && S.input.has_directive(\"use strict\"))\n                croak(\"Calling delete on expression not allowed in strict mode\", expr.start.line, expr.start.col, expr.start.pos);\n            break;\n        }\n        return new ctor({ operator: op, expression: expr });\n    }\n\n    var expr_op = function(left, min_prec, no_in) {\n        var op = is(\"operator\") ? S.token.value : null;\n        if (op == \"in\" && no_in) op = null;\n        if (op == \"**\" && left instanceof AST_UnaryPrefix\n            /* unary token in front not allowed - parenthesis required */\n            && !is_token(left.start, \"punc\", \"(\")\n            && left.operator !== \"--\" && left.operator !== \"++\")\n                unexpected(left.start);\n        var prec = op != null ? PRECEDENCE[op] : null;\n        if (prec != null && (prec > min_prec || (op === \"**\" && min_prec === prec))) {\n            next();\n            var right = expr_op(maybe_unary(true), prec, no_in);\n            return expr_op(new AST_Binary({\n                start    : left.start,\n                left     : left,\n                operator : op,\n                right    : right,\n                end      : right.end\n            }), min_prec, no_in);\n        }\n        return left;\n    };\n\n    function expr_ops(no_in) {\n        return expr_op(maybe_unary(true, true), 0, no_in);\n    }\n\n    var maybe_conditional = function(no_in) {\n        var start = S.token;\n        var expr = expr_ops(no_in);\n        if (is(\"operator\", \"?\")) {\n            next();\n            var yes = expression(false);\n            expect(\":\");\n            return new AST_Conditional({\n                start       : start,\n                condition   : expr,\n                consequent  : yes,\n                alternative : expression(false, no_in),\n                end         : prev()\n            });\n        }\n        return expr;\n    };\n\n    function is_assignable(expr) {\n        return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;\n    }\n\n    function to_destructuring(node) {\n        if (node instanceof AST_Object) {\n            node = new AST_Destructuring({\n                start: node.start,\n                names: node.properties.map(to_destructuring),\n                is_array: false,\n                end: node.end\n            });\n        } else if (node instanceof AST_Array) {\n            var names = [];\n\n            for (var i = 0; i < node.elements.length; i++) {\n                // Only allow expansion as last element\n                if (node.elements[i] instanceof AST_Expansion) {\n                    if (i + 1 !== node.elements.length) {\n                        token_error(node.elements[i].start, \"Spread must the be last element in destructuring array\");\n                    }\n                    node.elements[i].expression = to_destructuring(node.elements[i].expression);\n                }\n\n                names.push(to_destructuring(node.elements[i]));\n            }\n\n            node = new AST_Destructuring({\n                start: node.start,\n                names: names,\n                is_array: true,\n                end: node.end\n            });\n        } else if (node instanceof AST_ObjectProperty) {\n            node.value = to_destructuring(node.value);\n        } else if (node instanceof AST_Assign) {\n            node = new AST_DefaultAssign({\n                start: node.start,\n                left: node.left,\n                operator: \"=\",\n                right: node.right,\n                end: node.end\n            });\n        }\n        return node;\n    }\n\n    // In ES6, AssignmentExpression can also be an ArrowFunction\n    var maybe_assign = function(no_in) {\n        handle_regexp();\n        var start = S.token;\n\n        if (start.type == \"name\" && start.value == \"yield\") {\n            if (is_in_generator()) {\n                next();\n                return _yield_expression();\n            } else if (S.input.has_directive(\"use strict\")) {\n                token_error(S.token, \"Unexpected yield identifier inside strict mode\");\n            }\n        }\n\n        var left = maybe_conditional(no_in);\n        var val = S.token.value;\n\n        if (is(\"operator\") && ASSIGNMENT(val)) {\n            if (is_assignable(left) || (left = to_destructuring(left)) instanceof AST_Destructuring) {\n                next();\n                return new AST_Assign({\n                    start    : start,\n                    left     : left,\n                    operator : val,\n                    right    : maybe_assign(no_in),\n                    end      : prev()\n                });\n            }\n            croak(\"Invalid assignment\");\n        }\n        return left;\n    };\n\n    var expression = function(commas, no_in) {\n        var start = S.token;\n        var exprs = [];\n        while (true) {\n            exprs.push(maybe_assign(no_in));\n            if (!commas || !is(\"punc\", \",\")) break;\n            next();\n            commas = true;\n        }\n        return exprs.length == 1 ? exprs[0] : new AST_Sequence({\n            start       : start,\n            expressions : exprs,\n            end         : peek()\n        });\n    };\n\n    function in_loop(cont) {\n        ++S.in_loop;\n        var ret = cont();\n        --S.in_loop;\n        return ret;\n    }\n\n    if (options.expression) {\n        return expression(true);\n    }\n\n    return (function() {\n        var start = S.token;\n        var body = [];\n        S.input.push_directives_stack();\n        if (options.module) S.input.add_directive(\"use strict\");\n        while (!is(\"eof\"))\n            body.push(statement());\n        S.input.pop_directives_stack();\n        var end = prev();\n        var toplevel = options.toplevel;\n        if (toplevel) {\n            toplevel.body = toplevel.body.concat(body);\n            toplevel.end = end;\n        } else {\n            toplevel = new AST_Toplevel({ start: start, body: body, end: end });\n        }\n        return toplevel;\n    })();\n\n}\n\nexport {\n    get_full_char_code,\n    get_full_char,\n    is_identifier_char,\n    is_identifier_string,\n    is_identifier,\n    is_surrogate_pair_head,\n    is_surrogate_pair_tail,\n    js_error,\n    JS_Parse_Error,\n    parse,\n    PRECEDENCE,\n    RESERVED_WORDS,\n    tokenizer,\n};\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    HOP,\n    MAP,\n    noop,\n    string_template,\n} from \"./utils.js\";\nimport { parse } from \"./parse.js\";\n\nfunction DEFNODE(type, props, methods, base) {\n    if (arguments.length < 4) base = AST_Node;\n    if (!props) props = [];\n    else props = props.split(/\\s+/);\n    var self_props = props;\n    if (base && base.PROPS)\n        props = props.concat(base.PROPS);\n    var code = \"return function AST_\" + type + \"(props){ if (props) { \";\n    for (var i = props.length; --i >= 0;) {\n        code += \"this.\" + props[i] + \" = props.\" + props[i] + \";\";\n    }\n    var proto = base && new base;\n    if (proto && proto.initialize || (methods && methods.initialize))\n        code += \"this.initialize();\";\n    code += \"}}\";\n    var ctor = new Function(code)();\n    if (proto) {\n        ctor.prototype = proto;\n        ctor.BASE = base;\n    }\n    if (base) base.SUBCLASSES.push(ctor);\n    ctor.prototype.CTOR = ctor;\n    ctor.PROPS = props || null;\n    ctor.SELF_PROPS = self_props;\n    ctor.SUBCLASSES = [];\n    if (type) {\n        ctor.prototype.TYPE = ctor.TYPE = type;\n    }\n    if (methods) for (i in methods) if (HOP(methods, i)) {\n        if (/^\\$/.test(i)) {\n            ctor[i.substr(1)] = methods[i];\n        } else {\n            ctor.prototype[i] = methods[i];\n        }\n    }\n    ctor.DEFMETHOD = function(name, method) {\n        this.prototype[name] = method;\n    };\n    return ctor;\n}\n\nvar AST_Token = DEFNODE(\"Token\", \"type value line col pos endline endcol endpos nlb comments_before comments_after file raw\", {\n}, null);\n\nvar AST_Node = DEFNODE(\"Node\", \"start end\", {\n    _clone: function(deep) {\n        if (deep) {\n            var self = this.clone();\n            return self.transform(new TreeTransformer(function(node) {\n                if (node !== self) {\n                    return node.clone(true);\n                }\n            }));\n        }\n        return new this.CTOR(this);\n    },\n    clone: function(deep) {\n        return this._clone(deep);\n    },\n    $documentation: \"Base class of all AST nodes\",\n    $propdoc: {\n        start: \"[AST_Token] The first token of this node\",\n        end: \"[AST_Token] The last token of this node\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this);\n    },\n    walk: function(visitor) {\n        return this._walk(visitor); // not sure the indirection will be any help\n    }\n}, null);\n\nAST_Node.warn_function = null;\nAST_Node.warn = function(txt, props) {\n    if (AST_Node.warn_function)\n        AST_Node.warn_function(string_template(txt, props));\n};\n\n/* -----[ statements ]----- */\n\nvar AST_Statement = DEFNODE(\"Statement\", null, {\n    $documentation: \"Base class of all statements\",\n});\n\nvar AST_Debugger = DEFNODE(\"Debugger\", null, {\n    $documentation: \"Represents a debugger statement\",\n}, AST_Statement);\n\nvar AST_Directive = DEFNODE(\"Directive\", \"value quote\", {\n    $documentation: \"Represents a directive, like \\\"use strict\\\";\",\n    $propdoc: {\n        value: \"[string] The value of this directive as a plain string (it's not an AST_String!)\",\n        quote: \"[string] the original quote character\"\n    },\n}, AST_Statement);\n\nvar AST_SimpleStatement = DEFNODE(\"SimpleStatement\", \"body\", {\n    $documentation: \"A statement consisting of an expression, i.e. a = 1 + 2\",\n    $propdoc: {\n        body: \"[AST_Node] an expression node (should not be instanceof AST_Statement)\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.body._walk(visitor);\n        });\n    }\n}, AST_Statement);\n\nfunction walk_body(node, visitor) {\n    var body = node.body;\n    if (body instanceof AST_Node) {\n        body._walk(visitor);\n    } else for (var i = 0, len = body.length; i < len; i++) {\n        body[i]._walk(visitor);\n    }\n}\n\nfunction clone_block_scope(deep) {\n    var clone = this._clone(deep);\n    if (this.block_scope) {\n        // TODO this is sometimes undefined during compression.\n        // But it should always have a value!\n        clone.block_scope = this.block_scope.clone();\n    }\n    return clone;\n}\n\nvar AST_Block = DEFNODE(\"Block\", \"body block_scope\", {\n    $documentation: \"A body of statements (usually braced)\",\n    $propdoc: {\n        body: \"[AST_Statement*] an array of statements\",\n        block_scope: \"[AST_Scope] the block scope\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            walk_body(this, visitor);\n        });\n    },\n    clone: clone_block_scope\n}, AST_Statement);\n\nvar AST_BlockStatement = DEFNODE(\"BlockStatement\", null, {\n    $documentation: \"A block statement\",\n}, AST_Block);\n\nvar AST_EmptyStatement = DEFNODE(\"EmptyStatement\", null, {\n    $documentation: \"The empty statement (empty block or simply a semicolon)\"\n}, AST_Statement);\n\nvar AST_StatementWithBody = DEFNODE(\"StatementWithBody\", \"body\", {\n    $documentation: \"Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`\",\n    $propdoc: {\n        body: \"[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement\"\n    }\n}, AST_Statement);\n\nvar AST_LabeledStatement = DEFNODE(\"LabeledStatement\", \"label\", {\n    $documentation: \"Statement with a label\",\n    $propdoc: {\n        label: \"[AST_Label] a label definition\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.label._walk(visitor);\n            this.body._walk(visitor);\n        });\n    },\n    clone: function(deep) {\n        var node = this._clone(deep);\n        if (deep) {\n            var label = node.label;\n            var def = this.label;\n            node.walk(new TreeWalker(function(node) {\n                if (node instanceof AST_LoopControl\n                    && node.label && node.label.thedef === def) {\n                    node.label.thedef = label;\n                    label.references.push(node);\n                }\n            }));\n        }\n        return node;\n    }\n}, AST_StatementWithBody);\n\nvar AST_IterationStatement = DEFNODE(\"IterationStatement\", \"block_scope\", {\n    $documentation: \"Internal class.  All loops inherit from it.\",\n    $propdoc: {\n        block_scope: \"[AST_Scope] the block scope for this iteration statement.\"\n    },\n    clone: clone_block_scope\n}, AST_StatementWithBody);\n\nvar AST_DWLoop = DEFNODE(\"DWLoop\", \"condition\", {\n    $documentation: \"Base class for do/while statements\",\n    $propdoc: {\n        condition: \"[AST_Node] the loop condition.  Should not be instanceof AST_Statement\"\n    }\n}, AST_IterationStatement);\n\nvar AST_Do = DEFNODE(\"Do\", null, {\n    $documentation: \"A `do` statement\",\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.body._walk(visitor);\n            this.condition._walk(visitor);\n        });\n    }\n}, AST_DWLoop);\n\nvar AST_While = DEFNODE(\"While\", null, {\n    $documentation: \"A `while` statement\",\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.condition._walk(visitor);\n            this.body._walk(visitor);\n        });\n    }\n}, AST_DWLoop);\n\nvar AST_For = DEFNODE(\"For\", \"init condition step\", {\n    $documentation: \"A `for` statement\",\n    $propdoc: {\n        init: \"[AST_Node?] the `for` initialization code, or null if empty\",\n        condition: \"[AST_Node?] the `for` termination clause, or null if empty\",\n        step: \"[AST_Node?] the `for` update clause, or null if empty\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            if (this.init) this.init._walk(visitor);\n            if (this.condition) this.condition._walk(visitor);\n            if (this.step) this.step._walk(visitor);\n            this.body._walk(visitor);\n        });\n    }\n}, AST_IterationStatement);\n\nvar AST_ForIn = DEFNODE(\"ForIn\", \"init object\", {\n    $documentation: \"A `for ... in` statement\",\n    $propdoc: {\n        init: \"[AST_Node] the `for/in` initialization code\",\n        object: \"[AST_Node] the object that we're looping through\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.init._walk(visitor);\n            this.object._walk(visitor);\n            this.body._walk(visitor);\n        });\n    }\n}, AST_IterationStatement);\n\nvar AST_ForOf = DEFNODE(\"ForOf\", \"await\", {\n    $documentation: \"A `for ... of` statement\",\n}, AST_ForIn);\n\nvar AST_With = DEFNODE(\"With\", \"expression\", {\n    $documentation: \"A `with` statement\",\n    $propdoc: {\n        expression: \"[AST_Node] the `with` expression\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n            this.body._walk(visitor);\n        });\n    }\n}, AST_StatementWithBody);\n\n/* -----[ scope and functions ]----- */\n\nvar AST_Scope = DEFNODE(\"Scope\", \"variables functions uses_with uses_eval parent_scope enclosed cname\", {\n    $documentation: \"Base class for all statements introducing a lexical scope\",\n    $propdoc: {\n        variables: \"[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope\",\n        functions: \"[Object/S] like `variables`, but only lists function declarations\",\n        uses_with: \"[boolean/S] tells whether this scope uses the `with` statement\",\n        uses_eval: \"[boolean/S] tells whether this scope contains a direct call to the global `eval`\",\n        parent_scope: \"[AST_Scope?/S] link to the parent scope\",\n        enclosed: \"[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes\",\n        cname: \"[integer/S] current index for mangling variables (used internally by the mangler)\",\n    },\n    get_defun_scope: function() {\n        var self = this;\n        while (self.is_block_scope()) {\n            self = self.parent_scope;\n        }\n        return self;\n    },\n    clone: function(deep) {\n        var node = this._clone(deep);\n        if (this.variables) node.variables = this.variables.clone();\n        if (this.functions) node.functions = this.functions.clone();\n        if (this.enclosed) node.enclosed = this.enclosed.slice();\n        return node;\n    },\n    pinned: function() {\n        return this.uses_eval || this.uses_with;\n    }\n}, AST_Block);\n\nvar AST_Toplevel = DEFNODE(\"Toplevel\", \"globals\", {\n    $documentation: \"The toplevel scope\",\n    $propdoc: {\n        globals: \"[Object/S] a map of name -> SymbolDef for all undeclared names\",\n    },\n    wrap_commonjs: function(name) {\n        var body = this.body;\n        var wrapped_tl = \"(function(exports){'$ORIG';})(typeof \" + name + \"=='undefined'?(\" + name + \"={}):\" + name + \");\";\n        wrapped_tl = parse(wrapped_tl);\n        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function(node) {\n            if (node instanceof AST_Directive && node.value == \"$ORIG\") {\n                return MAP.splice(body);\n            }\n        }));\n        return wrapped_tl;\n    },\n    wrap_enclose: function(args_values) {\n        if (typeof args_values != \"string\") args_values = \"\";\n        var index = args_values.indexOf(\":\");\n        if (index < 0) index = args_values.length;\n        var body = this.body;\n        return parse([\n            \"(function(\",\n            args_values.slice(0, index),\n            '){\"$ORIG\"})(',\n            args_values.slice(index + 1),\n            \")\"\n        ].join(\"\")).transform(new TreeTransformer(function(node) {\n            if (node instanceof AST_Directive && node.value == \"$ORIG\") {\n                return MAP.splice(body);\n            }\n        }));\n    }\n}, AST_Scope);\n\nvar AST_Expansion = DEFNODE(\"Expansion\", \"expression\", {\n    $documentation: \"An expandible argument, such as ...rest, a splat, such as [1,2,...all], or an expansion in a variable declaration, such as var [first, ...rest] = list\",\n    $propdoc: {\n        expression: \"[AST_Node] the thing to be expanded\"\n    },\n    _walk: function(visitor) {\n        var self = this;\n        return visitor._visit(this, function() {\n            self.expression.walk(visitor);\n        });\n    }\n});\n\nvar AST_Lambda = DEFNODE(\"Lambda\", \"name argnames uses_arguments is_generator async\", {\n    $documentation: \"Base class for functions\",\n    $propdoc: {\n        name: \"[AST_SymbolDeclaration?] the name of this function\",\n        argnames: \"[AST_SymbolFunarg|AST_Destructuring|AST_Expansion|AST_DefaultAssign*] array of function arguments, destructurings, or expanding arguments\",\n        uses_arguments: \"[boolean/S] tells whether this function accesses the arguments array\",\n        is_generator: \"[boolean] is this a generator method\",\n        async: \"[boolean] is this method async\",\n    },\n    args_as_names: function () {\n        var out = [];\n        for (var i = 0; i < this.argnames.length; i++) {\n            if (this.argnames[i] instanceof AST_Destructuring) {\n                out = out.concat(this.argnames[i].all_symbols());\n            } else {\n                out.push(this.argnames[i]);\n            }\n        }\n        return out;\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            if (this.name) this.name._walk(visitor);\n            var argnames = this.argnames;\n            for (var i = 0, len = argnames.length; i < len; i++) {\n                argnames[i]._walk(visitor);\n            }\n            walk_body(this, visitor);\n        });\n    }\n}, AST_Scope);\n\nvar AST_Accessor = DEFNODE(\"Accessor\", null, {\n    $documentation: \"A setter/getter function.  The `name` property is always null.\"\n}, AST_Lambda);\n\nvar AST_Function = DEFNODE(\"Function\", \"inlined\", {\n    $documentation: \"A function expression\"\n}, AST_Lambda);\n\nvar AST_Arrow = DEFNODE(\"Arrow\", \"inlined\", {\n    $documentation: \"An ES6 Arrow function ((a) => b)\"\n}, AST_Lambda);\n\nvar AST_Defun = DEFNODE(\"Defun\", \"inlined\", {\n    $documentation: \"A function definition\"\n}, AST_Lambda);\n\n/* -----[ DESTRUCTURING ]----- */\nvar AST_Destructuring = DEFNODE(\"Destructuring\", \"names is_array\", {\n    $documentation: \"A destructuring of several names. Used in destructuring assignment and with destructuring function argument names\",\n    $propdoc: {\n        \"names\": \"[AST_Node*] Array of properties or elements\",\n        \"is_array\": \"[Boolean] Whether the destructuring represents an object or array\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.names.forEach(function(name) {\n                name._walk(visitor);\n            });\n        });\n    },\n    all_symbols: function() {\n        var out = [];\n        this.walk(new TreeWalker(function (node) {\n            if (node instanceof AST_Symbol) {\n                out.push(node);\n            }\n            if (node instanceof AST_Expansion) {\n                out.push(node.expression);\n            }\n        }));\n        return out;\n    }\n});\n\nvar AST_PrefixedTemplateString = DEFNODE(\"PrefixedTemplateString\", \"template_string prefix\", {\n    $documentation: \"A templatestring with a prefix, such as String.raw`foobarbaz`\",\n    $propdoc: {\n        template_string: \"[AST_TemplateString] The template string\",\n        prefix: \"[AST_SymbolRef|AST_PropAccess] The prefix, which can be a symbol such as `foo` or a dotted expression such as `String.raw`.\"\n    },\n    _walk: function(visitor) {\n        this.prefix._walk(visitor);\n        this.template_string._walk(visitor);\n    }\n});\n\nvar AST_TemplateString = DEFNODE(\"TemplateString\", \"segments\", {\n    $documentation: \"A template string literal\",\n    $propdoc: {\n        segments: \"[AST_Node*] One or more segments, starting with AST_TemplateSegment. AST_Node may follow AST_TemplateSegment, but each AST_Node must be followed by AST_TemplateSegment.\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.segments.forEach(function(seg) {\n                seg._walk(visitor);\n            });\n        });\n    }\n});\n\nvar AST_TemplateSegment = DEFNODE(\"TemplateSegment\", \"value raw\", {\n    $documentation: \"A segment of a template string literal\",\n    $propdoc: {\n        value: \"Content of the segment\",\n        raw: \"Raw content of the segment\"\n    }\n});\n\n/* -----[ JUMPS ]----- */\n\nvar AST_Jump = DEFNODE(\"Jump\", null, {\n    $documentation: \"Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)\"\n}, AST_Statement);\n\nvar AST_Exit = DEFNODE(\"Exit\", \"value\", {\n    $documentation: \"Base class for “exits” (`return` and `throw`)\",\n    $propdoc: {\n        value: \"[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, this.value && function() {\n            this.value._walk(visitor);\n        });\n    }\n}, AST_Jump);\n\nvar AST_Return = DEFNODE(\"Return\", null, {\n    $documentation: \"A `return` statement\"\n}, AST_Exit);\n\nvar AST_Throw = DEFNODE(\"Throw\", null, {\n    $documentation: \"A `throw` statement\"\n}, AST_Exit);\n\nvar AST_LoopControl = DEFNODE(\"LoopControl\", \"label\", {\n    $documentation: \"Base class for loop control statements (`break` and `continue`)\",\n    $propdoc: {\n        label: \"[AST_LabelRef?] the label, or null if none\",\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, this.label && function() {\n            this.label._walk(visitor);\n        });\n    }\n}, AST_Jump);\n\nvar AST_Break = DEFNODE(\"Break\", null, {\n    $documentation: \"A `break` statement\"\n}, AST_LoopControl);\n\nvar AST_Continue = DEFNODE(\"Continue\", null, {\n    $documentation: \"A `continue` statement\"\n}, AST_LoopControl);\n\n/* -----[ IF ]----- */\n\nvar AST_If = DEFNODE(\"If\", \"condition alternative\", {\n    $documentation: \"A `if` statement\",\n    $propdoc: {\n        condition: \"[AST_Node] the `if` condition\",\n        alternative: \"[AST_Statement?] the `else` part, or null if not present\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.condition._walk(visitor);\n            this.body._walk(visitor);\n            if (this.alternative) this.alternative._walk(visitor);\n        });\n    }\n}, AST_StatementWithBody);\n\n/* -----[ SWITCH ]----- */\n\nvar AST_Switch = DEFNODE(\"Switch\", \"expression\", {\n    $documentation: \"A `switch` statement\",\n    $propdoc: {\n        expression: \"[AST_Node] the `switch` “discriminant”\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n            walk_body(this, visitor);\n        });\n    }\n}, AST_Block);\n\nvar AST_SwitchBranch = DEFNODE(\"SwitchBranch\", null, {\n    $documentation: \"Base class for `switch` branches\",\n}, AST_Block);\n\nvar AST_Default = DEFNODE(\"Default\", null, {\n    $documentation: \"A `default` switch branch\",\n}, AST_SwitchBranch);\n\nvar AST_Case = DEFNODE(\"Case\", \"expression\", {\n    $documentation: \"A `case` switch branch\",\n    $propdoc: {\n        expression: \"[AST_Node] the `case` expression\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n            walk_body(this, visitor);\n        });\n    }\n}, AST_SwitchBranch);\n\n/* -----[ EXCEPTIONS ]----- */\n\nvar AST_Try = DEFNODE(\"Try\", \"bcatch bfinally\", {\n    $documentation: \"A `try` statement\",\n    $propdoc: {\n        bcatch: \"[AST_Catch?] the catch block, or null if not present\",\n        bfinally: \"[AST_Finally?] the finally block, or null if not present\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            walk_body(this, visitor);\n            if (this.bcatch) this.bcatch._walk(visitor);\n            if (this.bfinally) this.bfinally._walk(visitor);\n        });\n    }\n}, AST_Block);\n\nvar AST_Catch = DEFNODE(\"Catch\", \"argname\", {\n    $documentation: \"A `catch` node; only makes sense as part of a `try` statement\",\n    $propdoc: {\n        argname: \"[AST_SymbolCatch|AST_Destructuring|AST_Expansion|AST_DefaultAssign] symbol for the exception\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            if (this.argname) this.argname._walk(visitor);\n            walk_body(this, visitor);\n        });\n    }\n}, AST_Block);\n\nvar AST_Finally = DEFNODE(\"Finally\", null, {\n    $documentation: \"A `finally` node; only makes sense as part of a `try` statement\"\n}, AST_Block);\n\n/* -----[ VAR/CONST ]----- */\n\nvar AST_Definitions = DEFNODE(\"Definitions\", \"definitions\", {\n    $documentation: \"Base class for `var` or `const` nodes (variable declarations/initializations)\",\n    $propdoc: {\n        definitions: \"[AST_VarDef*] array of variable definitions\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            var definitions = this.definitions;\n            for (var i = 0, len = definitions.length; i < len; i++) {\n                definitions[i]._walk(visitor);\n            }\n        });\n    }\n}, AST_Statement);\n\nvar AST_Var = DEFNODE(\"Var\", null, {\n    $documentation: \"A `var` statement\"\n}, AST_Definitions);\n\nvar AST_Let = DEFNODE(\"Let\", null, {\n    $documentation: \"A `let` statement\"\n}, AST_Definitions);\n\nvar AST_Const = DEFNODE(\"Const\", null, {\n    $documentation: \"A `const` statement\"\n}, AST_Definitions);\n\nvar AST_NameMapping = DEFNODE(\"NameMapping\", \"foreign_name name\", {\n    $documentation: \"The part of the export/import statement that declare names from a module.\",\n    $propdoc: {\n        foreign_name: \"[AST_SymbolExportForeign|AST_SymbolImportForeign] The name being exported/imported (as specified in the module)\",\n        name: \"[AST_SymbolExport|AST_SymbolImport] The name as it is visible to this module.\"\n    },\n    _walk: function (visitor) {\n        return visitor._visit(this, function() {\n            this.foreign_name._walk(visitor);\n            this.name._walk(visitor);\n        });\n    }\n});\n\nvar AST_Import = DEFNODE(\"Import\", \"imported_name imported_names module_name\", {\n    $documentation: \"An `import` statement\",\n    $propdoc: {\n        imported_name: \"[AST_SymbolImport] The name of the variable holding the module's default export.\",\n        imported_names: \"[AST_NameMapping*] The names of non-default imported variables\",\n        module_name: \"[AST_String] String literal describing where this module came from\",\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            if (this.imported_name) {\n                this.imported_name._walk(visitor);\n            }\n            if (this.imported_names) {\n                this.imported_names.forEach(function(name_import) {\n                    name_import._walk(visitor);\n                });\n            }\n            this.module_name._walk(visitor);\n        });\n    }\n});\n\nvar AST_Export = DEFNODE(\"Export\", \"exported_definition exported_value is_default exported_names module_name\", {\n    $documentation: \"An `export` statement\",\n    $propdoc: {\n        exported_definition: \"[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition\",\n        exported_value: \"[AST_Node?] An exported value\",\n        exported_names: \"[AST_NameMapping*?] List of exported names\",\n        module_name: \"[AST_String?] Name of the file to load exports from\",\n        is_default: \"[Boolean] Whether this is the default exported value of this module\"\n    },\n    _walk: function (visitor) {\n        visitor._visit(this, function () {\n            if (this.exported_definition) {\n                this.exported_definition._walk(visitor);\n            }\n            if (this.exported_value) {\n                this.exported_value._walk(visitor);\n            }\n            if (this.exported_names) {\n                this.exported_names.forEach(function(name_export) {\n                    name_export._walk(visitor);\n                });\n            }\n            if (this.module_name) {\n                this.module_name._walk(visitor);\n            }\n        });\n    }\n}, AST_Statement);\n\nvar AST_VarDef = DEFNODE(\"VarDef\", \"name value\", {\n    $documentation: \"A variable declaration; only appears in a AST_Definitions node\",\n    $propdoc: {\n        name: \"[AST_Destructuring|AST_SymbolConst|AST_SymbolLet|AST_SymbolVar] name of the variable\",\n        value: \"[AST_Node?] initializer, or null of there's no initializer\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.name._walk(visitor);\n            if (this.value) this.value._walk(visitor);\n        });\n    }\n});\n\n/* -----[ OTHER ]----- */\n\nvar AST_Call = DEFNODE(\"Call\", \"expression args\", {\n    $documentation: \"A function call expression\",\n    $propdoc: {\n        expression: \"[AST_Node] expression to invoke as function\",\n        args: \"[AST_Node*] array of arguments\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            var args = this.args;\n            for (var i = 0, len = args.length; i < len; i++) {\n                args[i]._walk(visitor);\n            }\n            this.expression._walk(visitor);\n        });\n    }\n});\n\nvar AST_New = DEFNODE(\"New\", null, {\n    $documentation: \"An object instantiation.  Derives from a function call since it has exactly the same properties\"\n}, AST_Call);\n\nvar AST_Sequence = DEFNODE(\"Sequence\", \"expressions\", {\n    $documentation: \"A sequence expression (comma-separated expressions)\",\n    $propdoc: {\n        expressions: \"[AST_Node*] array of expressions (at least two)\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expressions.forEach(function(node) {\n                node._walk(visitor);\n            });\n        });\n    }\n});\n\nvar AST_PropAccess = DEFNODE(\"PropAccess\", \"expression property\", {\n    $documentation: \"Base class for property access expressions, i.e. `a.foo` or `a[\\\"foo\\\"]`\",\n    $propdoc: {\n        expression: \"[AST_Node] the “container” expression\",\n        property: \"[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node\"\n    }\n});\n\nvar AST_Dot = DEFNODE(\"Dot\", null, {\n    $documentation: \"A dotted property access expression\",\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n        });\n    }\n}, AST_PropAccess);\n\nvar AST_Sub = DEFNODE(\"Sub\", null, {\n    $documentation: \"Index-style property access, i.e. `a[\\\"foo\\\"]`\",\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n            this.property._walk(visitor);\n        });\n    }\n}, AST_PropAccess);\n\nvar AST_Unary = DEFNODE(\"Unary\", \"operator expression\", {\n    $documentation: \"Base class for unary expressions\",\n    $propdoc: {\n        operator: \"[string] the operator\",\n        expression: \"[AST_Node] expression that this unary operator applies to\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n        });\n    }\n});\n\nvar AST_UnaryPrefix = DEFNODE(\"UnaryPrefix\", null, {\n    $documentation: \"Unary prefix expression, i.e. `typeof i` or `++i`\"\n}, AST_Unary);\n\nvar AST_UnaryPostfix = DEFNODE(\"UnaryPostfix\", null, {\n    $documentation: \"Unary postfix expression, i.e. `i++`\"\n}, AST_Unary);\n\nvar AST_Binary = DEFNODE(\"Binary\", \"operator left right\", {\n    $documentation: \"Binary expression, i.e. `a + b`\",\n    $propdoc: {\n        left: \"[AST_Node] left-hand side expression\",\n        operator: \"[string] the operator\",\n        right: \"[AST_Node] right-hand side expression\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.left._walk(visitor);\n            this.right._walk(visitor);\n        });\n    }\n});\n\nvar AST_Conditional = DEFNODE(\"Conditional\", \"condition consequent alternative\", {\n    $documentation: \"Conditional expression using the ternary operator, i.e. `a ? b : c`\",\n    $propdoc: {\n        condition: \"[AST_Node]\",\n        consequent: \"[AST_Node]\",\n        alternative: \"[AST_Node]\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.condition._walk(visitor);\n            this.consequent._walk(visitor);\n            this.alternative._walk(visitor);\n        });\n    }\n});\n\nvar AST_Assign = DEFNODE(\"Assign\", null, {\n    $documentation: \"An assignment expression — `a = b + 5`\",\n}, AST_Binary);\n\nvar AST_DefaultAssign = DEFNODE(\"DefaultAssign\", null, {\n    $documentation: \"A default assignment expression like in `(a = 3) => a`\"\n}, AST_Binary);\n\n/* -----[ LITERALS ]----- */\n\nvar AST_Array = DEFNODE(\"Array\", \"elements\", {\n    $documentation: \"An array literal\",\n    $propdoc: {\n        elements: \"[AST_Node*] array of elements\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            var elements = this.elements;\n            for (var i = 0, len = elements.length; i < len; i++) {\n                elements[i]._walk(visitor);\n            }\n        });\n    }\n});\n\nvar AST_Object = DEFNODE(\"Object\", \"properties\", {\n    $documentation: \"An object literal\",\n    $propdoc: {\n        properties: \"[AST_ObjectProperty*] array of properties\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            var properties = this.properties;\n            for (var i = 0, len = properties.length; i < len; i++) {\n                properties[i]._walk(visitor);\n            }\n        });\n    }\n});\n\nvar AST_ObjectProperty = DEFNODE(\"ObjectProperty\", \"key value\", {\n    $documentation: \"Base class for literal object properties\",\n    $propdoc: {\n        key: \"[string|AST_Node] property name. For ObjectKeyVal this is a string. For getters, setters and computed property this is an AST_Node.\",\n        value: \"[AST_Node] property value.  For getters and setters this is an AST_Accessor.\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            if (this.key instanceof AST_Node)\n                this.key._walk(visitor);\n            this.value._walk(visitor);\n        });\n    }\n});\n\nvar AST_ObjectKeyVal = DEFNODE(\"ObjectKeyVal\", \"quote\", {\n    $documentation: \"A key: value object property\",\n    $propdoc: {\n        quote: \"[string] the original quote character\"\n    }\n}, AST_ObjectProperty);\n\nvar AST_ObjectSetter = DEFNODE(\"ObjectSetter\", \"quote static\", {\n    $propdoc: {\n        quote: \"[string|undefined] the original quote character, if any\",\n        static: \"[boolean] whether this is a static setter (classes only)\"\n    },\n    $documentation: \"An object setter property\",\n}, AST_ObjectProperty);\n\nvar AST_ObjectGetter = DEFNODE(\"ObjectGetter\", \"quote static\", {\n    $propdoc: {\n        quote: \"[string|undefined] the original quote character, if any\",\n        static: \"[boolean] whether this is a static getter (classes only)\"\n    },\n    $documentation: \"An object getter property\",\n}, AST_ObjectProperty);\n\nvar AST_ConciseMethod = DEFNODE(\"ConciseMethod\", \"quote static is_generator async\", {\n    $propdoc: {\n        quote: \"[string|undefined] the original quote character, if any\",\n        static: \"[boolean] is this method static (classes only)\",\n        is_generator: \"[boolean] is this a generator method\",\n        async: \"[boolean] is this method async\",\n    },\n    $documentation: \"An ES6 concise method inside an object or class\"\n}, AST_ObjectProperty);\n\nvar AST_Class = DEFNODE(\"Class\", \"name extends properties inlined\", {\n    $propdoc: {\n        name: \"[AST_SymbolClass|AST_SymbolDefClass?] optional class name.\",\n        extends: \"[AST_Node]? optional parent class\",\n        properties: \"[AST_ObjectProperty*] array of properties\"\n    },\n    $documentation: \"An ES6 class\",\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            if (this.name) {\n                this.name._walk(visitor);\n            }\n            if (this.extends) {\n                this.extends._walk(visitor);\n            }\n            this.properties.forEach(function(prop) {\n                prop._walk(visitor);\n            });\n        });\n    },\n}, AST_Scope);\n\nvar AST_DefClass = DEFNODE(\"DefClass\", null, {\n    $documentation: \"A class definition\",\n}, AST_Class);\n\nvar AST_ClassExpression = DEFNODE(\"ClassExpression\", null, {\n    $documentation: \"A class expression.\"\n}, AST_Class);\n\nvar AST_Symbol = DEFNODE(\"Symbol\", \"scope name thedef\", {\n    $propdoc: {\n        name: \"[string] name of this symbol\",\n        scope: \"[AST_Scope/S] the current scope (not necessarily the definition scope)\",\n        thedef: \"[SymbolDef/S] the definition of this symbol\"\n    },\n    $documentation: \"Base class for all symbols\"\n});\n\nvar AST_NewTarget = DEFNODE(\"NewTarget\", null, {\n    $documentation: \"A reference to new.target\"\n});\n\nvar AST_SymbolDeclaration = DEFNODE(\"SymbolDeclaration\", \"init\", {\n    $documentation: \"A declaration symbol (symbol in var/const, function name or argument, symbol in catch)\",\n}, AST_Symbol);\n\nvar AST_SymbolVar = DEFNODE(\"SymbolVar\", null, {\n    $documentation: \"Symbol defining a variable\",\n}, AST_SymbolDeclaration);\n\nvar AST_SymbolBlockDeclaration = DEFNODE(\"SymbolBlockDeclaration\", null, {\n    $documentation: \"Base class for block-scoped declaration symbols\"\n}, AST_SymbolDeclaration);\n\nvar AST_SymbolConst = DEFNODE(\"SymbolConst\", null, {\n    $documentation: \"A constant declaration\"\n}, AST_SymbolBlockDeclaration);\n\nvar AST_SymbolLet = DEFNODE(\"SymbolLet\", null, {\n    $documentation: \"A block-scoped `let` declaration\"\n}, AST_SymbolBlockDeclaration);\n\nvar AST_SymbolFunarg = DEFNODE(\"SymbolFunarg\", null, {\n    $documentation: \"Symbol naming a function argument\",\n}, AST_SymbolVar);\n\nvar AST_SymbolDefun = DEFNODE(\"SymbolDefun\", null, {\n    $documentation: \"Symbol defining a function\",\n}, AST_SymbolDeclaration);\n\nvar AST_SymbolMethod = DEFNODE(\"SymbolMethod\", null, {\n    $documentation: \"Symbol in an object defining a method\",\n}, AST_Symbol);\n\nvar AST_SymbolLambda = DEFNODE(\"SymbolLambda\", null, {\n    $documentation: \"Symbol naming a function expression\",\n}, AST_SymbolDeclaration);\n\nvar AST_SymbolDefClass = DEFNODE(\"SymbolDefClass\", null, {\n    $documentation: \"Symbol naming a class's name in a class declaration. Lexically scoped to its containing scope, and accessible within the class.\"\n}, AST_SymbolBlockDeclaration);\n\nvar AST_SymbolClass = DEFNODE(\"SymbolClass\", null, {\n    $documentation: \"Symbol naming a class's name. Lexically scoped to the class.\"\n}, AST_SymbolDeclaration);\n\nvar AST_SymbolCatch = DEFNODE(\"SymbolCatch\", null, {\n    $documentation: \"Symbol naming the exception in catch\",\n}, AST_SymbolBlockDeclaration);\n\nvar AST_SymbolImport = DEFNODE(\"SymbolImport\", null, {\n    $documentation: \"Symbol referring to an imported name\",\n}, AST_SymbolBlockDeclaration);\n\nvar AST_SymbolImportForeign = DEFNODE(\"SymbolImportForeign\", null, {\n    $documentation: \"A symbol imported from a module, but it is defined in the other module, and its real name is irrelevant for this module's purposes\",\n}, AST_Symbol);\n\nvar AST_Label = DEFNODE(\"Label\", \"references\", {\n    $documentation: \"Symbol naming a label (declaration)\",\n    $propdoc: {\n        references: \"[AST_LoopControl*] a list of nodes referring to this label\"\n    },\n    initialize: function() {\n        this.references = [];\n        this.thedef = this;\n    }\n}, AST_Symbol);\n\nvar AST_SymbolRef = DEFNODE(\"SymbolRef\", null, {\n    $documentation: \"Reference to some symbol (not definition/declaration)\",\n}, AST_Symbol);\n\nvar AST_SymbolExport = DEFNODE(\"SymbolExport\", null, {\n    $documentation: \"Symbol referring to a name to export\",\n}, AST_SymbolRef);\n\nvar AST_SymbolExportForeign = DEFNODE(\"SymbolExportForeign\", null, {\n    $documentation: \"A symbol exported from this module, but it is used in the other module, and its real name is irrelevant for this module's purposes\",\n}, AST_Symbol);\n\nvar AST_LabelRef = DEFNODE(\"LabelRef\", null, {\n    $documentation: \"Reference to a label symbol\",\n}, AST_Symbol);\n\nvar AST_This = DEFNODE(\"This\", null, {\n    $documentation: \"The `this` symbol\",\n}, AST_Symbol);\n\nvar AST_Super = DEFNODE(\"Super\", null, {\n    $documentation: \"The `super` symbol\",\n}, AST_This);\n\nvar AST_Constant = DEFNODE(\"Constant\", null, {\n    $documentation: \"Base class for all constants\",\n    getValue: function() {\n        return this.value;\n    }\n});\n\nvar AST_String = DEFNODE(\"String\", \"value quote\", {\n    $documentation: \"A string literal\",\n    $propdoc: {\n        value: \"[string] the contents of this string\",\n        quote: \"[string] the original quote character\"\n    }\n}, AST_Constant);\n\nvar AST_Number = DEFNODE(\"Number\", \"value literal\", {\n    $documentation: \"A number literal\",\n    $propdoc: {\n        value: \"[number] the numeric value\",\n        literal: \"[string] numeric value as string (optional)\"\n    }\n}, AST_Constant);\n\nvar AST_RegExp = DEFNODE(\"RegExp\", \"value\", {\n    $documentation: \"A regexp literal\",\n    $propdoc: {\n        value: \"[RegExp] the actual regexp\",\n    }\n}, AST_Constant);\n\nvar AST_Atom = DEFNODE(\"Atom\", null, {\n    $documentation: \"Base class for atoms\",\n}, AST_Constant);\n\nvar AST_Null = DEFNODE(\"Null\", null, {\n    $documentation: \"The `null` atom\",\n    value: null\n}, AST_Atom);\n\nvar AST_NaN = DEFNODE(\"NaN\", null, {\n    $documentation: \"The impossible value\",\n    value: 0/0\n}, AST_Atom);\n\nvar AST_Undefined = DEFNODE(\"Undefined\", null, {\n    $documentation: \"The `undefined` value\",\n    value: (function() {}())\n}, AST_Atom);\n\nvar AST_Hole = DEFNODE(\"Hole\", null, {\n    $documentation: \"A hole in an array\",\n    value: (function() {}())\n}, AST_Atom);\n\nvar AST_Infinity = DEFNODE(\"Infinity\", null, {\n    $documentation: \"The `Infinity` value\",\n    value: 1/0\n}, AST_Atom);\n\nvar AST_Boolean = DEFNODE(\"Boolean\", null, {\n    $documentation: \"Base class for booleans\",\n}, AST_Atom);\n\nvar AST_False = DEFNODE(\"False\", null, {\n    $documentation: \"The `false` atom\",\n    value: false\n}, AST_Boolean);\n\nvar AST_True = DEFNODE(\"True\", null, {\n    $documentation: \"The `true` atom\",\n    value: true\n}, AST_Boolean);\n\nvar AST_Await = DEFNODE(\"Await\", \"expression\", {\n    $documentation: \"An `await` statement\",\n    $propdoc: {\n        expression: \"[AST_Node] the mandatory expression being awaited\",\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, function() {\n            this.expression._walk(visitor);\n        });\n    }\n});\n\nvar AST_Yield = DEFNODE(\"Yield\", \"expression is_star\", {\n    $documentation: \"A `yield` statement\",\n    $propdoc: {\n        expression: \"[AST_Node?] the value returned or thrown by this statement; could be null (representing undefined) but only when is_star is set to false\",\n        is_star: \"[Boolean] Whether this is a yield or yield* statement\"\n    },\n    _walk: function(visitor) {\n        return visitor._visit(this, this.expression && function() {\n            this.expression._walk(visitor);\n        });\n    }\n});\n\n/* -----[ TreeWalker ]----- */\n\nfunction TreeWalker(callback) {\n    this.visit = callback;\n    this.stack = [];\n    this.directives = Object.create(null);\n}\nTreeWalker.prototype = {\n    _visit: function(node, descend) {\n        this.push(node);\n        var ret = this.visit(node, descend ? function() {\n            descend.call(node);\n        } : noop);\n        if (!ret && descend) {\n            descend.call(node);\n        }\n        this.pop();\n        return ret;\n    },\n    parent: function(n) {\n        return this.stack[this.stack.length - 2 - (n || 0)];\n    },\n    push: function(node) {\n        if (node instanceof AST_Lambda) {\n            this.directives = Object.create(this.directives);\n        } else if (node instanceof AST_Directive && !this.directives[node.value]) {\n            this.directives[node.value] = node;\n        } else if (node instanceof AST_Class) {\n            this.directives = Object.create(this.directives);\n            if (!this.directives[\"use strict\"]) {\n                this.directives[\"use strict\"] = node;\n            }\n        }\n        this.stack.push(node);\n    },\n    pop: function() {\n        var node = this.stack.pop();\n        if (node instanceof AST_Lambda || node instanceof AST_Class) {\n            this.directives = Object.getPrototypeOf(this.directives);\n        }\n    },\n    self: function() {\n        return this.stack[this.stack.length - 1];\n    },\n    find_parent: function(type) {\n        var stack = this.stack;\n        for (var i = stack.length; --i >= 0;) {\n            var x = stack[i];\n            if (x instanceof type) return x;\n        }\n    },\n    has_directive: function(type) {\n        var dir = this.directives[type];\n        if (dir) return dir;\n        var node = this.stack[this.stack.length - 1];\n        if (node instanceof AST_Scope && node.body) {\n            for (var i = 0; i < node.body.length; ++i) {\n                var st = node.body[i];\n                if (!(st instanceof AST_Directive)) break;\n                if (st.value == type) return st;\n            }\n        }\n    },\n    loopcontrol_target: function(node) {\n        var stack = this.stack;\n        if (node.label) for (var i = stack.length; --i >= 0;) {\n            var x = stack[i];\n            if (x instanceof AST_LabeledStatement && x.label.name == node.label.name)\n                return x.body;\n        } else for (var i = stack.length; --i >= 0;) {\n            var x = stack[i];\n            if (x instanceof AST_IterationStatement\n                || node instanceof AST_Break && x instanceof AST_Switch)\n                return x;\n        }\n    }\n};\n\n// Tree transformer helpers.\nfunction TreeTransformer(before, after) {\n    TreeWalker.call(this);\n    this.before = before;\n    this.after = after;\n}\nTreeTransformer.prototype = new TreeWalker;\n\nexport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Atom,\n    AST_Await,\n    AST_Binary,\n    AST_Block,\n    AST_BlockStatement,\n    AST_Boolean,\n    AST_Break,\n    AST_Call,\n    AST_Case,\n    AST_Catch,\n    AST_Class,\n    AST_ClassExpression,\n    AST_ConciseMethod,\n    AST_Conditional,\n    AST_Const,\n    AST_Constant,\n    AST_Continue,\n    AST_Debugger,\n    AST_Default,\n    AST_DefaultAssign,\n    AST_DefClass,\n    AST_Definitions,\n    AST_Defun,\n    AST_Destructuring,\n    AST_Directive,\n    AST_Do,\n    AST_Dot,\n    AST_DWLoop,\n    AST_EmptyStatement,\n    AST_Exit,\n    AST_Expansion,\n    AST_Export,\n    AST_False,\n    AST_Finally,\n    AST_For,\n    AST_ForIn,\n    AST_ForOf,\n    AST_Function,\n    AST_Hole,\n    AST_If,\n    AST_Import,\n    AST_Infinity,\n    AST_IterationStatement,\n    AST_Jump,\n    AST_Label,\n    AST_LabeledStatement,\n    AST_LabelRef,\n    AST_Lambda,\n    AST_Let,\n    AST_LoopControl,\n    AST_NameMapping,\n    AST_NaN,\n    AST_New,\n    AST_NewTarget,\n    AST_Node,\n    AST_Null,\n    AST_Number,\n    AST_Object,\n    AST_ObjectGetter,\n    AST_ObjectKeyVal,\n    AST_ObjectProperty,\n    AST_ObjectSetter,\n    AST_PrefixedTemplateString,\n    AST_PropAccess,\n    AST_RegExp,\n    AST_Return,\n    AST_Scope,\n    AST_Sequence,\n    AST_SimpleStatement,\n    AST_Statement,\n    AST_StatementWithBody,\n    AST_String,\n    AST_Sub,\n    AST_Super,\n    AST_Switch,\n    AST_SwitchBranch,\n    AST_Symbol,\n    AST_SymbolBlockDeclaration,\n    AST_SymbolCatch,\n    AST_SymbolClass,\n    AST_SymbolConst,\n    AST_SymbolDeclaration,\n    AST_SymbolDefClass,\n    AST_SymbolDefun,\n    AST_SymbolExport,\n    AST_SymbolExportForeign,\n    AST_SymbolFunarg,\n    AST_SymbolImport,\n    AST_SymbolImportForeign,\n    AST_SymbolLambda,\n    AST_SymbolLet,\n    AST_SymbolMethod,\n    AST_SymbolRef,\n    AST_SymbolVar,\n    AST_TemplateSegment,\n    AST_TemplateString,\n    AST_This,\n    AST_Throw,\n    AST_Token,\n    AST_Toplevel,\n    AST_True,\n    AST_Try,\n    AST_Unary,\n    AST_UnaryPostfix,\n    AST_UnaryPrefix,\n    AST_Undefined,\n    AST_Var,\n    AST_VarDef,\n    AST_While,\n    AST_With,\n    AST_Yield,\n    TreeTransformer,\n    TreeWalker,\n    walk_body,\n};\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    AST_Array,\n    AST_Await,\n    AST_Binary,\n    AST_Block,\n    AST_Call,\n    AST_Case,\n    AST_Catch,\n    AST_Class,\n    AST_Conditional,\n    AST_Definitions,\n    AST_Destructuring,\n    AST_Do,\n    AST_Dot,\n    AST_Exit,\n    AST_Expansion,\n    AST_Export,\n    AST_For,\n    AST_ForIn,\n    AST_If,\n    AST_Import,\n    AST_LabeledStatement,\n    AST_Lambda,\n    AST_LoopControl,\n    AST_NameMapping,\n    AST_Node,\n    AST_Object,\n    AST_ObjectProperty,\n    AST_PrefixedTemplateString,\n    AST_Sequence,\n    AST_SimpleStatement,\n    AST_Sub,\n    AST_Switch,\n    AST_TemplateString,\n    AST_Try,\n    AST_Unary,\n    AST_VarDef,\n    AST_While,\n    AST_With,\n    AST_Yield,\n} from \"./ast.js\";\nimport {\n    MAP,\n    noop,\n} from \"./utils.js\";\n\n(function(undefined) {\n\n    function _(node, descend) {\n        node.DEFMETHOD(\"transform\", function(tw, in_list) {\n            var x, y;\n            tw.push(this);\n            if (tw.before) x = tw.before(this, descend, in_list);\n            if (x === undefined) {\n                x = this;\n                descend(x, tw);\n                if (tw.after) {\n                    y = tw.after(x, in_list);\n                    if (y !== undefined) x = y;\n                }\n            }\n            tw.pop();\n            return x;\n        });\n    }\n\n    function do_list(list, tw) {\n        return MAP(list, function(node) {\n            return node.transform(tw, true);\n        });\n    }\n\n    _(AST_Node, noop);\n\n    _(AST_LabeledStatement, function(self, tw) {\n        self.label = self.label.transform(tw);\n        self.body = self.body.transform(tw);\n    });\n\n    _(AST_SimpleStatement, function(self, tw) {\n        self.body = self.body.transform(tw);\n    });\n\n    _(AST_Block, function(self, tw) {\n        self.body = do_list(self.body, tw);\n    });\n\n    _(AST_Do, function(self, tw) {\n        self.body = self.body.transform(tw);\n        self.condition = self.condition.transform(tw);\n    });\n\n    _(AST_While, function(self, tw) {\n        self.condition = self.condition.transform(tw);\n        self.body = self.body.transform(tw);\n    });\n\n    _(AST_For, function(self, tw) {\n        if (self.init) self.init = self.init.transform(tw);\n        if (self.condition) self.condition = self.condition.transform(tw);\n        if (self.step) self.step = self.step.transform(tw);\n        self.body = self.body.transform(tw);\n    });\n\n    _(AST_ForIn, function(self, tw) {\n        self.init = self.init.transform(tw);\n        self.object = self.object.transform(tw);\n        self.body = self.body.transform(tw);\n    });\n\n    _(AST_With, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n        self.body = self.body.transform(tw);\n    });\n\n    _(AST_Exit, function(self, tw) {\n        if (self.value) self.value = self.value.transform(tw);\n    });\n\n    _(AST_LoopControl, function(self, tw) {\n        if (self.label) self.label = self.label.transform(tw);\n    });\n\n    _(AST_If, function(self, tw) {\n        self.condition = self.condition.transform(tw);\n        self.body = self.body.transform(tw);\n        if (self.alternative) self.alternative = self.alternative.transform(tw);\n    });\n\n    _(AST_Switch, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n        self.body = do_list(self.body, tw);\n    });\n\n    _(AST_Case, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n        self.body = do_list(self.body, tw);\n    });\n\n    _(AST_Try, function(self, tw) {\n        self.body = do_list(self.body, tw);\n        if (self.bcatch) self.bcatch = self.bcatch.transform(tw);\n        if (self.bfinally) self.bfinally = self.bfinally.transform(tw);\n    });\n\n    _(AST_Catch, function(self, tw) {\n        if (self.argname) self.argname = self.argname.transform(tw);\n        self.body = do_list(self.body, tw);\n    });\n\n    _(AST_Definitions, function(self, tw) {\n        self.definitions = do_list(self.definitions, tw);\n    });\n\n    _(AST_VarDef, function(self, tw) {\n        self.name = self.name.transform(tw);\n        if (self.value) self.value = self.value.transform(tw);\n    });\n\n    _(AST_Destructuring, function(self, tw) {\n        self.names = do_list(self.names, tw);\n    });\n\n    _(AST_Lambda, function(self, tw) {\n        if (self.name) self.name = self.name.transform(tw);\n        self.argnames = do_list(self.argnames, tw);\n        if (self.body instanceof AST_Node) {\n            self.body = self.body.transform(tw);\n        } else {\n            self.body = do_list(self.body, tw);\n        }\n    });\n\n    _(AST_Call, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n        self.args = do_list(self.args, tw);\n    });\n\n    _(AST_Sequence, function(self, tw) {\n        self.expressions = do_list(self.expressions, tw);\n    });\n\n    _(AST_Dot, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n    });\n\n    _(AST_Sub, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n        self.property = self.property.transform(tw);\n    });\n\n    _(AST_Yield, function(self, tw) {\n        if (self.expression) self.expression = self.expression.transform(tw);\n    });\n\n    _(AST_Await, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n    });\n\n    _(AST_Unary, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n    });\n\n    _(AST_Binary, function(self, tw) {\n        self.left = self.left.transform(tw);\n        self.right = self.right.transform(tw);\n    });\n\n    _(AST_Conditional, function(self, tw) {\n        self.condition = self.condition.transform(tw);\n        self.consequent = self.consequent.transform(tw);\n        self.alternative = self.alternative.transform(tw);\n    });\n\n    _(AST_Array, function(self, tw) {\n        self.elements = do_list(self.elements, tw);\n    });\n\n    _(AST_Object, function(self, tw) {\n        self.properties = do_list(self.properties, tw);\n    });\n\n    _(AST_ObjectProperty, function(self, tw) {\n        if (self.key instanceof AST_Node) {\n            self.key = self.key.transform(tw);\n        }\n        self.value = self.value.transform(tw);\n    });\n\n    _(AST_Class, function(self, tw) {\n        if (self.name) self.name = self.name.transform(tw);\n        if (self.extends) self.extends = self.extends.transform(tw);\n        self.properties = do_list(self.properties, tw);\n    });\n\n    _(AST_Expansion, function(self, tw) {\n        self.expression = self.expression.transform(tw);\n    });\n\n    _(AST_NameMapping, function(self, tw) {\n        self.foreign_name = self.foreign_name.transform(tw);\n        self.name = self.name.transform(tw);\n    });\n\n    _(AST_Import, function(self, tw) {\n        if (self.imported_name) self.imported_name = self.imported_name.transform(tw);\n        if (self.imported_names) do_list(self.imported_names, tw);\n        self.module_name = self.module_name.transform(tw);\n    });\n\n    _(AST_Export, function(self, tw) {\n        if (self.exported_definition) self.exported_definition = self.exported_definition.transform(tw);\n        if (self.exported_value) self.exported_value = self.exported_value.transform(tw);\n        if (self.exported_names) do_list(self.exported_names, tw);\n        if (self.module_name) self.module_name = self.module_name.transform(tw);\n    });\n\n    _(AST_TemplateString, function(self, tw) {\n        self.segments = do_list(self.segments, tw);\n    });\n\n    _(AST_PrefixedTemplateString, function(self, tw) {\n        self.prefix = self.prefix.transform(tw);\n        self.template_string = self.template_string.transform(tw);\n    });\n\n})();\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    all,\n    defaults,\n    first_in_statement,\n    makePredicate,\n    noop,\n    repeat_string,\n    return_false,\n    return_true,\n} from \"./utils.js\";\n\nimport {\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Await,\n    AST_Binary,\n    AST_BlockStatement,\n    AST_Break,\n    AST_Call,\n    AST_Case,\n    AST_Catch,\n    AST_Class,\n    AST_ClassExpression,\n    AST_ConciseMethod,\n    AST_Conditional,\n    AST_Const,\n    AST_Constant,\n    AST_Continue,\n    AST_Debugger,\n    AST_Default,\n    AST_DefaultAssign,\n    AST_Definitions,\n    AST_Defun,\n    AST_Destructuring,\n    AST_Directive,\n    AST_Do,\n    AST_Dot,\n    AST_EmptyStatement,\n    AST_Exit,\n    AST_Expansion,\n    AST_Export,\n    AST_Finally,\n    AST_For,\n    AST_ForIn,\n    AST_ForOf,\n    AST_Function,\n    AST_Hole,\n    AST_If,\n    AST_Import,\n    AST_Jump,\n    AST_LabeledStatement,\n    AST_Lambda,\n    AST_Let,\n    AST_LoopControl,\n    AST_NameMapping,\n    AST_New,\n    AST_NewTarget,\n    AST_Node,\n    AST_Number,\n    AST_Object,\n    AST_ObjectGetter,\n    AST_ObjectKeyVal,\n    AST_ObjectProperty,\n    AST_ObjectSetter,\n    AST_PrefixedTemplateString,\n    AST_PropAccess,\n    AST_RegExp,\n    AST_Return,\n    AST_Scope,\n    AST_Sequence,\n    AST_SimpleStatement,\n    AST_Statement,\n    AST_StatementWithBody,\n    AST_String,\n    AST_Sub,\n    AST_Super,\n    AST_Switch,\n    AST_SwitchBranch,\n    AST_Symbol,\n    AST_SymbolMethod,\n    AST_SymbolRef,\n    AST_TemplateSegment,\n    AST_TemplateString,\n    AST_This,\n    AST_Throw,\n    AST_Toplevel,\n    AST_Try,\n    AST_Unary,\n    AST_UnaryPostfix,\n    AST_UnaryPrefix,\n    AST_Var,\n    AST_VarDef,\n    AST_While,\n    AST_With,\n    AST_Yield,\n    TreeWalker,\n} from \"./ast.js\";\nimport {\n    get_full_char_code,\n    get_full_char,\n    is_identifier_char,\n    is_identifier_string,\n    is_identifier,\n    is_surrogate_pair_head,\n    is_surrogate_pair_tail,\n    PRECEDENCE,\n    RESERVED_WORDS,\n} from \"./parse.js\";\n\nvar EXPECT_DIRECTIVE = /^$|[;{][\\s\\n]*$/;\n\nfunction is_some_comments(comment) {\n    // multiline comment\n    return comment.type == \"comment2\" && /@preserve|@license|@cc_on/i.test(comment.value);\n}\n\nfunction OutputStream(options) {\n\n    var readonly = !options;\n    options = defaults(options, {\n        ascii_only       : false,\n        beautify         : false,\n        braces           : false,\n        comments         : false,\n        ecma             : 5,\n        ie8              : false,\n        indent_level     : 4,\n        indent_start     : 0,\n        inline_script    : true,\n        keep_quoted_props: false,\n        max_line_len     : false,\n        preamble         : null,\n        quote_keys       : false,\n        quote_style      : 0,\n        safari10         : false,\n        semicolons       : true,\n        shebang          : true,\n        shorthand        : undefined,\n        source_map       : null,\n        webkit           : false,\n        width            : 80,\n        wrap_iife        : false,\n    }, true);\n\n    if (options.shorthand === undefined)\n        options.shorthand = options.ecma > 5;\n\n    // Convert comment option to RegExp if neccessary and set up comments filter\n    var comment_filter = return_false; // Default case, throw all comments away\n    if (options.comments) {\n        var comments = options.comments;\n        if (typeof options.comments === \"string\" && /^\\/.*\\/[a-zA-Z]*$/.test(options.comments)) {\n            var regex_pos = options.comments.lastIndexOf(\"/\");\n            comments = new RegExp(\n                options.comments.substr(1, regex_pos - 1),\n                options.comments.substr(regex_pos + 1)\n            );\n        }\n        if (comments instanceof RegExp) {\n            comment_filter = function(comment) {\n                return comment.type != \"comment5\" && comments.test(comment.value);\n            };\n        } else if (typeof comments === \"function\") {\n            comment_filter = function(comment) {\n                return comment.type != \"comment5\" && comments(this, comment);\n            };\n        } else if (comments === \"some\") {\n            comment_filter = is_some_comments;\n        } else { // NOTE includes \"all\" option\n            comment_filter = return_true;\n        }\n    }\n\n    var indentation = 0;\n    var current_col = 0;\n    var current_line = 1;\n    var current_pos = 0;\n    var OUTPUT = \"\";\n\n    var to_utf8 = options.ascii_only ? function(str, identifier) {\n        if (options.ecma >= 6) {\n            str = str.replace(/[\\ud800-\\udbff][\\udc00-\\udfff]/g, function(ch) {\n                var code = get_full_char_code(ch, 0).toString(16);\n                return \"\\\\u{\" + code + \"}\";\n            });\n        }\n        return str.replace(/[\\u0000-\\u001f\\u007f-\\uffff]/g, function(ch) {\n            var code = ch.charCodeAt(0).toString(16);\n            if (code.length <= 2 && !identifier) {\n                while (code.length < 2) code = \"0\" + code;\n                return \"\\\\x\" + code;\n            } else {\n                while (code.length < 4) code = \"0\" + code;\n                return \"\\\\u\" + code;\n            }\n        });\n    } : function(str) {\n        var s = \"\";\n        for (var i = 0, len = str.length; i < len; i++) {\n            if (is_surrogate_pair_head(str[i]) && !is_surrogate_pair_tail(str[i + 1])\n                || is_surrogate_pair_tail(str[i]) && !is_surrogate_pair_head(str[i - 1])) {\n                s += \"\\\\u\" + str.charCodeAt(i).toString(16);\n            } else {\n                s += str[i];\n            }\n        }\n        return s;\n    };\n\n    function make_string(str, quote) {\n        var dq = 0, sq = 0;\n        str = str.replace(/[\\\\\\b\\f\\n\\r\\v\\t\\x22\\x27\\u2028\\u2029\\0\\ufeff]/g,\n          function(s, i) {\n            switch (s) {\n              case '\"': ++dq; return '\"';\n              case \"'\": ++sq; return \"'\";\n              case \"\\\\\": return \"\\\\\\\\\";\n              case \"\\n\": return \"\\\\n\";\n              case \"\\r\": return \"\\\\r\";\n              case \"\\t\": return \"\\\\t\";\n              case \"\\b\": return \"\\\\b\";\n              case \"\\f\": return \"\\\\f\";\n              case \"\\x0B\": return options.ie8 ? \"\\\\x0B\" : \"\\\\v\";\n              case \"\\u2028\": return \"\\\\u2028\";\n              case \"\\u2029\": return \"\\\\u2029\";\n              case \"\\ufeff\": return \"\\\\ufeff\";\n              case \"\\0\":\n                  return /[0-9]/.test(get_full_char(str, i+1)) ? \"\\\\x00\" : \"\\\\0\";\n            }\n            return s;\n        });\n        function quote_single() {\n            return \"'\" + str.replace(/\\x27/g, \"\\\\'\") + \"'\";\n        }\n        function quote_double() {\n            return '\"' + str.replace(/\\x22/g, '\\\\\"') + '\"';\n        }\n        function quote_template() {\n            return \"`\" + str.replace(/`/g, \"\\\\`\") + \"`\";\n        }\n        str = to_utf8(str);\n        if (quote === \"`\") return quote_template();\n        switch (options.quote_style) {\n          case 1:\n            return quote_single();\n          case 2:\n            return quote_double();\n          case 3:\n            return quote == \"'\" ? quote_single() : quote_double();\n          default:\n            return dq > sq ? quote_single() : quote_double();\n        }\n    }\n\n    function encode_string(str, quote) {\n        var ret = make_string(str, quote);\n        if (options.inline_script) {\n            ret = ret.replace(/<\\x2f(script)([>\\/\\t\\n\\f\\r ])/gi, \"<\\\\/$1$2\");\n            ret = ret.replace(/\\x3c!--/g, \"\\\\x3c!--\");\n            ret = ret.replace(/--\\x3e/g, \"--\\\\x3e\");\n        }\n        return ret;\n    }\n\n    function make_name(name) {\n        name = name.toString();\n        name = to_utf8(name, true);\n        return name;\n    }\n\n    function make_indent(back) {\n        return repeat_string(\" \", options.indent_start + indentation - back * options.indent_level);\n    }\n\n    /* -----[ beautification/minification ]----- */\n\n    var has_parens = false;\n    var might_need_space = false;\n    var might_need_semicolon = false;\n    var might_add_newline = 0;\n    var need_newline_indented = false;\n    var need_space = false;\n    var newline_insert = -1;\n    var last = \"\";\n    var mapping_token, mapping_name, mappings = options.source_map && [];\n\n    var do_add_mapping = mappings ? function() {\n        mappings.forEach(function(mapping) {\n            try {\n                options.source_map.add(\n                    mapping.token.file,\n                    mapping.line, mapping.col,\n                    mapping.token.line, mapping.token.col,\n                    !mapping.name && mapping.token.type == \"name\" ? mapping.token.value : mapping.name\n                );\n            } catch(ex) {\n                mapping.token.file != null && AST_Node.warn(\"Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]\", {\n                    file: mapping.token.file,\n                    line: mapping.token.line,\n                    col: mapping.token.col,\n                    cline: mapping.line,\n                    ccol: mapping.col,\n                    name: mapping.name || \"\"\n                });\n            }\n        });\n        mappings = [];\n    } : noop;\n\n    var ensure_line_len = options.max_line_len ? function() {\n        if (current_col > options.max_line_len) {\n            if (might_add_newline) {\n                var left = OUTPUT.slice(0, might_add_newline);\n                var right = OUTPUT.slice(might_add_newline);\n                if (mappings) {\n                    var delta = right.length - current_col;\n                    mappings.forEach(function(mapping) {\n                        mapping.line++;\n                        mapping.col += delta;\n                    });\n                }\n                OUTPUT = left + \"\\n\" + right;\n                current_line++;\n                current_pos++;\n                current_col = right.length;\n            }\n            if (current_col > options.max_line_len) {\n                AST_Node.warn(\"Output exceeds {max_line_len} characters\", options);\n            }\n        }\n        if (might_add_newline) {\n            might_add_newline = 0;\n            do_add_mapping();\n        }\n    } : noop;\n\n    var requireSemicolonChars = makePredicate(\"( [ + * / - , . `\");\n\n    function print(str) {\n        str = String(str);\n        var ch = get_full_char(str, 0);\n        if (need_newline_indented && ch) {\n            need_newline_indented = false;\n            if (ch !== \"\\n\") {\n                print(\"\\n\");\n                indent();\n            }\n        }\n        if (need_space && ch) {\n            need_space = false;\n            if (!/[\\s;})]/.test(ch)) {\n                space();\n            }\n        }\n        newline_insert = -1;\n        var prev = last.charAt(last.length - 1);\n        if (might_need_semicolon) {\n            might_need_semicolon = false;\n\n            if (prev === \":\" && ch === \"}\" || (!ch || !\";}\".includes(ch)) && prev !== \";\") {\n                if (options.semicolons || requireSemicolonChars(ch)) {\n                    OUTPUT += \";\";\n                    current_col++;\n                    current_pos++;\n                } else {\n                    ensure_line_len();\n                    OUTPUT += \"\\n\";\n                    current_pos++;\n                    current_line++;\n                    current_col = 0;\n\n                    if (/^\\s+$/.test(str)) {\n                        // reset the semicolon flag, since we didn't print one\n                        // now and might still have to later\n                        might_need_semicolon = true;\n                    }\n                }\n\n                if (!options.beautify)\n                    might_need_space = false;\n            }\n        }\n\n        if (might_need_space) {\n            if ((is_identifier_char(prev)\n                    && (is_identifier_char(ch) || ch == \"\\\\\"))\n                || (ch == \"/\" && ch == prev)\n                || ((ch == \"+\" || ch == \"-\") && ch == last)\n            ) {\n                OUTPUT += \" \";\n                current_col++;\n                current_pos++;\n            }\n            might_need_space = false;\n        }\n\n        if (mapping_token) {\n            mappings.push({\n                token: mapping_token,\n                name: mapping_name,\n                line: current_line,\n                col: current_col\n            });\n            mapping_token = false;\n            if (!might_add_newline) do_add_mapping();\n        }\n\n        OUTPUT += str;\n        has_parens = str[str.length - 1] == \"(\";\n        current_pos += str.length;\n        var a = str.split(/\\r?\\n/), n = a.length - 1;\n        current_line += n;\n        current_col += a[0].length;\n        if (n > 0) {\n            ensure_line_len();\n            current_col = a[n].length;\n        }\n        last = str;\n    }\n\n    var star = function() {\n        print(\"*\");\n    };\n\n    var space = options.beautify ? function() {\n        print(\" \");\n    } : function() {\n        might_need_space = true;\n    };\n\n    var indent = options.beautify ? function(half) {\n        if (options.beautify) {\n            print(make_indent(half ? 0.5 : 0));\n        }\n    } : noop;\n\n    var with_indent = options.beautify ? function(col, cont) {\n        if (col === true) col = next_indent();\n        var save_indentation = indentation;\n        indentation = col;\n        var ret = cont();\n        indentation = save_indentation;\n        return ret;\n    } : function(col, cont) { return cont(); };\n\n    var newline = options.beautify ? function() {\n        if (newline_insert < 0) return print(\"\\n\");\n        if (OUTPUT[newline_insert] != \"\\n\") {\n            OUTPUT = OUTPUT.slice(0, newline_insert) + \"\\n\" + OUTPUT.slice(newline_insert);\n            current_pos++;\n            current_line++;\n        }\n        newline_insert++;\n    } : options.max_line_len ? function() {\n        ensure_line_len();\n        might_add_newline = OUTPUT.length;\n    } : noop;\n\n    var semicolon = options.beautify ? function() {\n        print(\";\");\n    } : function() {\n        might_need_semicolon = true;\n    };\n\n    function force_semicolon() {\n        might_need_semicolon = false;\n        print(\";\");\n    }\n\n    function next_indent() {\n        return indentation + options.indent_level;\n    }\n\n    function with_block(cont) {\n        var ret;\n        print(\"{\");\n        newline();\n        with_indent(next_indent(), function() {\n            ret = cont();\n        });\n        indent();\n        print(\"}\");\n        return ret;\n    }\n\n    function with_parens(cont) {\n        print(\"(\");\n        //XXX: still nice to have that for argument lists\n        //var ret = with_indent(current_col, cont);\n        var ret = cont();\n        print(\")\");\n        return ret;\n    }\n\n    function with_square(cont) {\n        print(\"[\");\n        //var ret = with_indent(current_col, cont);\n        var ret = cont();\n        print(\"]\");\n        return ret;\n    }\n\n    function comma() {\n        print(\",\");\n        space();\n    }\n\n    function colon() {\n        print(\":\");\n        space();\n    }\n\n    var add_mapping = mappings ? function(token, name) {\n        mapping_token = token;\n        mapping_name = name;\n    } : noop;\n\n    function get() {\n        if (might_add_newline) {\n            ensure_line_len();\n        }\n        return OUTPUT;\n    }\n\n    function has_nlb() {\n        var index = OUTPUT.lastIndexOf(\"\\n\");\n        return /^ *$/.test(OUTPUT.slice(index + 1));\n    }\n\n    function prepend_comments(node) {\n        var self = this;\n        var start = node.start;\n        if (!start) return;\n        if (start.comments_before && start.comments_before._dumped === self) return;\n        var comments = start.comments_before;\n        if (!comments) {\n            comments = start.comments_before = [];\n        }\n        comments._dumped = self;\n\n        if (node instanceof AST_Exit && node.value) {\n            var tw = new TreeWalker(function(node) {\n                var parent = tw.parent();\n                if (parent instanceof AST_Exit\n                    || parent instanceof AST_Binary && parent.left === node\n                    || parent.TYPE == \"Call\" && parent.expression === node\n                    || parent instanceof AST_Conditional && parent.condition === node\n                    || parent instanceof AST_Dot && parent.expression === node\n                    || parent instanceof AST_Sequence && parent.expressions[0] === node\n                    || parent instanceof AST_Sub && parent.expression === node\n                    || parent instanceof AST_UnaryPostfix) {\n                    if (!node.start) return;\n                    var text = node.start.comments_before;\n                    if (text && text._dumped !== self) {\n                        text._dumped = self;\n                        comments = comments.concat(text);\n                    }\n                } else {\n                    return true;\n                }\n            });\n            tw.push(node);\n            node.value.walk(tw);\n        }\n\n        if (current_pos == 0) {\n            if (comments.length > 0 && options.shebang && comments[0].type == \"comment5\") {\n                print(\"#!\" + comments.shift().value + \"\\n\");\n                indent();\n            }\n            var preamble = options.preamble;\n            if (preamble) {\n                print(preamble.replace(/\\r\\n?|[\\n\\u2028\\u2029]|\\s*$/g, \"\\n\"));\n            }\n        }\n\n        comments = comments.filter(comment_filter, node);\n        if (comments.length == 0) return;\n        var last_nlb = has_nlb();\n        comments.forEach(function(c, i) {\n            if (!last_nlb) {\n                if (c.nlb) {\n                    print(\"\\n\");\n                    indent();\n                    last_nlb = true;\n                } else if (i > 0) {\n                    space();\n                }\n            }\n            if (/comment[134]/.test(c.type)) {\n                print(\"//\" + c.value.replace(/[@#]__PURE__/g, \" \") + \"\\n\");\n                indent();\n                last_nlb = true;\n            } else if (c.type == \"comment2\") {\n                print(\"/*\" + c.value.replace(/[@#]__PURE__/g, \" \") + \"*/\");\n                last_nlb = false;\n            }\n        });\n        if (!last_nlb) {\n            if (start.nlb) {\n                print(\"\\n\");\n                indent();\n            } else {\n                space();\n            }\n        }\n    }\n\n    function append_comments(node, tail) {\n        var self = this;\n        var token = node.end;\n        if (!token) return;\n        var comments = token[tail ? \"comments_before\" : \"comments_after\"];\n        if (!comments || comments._dumped === self) return;\n        if (!(node instanceof AST_Statement || all(comments, function(c) {\n            return !/comment[134]/.test(c.type);\n        }))) return;\n        comments._dumped = self;\n        var insert = OUTPUT.length;\n        comments.filter(comment_filter, node).forEach(function(c, i) {\n            need_space = false;\n            if (need_newline_indented) {\n                print(\"\\n\");\n                indent();\n                need_newline_indented = false;\n            } else if (c.nlb && (i > 0 || !has_nlb())) {\n                print(\"\\n\");\n                indent();\n            } else if (i > 0 || !tail) {\n                space();\n            }\n            if (/comment[134]/.test(c.type)) {\n                print(\"//\" + c.value.replace(/[@#]__PURE__/g, \" \"));\n                need_newline_indented = true;\n            } else if (c.type == \"comment2\") {\n                print(\"/*\" + c.value.replace(/[@#]__PURE__/g, \" \") + \"*/\");\n                need_space = true;\n            }\n        });\n        if (OUTPUT.length > insert) newline_insert = insert;\n    }\n\n    var stack = [];\n    return {\n        get             : get,\n        toString        : get,\n        indent          : indent,\n        indentation     : function() { return indentation; },\n        current_width   : function() { return current_col - indentation; },\n        should_break    : function() { return options.width && this.current_width() >= options.width; },\n        has_parens      : function() { return has_parens; },\n        newline         : newline,\n        print           : print,\n        star            : star,\n        space           : space,\n        comma           : comma,\n        colon           : colon,\n        last            : function() { return last; },\n        semicolon       : semicolon,\n        force_semicolon : force_semicolon,\n        to_utf8         : to_utf8,\n        print_name      : function(name) { print(make_name(name)); },\n        print_string    : function(str, quote, escape_directive) {\n            var encoded = encode_string(str, quote);\n            if (escape_directive === true && !encoded.includes(\"\\\\\")) {\n                // Insert semicolons to break directive prologue\n                if (!EXPECT_DIRECTIVE.test(OUTPUT)) {\n                    force_semicolon();\n                }\n                force_semicolon();\n            }\n            print(encoded);\n        },\n        print_template_string_chars: function(str) {\n            var encoded = encode_string(str, \"`\").replace(/\\${/g, \"\\\\${\");\n            return print(encoded.substr(1, encoded.length - 2));\n        },\n        encode_string   : encode_string,\n        next_indent     : next_indent,\n        with_indent     : with_indent,\n        with_block      : with_block,\n        with_parens     : with_parens,\n        with_square     : with_square,\n        add_mapping     : add_mapping,\n        option          : function(opt) { return options[opt]; },\n        prepend_comments: readonly ? noop : prepend_comments,\n        append_comments : readonly || comment_filter === return_false ? noop : append_comments,\n        line            : function() { return current_line; },\n        col             : function() { return current_col; },\n        pos             : function() { return current_pos; },\n        push_node       : function(node) { stack.push(node); },\n        pop_node        : function() { return stack.pop(); },\n        parent          : function(n) {\n            return stack[stack.length - 2 - (n || 0)];\n        }\n    };\n\n}\n\n/* -----[ code generators ]----- */\n\n(function() {\n\n    /* -----[ utils ]----- */\n\n    function DEFPRINT(nodetype, generator) {\n        nodetype.DEFMETHOD(\"_codegen\", generator);\n    }\n\n    var in_directive = false;\n    var active_scope = null;\n    var use_asm = null;\n\n    AST_Node.DEFMETHOD(\"print\", function(stream, force_parens) {\n        var self = this, generator = self._codegen;\n        if (self instanceof AST_Scope) {\n            active_scope = self;\n        } else if (!use_asm && self instanceof AST_Directive && self.value == \"use asm\") {\n            use_asm = active_scope;\n        }\n        function doit() {\n            stream.prepend_comments(self);\n            self.add_source_map(stream);\n            generator(self, stream);\n            stream.append_comments(self);\n        }\n        stream.push_node(self);\n        if (force_parens || self.needs_parens(stream)) {\n            stream.with_parens(doit);\n        } else {\n            doit();\n        }\n        stream.pop_node();\n        if (self === use_asm) {\n            use_asm = null;\n        }\n    });\n    AST_Node.DEFMETHOD(\"_print\", AST_Node.prototype.print);\n\n    AST_Node.DEFMETHOD(\"print_to_string\", function(options) {\n        var s = OutputStream(options);\n        this.print(s);\n        return s.get();\n    });\n\n    /* -----[ PARENTHESES ]----- */\n\n    function PARENS(nodetype, func) {\n        if (Array.isArray(nodetype)) {\n            nodetype.forEach(function(nodetype) {\n                PARENS(nodetype, func);\n            });\n        } else {\n            nodetype.DEFMETHOD(\"needs_parens\", func);\n        }\n    }\n\n    PARENS(AST_Node, return_false);\n\n    // a function expression needs parens around it when it's provably\n    // the first token to appear in a statement.\n    PARENS(AST_Function, function(output) {\n        if (!output.has_parens() && first_in_statement(output)) {\n            return true;\n        }\n\n        if (output.option(\"webkit\")) {\n            var p = output.parent();\n            if (p instanceof AST_PropAccess && p.expression === this) {\n                return true;\n            }\n        }\n\n        if (output.option(\"wrap_iife\")) {\n            var p = output.parent();\n            return p instanceof AST_Call && p.expression === this;\n        }\n\n        return false;\n    });\n\n    PARENS(AST_Arrow, function(output) {\n        var p = output.parent();\n        return p instanceof AST_PropAccess && p.expression === this;\n    });\n\n    // same goes for an object literal, because otherwise it would be\n    // interpreted as a block of code.\n    PARENS(AST_Object, function(output) {\n        return !output.has_parens() && first_in_statement(output);\n    });\n\n    PARENS(AST_ClassExpression, first_in_statement);\n\n    PARENS(AST_Unary, function(output) {\n        var p = output.parent();\n        return p instanceof AST_PropAccess && p.expression === this\n            || p instanceof AST_Call && p.expression === this\n            || p instanceof AST_Binary\n                && p.operator === \"**\"\n                && this instanceof AST_UnaryPrefix\n                && p.left === this\n                && this.operator !== \"++\"\n                && this.operator !== \"--\";\n    });\n\n    PARENS(AST_Await, function(output) {\n        var p = output.parent();\n        return p instanceof AST_PropAccess && p.expression === this\n            || p instanceof AST_Call && p.expression === this\n            || output.option(\"safari10\") && p instanceof AST_UnaryPrefix;\n    });\n\n    PARENS(AST_Sequence, function(output) {\n        var p = output.parent();\n        return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)\n            || p instanceof AST_Unary                         // !(foo, bar, baz)\n            || p instanceof AST_Binary                        // 1 + (2, 3) + 4 ==> 8\n            || p instanceof AST_VarDef                        // var a = (1, 2), b = a + a; ==> b == 4\n            || p instanceof AST_PropAccess                    // (1, {foo:2}).foo or (1, {foo:2})[\"foo\"] ==> 2\n            || p instanceof AST_Array                         // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]\n            || p instanceof AST_ObjectProperty                // { foo: (1, 2) }.foo ==> 2\n            || p instanceof AST_Conditional                   /* (false, true) ? (a = 10, b = 20) : (c = 30)\n                                                               * ==> 20 (side effect, set a := 10 and b := 20) */\n            || p instanceof AST_Arrow                         // x => (x, x)\n            || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))\n            || p instanceof AST_Expansion                     // [...(a, b)]\n            || p instanceof AST_ForOf && this === p.object    // for (e of (foo, bar)) {}\n            || p instanceof AST_Yield                         // yield (foo, bar)\n            || p instanceof AST_Export                        // export default (foo, bar)\n        ;\n    });\n\n    PARENS(AST_Binary, function(output) {\n        var p = output.parent();\n        // (foo && bar)()\n        if (p instanceof AST_Call && p.expression === this)\n            return true;\n        // typeof (foo && bar)\n        if (p instanceof AST_Unary)\n            return true;\n        // (foo && bar)[\"prop\"], (foo && bar).prop\n        if (p instanceof AST_PropAccess && p.expression === this)\n            return true;\n        // this deals with precedence: 3 * (2 + 1)\n        if (p instanceof AST_Binary) {\n            var po = p.operator, pp = PRECEDENCE[po];\n            var so = this.operator, sp = PRECEDENCE[so];\n            if (pp > sp\n                || (pp == sp\n                    && (this === p.right || po == \"**\"))) {\n                return true;\n            }\n        }\n    });\n\n    PARENS(AST_Yield, function(output) {\n        var p = output.parent();\n        // (yield 1) + (yield 2)\n        // a = yield 3\n        if (p instanceof AST_Binary && p.operator !== \"=\")\n            return true;\n        // (yield 1)()\n        // new (yield 1)()\n        if (p instanceof AST_Call && p.expression === this)\n            return true;\n        // (yield 1) ? yield 2 : yield 3\n        if (p instanceof AST_Conditional && p.condition === this)\n            return true;\n        // -(yield 4)\n        if (p instanceof AST_Unary)\n            return true;\n        // (yield x).foo\n        // (yield x)['foo']\n        if (p instanceof AST_PropAccess && p.expression === this)\n            return true;\n    });\n\n    PARENS(AST_PropAccess, function(output) {\n        var p = output.parent();\n        if (p instanceof AST_New && p.expression === this) {\n            // i.e. new (foo.bar().baz)\n            //\n            // if there's one call into this subtree, then we need\n            // parens around it too, otherwise the call will be\n            // interpreted as passing the arguments to the upper New\n            // expression.\n            var parens = false;\n            this.walk(new TreeWalker(function(node) {\n                if (parens || node instanceof AST_Scope) return true;\n                if (node instanceof AST_Call) {\n                    parens = true;\n                    return true;\n                }\n            }));\n            return parens;\n        }\n    });\n\n    PARENS(AST_Call, function(output) {\n        var p = output.parent(), p1;\n        if (p instanceof AST_New && p.expression === this\n            || p instanceof AST_Export && p.is_default && this.expression instanceof AST_Function)\n            return true;\n\n        // workaround for Safari bug.\n        // https://bugs.webkit.org/show_bug.cgi?id=123506\n        return this.expression instanceof AST_Function\n            && p instanceof AST_PropAccess\n            && p.expression === this\n            && (p1 = output.parent(1)) instanceof AST_Assign\n            && p1.left === p;\n    });\n\n    PARENS(AST_New, function(output) {\n        var p = output.parent();\n        if (!need_constructor_parens(this, output)\n            && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)[\"getTime\"]()\n                || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)\n            return true;\n    });\n\n    PARENS(AST_Number, function(output) {\n        var p = output.parent();\n        if (p instanceof AST_PropAccess && p.expression === this) {\n            var value = this.getValue();\n            if (value < 0 || /^0/.test(make_num(value))) {\n                return true;\n            }\n        }\n    });\n\n    PARENS([ AST_Assign, AST_Conditional ], function(output) {\n        var p = output.parent();\n        // !(a = false) → true\n        if (p instanceof AST_Unary)\n            return true;\n        // 1 + (a = 2) + 3 → 6, side effect setting a = 2\n        if (p instanceof AST_Binary && !(p instanceof AST_Assign))\n            return true;\n        // (a = func)() —or— new (a = Object)()\n        if (p instanceof AST_Call && p.expression === this)\n            return true;\n        // (a = foo) ? bar : baz\n        if (p instanceof AST_Conditional && p.condition === this)\n            return true;\n        // (a = foo)[\"prop\"] —or— (a = foo).prop\n        if (p instanceof AST_PropAccess && p.expression === this)\n            return true;\n        // ({a, b} = {a: 1, b: 2}), a destructuring assignment\n        if (this instanceof AST_Assign && this.left instanceof AST_Destructuring && this.left.is_array === false)\n            return true;\n    });\n\n    /* -----[ PRINTERS ]----- */\n\n    DEFPRINT(AST_Directive, function(self, output) {\n        output.print_string(self.value, self.quote);\n        output.semicolon();\n    });\n\n    DEFPRINT(AST_Expansion, function (self, output) {\n        output.print(\"...\");\n        self.expression.print(output);\n    });\n\n    DEFPRINT(AST_Destructuring, function (self, output) {\n        output.print(self.is_array ? \"[\" : \"{\");\n        var len = self.names.length;\n        self.names.forEach(function (name, i) {\n            if (i > 0) output.comma();\n            name.print(output);\n            // If the final element is a hole, we need to make sure it\n            // doesn't look like a trailing comma, by inserting an actual\n            // trailing comma.\n            if (i == len - 1 && name instanceof AST_Hole) output.comma();\n        });\n        output.print(self.is_array ? \"]\" : \"}\");\n    });\n\n    DEFPRINT(AST_Debugger, function(self, output) {\n        output.print(\"debugger\");\n        output.semicolon();\n    });\n\n    /* -----[ statements ]----- */\n\n    function display_body(body, is_toplevel, output, allow_directives) {\n        var last = body.length - 1;\n        in_directive = allow_directives;\n        body.forEach(function(stmt, i) {\n            if (in_directive === true && !(stmt instanceof AST_Directive ||\n                stmt instanceof AST_EmptyStatement ||\n                (stmt instanceof AST_SimpleStatement && stmt.body instanceof AST_String)\n            )) {\n                in_directive = false;\n            }\n            if (!(stmt instanceof AST_EmptyStatement)) {\n                output.indent();\n                stmt.print(output);\n                if (!(i == last && is_toplevel)) {\n                    output.newline();\n                    if (is_toplevel) output.newline();\n                }\n            }\n            if (in_directive === true &&\n                stmt instanceof AST_SimpleStatement &&\n                stmt.body instanceof AST_String\n            ) {\n                in_directive = false;\n            }\n        });\n        in_directive = false;\n    }\n\n    AST_StatementWithBody.DEFMETHOD(\"_do_print_body\", function(output) {\n        force_statement(this.body, output);\n    });\n\n    DEFPRINT(AST_Statement, function(self, output) {\n        self.body.print(output);\n        output.semicolon();\n    });\n    DEFPRINT(AST_Toplevel, function(self, output) {\n        display_body(self.body, true, output, true);\n        output.print(\"\");\n    });\n    DEFPRINT(AST_LabeledStatement, function(self, output) {\n        self.label.print(output);\n        output.colon();\n        self.body.print(output);\n    });\n    DEFPRINT(AST_SimpleStatement, function(self, output) {\n        self.body.print(output);\n        output.semicolon();\n    });\n    function print_braced_empty(self, output) {\n        output.print(\"{\");\n        output.with_indent(output.next_indent(), function() {\n            output.append_comments(self, true);\n        });\n        output.print(\"}\");\n    }\n    function print_braced(self, output, allow_directives) {\n        if (self.body.length > 0) {\n            output.with_block(function() {\n                display_body(self.body, false, output, allow_directives);\n            });\n        } else print_braced_empty(self, output);\n    }\n    DEFPRINT(AST_BlockStatement, function(self, output) {\n        print_braced(self, output);\n    });\n    DEFPRINT(AST_EmptyStatement, function(self, output) {\n        output.semicolon();\n    });\n    DEFPRINT(AST_Do, function(self, output) {\n        output.print(\"do\");\n        output.space();\n        make_block(self.body, output);\n        output.space();\n        output.print(\"while\");\n        output.space();\n        output.with_parens(function() {\n            self.condition.print(output);\n        });\n        output.semicolon();\n    });\n    DEFPRINT(AST_While, function(self, output) {\n        output.print(\"while\");\n        output.space();\n        output.with_parens(function() {\n            self.condition.print(output);\n        });\n        output.space();\n        self._do_print_body(output);\n    });\n    DEFPRINT(AST_For, function(self, output) {\n        output.print(\"for\");\n        output.space();\n        output.with_parens(function() {\n            if (self.init) {\n                if (self.init instanceof AST_Definitions) {\n                    self.init.print(output);\n                } else {\n                    parenthesize_for_noin(self.init, output, true);\n                }\n                output.print(\";\");\n                output.space();\n            } else {\n                output.print(\";\");\n            }\n            if (self.condition) {\n                self.condition.print(output);\n                output.print(\";\");\n                output.space();\n            } else {\n                output.print(\";\");\n            }\n            if (self.step) {\n                self.step.print(output);\n            }\n        });\n        output.space();\n        self._do_print_body(output);\n    });\n    DEFPRINT(AST_ForIn, function(self, output) {\n        output.print(\"for\");\n        if (self.await) {\n            output.space();\n            output.print(\"await\");\n        }\n        output.space();\n        output.with_parens(function() {\n            self.init.print(output);\n            output.space();\n            output.print(self instanceof AST_ForOf ? \"of\" : \"in\");\n            output.space();\n            self.object.print(output);\n        });\n        output.space();\n        self._do_print_body(output);\n    });\n    DEFPRINT(AST_With, function(self, output) {\n        output.print(\"with\");\n        output.space();\n        output.with_parens(function() {\n            self.expression.print(output);\n        });\n        output.space();\n        self._do_print_body(output);\n    });\n\n    /* -----[ functions ]----- */\n    AST_Lambda.DEFMETHOD(\"_do_print\", function(output, nokeyword) {\n        var self = this;\n        if (!nokeyword) {\n            if (self.async) {\n                output.print(\"async\");\n                output.space();\n            }\n            output.print(\"function\");\n            if (self.is_generator) {\n                output.star();\n            }\n            if (self.name) {\n                output.space();\n            }\n        }\n        if (self.name instanceof AST_Symbol) {\n            self.name.print(output);\n        } else if (nokeyword && self.name instanceof AST_Node) {\n            output.with_square(function() {\n                self.name.print(output); // Computed method name\n            });\n        }\n        output.with_parens(function() {\n            self.argnames.forEach(function(arg, i) {\n                if (i) output.comma();\n                arg.print(output);\n            });\n        });\n        output.space();\n        print_braced(self, output, true);\n    });\n    DEFPRINT(AST_Lambda, function(self, output) {\n        self._do_print(output);\n    });\n\n    DEFPRINT(AST_PrefixedTemplateString, function(self, output) {\n        var tag = self.prefix;\n        var parenthesize_tag = tag instanceof AST_Arrow\n            || tag instanceof AST_Binary\n            || tag instanceof AST_Conditional\n            || tag instanceof AST_Sequence\n            || tag instanceof AST_Unary;\n        if (parenthesize_tag) output.print(\"(\");\n        self.prefix.print(output);\n        if (parenthesize_tag) output.print(\")\");\n        self.template_string.print(output);\n    });\n    DEFPRINT(AST_TemplateString, function(self, output) {\n        var is_tagged = output.parent() instanceof AST_PrefixedTemplateString;\n\n        output.print(\"`\");\n        for (var i = 0; i < self.segments.length; i++) {\n            if (!(self.segments[i] instanceof AST_TemplateSegment)) {\n                output.print(\"${\");\n                self.segments[i].print(output);\n                output.print(\"}\");\n            } else if (is_tagged) {\n                output.print(self.segments[i].raw);\n            } else {\n                output.print_template_string_chars(self.segments[i].value);\n            }\n        }\n        output.print(\"`\");\n    });\n\n    AST_Arrow.DEFMETHOD(\"_do_print\", function(output) {\n        var self = this;\n        var parent = output.parent();\n        var needs_parens = parent instanceof AST_Binary ||\n            parent instanceof AST_Unary ||\n            (parent instanceof AST_Call && self === parent.expression);\n        if (needs_parens) { output.print(\"(\"); }\n        if (self.async) {\n            output.print(\"async\");\n            output.space();\n        }\n        if (self.argnames.length === 1 && self.argnames[0] instanceof AST_Symbol) {\n            self.argnames[0].print(output);\n        } else {\n            output.with_parens(function() {\n                self.argnames.forEach(function(arg, i) {\n                    if (i) output.comma();\n                    arg.print(output);\n                });\n            });\n        }\n        output.space();\n        output.print(\"=>\");\n        output.space();\n        if (self.body instanceof AST_Node) {\n            self.body.print(output);\n        } else {\n            print_braced(self, output);\n        }\n        if (needs_parens) { output.print(\")\"); }\n    });\n\n    /* -----[ exits ]----- */\n    AST_Exit.DEFMETHOD(\"_do_print\", function(output, kind) {\n        output.print(kind);\n        if (this.value) {\n            output.space();\n            this.value.print(output);\n        }\n        output.semicolon();\n    });\n    DEFPRINT(AST_Return, function(self, output) {\n        self._do_print(output, \"return\");\n    });\n    DEFPRINT(AST_Throw, function(self, output) {\n        self._do_print(output, \"throw\");\n    });\n\n    /* -----[ yield ]----- */\n\n    DEFPRINT(AST_Yield, function(self, output) {\n        var star = self.is_star ? \"*\" : \"\";\n        output.print(\"yield\" + star);\n        if (self.expression) {\n            output.space();\n            self.expression.print(output);\n        }\n    });\n\n    DEFPRINT(AST_Await, function(self, output) {\n        output.print(\"await\");\n        output.space();\n        var e = self.expression;\n        var parens = !(\n               e instanceof AST_Call\n            || e instanceof AST_SymbolRef\n            || e instanceof AST_PropAccess\n            || e instanceof AST_Unary\n            || e instanceof AST_Constant\n        );\n        if (parens) output.print(\"(\");\n        self.expression.print(output);\n        if (parens) output.print(\")\");\n    });\n\n    /* -----[ loop control ]----- */\n    AST_LoopControl.DEFMETHOD(\"_do_print\", function(output, kind) {\n        output.print(kind);\n        if (this.label) {\n            output.space();\n            this.label.print(output);\n        }\n        output.semicolon();\n    });\n    DEFPRINT(AST_Break, function(self, output) {\n        self._do_print(output, \"break\");\n    });\n    DEFPRINT(AST_Continue, function(self, output) {\n        self._do_print(output, \"continue\");\n    });\n\n    /* -----[ if ]----- */\n    function make_then(self, output) {\n        var b = self.body;\n        if (output.option(\"braces\")\n            || output.option(\"ie8\") && b instanceof AST_Do)\n            return make_block(b, output);\n        // The squeezer replaces \"block\"-s that contain only a single\n        // statement with the statement itself; technically, the AST\n        // is correct, but this can create problems when we output an\n        // IF having an ELSE clause where the THEN clause ends in an\n        // IF *without* an ELSE block (then the outer ELSE would refer\n        // to the inner IF).  This function checks for this case and\n        // adds the block braces if needed.\n        if (!b) return output.force_semicolon();\n        while (true) {\n            if (b instanceof AST_If) {\n                if (!b.alternative) {\n                    make_block(self.body, output);\n                    return;\n                }\n                b = b.alternative;\n            } else if (b instanceof AST_StatementWithBody) {\n                b = b.body;\n            } else break;\n        }\n        force_statement(self.body, output);\n    }\n    DEFPRINT(AST_If, function(self, output) {\n        output.print(\"if\");\n        output.space();\n        output.with_parens(function() {\n            self.condition.print(output);\n        });\n        output.space();\n        if (self.alternative) {\n            make_then(self, output);\n            output.space();\n            output.print(\"else\");\n            output.space();\n            if (self.alternative instanceof AST_If)\n                self.alternative.print(output);\n            else\n                force_statement(self.alternative, output);\n        } else {\n            self._do_print_body(output);\n        }\n    });\n\n    /* -----[ switch ]----- */\n    DEFPRINT(AST_Switch, function(self, output) {\n        output.print(\"switch\");\n        output.space();\n        output.with_parens(function() {\n            self.expression.print(output);\n        });\n        output.space();\n        var last = self.body.length - 1;\n        if (last < 0) print_braced_empty(self, output);\n        else output.with_block(function() {\n            self.body.forEach(function(branch, i) {\n                output.indent(true);\n                branch.print(output);\n                if (i < last && branch.body.length > 0)\n                    output.newline();\n            });\n        });\n    });\n    AST_SwitchBranch.DEFMETHOD(\"_do_print_body\", function(output) {\n        output.newline();\n        this.body.forEach(function(stmt) {\n            output.indent();\n            stmt.print(output);\n            output.newline();\n        });\n    });\n    DEFPRINT(AST_Default, function(self, output) {\n        output.print(\"default:\");\n        self._do_print_body(output);\n    });\n    DEFPRINT(AST_Case, function(self, output) {\n        output.print(\"case\");\n        output.space();\n        self.expression.print(output);\n        output.print(\":\");\n        self._do_print_body(output);\n    });\n\n    /* -----[ exceptions ]----- */\n    DEFPRINT(AST_Try, function(self, output) {\n        output.print(\"try\");\n        output.space();\n        print_braced(self, output);\n        if (self.bcatch) {\n            output.space();\n            self.bcatch.print(output);\n        }\n        if (self.bfinally) {\n            output.space();\n            self.bfinally.print(output);\n        }\n    });\n    DEFPRINT(AST_Catch, function(self, output) {\n        output.print(\"catch\");\n        if (self.argname) {\n            output.space();\n            output.with_parens(function() {\n                self.argname.print(output);\n            });\n        }\n        output.space();\n        print_braced(self, output);\n    });\n    DEFPRINT(AST_Finally, function(self, output) {\n        output.print(\"finally\");\n        output.space();\n        print_braced(self, output);\n    });\n\n    /* -----[ var/const ]----- */\n    AST_Definitions.DEFMETHOD(\"_do_print\", function(output, kind) {\n        output.print(kind);\n        output.space();\n        this.definitions.forEach(function(def, i) {\n            if (i) output.comma();\n            def.print(output);\n        });\n        var p = output.parent();\n        var in_for = p instanceof AST_For || p instanceof AST_ForIn;\n        var output_semicolon = !in_for || p && p.init !== this;\n        if (output_semicolon)\n            output.semicolon();\n    });\n    DEFPRINT(AST_Let, function(self, output) {\n        self._do_print(output, \"let\");\n    });\n    DEFPRINT(AST_Var, function(self, output) {\n        self._do_print(output, \"var\");\n    });\n    DEFPRINT(AST_Const, function(self, output) {\n        self._do_print(output, \"const\");\n    });\n    DEFPRINT(AST_Import, function(self, output) {\n        output.print(\"import\");\n        output.space();\n        if (self.imported_name) {\n            self.imported_name.print(output);\n        }\n        if (self.imported_name && self.imported_names) {\n            output.print(\",\");\n            output.space();\n        }\n        if (self.imported_names) {\n            if (self.imported_names.length === 1 && self.imported_names[0].foreign_name.name === \"*\") {\n                self.imported_names[0].print(output);\n            } else {\n                output.print(\"{\");\n                self.imported_names.forEach(function (name_import, i) {\n                    output.space();\n                    name_import.print(output);\n                    if (i < self.imported_names.length - 1) {\n                        output.print(\",\");\n                    }\n                });\n                output.space();\n                output.print(\"}\");\n            }\n        }\n        if (self.imported_name || self.imported_names) {\n            output.space();\n            output.print(\"from\");\n            output.space();\n        }\n        self.module_name.print(output);\n        output.semicolon();\n    });\n\n    DEFPRINT(AST_NameMapping, function(self, output) {\n        var is_import = output.parent() instanceof AST_Import;\n        var definition = self.name.definition();\n        var names_are_different =\n            (definition && definition.mangled_name || self.name.name) !==\n            self.foreign_name.name;\n        if (names_are_different) {\n            if (is_import) {\n                output.print(self.foreign_name.name);\n            } else {\n                self.name.print(output);\n            }\n            output.space();\n            output.print(\"as\");\n            output.space();\n            if (is_import) {\n                self.name.print(output);\n            } else {\n                output.print(self.foreign_name.name);\n            }\n        } else {\n            self.name.print(output);\n        }\n    });\n\n    DEFPRINT(AST_Export, function(self, output) {\n        output.print(\"export\");\n        output.space();\n        if (self.is_default) {\n            output.print(\"default\");\n            output.space();\n        }\n        if (self.exported_names) {\n            if (self.exported_names.length === 1 && self.exported_names[0].name.name === \"*\") {\n                self.exported_names[0].print(output);\n            } else {\n                output.print(\"{\");\n                self.exported_names.forEach(function(name_export, i) {\n                    output.space();\n                    name_export.print(output);\n                    if (i < self.exported_names.length - 1) {\n                        output.print(\",\");\n                    }\n                });\n                output.space();\n                output.print(\"}\");\n            }\n        } else if (self.exported_value) {\n            self.exported_value.print(output);\n        } else if (self.exported_definition) {\n            self.exported_definition.print(output);\n            if (self.exported_definition instanceof AST_Definitions) return;\n        }\n        if (self.module_name) {\n            output.space();\n            output.print(\"from\");\n            output.space();\n            self.module_name.print(output);\n        }\n        if (self.exported_value\n                && !(self.exported_value instanceof AST_Defun ||\n                    self.exported_value instanceof AST_Function ||\n                    self.exported_value instanceof AST_Class)\n            || self.module_name\n            || self.exported_names\n        ) {\n            output.semicolon();\n        }\n    });\n\n    function parenthesize_for_noin(node, output, noin) {\n        var parens = false;\n        // need to take some precautions here:\n        //    https://github.com/mishoo/UglifyJS2/issues/60\n        if (noin) node.walk(new TreeWalker(function(node) {\n            if (parens || node instanceof AST_Scope) return true;\n            if (node instanceof AST_Binary && node.operator == \"in\") {\n                parens = true;\n                return true;\n            }\n        }));\n        node.print(output, parens);\n    }\n\n    DEFPRINT(AST_VarDef, function(self, output) {\n        self.name.print(output);\n        if (self.value) {\n            output.space();\n            output.print(\"=\");\n            output.space();\n            var p = output.parent(1);\n            var noin = p instanceof AST_For || p instanceof AST_ForIn;\n            parenthesize_for_noin(self.value, output, noin);\n        }\n    });\n\n    /* -----[ other expressions ]----- */\n    DEFPRINT(AST_Call, function(self, output) {\n        self.expression.print(output);\n        if (self instanceof AST_New && !need_constructor_parens(self, output))\n            return;\n        if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {\n            output.add_mapping(self.start);\n        }\n        output.with_parens(function() {\n            self.args.forEach(function(expr, i) {\n                if (i) output.comma();\n                expr.print(output);\n            });\n        });\n    });\n    DEFPRINT(AST_New, function(self, output) {\n        output.print(\"new\");\n        output.space();\n        AST_Call.prototype._codegen(self, output);\n    });\n\n    AST_Sequence.DEFMETHOD(\"_do_print\", function(output) {\n        this.expressions.forEach(function(node, index) {\n            if (index > 0) {\n                output.comma();\n                if (output.should_break()) {\n                    output.newline();\n                    output.indent();\n                }\n            }\n            node.print(output);\n        });\n    });\n    DEFPRINT(AST_Sequence, function(self, output) {\n        self._do_print(output);\n        // var p = output.parent();\n        // if (p instanceof AST_Statement) {\n        //     output.with_indent(output.next_indent(), function(){\n        //         self._do_print(output);\n        //     });\n        // } else {\n        //     self._do_print(output);\n        // }\n    });\n    DEFPRINT(AST_Dot, function(self, output) {\n        var expr = self.expression;\n        expr.print(output);\n        var prop = self.property;\n        if (output.option(\"ie8\") && RESERVED_WORDS(prop)) {\n            output.print(\"[\");\n            output.add_mapping(self.end);\n            output.print_string(prop);\n            output.print(\"]\");\n        } else {\n            if (expr instanceof AST_Number && expr.getValue() >= 0) {\n                if (!/[xa-f.)]/i.test(output.last())) {\n                    output.print(\".\");\n                }\n            }\n            output.print(\".\");\n            // the name after dot would be mapped about here.\n            output.add_mapping(self.end);\n            output.print_name(prop);\n        }\n    });\n    DEFPRINT(AST_Sub, function(self, output) {\n        self.expression.print(output);\n        output.print(\"[\");\n        self.property.print(output);\n        output.print(\"]\");\n    });\n    DEFPRINT(AST_UnaryPrefix, function(self, output) {\n        var op = self.operator;\n        output.print(op);\n        if (/^[a-z]/i.test(op)\n            || (/[+-]$/.test(op)\n                && self.expression instanceof AST_UnaryPrefix\n                && /^[+-]/.test(self.expression.operator))) {\n            output.space();\n        }\n        self.expression.print(output);\n    });\n    DEFPRINT(AST_UnaryPostfix, function(self, output) {\n        self.expression.print(output);\n        output.print(self.operator);\n    });\n    DEFPRINT(AST_Binary, function(self, output) {\n        var op = self.operator;\n        self.left.print(output);\n        if (op[0] == \">\" /* \">>\" \">>>\" \">\" \">=\" */\n            && self.left instanceof AST_UnaryPostfix\n            && self.left.operator == \"--\") {\n            // space is mandatory to avoid outputting -->\n            output.print(\" \");\n        } else {\n            // the space is optional depending on \"beautify\"\n            output.space();\n        }\n        output.print(op);\n        if ((op == \"<\" || op == \"<<\")\n            && self.right instanceof AST_UnaryPrefix\n            && self.right.operator == \"!\"\n            && self.right.expression instanceof AST_UnaryPrefix\n            && self.right.expression.operator == \"--\") {\n            // space is mandatory to avoid outputting <!--\n            output.print(\" \");\n        } else {\n            // the space is optional depending on \"beautify\"\n            output.space();\n        }\n        self.right.print(output);\n    });\n    DEFPRINT(AST_Conditional, function(self, output) {\n        self.condition.print(output);\n        output.space();\n        output.print(\"?\");\n        output.space();\n        self.consequent.print(output);\n        output.space();\n        output.colon();\n        self.alternative.print(output);\n    });\n\n    /* -----[ literals ]----- */\n    DEFPRINT(AST_Array, function(self, output) {\n        output.with_square(function() {\n            var a = self.elements, len = a.length;\n            if (len > 0) output.space();\n            a.forEach(function(exp, i) {\n                if (i) output.comma();\n                exp.print(output);\n                // If the final element is a hole, we need to make sure it\n                // doesn't look like a trailing comma, by inserting an actual\n                // trailing comma.\n                if (i === len - 1 && exp instanceof AST_Hole)\n                  output.comma();\n            });\n            if (len > 0) output.space();\n        });\n    });\n    DEFPRINT(AST_Object, function(self, output) {\n        if (self.properties.length > 0) output.with_block(function() {\n            self.properties.forEach(function(prop, i) {\n                if (i) {\n                    output.print(\",\");\n                    output.newline();\n                }\n                output.indent();\n                prop.print(output);\n            });\n            output.newline();\n        });\n        else print_braced_empty(self, output);\n    });\n    DEFPRINT(AST_Class, function(self, output) {\n        output.print(\"class\");\n        output.space();\n        if (self.name) {\n            self.name.print(output);\n            output.space();\n        }\n        if (self.extends) {\n            var parens = (\n                   !(self.extends instanceof AST_SymbolRef)\n                && !(self.extends instanceof AST_PropAccess)\n                && !(self.extends instanceof AST_ClassExpression)\n                && !(self.extends instanceof AST_Function)\n            );\n            output.print(\"extends\");\n            if (parens) {\n                output.print(\"(\");\n            } else {\n                output.space();\n            }\n            self.extends.print(output);\n            if (parens) {\n                output.print(\")\");\n            } else {\n                output.space();\n            }\n        }\n        if (self.properties.length > 0) output.with_block(function() {\n            self.properties.forEach(function(prop, i) {\n                if (i) {\n                    output.newline();\n                }\n                output.indent();\n                prop.print(output);\n            });\n            output.newline();\n        });\n        else output.print(\"{}\");\n    });\n    DEFPRINT(AST_NewTarget, function(self, output) {\n        output.print(\"new.target\");\n    });\n\n    function print_property_name(key, quote, output) {\n        if (output.option(\"quote_keys\")) {\n            output.print_string(key);\n        } else if (\"\" + +key == key && key >= 0) {\n            output.print(make_num(key));\n        } else if (RESERVED_WORDS(key) ? !output.option(\"ie8\") : is_identifier_string(key)) {\n            if (quote && output.option(\"keep_quoted_props\")) {\n                output.print_string(key, quote);\n            } else {\n                output.print_name(key);\n            }\n        } else {\n            output.print_string(key, quote);\n        }\n    }\n\n    DEFPRINT(AST_ObjectKeyVal, function(self, output) {\n        function get_name(self) {\n            var def = self.definition();\n            return def ? def.mangled_name || def.name : self.name;\n        }\n\n        var allowShortHand = output.option(\"shorthand\");\n        if (allowShortHand &&\n            self.value instanceof AST_Symbol &&\n            is_identifier_string(self.key) &&\n            get_name(self.value) === self.key &&\n            is_identifier(self.key)\n        ) {\n            print_property_name(self.key, self.quote, output);\n\n        } else if (allowShortHand &&\n            self.value instanceof AST_DefaultAssign &&\n            self.value.left instanceof AST_Symbol &&\n            is_identifier_string(self.key) &&\n            get_name(self.value.left) === self.key\n        ) {\n            print_property_name(self.key, self.quote, output);\n            output.space();\n            output.print(\"=\");\n            output.space();\n            self.value.right.print(output);\n        } else {\n            if (!(self.key instanceof AST_Node)) {\n                print_property_name(self.key, self.quote, output);\n            } else {\n                output.with_square(function() {\n                    self.key.print(output);\n                });\n            }\n            output.colon();\n            self.value.print(output);\n        }\n    });\n    AST_ObjectProperty.DEFMETHOD(\"_print_getter_setter\", function(type, output) {\n        var self = this;\n        if (self.static) {\n            output.print(\"static\");\n            output.space();\n        }\n        if (type) {\n            output.print(type);\n            output.space();\n        }\n        if (self.key instanceof AST_SymbolMethod) {\n            print_property_name(self.key.name, self.quote, output);\n        } else {\n            output.with_square(function() {\n                self.key.print(output);\n            });\n        }\n        self.value._do_print(output, true);\n    });\n    DEFPRINT(AST_ObjectSetter, function(self, output) {\n        self._print_getter_setter(\"set\", output);\n    });\n    DEFPRINT(AST_ObjectGetter, function(self, output) {\n        self._print_getter_setter(\"get\", output);\n    });\n    DEFPRINT(AST_ConciseMethod, function(self, output) {\n        var type;\n        if (self.is_generator && self.async) {\n            type = \"async*\";\n        } else if (self.is_generator) {\n            type = \"*\";\n        } else if (self.async) {\n            type = \"async\";\n        }\n        self._print_getter_setter(type, output);\n    });\n    AST_Symbol.DEFMETHOD(\"_do_print\", function(output) {\n        var def = this.definition();\n        output.print_name(def ? def.mangled_name || def.name : this.name);\n    });\n    DEFPRINT(AST_Symbol, function (self, output) {\n        self._do_print(output);\n    });\n    DEFPRINT(AST_Hole, noop);\n    DEFPRINT(AST_This, function(self, output) {\n        output.print(\"this\");\n    });\n    DEFPRINT(AST_Super, function(self, output) {\n        output.print(\"super\");\n    });\n    DEFPRINT(AST_Constant, function(self, output) {\n        output.print(self.getValue());\n    });\n    DEFPRINT(AST_String, function(self, output) {\n        output.print_string(self.getValue(), self.quote, in_directive);\n    });\n    DEFPRINT(AST_Number, function(self, output) {\n        if (use_asm && self.start && self.start.raw != null) {\n            output.print(self.start.raw);\n        } else {\n            output.print(make_num(self.getValue()));\n        }\n    });\n\n    DEFPRINT(AST_RegExp, function(self, output) {\n        var regexp = self.getValue();\n        var str = regexp.toString();\n        str = output.to_utf8(str);\n        output.print(str);\n        var p = output.parent();\n        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)\n            output.print(\" \");\n    });\n\n    function force_statement(stat, output) {\n        if (output.option(\"braces\")) {\n            make_block(stat, output);\n        } else {\n            if (!stat || stat instanceof AST_EmptyStatement)\n                output.force_semicolon();\n            else\n                stat.print(output);\n        }\n    }\n\n    // self should be AST_New.  decide if we want to show parens or not.\n    function need_constructor_parens(self, output) {\n        // Always print parentheses with arguments\n        if (self.args.length > 0) return true;\n\n        return output.option(\"beautify\");\n    }\n\n    function best_of(a) {\n        var best = a[0], len = best.length;\n        for (var i = 1; i < a.length; ++i) {\n            if (a[i].length < len) {\n                best = a[i];\n                len = best.length;\n            }\n        }\n        return best;\n    }\n\n    function make_num(num) {\n        var str = num.toString(10), a = [ str.replace(/^0\\./, \".\").replace(\"e+\", \"e\") ], m;\n        if (Math.floor(num) === num) {\n            a.push(\n                (num >= 0 ? \"0x\" : \"-0x\") + num.toString(16).toLowerCase() // probably pointless\n            );\n            if ((m = /^(.*?)(0{3,})$/.exec(num))) {\n                a.push(m[1] + \"e\" + m[2].length);\n            }\n        } else if ((m = /^0?\\.(0+)(.*)$/.exec(num))) {\n            a.push(m[2] + \"e-\" + (m[1].length + m[2].length));\n        }\n        return best_of(a);\n    }\n\n    function make_block(stmt, output) {\n        if (!stmt || stmt instanceof AST_EmptyStatement)\n            output.print(\"{}\");\n        else if (stmt instanceof AST_BlockStatement)\n            stmt.print(output);\n        else output.with_block(function() {\n            output.indent();\n            stmt.print(output);\n            output.newline();\n        });\n    }\n\n    /* -----[ source map generators ]----- */\n\n    function DEFMAP(nodetype, generator) {\n        nodetype.forEach(function(nodetype) {\n            nodetype.DEFMETHOD(\"add_source_map\", generator);\n        });\n    }\n\n    DEFMAP([\n        // We could easily add info for ALL nodes, but it seems to me that\n        // would be quite wasteful, hence this noop in the base class.\n        AST_Node,\n        // since the label symbol will mark it\n        AST_LabeledStatement,\n        AST_Toplevel,\n    ], noop);\n\n    // XXX: I'm not exactly sure if we need it for all of these nodes,\n    // or if we should add even more.\n    DEFMAP([\n        AST_Array,\n        AST_BlockStatement,\n        AST_Catch,\n        AST_Class,\n        AST_Constant,\n        AST_Debugger,\n        AST_Definitions,\n        AST_Directive,\n        AST_Finally,\n        AST_Jump,\n        AST_Lambda,\n        AST_New,\n        AST_Object,\n        AST_StatementWithBody,\n        AST_Symbol,\n        AST_Switch,\n        AST_SwitchBranch,\n        AST_Try,\n    ], function(output) {\n        output.add_mapping(this.start);\n    });\n\n    DEFMAP([\n        AST_ObjectGetter,\n        AST_ObjectSetter,\n    ], function(output) {\n        output.add_mapping(this.start, this.key.name);\n    });\n\n    DEFMAP([ AST_ObjectProperty ], function(output) {\n        output.add_mapping(this.start, this.key);\n    });\n})();\n\nexport {\n    OutputStream,\n};\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    all,\n    defaults,\n    Dictionary,\n    keep_name,\n    member,\n    mergeSort,\n    push_uniq,\n    return_false,\n    return_this,\n    return_true,\n    string_template,\n} from \"./utils.js\";\nimport {\n    AST_Arrow,\n    AST_Block,\n    AST_Call,\n    AST_Class,\n    AST_Conditional,\n    AST_DefClass,\n    AST_Defun,\n    AST_Destructuring,\n    AST_Dot,\n    AST_Export,\n    AST_For,\n    AST_ForIn,\n    AST_Function,\n    AST_Import,\n    AST_IterationStatement,\n    AST_Label,\n    AST_LabeledStatement,\n    AST_LabelRef,\n    AST_Lambda,\n    AST_LoopControl,\n    AST_NameMapping,\n    AST_Node,\n    AST_Scope,\n    AST_Sequence,\n    AST_String,\n    AST_Sub,\n    AST_SwitchBranch,\n    AST_Symbol,\n    AST_SymbolBlockDeclaration,\n    AST_SymbolCatch,\n    AST_SymbolClass,\n    AST_SymbolConst,\n    AST_SymbolDefClass,\n    AST_SymbolDefun,\n    AST_SymbolExport,\n    AST_SymbolFunarg,\n    AST_SymbolImport,\n    AST_SymbolLambda,\n    AST_SymbolLet,\n    AST_SymbolMethod,\n    AST_SymbolRef,\n    AST_SymbolVar,\n    AST_Toplevel,\n    AST_With,\n    TreeWalker,\n} from \"./ast.js\";\nimport {\n    is_identifier,\n    js_error,\n} from \"./parse.js\";\n\nfunction SymbolDef(scope, orig, init) {\n    this.name = orig.name;\n    this.orig = [ orig ];\n    this.init = init;\n    this.eliminated = 0;\n    this.scope = scope;\n    this.references = [];\n    this.replaced = 0;\n    this.global = false;\n    this.export = false;\n    this.mangled_name = null;\n    this.undeclared = false;\n    this.id = SymbolDef.next_id++;\n}\n\nSymbolDef.next_id = 1;\n\nvar MASK_EXPORT_DONT_MANGLE = 1 << 0;\nvar MASK_EXPORT_WANT_MANGLE = 1 << 1;\n\nSymbolDef.prototype = {\n    unmangleable: function(options) {\n        if (!options) options = {};\n\n        return this.global && !options.toplevel\n            || (this.export & MASK_EXPORT_DONT_MANGLE)\n            || this.undeclared\n            || !options.eval && this.scope.pinned()\n            || (this.orig[0] instanceof AST_SymbolLambda\n                  || this.orig[0] instanceof AST_SymbolDefun) && keep_name(options.keep_fnames, this.orig[0].name)\n            || this.orig[0] instanceof AST_SymbolMethod\n            || (this.orig[0] instanceof AST_SymbolClass\n                  || this.orig[0] instanceof AST_SymbolDefClass) && keep_name(options.keep_classnames, this.orig[0].name);\n    },\n    mangle: function(options) {\n        var cache = options.cache && options.cache.props;\n        if (this.global && cache && cache.has(this.name)) {\n            this.mangled_name = cache.get(this.name);\n        } else if (!this.mangled_name && !this.unmangleable(options)) {\n            var s = this.scope;\n            var sym = this.orig[0];\n            if (options.ie8 && sym instanceof AST_SymbolLambda)\n                s = s.parent_scope;\n            var def;\n            if (def = this.redefined()) {\n                this.mangled_name = def.mangled_name || def.name;\n            } else\n                this.mangled_name = s.next_mangled(options, this);\n            if (this.global && cache) {\n                cache.set(this.name, this.mangled_name);\n            }\n        }\n    },\n    redefined: function() {\n        return this.defun && this.defun.variables.get(this.name);\n    }\n};\n\nAST_Toplevel.DEFMETHOD(\"figure_out_scope\", function(options) {\n    options = defaults(options, {\n        cache: null,\n        ie8: false,\n        safari10: false,\n    });\n\n    // pass 1: setup scope chaining and handle definitions\n    var self = this;\n    var scope = self.parent_scope = null;\n    var labels = new Dictionary();\n    var defun = null;\n    var in_destructuring = null;\n    var for_scopes = [];\n    var tw = new TreeWalker(function(node, descend) {\n        if (node.is_block_scope()) {\n            var save_scope = scope;\n            node.block_scope = scope = new AST_Scope(node);\n            scope.init_scope_vars(save_scope);\n            if (!(node instanceof AST_Scope)) {\n                scope.uses_with = save_scope.uses_with;\n                scope.uses_eval = save_scope.uses_eval;\n                scope.directives = save_scope.directives;\n            }\n            if (options.safari10) {\n                if (node instanceof AST_For || node instanceof AST_ForIn) {\n                    for_scopes.push(scope);\n                }\n            }\n            descend();\n            scope = save_scope;\n            return true;\n        }\n        if (node instanceof AST_Destructuring) {\n            in_destructuring = node;  // These don't nest\n            descend();\n            in_destructuring = null;\n            return true;\n        }\n        if (node instanceof AST_Scope) {\n            node.init_scope_vars(scope);\n            var save_scope = scope;\n            var save_defun = defun;\n            var save_labels = labels;\n            defun = scope = node;\n            labels = new Dictionary();\n            descend();\n            scope = save_scope;\n            defun = save_defun;\n            labels = save_labels;\n            return true;        // don't descend again in TreeWalker\n        }\n        if (node instanceof AST_LabeledStatement) {\n            var l = node.label;\n            if (labels.has(l.name)) {\n                throw new Error(string_template(\"Label {name} defined twice\", l));\n            }\n            labels.set(l.name, l);\n            descend();\n            labels.del(l.name);\n            return true;        // no descend again\n        }\n        if (node instanceof AST_With) {\n            for (var s = scope; s; s = s.parent_scope)\n                s.uses_with = true;\n            return;\n        }\n        if (node instanceof AST_Symbol) {\n            node.scope = scope;\n        }\n        if (node instanceof AST_Label) {\n            node.thedef = node;\n            node.references = [];\n        }\n        if (node instanceof AST_SymbolLambda) {\n            defun.def_function(node, node.name == \"arguments\" ? undefined : defun);\n        } else if (node instanceof AST_SymbolDefun) {\n            // Careful here, the scope where this should be defined is\n            // the parent scope.  The reason is that we enter a new\n            // scope when we encounter the AST_Defun node (which is\n            // instanceof AST_Scope) but we get to the symbol a bit\n            // later.\n            mark_export((node.scope = defun.parent_scope.get_defun_scope()).def_function(node, defun), 1);\n        } else if (node instanceof AST_SymbolClass) {\n            mark_export(defun.def_variable(node, defun), 1);\n        } else if (node instanceof AST_SymbolImport) {\n            scope.def_variable(node);\n        } else if (node instanceof AST_SymbolDefClass) {\n            // This deals with the name of the class being available\n            // inside the class.\n            mark_export((node.scope = defun.parent_scope).def_function(node, defun), 1);\n        } else if (node instanceof AST_SymbolVar\n            || node instanceof AST_SymbolLet\n            || node instanceof AST_SymbolConst) {\n            var def;\n            if (node instanceof AST_SymbolBlockDeclaration) {\n                def = scope.def_variable(node, null);\n            } else {\n                def = defun.def_variable(node, node.TYPE == \"SymbolVar\" ? null : undefined);\n            }\n            if (!all(def.orig, function(sym) {\n                if (sym === node) return true;\n                if (node instanceof AST_SymbolBlockDeclaration) {\n                    return sym instanceof AST_SymbolLambda;\n                }\n                return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst);\n            })) {\n                js_error(\n                    node.name + \" redeclared\",\n                    node.start.file,\n                    node.start.line,\n                    node.start.col,\n                    node.start.pos\n                );\n            }\n            if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2);\n            def.destructuring = in_destructuring;\n            if (defun !== scope) {\n                node.mark_enclosed(options);\n                var def = scope.find_variable(node);\n                if (node.thedef !== def) {\n                    node.thedef = def;\n                    node.reference(options);\n                }\n            }\n        } else if (node instanceof AST_SymbolCatch) {\n            scope.def_variable(node).defun = defun;\n        } else if (node instanceof AST_LabelRef) {\n            var sym = labels.get(node.name);\n            if (!sym) throw new Error(string_template(\"Undefined label {name} [{line},{col}]\", {\n                name: node.name,\n                line: node.start.line,\n                col: node.start.col\n            }));\n            node.thedef = sym;\n        }\n        if (!(scope instanceof AST_Toplevel) && (node instanceof AST_Export || node instanceof AST_Import)) {\n            js_error(\n                node.TYPE + \" statement may only appear at top level\",\n                node.start.file,\n                node.start.line,\n                node.start.col,\n                node.start.pos\n            );\n        }\n\n        function mark_export(def, level) {\n            if (in_destructuring) {\n                var i = 0;\n                do {\n                    level++;\n                } while (tw.parent(i++) !== in_destructuring);\n            }\n            var node = tw.parent(level);\n            if (def.export = node instanceof AST_Export && MASK_EXPORT_DONT_MANGLE) {\n                var exported = node.exported_definition;\n                if ((exported instanceof AST_Defun || exported instanceof AST_DefClass) && node.is_default) {\n                    def.export = MASK_EXPORT_WANT_MANGLE;\n                }\n            }\n        }\n    });\n    self.walk(tw);\n\n    // pass 2: find back references and eval\n    self.globals = new Dictionary();\n    var tw = new TreeWalker(function(node, descend) {\n        if (node instanceof AST_LoopControl && node.label) {\n            node.label.thedef.references.push(node);\n            return true;\n        }\n        if (node instanceof AST_SymbolRef) {\n            var name = node.name;\n            if (name == \"eval\" && tw.parent() instanceof AST_Call) {\n                for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {\n                    s.uses_eval = true;\n                }\n            }\n            var sym;\n            if (tw.parent() instanceof AST_NameMapping && tw.parent(1).module_name\n                || !(sym = node.scope.find_variable(name))) {\n                sym = self.def_global(node);\n                if (node instanceof AST_SymbolExport) sym.export = MASK_EXPORT_DONT_MANGLE;\n            } else if (sym.scope instanceof AST_Lambda && name == \"arguments\") {\n                sym.scope.uses_arguments = true;\n            }\n            node.thedef = sym;\n            node.reference(options);\n            if (node.scope.is_block_scope()\n                && !(sym.orig[0] instanceof AST_SymbolBlockDeclaration)) {\n                node.scope = node.scope.get_defun_scope();\n            }\n            return true;\n        }\n        // ensure mangling works if catch reuses a scope variable\n        var def;\n        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {\n            var s = node.scope;\n            while (s) {\n                push_uniq(s.enclosed, def);\n                if (s === def.scope) break;\n                s = s.parent_scope;\n            }\n        }\n    });\n    self.walk(tw);\n\n    // pass 3: work around IE8 and Safari catch scope bugs\n    if (options.ie8 || options.safari10) {\n        self.walk(new TreeWalker(function(node, descend) {\n            if (node instanceof AST_SymbolCatch) {\n                var name = node.name;\n                var refs = node.thedef.references;\n                var scope = node.thedef.defun;\n                var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);\n                refs.forEach(function(ref) {\n                    ref.thedef = def;\n                    ref.reference(options);\n                });\n                node.thedef = def;\n                node.reference(options);\n                return true;\n            }\n        }));\n    }\n\n    // pass 4: add symbol definitions to loop scopes\n    // Safari/Webkit bug workaround - loop init let variable shadowing argument.\n    // https://github.com/mishoo/UglifyJS2/issues/1753\n    // https://bugs.webkit.org/show_bug.cgi?id=171041\n    if (options.safari10) {\n        for (var i = 0; i < for_scopes.length; i++) {\n            var scope = for_scopes[i];\n            scope.parent_scope.variables.each(function(def) {\n                push_uniq(scope.enclosed, def);\n            });\n        }\n    }\n});\n\nAST_Toplevel.DEFMETHOD(\"def_global\", function(node) {\n    var globals = this.globals, name = node.name;\n    if (globals.has(name)) {\n        return globals.get(name);\n    } else {\n        var g = new SymbolDef(this, node);\n        g.undeclared = true;\n        g.global = true;\n        globals.set(name, g);\n        return g;\n    }\n});\n\nAST_Scope.DEFMETHOD(\"init_scope_vars\", function(parent_scope) {\n    this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)\n    this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)\n    this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement\n    this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`\n    this.parent_scope = parent_scope;   // the parent scope\n    this.enclosed = [];                 // a list of variables from this or outer scope(s) that are referenced from this or inner scopes\n    this.cname = -1;                    // the current index for mangling functions/variables\n});\n\nAST_Node.DEFMETHOD(\"is_block_scope\", return_false);\nAST_Class.DEFMETHOD(\"is_block_scope\", return_false);\nAST_Lambda.DEFMETHOD(\"is_block_scope\", return_false);\nAST_Toplevel.DEFMETHOD(\"is_block_scope\", return_false);\nAST_SwitchBranch.DEFMETHOD(\"is_block_scope\", return_false);\nAST_Block.DEFMETHOD(\"is_block_scope\", return_true);\nAST_IterationStatement.DEFMETHOD(\"is_block_scope\", return_true);\n\nAST_Lambda.DEFMETHOD(\"init_scope_vars\", function() {\n    AST_Scope.prototype.init_scope_vars.apply(this, arguments);\n    this.uses_arguments = false;\n    this.def_variable(new AST_SymbolFunarg({\n        name: \"arguments\",\n        start: this.start,\n        end: this.end\n    }));\n});\n\nAST_Arrow.DEFMETHOD(\"init_scope_vars\", function() {\n    AST_Scope.prototype.init_scope_vars.apply(this, arguments);\n    this.uses_arguments = false;\n});\n\nAST_Symbol.DEFMETHOD(\"mark_enclosed\", function(options) {\n    var def = this.definition();\n    var s = this.scope;\n    while (s) {\n        push_uniq(s.enclosed, def);\n        if (options.keep_fnames) {\n            s.functions.each(function(d) {\n                if (keep_name(options.keep_fnames, d.name)) {\n                    push_uniq(def.scope.enclosed, d);\n                }\n            });\n        }\n        if (s === def.scope) break;\n        s = s.parent_scope;\n    }\n});\n\nAST_Symbol.DEFMETHOD(\"reference\", function(options) {\n    this.definition().references.push(this);\n    this.mark_enclosed(options);\n});\n\nAST_Scope.DEFMETHOD(\"find_variable\", function(name) {\n    if (name instanceof AST_Symbol) name = name.name;\n    return this.variables.get(name)\n        || (this.parent_scope && this.parent_scope.find_variable(name));\n});\n\nAST_Scope.DEFMETHOD(\"def_function\", function(symbol, init) {\n    var def = this.def_variable(symbol, init);\n    if (!def.init || def.init instanceof AST_Defun) def.init = init;\n    this.functions.set(symbol.name, def);\n    return def;\n});\n\nAST_Scope.DEFMETHOD(\"def_variable\", function(symbol, init) {\n    var def = this.variables.get(symbol.name);\n    if (def) {\n        def.orig.push(symbol);\n        if (def.init && (def.scope !== symbol.scope || def.init instanceof AST_Function)) {\n            def.init = init;\n        }\n    } else {\n        def = new SymbolDef(this, symbol, init);\n        this.variables.set(symbol.name, def);\n        def.global = !this.parent_scope;\n    }\n    return symbol.thedef = def;\n});\n\nfunction next_mangled(scope, options) {\n    var ext = scope.enclosed;\n    out: while (true) {\n        var m = base54(++scope.cname);\n        if (!is_identifier(m)) continue; // skip over \"do\"\n\n        // https://github.com/mishoo/UglifyJS2/issues/242 -- do not\n        // shadow a name reserved from mangling.\n        if (member(m, options.reserved)) continue;\n\n        // we must ensure that the mangled name does not shadow a name\n        // from some parent scope that is referenced in this or in\n        // inner scopes.\n        for (var i = ext.length; --i >= 0;) {\n            var sym = ext[i];\n            var name = sym.mangled_name || (sym.unmangleable(options) && sym.name);\n            if (m == name) continue out;\n        }\n        return m;\n    }\n}\n\nAST_Scope.DEFMETHOD(\"next_mangled\", function(options) {\n    return next_mangled(this, options);\n});\n\nAST_Toplevel.DEFMETHOD(\"next_mangled\", function(options) {\n    var name;\n    do {\n        name = next_mangled(this, options);\n    } while (this.mangled_names.has(name));\n    return name;\n});\n\nAST_Function.DEFMETHOD(\"next_mangled\", function(options, def) {\n    // #179, #326\n    // in Safari strict mode, something like (function x(x){...}) is a syntax error;\n    // a function expression's argument cannot shadow the function expression's name\n\n    var tricky_def = def.orig[0] instanceof AST_SymbolFunarg && this.name && this.name.definition();\n\n    // the function's mangled_name is null when keep_fnames is true\n    var tricky_name = tricky_def ? tricky_def.mangled_name || tricky_def.name : null;\n\n    while (true) {\n        var name = next_mangled(this, options);\n        if (!tricky_name || tricky_name != name)\n            return name;\n    }\n});\n\nAST_Symbol.DEFMETHOD(\"unmangleable\", function(options) {\n    var def = this.definition();\n    return !def || def.unmangleable(options);\n});\n\n// labels are always mangleable\nAST_Label.DEFMETHOD(\"unmangleable\", return_false);\n\nAST_Symbol.DEFMETHOD(\"unreferenced\", function() {\n    return !this.definition().references.length && !this.scope.pinned();\n});\n\nAST_Symbol.DEFMETHOD(\"definition\", function() {\n    return this.thedef;\n});\n\nAST_Symbol.DEFMETHOD(\"global\", function() {\n    return this.definition().global;\n});\n\nAST_Toplevel.DEFMETHOD(\"_default_mangler_options\", function(options) {\n    options = defaults(options, {\n        eval        : false,\n        ie8         : false,\n        keep_classnames: false,\n        keep_fnames : false,\n        module      : false,\n        reserved    : [],\n        toplevel    : false,\n    });\n    if (options[\"module\"]) {\n        options.toplevel = true;\n    }\n    if (!Array.isArray(options.reserved)) options.reserved = [];\n    // Never mangle arguments\n    push_uniq(options.reserved, \"arguments\");\n    return options;\n});\n\nAST_Toplevel.DEFMETHOD(\"mangle_names\", function(options) {\n    options = this._default_mangler_options(options);\n\n    // We only need to mangle declaration nodes.  Special logic wired\n    // into the code generator will display the mangled name if it's\n    // present (and for AST_SymbolRef-s it'll use the mangled name of\n    // the AST_SymbolDeclaration that it points to).\n    var lname = -1;\n    var to_mangle = [];\n\n    var mangled_names = this.mangled_names = new Set();\n    if (options.cache) {\n        this.globals.each(collect);\n        if (options.cache.props) {\n            options.cache.props.each(function(mangled_name) {\n                mangled_names.add(mangled_name);\n            });\n        }\n    }\n\n    var tw = new TreeWalker(function(node, descend) {\n        if (node instanceof AST_LabeledStatement) {\n            // lname is incremented when we get to the AST_Label\n            var save_nesting = lname;\n            descend();\n            lname = save_nesting;\n            return true;        // don't descend again in TreeWalker\n        }\n        if (node instanceof AST_Scope) {\n            node.variables.each(collect);\n            return;\n        }\n        if (node.is_block_scope()) {\n            node.block_scope.variables.each(collect);\n            return;\n        }\n        if (node instanceof AST_Label) {\n            var name;\n            do name = base54(++lname); while (!is_identifier(name));\n            node.mangled_name = name;\n            return true;\n        }\n        if (!(options.ie8 || options.safari10) && node instanceof AST_SymbolCatch) {\n            to_mangle.push(node.definition());\n            return;\n        }\n    });\n    this.walk(tw);\n    to_mangle.forEach(function(def) { def.mangle(options); });\n\n    function collect(symbol) {\n        if (!member(symbol.name, options.reserved)) {\n            if (!(symbol.export & MASK_EXPORT_DONT_MANGLE)) {\n                to_mangle.push(symbol);\n            }\n        }\n    }\n});\n\nAST_Toplevel.DEFMETHOD(\"find_colliding_names\", function(options) {\n    var cache = options.cache && options.cache.props;\n    var avoid = Object.create(null);\n    options.reserved.forEach(to_avoid);\n    this.globals.each(add_def);\n    this.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_Scope) node.variables.each(add_def);\n        if (node instanceof AST_SymbolCatch) add_def(node.definition());\n    }));\n    return avoid;\n\n    function to_avoid(name) {\n        avoid[name] = true;\n    }\n\n    function add_def(def) {\n        var name = def.name;\n        if (def.global && cache && cache.has(name)) name = cache.get(name);\n        else if (!def.unmangleable(options)) return;\n        to_avoid(name);\n    }\n});\n\nAST_Toplevel.DEFMETHOD(\"expand_names\", function(options) {\n    base54.reset();\n    base54.sort();\n    options = this._default_mangler_options(options);\n    var avoid = this.find_colliding_names(options);\n    var cname = 0;\n    this.globals.each(rename);\n    this.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_Scope) node.variables.each(rename);\n        if (node instanceof AST_SymbolCatch) rename(node.definition());\n    }));\n\n    function next_name() {\n        var name;\n        do {\n            name = base54(cname++);\n        } while (avoid[name] || !is_identifier(name));\n        return name;\n    }\n\n    function rename(def) {\n        if (def.global && options.cache) return;\n        if (def.unmangleable(options)) return;\n        if (member(def.name, options.reserved)) return;\n        var d = def.redefined();\n        def.name = d ? d.name : next_name();\n        def.orig.forEach(function(sym) {\n            sym.name = def.name;\n        });\n        def.references.forEach(function(sym) {\n            sym.name = def.name;\n        });\n    }\n});\n\nAST_Node.DEFMETHOD(\"tail_node\", return_this);\nAST_Sequence.DEFMETHOD(\"tail_node\", function() {\n    return this.expressions[this.expressions.length - 1];\n});\n\nAST_Toplevel.DEFMETHOD(\"compute_char_frequency\", function(options) {\n    options = this._default_mangler_options(options);\n    try {\n        AST_Node.prototype.print = function(stream, force_parens) {\n            this._print(stream, force_parens);\n            if (this instanceof AST_Symbol && !this.unmangleable(options)) {\n                base54.consider(this.name, -1);\n            } else if (options.properties) {\n                if (this instanceof AST_Dot) {\n                    base54.consider(this.property, -1);\n                } else if (this instanceof AST_Sub) {\n                    skip_string(this.property);\n                }\n            }\n        };\n        base54.consider(this.print_to_string(), 1);\n    } finally {\n        AST_Node.prototype.print = AST_Node.prototype._print;\n    }\n    base54.sort();\n\n    function skip_string(node) {\n        if (node instanceof AST_String) {\n            base54.consider(node.value, -1);\n        } else if (node instanceof AST_Conditional) {\n            skip_string(node.consequent);\n            skip_string(node.alternative);\n        } else if (node instanceof AST_Sequence) {\n            skip_string(node.tail_node());\n        }\n    }\n});\n\nvar base54 = (function() {\n    var leading = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_\".split(\"\");\n    var digits = \"0123456789\".split(\"\");\n    var chars, frequency;\n    function reset() {\n        frequency = Object.create(null);\n        leading.forEach(function(ch) {\n            frequency[ch] = 0;\n        });\n        digits.forEach(function(ch) {\n            frequency[ch] = 0;\n        });\n    }\n    base54.consider = function(str, delta) {\n        for (var i = str.length; --i >= 0;) {\n            frequency[str[i]] += delta;\n        }\n    };\n    function compare(a, b) {\n        return frequency[b] - frequency[a];\n    }\n    base54.sort = function() {\n        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));\n    };\n    base54.reset = reset;\n    reset();\n    function base54(num) {\n        var ret = \"\", base = 54;\n        num++;\n        do {\n            num--;\n            ret += chars[num % base];\n            num = Math.floor(num / base);\n            base = 64;\n        } while (num > 0);\n        return ret;\n    }\n    return base54;\n})();\n\nexport {\n    base54,\n    SymbolDef,\n};\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport {\n    all,\n    defaults,\n    Dictionary,\n    find_if,\n    first_in_statement,\n    HOP,\n    keep_name,\n    makePredicate,\n    MAP,\n    member,\n    merge,\n    noop,\n    remove,\n    return_false,\n    return_null,\n    return_this,\n    return_true,\n    string_template,\n} from \"../utils.js\";\nimport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Await,\n    AST_Binary,\n    AST_Block,\n    AST_BlockStatement,\n    AST_Boolean,\n    AST_Break,\n    AST_Call,\n    AST_Case,\n    AST_Catch,\n    AST_Class,\n    AST_ClassExpression,\n    AST_ConciseMethod,\n    AST_Conditional,\n    AST_Const,\n    AST_Constant,\n    AST_Continue,\n    AST_Debugger,\n    AST_Default,\n    AST_DefaultAssign,\n    AST_DefClass,\n    AST_Definitions,\n    AST_Defun,\n    AST_Destructuring,\n    AST_Directive,\n    AST_Do,\n    AST_Dot,\n    AST_DWLoop,\n    AST_EmptyStatement,\n    AST_Exit,\n    AST_Expansion,\n    AST_Export,\n    AST_False,\n    AST_Finally,\n    AST_For,\n    AST_ForIn,\n    AST_Function,\n    AST_Hole,\n    AST_If,\n    AST_Import,\n    AST_Infinity,\n    AST_IterationStatement,\n    AST_Jump,\n    AST_LabeledStatement,\n    AST_Lambda,\n    AST_Let,\n    AST_LoopControl,\n    AST_NaN,\n    AST_New,\n    AST_Node,\n    AST_Null,\n    AST_Number,\n    AST_Object,\n    AST_ObjectGetter,\n    AST_ObjectKeyVal,\n    AST_ObjectProperty,\n    AST_PrefixedTemplateString,\n    AST_PropAccess,\n    AST_RegExp,\n    AST_Return,\n    AST_Scope,\n    AST_Sequence,\n    AST_SimpleStatement,\n    AST_Statement,\n    AST_String,\n    AST_Sub,\n    AST_Switch,\n    AST_SwitchBranch,\n    AST_Symbol,\n    AST_SymbolBlockDeclaration,\n    AST_SymbolCatch,\n    AST_SymbolConst,\n    AST_SymbolDeclaration,\n    AST_SymbolDefun,\n    AST_SymbolExport,\n    AST_SymbolFunarg,\n    AST_SymbolLambda,\n    AST_SymbolMethod,\n    AST_SymbolRef,\n    AST_SymbolVar,\n    AST_TemplateSegment,\n    AST_TemplateString,\n    AST_This,\n    AST_Toplevel,\n    AST_True,\n    AST_Try,\n    AST_Unary,\n    AST_UnaryPostfix,\n    AST_UnaryPrefix,\n    AST_Undefined,\n    AST_Var,\n    AST_VarDef,\n    AST_While,\n    AST_With,\n    AST_Yield,\n    TreeTransformer,\n    TreeWalker,\n    walk_body,\n} from \"../ast.js\";\nimport {\n    is_identifier_string,\n    JS_Parse_Error,\n    parse,\n    PRECEDENCE,\n} from \"../parse.js\";\nimport { OutputStream } from \"../output.js\";\nimport {\n    base54,\n    SymbolDef,\n} from \"../scope.js\";\n\nfunction Compressor(options, false_by_default) {\n    if (!(this instanceof Compressor))\n        return new Compressor(options, false_by_default);\n    TreeTransformer.call(this, this.before, this.after);\n    if (options.defaults !== undefined && !options.defaults) false_by_default = true;\n    this.options = defaults(options, {\n        arguments     : false,\n        arrows        : !false_by_default,\n        booleans      : !false_by_default,\n        booleans_as_integers : false,\n        collapse_vars : !false_by_default,\n        comparisons   : !false_by_default,\n        computed_props: !false_by_default,\n        conditionals  : !false_by_default,\n        dead_code     : !false_by_default,\n        defaults      : true,\n        directives    : !false_by_default,\n        drop_console  : false,\n        drop_debugger : !false_by_default,\n        ecma          : 5,\n        evaluate      : !false_by_default,\n        expression    : false,\n        global_defs   : false,\n        hoist_funs    : false,\n        hoist_props   : !false_by_default,\n        hoist_vars    : false,\n        ie8           : false,\n        if_return     : !false_by_default,\n        inline        : !false_by_default,\n        join_vars     : !false_by_default,\n        keep_classnames: false,\n        keep_fargs    : true,\n        keep_fnames   : false,\n        keep_infinity : false,\n        loops         : !false_by_default,\n        module        : false,\n        negate_iife   : !false_by_default,\n        passes        : 1,\n        properties    : !false_by_default,\n        pure_getters  : !false_by_default && \"strict\",\n        pure_funcs    : null,\n        reduce_funcs  : !false_by_default,\n        reduce_vars   : !false_by_default,\n        sequences     : !false_by_default,\n        side_effects  : !false_by_default,\n        switches      : !false_by_default,\n        top_retain    : null,\n        toplevel      : !!(options && options[\"top_retain\"]),\n        typeofs       : !false_by_default,\n        unsafe        : false,\n        unsafe_arrows : false,\n        unsafe_comps  : false,\n        unsafe_Function: false,\n        unsafe_math   : false,\n        unsafe_methods: false,\n        unsafe_proto  : false,\n        unsafe_regexp : false,\n        unsafe_undefined: false,\n        unused        : !false_by_default,\n        warnings      : false,\n    }, true);\n    var global_defs = this.options[\"global_defs\"];\n    if (typeof global_defs == \"object\") for (var key in global_defs) {\n        if (/^@/.test(key) && HOP(global_defs, key)) {\n            global_defs[key.slice(1)] = parse(global_defs[key], {\n                expression: true\n            });\n        }\n    }\n    if (this.options[\"inline\"] === true) this.options[\"inline\"] = 3;\n    var pure_funcs = this.options[\"pure_funcs\"];\n    if (typeof pure_funcs == \"function\") {\n        this.pure_funcs = pure_funcs;\n    } else {\n        this.pure_funcs = pure_funcs ? function(node) {\n            return !pure_funcs.includes(node.expression.print_to_string());\n        } : return_true;\n    }\n    var top_retain = this.options[\"top_retain\"];\n    if (top_retain instanceof RegExp) {\n        this.top_retain = function(def) {\n            return top_retain.test(def.name);\n        };\n    } else if (typeof top_retain == \"function\") {\n        this.top_retain = top_retain;\n    } else if (top_retain) {\n        if (typeof top_retain == \"string\") {\n            top_retain = top_retain.split(/,/);\n        }\n        this.top_retain = function(def) {\n            return top_retain.includes(def.name);\n        };\n    }\n    if (this.options[\"module\"]) {\n        this.directives[\"use strict\"] = true;\n        this.options[\"toplevel\"] = true;\n    }\n    var toplevel = this.options[\"toplevel\"];\n    this.toplevel = typeof toplevel == \"string\" ? {\n        funcs: /funcs/.test(toplevel),\n        vars: /vars/.test(toplevel)\n    } : {\n        funcs: toplevel,\n        vars: toplevel\n    };\n    var sequences = this.options[\"sequences\"];\n    this.sequences_limit = sequences == 1 ? 800 : sequences | 0;\n    this.warnings_produced = {};\n}\n\nCompressor.prototype = new TreeTransformer;\nmerge(Compressor.prototype, {\n    option: function(key) { return this.options[key]; },\n    exposed: function(def) {\n        if (def.export) return true;\n        if (def.global) for (var i = 0, len = def.orig.length; i < len; i++)\n            if (!this.toplevel[def.orig[i] instanceof AST_SymbolDefun ? \"funcs\" : \"vars\"])\n                return true;\n        return false;\n    },\n    in_boolean_context: function() {\n        if (!this.option(\"booleans\")) return false;\n        var self = this.self();\n        for (var i = 0, p; p = this.parent(i); i++) {\n            if (p instanceof AST_SimpleStatement\n                || p instanceof AST_Conditional && p.condition === self\n                || p instanceof AST_DWLoop && p.condition === self\n                || p instanceof AST_For && p.condition === self\n                || p instanceof AST_If && p.condition === self\n                || p instanceof AST_UnaryPrefix && p.operator == \"!\" && p.expression === self) {\n                return true;\n            }\n            if (p instanceof AST_Binary && (p.operator == \"&&\" || p.operator == \"||\")\n                || p instanceof AST_Conditional\n                || p.tail_node() === self) {\n                self = p;\n            } else {\n                return false;\n            }\n        }\n    },\n    compress: function(node) {\n        node = node.resolve_defines(this);\n        if (this.option(\"expression\")) {\n            node.process_expression(true);\n        }\n        var passes = +this.options.passes || 1;\n        var min_count = 1 / 0;\n        var stopping = false;\n        var mangle = { ie8: this.option(\"ie8\") };\n        for (var pass = 0; pass < passes; pass++) {\n            node.figure_out_scope(mangle);\n            if (pass === 0 && this.option(\"drop_console\")) {\n                // must be run before reduce_vars and compress pass\n                node = node.drop_console();\n            }\n            if (pass > 0 || this.option(\"reduce_vars\"))\n                node.reset_opt_flags(this);\n            node = node.transform(this);\n            if (passes > 1) {\n                var count = 0;\n                node.walk(new TreeWalker(function() {\n                    count++;\n                }));\n                this.info(\"pass \" + pass + \": last_count: \" + min_count + \", count: \" + count);\n                if (count < min_count) {\n                    min_count = count;\n                    stopping = false;\n                } else if (stopping) {\n                    break;\n                } else {\n                    stopping = true;\n                }\n            }\n        }\n        if (this.option(\"expression\")) {\n            node.process_expression(false);\n        }\n        return node;\n    },\n    info: function() {\n        if (this.options.warnings == \"verbose\") {\n            AST_Node.warn.apply(AST_Node, arguments);\n        }\n    },\n    warn: function(text, props) {\n        if (this.options.warnings) {\n            // only emit unique warnings\n            var message = string_template(text, props);\n            if (!(message in this.warnings_produced)) {\n                this.warnings_produced[message] = true;\n                AST_Node.warn.apply(AST_Node, arguments);\n            }\n        }\n    },\n    clear_warnings: function() {\n        this.warnings_produced = {};\n    },\n    before: function(node, descend, in_list) {\n        if (node._squeezed) return node;\n        var was_scope = false;\n        if (node instanceof AST_Scope) {\n            node = node.hoist_properties(this);\n            node = node.hoist_declarations(this);\n            was_scope = true;\n        }\n        // Before https://github.com/mishoo/UglifyJS2/pull/1602 AST_Node.optimize()\n        // would call AST_Node.transform() if a different instance of AST_Node is\n        // produced after def_optimize().\n        // This corrupts TreeWalker.stack, which cause AST look-ups to malfunction.\n        // Migrate and defer all children's AST_Node.transform() to below, which\n        // will now happen after this parent AST_Node has been properly substituted\n        // thus gives a consistent AST snapshot.\n        descend(node, this);\n        // Existing code relies on how AST_Node.optimize() worked, and omitting the\n        // following replacement call would result in degraded efficiency of both\n        // output and performance.\n        descend(node, this);\n        var opt = node.optimize(this);\n        if (was_scope && opt instanceof AST_Scope) {\n            opt.drop_unused(this);\n            descend(opt, this);\n        }\n        if (opt === node) opt._squeezed = true;\n        return opt;\n    }\n});\n\n(function() {\n\n    function def_optimize(node, optimizer) {\n        node.DEFMETHOD(\"optimize\", function(compressor) {\n            var self = this;\n            if (self._optimized) return self;\n            if (compressor.has_directive(\"use asm\")) return self;\n            var opt = optimizer(self, compressor);\n            opt._optimized = true;\n            return opt;\n        });\n    }\n\n    def_optimize(AST_Node, function(self, compressor) {\n        return self;\n    });\n\n    AST_Toplevel.DEFMETHOD(\"drop_console\", function() {\n        return this.transform(new TreeTransformer(function(self) {\n            if (self.TYPE == \"Call\") {\n                var exp = self.expression;\n                if (exp instanceof AST_PropAccess) {\n                    var name = exp.expression;\n                    while (name.expression) {\n                        name = name.expression;\n                    }\n                    if (is_undeclared_ref(name) && name.name == \"console\") {\n                        return make_node(AST_Undefined, self);\n                    }\n                }\n            }\n        }));\n    });\n\n    AST_Node.DEFMETHOD(\"equivalent_to\", function(node) {\n        return this.TYPE == node.TYPE && this.print_to_string() == node.print_to_string();\n    });\n\n    AST_Scope.DEFMETHOD(\"process_expression\", function(insert, compressor) {\n        var self = this;\n        var tt = new TreeTransformer(function(node) {\n            if (insert && node instanceof AST_SimpleStatement) {\n                return make_node(AST_Return, node, {\n                    value: node.body\n                });\n            }\n            if (!insert && node instanceof AST_Return) {\n                if (compressor) {\n                    var value = node.value && node.value.drop_side_effect_free(compressor, true);\n                    return value ? make_node(AST_SimpleStatement, node, {\n                        body: value\n                    }) : make_node(AST_EmptyStatement, node);\n                }\n                return make_node(AST_SimpleStatement, node, {\n                    body: node.value || make_node(AST_UnaryPrefix, node, {\n                        operator: \"void\",\n                        expression: make_node(AST_Number, node, {\n                            value: 0\n                        })\n                    })\n                });\n            }\n            if (node instanceof AST_Class || node instanceof AST_Lambda && node !== self) {\n                return node;\n            }\n            if (node instanceof AST_Block) {\n                var index = node.body.length - 1;\n                if (index >= 0) {\n                    node.body[index] = node.body[index].transform(tt);\n                }\n            } else if (node instanceof AST_If) {\n                node.body = node.body.transform(tt);\n                if (node.alternative) {\n                    node.alternative = node.alternative.transform(tt);\n                }\n            } else if (node instanceof AST_With) {\n                node.body = node.body.transform(tt);\n            }\n            return node;\n        });\n        self.transform(tt);\n    });\n\n    function read_property(obj, key) {\n        key = get_value(key);\n        if (key instanceof AST_Node) return;\n        var value;\n        if (obj instanceof AST_Array) {\n            var elements = obj.elements;\n            if (key == \"length\") return make_node_from_constant(elements.length, obj);\n            if (typeof key == \"number\" && key in elements) value = elements[key];\n        } else if (obj instanceof AST_Object) {\n            key = \"\" + key;\n            var props = obj.properties;\n            for (var i = props.length; --i >= 0;) {\n                var prop = props[i];\n                if (!(prop instanceof AST_ObjectKeyVal)) return;\n                if (!value && props[i].key === key) value = props[i].value;\n            }\n        }\n        return value instanceof AST_SymbolRef && value.fixed_value() || value;\n    }\n\n    function is_modified(compressor, tw, node, value, level, immutable) {\n        var parent = tw.parent(level);\n        var lhs = is_lhs(node, parent);\n        if (lhs) return lhs;\n        if (!immutable\n            && parent instanceof AST_Call\n            && parent.expression === node\n            && !(value instanceof AST_Arrow)\n            && !(value instanceof AST_Class)\n            && !parent.is_expr_pure(compressor)\n            && (!(value instanceof AST_Function)\n                || !(parent instanceof AST_New) && value.contains_this())) {\n            return true;\n        }\n        if (parent instanceof AST_Array) {\n            return is_modified(compressor, tw, parent, parent, level + 1);\n        }\n        if (parent instanceof AST_ObjectKeyVal && node === parent.value) {\n            var obj = tw.parent(level + 1);\n            return is_modified(compressor, tw, obj, obj, level + 2);\n        }\n        if (parent instanceof AST_PropAccess && parent.expression === node) {\n            var prop = read_property(value, parent.property);\n            return !immutable && is_modified(compressor, tw, parent, prop, level + 1);\n        }\n    }\n\n    (function(def_reduce_vars) {\n        def_reduce_vars(AST_Node, noop);\n\n        function reset_def(compressor, def) {\n            def.assignments = 0;\n            def.chained = false;\n            def.direct_access = false;\n            def.escaped = false;\n            if (def.scope.pinned()) {\n                def.fixed = false;\n            } else if (def.orig[0] instanceof AST_SymbolConst || !compressor.exposed(def)) {\n                def.fixed = def.init;\n            } else {\n                def.fixed = false;\n            }\n            def.recursive_refs = 0;\n            def.references = [];\n            def.should_replace = undefined;\n            def.single_use = undefined;\n        }\n\n        function reset_variables(tw, compressor, node) {\n            node.variables.each(function(def) {\n                reset_def(compressor, def);\n                if (def.fixed === null) {\n                    def.safe_ids = tw.safe_ids;\n                    mark(tw, def, true);\n                } else if (def.fixed) {\n                    tw.loop_ids[def.id] = tw.in_loop;\n                    mark(tw, def, true);\n                }\n            });\n        }\n\n        function reset_block_variables(compressor, node) {\n            if (node.block_scope) node.block_scope.variables.each(function(def) {\n                reset_def(compressor, def);\n            });\n        }\n\n        function push(tw) {\n            tw.safe_ids = Object.create(tw.safe_ids);\n        }\n\n        function pop(tw) {\n            tw.safe_ids = Object.getPrototypeOf(tw.safe_ids);\n        }\n\n        function mark(tw, def, safe) {\n            tw.safe_ids[def.id] = safe;\n        }\n\n        function safe_to_read(tw, def) {\n            if (def.single_use == \"m\") return false;\n            if (tw.safe_ids[def.id]) {\n                if (def.fixed == null) {\n                    var orig = def.orig[0];\n                    if (orig instanceof AST_SymbolFunarg || orig.name == \"arguments\") return false;\n                    def.fixed = make_node(AST_Undefined, orig);\n                }\n                return true;\n            }\n            return def.fixed instanceof AST_Defun;\n        }\n\n        function safe_to_assign(tw, def, value) {\n            if (def.fixed === undefined) return true;\n            if (def.fixed === null && def.safe_ids) {\n                def.safe_ids[def.id] = false;\n                delete def.safe_ids;\n                return true;\n            }\n            if (!HOP(tw.safe_ids, def.id)) return false;\n            if (!safe_to_read(tw, def)) return false;\n            if (def.fixed === false) return false;\n            if (def.fixed != null && (!value || def.references.length > def.assignments)) return false;\n            return all(def.orig, function(sym) {\n                return !(sym instanceof AST_SymbolConst\n                    || sym instanceof AST_SymbolDefun\n                    || sym instanceof AST_SymbolLambda);\n            });\n        }\n\n        function ref_once(tw, compressor, def) {\n            return compressor.option(\"unused\")\n                && !def.scope.pinned()\n                && def.references.length - def.recursive_refs == 1\n                && tw.loop_ids[def.id] === tw.in_loop;\n        }\n\n        function is_immutable(value) {\n            if (!value) return false;\n            return value.is_constant()\n                || value instanceof AST_Lambda\n                || value instanceof AST_This;\n        }\n\n        function mark_escaped(tw, d, scope, node, value, level, depth) {\n            var parent = tw.parent(level);\n            if (value) {\n                if (value.is_constant()) return;\n                if (value instanceof AST_ClassExpression) return;\n            }\n            if (parent instanceof AST_Assign && parent.operator == \"=\" && node === parent.right\n                || parent instanceof AST_Call && (node !== parent.expression || parent instanceof AST_New)\n                || parent instanceof AST_Exit && node === parent.value && node.scope !== d.scope\n                || parent instanceof AST_VarDef && node === parent.value\n                || parent instanceof AST_Yield && node === parent.value && node.scope !== d.scope) {\n                if (depth > 1 && !(value && value.is_constant_expression(scope))) depth = 1;\n                if (!d.escaped || d.escaped > depth) d.escaped = depth;\n                return;\n            } else if (parent instanceof AST_Array\n                || parent instanceof AST_Await\n                || parent instanceof AST_Binary && lazy_op(parent.operator)\n                || parent instanceof AST_Conditional && node !== parent.condition\n                || parent instanceof AST_Expansion\n                || parent instanceof AST_Sequence && node === parent.tail_node()) {\n                mark_escaped(tw, d, scope, parent, parent, level + 1, depth);\n            } else if (parent instanceof AST_ObjectKeyVal && node === parent.value) {\n                var obj = tw.parent(level + 1);\n                mark_escaped(tw, d, scope, obj, obj, level + 2, depth);\n            } else if (parent instanceof AST_PropAccess && node === parent.expression) {\n                value = read_property(value, parent.property);\n                mark_escaped(tw, d, scope, parent, value, level + 1, depth + 1);\n                if (value) return;\n            }\n            if (level > 0) return;\n            if (parent instanceof AST_Sequence && node !== parent.tail_node()) return;\n            if (parent instanceof AST_SimpleStatement) return;\n            d.direct_access = true;\n        }\n\n        var suppressor = new TreeWalker(function(node) {\n            if (!(node instanceof AST_Symbol)) return;\n            var d = node.definition();\n            if (!d) return;\n            if (node instanceof AST_SymbolRef) d.references.push(node);\n            d.fixed = false;\n        });\n        def_reduce_vars(AST_Accessor, function(tw, descend, compressor) {\n            push(tw);\n            reset_variables(tw, compressor, this);\n            descend();\n            pop(tw);\n            return true;\n        });\n        def_reduce_vars(AST_Arrow, mark_func_expr);\n        def_reduce_vars(AST_Assign, function(tw, descend, compressor) {\n            var node = this;\n            if (node.left instanceof AST_Destructuring) {\n                node.left.walk(suppressor);\n                return;\n            }\n            var sym = node.left;\n            if (!(sym instanceof AST_SymbolRef)) return;\n            var d = sym.definition();\n            var safe = safe_to_assign(tw, d, sym.scope, node.right);\n            d.assignments++;\n            if (!safe) return;\n            var fixed = d.fixed;\n            if (!fixed && node.operator != \"=\") return;\n            var eq = node.operator == \"=\";\n            var value = eq ? node.right : node;\n            if (is_modified(compressor, tw, node, value, 0)) return;\n            d.references.push(sym);\n            if (!eq) d.chained = true;\n            d.fixed = eq ? function() {\n                return node.right;\n            } : function() {\n                return make_node(AST_Binary, node, {\n                    operator: node.operator.slice(0, -1),\n                    left: fixed instanceof AST_Node ? fixed : fixed(),\n                    right: node.right\n                });\n            };\n            mark(tw, d, false);\n            node.right.walk(tw);\n            mark(tw, d, true);\n            mark_escaped(tw, d, sym.scope, node, value, 0, 1);\n            return true;\n        });\n        def_reduce_vars(AST_Binary, function(tw) {\n            if (!lazy_op(this.operator)) return;\n            this.left.walk(tw);\n            push(tw);\n            this.right.walk(tw);\n            pop(tw);\n            return true;\n        });\n        def_reduce_vars(AST_Block, function(tw, descend, compressor) {\n            reset_block_variables(compressor, this);\n        });\n        def_reduce_vars(AST_Case, function(tw) {\n            push(tw);\n            this.expression.walk(tw);\n            pop(tw);\n            push(tw);\n            walk_body(this, tw);\n            pop(tw);\n            return true;\n        });\n        def_reduce_vars(AST_ClassExpression, function(tw, descend) {\n            this.inlined = false;\n            push(tw);\n            descend();\n            pop(tw);\n            return true;\n        });\n        def_reduce_vars(AST_Conditional, function(tw) {\n            this.condition.walk(tw);\n            push(tw);\n            this.consequent.walk(tw);\n            pop(tw);\n            push(tw);\n            this.alternative.walk(tw);\n            pop(tw);\n            return true;\n        });\n        def_reduce_vars(AST_Default, function(tw, descend) {\n            push(tw);\n            descend();\n            pop(tw);\n            return true;\n        });\n\n        function mark_def_node(tw, descend, compressor) {\n            this.inlined = false;\n            var save_ids = tw.safe_ids;\n            tw.safe_ids = Object.create(null);\n            reset_variables(tw, compressor, this);\n            descend();\n            tw.safe_ids = save_ids;\n            return true;\n        }\n\n        def_reduce_vars(AST_DefClass, mark_def_node);\n        def_reduce_vars(AST_Defun, mark_def_node);\n        def_reduce_vars(AST_Do, function(tw, descend, compressor) {\n            reset_block_variables(compressor, this);\n            var saved_loop = tw.in_loop;\n            tw.in_loop = this;\n            push(tw);\n            this.body.walk(tw);\n            if (has_break_or_continue(this)) {\n                pop(tw);\n                push(tw);\n            }\n            this.condition.walk(tw);\n            pop(tw);\n            tw.in_loop = saved_loop;\n            return true;\n        });\n        def_reduce_vars(AST_For, function(tw, descend, compressor) {\n            reset_block_variables(compressor, this);\n            if (this.init) this.init.walk(tw);\n            var saved_loop = tw.in_loop;\n            tw.in_loop = this;\n            push(tw);\n            if (this.condition) this.condition.walk(tw);\n            this.body.walk(tw);\n            if (this.step) {\n                if (has_break_or_continue(this)) {\n                    pop(tw);\n                    push(tw);\n                }\n                this.step.walk(tw);\n            }\n            pop(tw);\n            tw.in_loop = saved_loop;\n            return true;\n        });\n        def_reduce_vars(AST_ForIn, function(tw, descend, compressor) {\n            reset_block_variables(compressor, this);\n            this.init.walk(suppressor);\n            this.object.walk(tw);\n            var saved_loop = tw.in_loop;\n            tw.in_loop = this;\n            push(tw);\n            this.body.walk(tw);\n            pop(tw);\n            tw.in_loop = saved_loop;\n            return true;\n        });\n\n        function mark_func_expr(tw, descend, compressor) {\n            var node = this;\n            node.inlined = false;\n            push(tw);\n            reset_variables(tw, compressor, node);\n            var iife;\n            if (!node.name\n                && (iife = tw.parent()) instanceof AST_Call\n                && iife.expression === node) {\n                // Virtually turn IIFE parameters into variable definitions:\n                //   (function(a,b) {...})(c,d) => (function() {var a=c,b=d; ...})()\n                // So existing transformation rules can work on them.\n                node.argnames.forEach(function(arg, i) {\n                    if (!arg.definition) return;\n                    var d = arg.definition();\n                    if (d.fixed === undefined && (!node.uses_arguments || tw.has_directive(\"use strict\"))) {\n                        d.fixed = function() {\n                            return iife.args[i] || make_node(AST_Undefined, iife);\n                        };\n                        tw.loop_ids[d.id] = tw.in_loop;\n                        mark(tw, d, true);\n                    } else {\n                        d.fixed = false;\n                    }\n                });\n            }\n            descend();\n            pop(tw);\n            return true;\n        }\n\n        def_reduce_vars(AST_Function, mark_func_expr);\n        def_reduce_vars(AST_If, function(tw) {\n            this.condition.walk(tw);\n            push(tw);\n            this.body.walk(tw);\n            pop(tw);\n            if (this.alternative) {\n                push(tw);\n                this.alternative.walk(tw);\n                pop(tw);\n            }\n            return true;\n        });\n        def_reduce_vars(AST_LabeledStatement, function(tw) {\n            push(tw);\n            this.body.walk(tw);\n            pop(tw);\n            return true;\n        });\n        def_reduce_vars(AST_SymbolCatch, function() {\n            this.definition().fixed = false;\n        });\n        def_reduce_vars(AST_SymbolRef, function(tw, descend, compressor) {\n            var d = this.definition();\n            d.references.push(this);\n            if (d.references.length == 1\n                && !d.fixed\n                && d.orig[0] instanceof AST_SymbolDefun) {\n                tw.loop_ids[d.id] = tw.in_loop;\n            }\n            var value;\n            if (d.fixed === undefined || !safe_to_read(tw, d)) {\n                d.fixed = false;\n            } else if (d.fixed) {\n                value = this.fixed_value();\n                if (value instanceof AST_Lambda && recursive_ref(tw, d)) {\n                    d.recursive_refs++;\n                } else if (value && !compressor.exposed(d) && ref_once(tw, compressor, d)) {\n                    d.single_use = value instanceof AST_Lambda && !value.pinned()\n                        || value instanceof AST_Class\n                        || d.scope === this.scope && value.is_constant_expression();\n                } else {\n                    d.single_use = false;\n                }\n                if (is_modified(compressor, tw, this, value, 0, is_immutable(value))) {\n                    if (d.single_use) {\n                        d.single_use = \"m\";\n                    } else {\n                        d.fixed = false;\n                    }\n                }\n            }\n            mark_escaped(tw, d, this.scope, this, value, 0, 1);\n        });\n        def_reduce_vars(AST_Toplevel, function(tw, descend, compressor) {\n            this.globals.each(function(def) {\n                reset_def(compressor, def);\n            });\n            reset_variables(tw, compressor, this);\n        });\n        def_reduce_vars(AST_Try, function(tw, descend, compressor) {\n            reset_block_variables(compressor, this);\n            push(tw);\n            walk_body(this, tw);\n            pop(tw);\n            if (this.bcatch) {\n                push(tw);\n                this.bcatch.walk(tw);\n                pop(tw);\n            }\n            if (this.bfinally) this.bfinally.walk(tw);\n            return true;\n        });\n        def_reduce_vars(AST_Unary, function(tw, descend) {\n            var node = this;\n            if (node.operator != \"++\" && node.operator != \"--\") return;\n            var exp = node.expression;\n            if (!(exp instanceof AST_SymbolRef)) return;\n            var d = exp.definition();\n            var safe = safe_to_assign(tw, d, true);\n            d.assignments++;\n            if (!safe) return;\n            var fixed = d.fixed;\n            if (!fixed) return;\n            d.references.push(exp);\n            d.chained = true;\n            d.fixed = function() {\n                return make_node(AST_Binary, node, {\n                    operator: node.operator.slice(0, -1),\n                    left: make_node(AST_UnaryPrefix, node, {\n                        operator: \"+\",\n                        expression: fixed instanceof AST_Node ? fixed : fixed()\n                    }),\n                    right: make_node(AST_Number, node, {\n                        value: 1\n                    })\n                });\n            };\n            mark(tw, d, true);\n            return true;\n        });\n        def_reduce_vars(AST_VarDef, function(tw, descend) {\n            var node = this;\n            if (node.name instanceof AST_Destructuring) {\n                node.name.walk(suppressor);\n                return;\n            }\n            var d = node.name.definition();\n            if (node.value) {\n                if (safe_to_assign(tw, d, node.value)) {\n                    d.fixed = function() {\n                        return node.value;\n                    };\n                    tw.loop_ids[d.id] = tw.in_loop;\n                    mark(tw, d, false);\n                    descend();\n                    mark(tw, d, true);\n                    return true;\n                } else {\n                    d.fixed = false;\n                }\n            }\n        });\n        def_reduce_vars(AST_While, function(tw, descend, compressor) {\n            reset_block_variables(compressor, this);\n            var saved_loop = tw.in_loop;\n            tw.in_loop = this;\n            push(tw);\n            descend();\n            pop(tw);\n            tw.in_loop = saved_loop;\n            return true;\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"reduce_vars\", func);\n    });\n\n    AST_Toplevel.DEFMETHOD(\"reset_opt_flags\", function(compressor) {\n        var self = this;\n        var reduce_vars = compressor.option(\"reduce_vars\");\n        var tw = new TreeWalker(function(node, descend) {\n            node._squeezed = false;\n            node._optimized = false;\n            if (reduce_vars) {\n                if (compressor.top_retain) {\n                    if (tw.parent() === self)\n                        node._top = true;\n                    else\n                        delete node._top;\n                }\n                return node.reduce_vars(tw, descend, compressor);\n            }\n        });\n        // Stack of look-up tables to keep track of whether a `SymbolDef` has been\n        // properly assigned before use:\n        // - `push()` & `pop()` when visiting conditional branches\n        // - backup & restore via `save_ids` when visiting out-of-order sections\n        tw.safe_ids = Object.create(null);\n        tw.in_loop = null;\n        tw.loop_ids = Object.create(null);\n        self.walk(tw);\n    });\n\n    AST_Symbol.DEFMETHOD(\"fixed_value\", function() {\n        var fixed = this.definition().fixed;\n        if (!fixed || fixed instanceof AST_Node) return fixed;\n        return fixed();\n    });\n\n    AST_SymbolRef.DEFMETHOD(\"is_immutable\", function() {\n        var orig = this.definition().orig;\n        return orig.length == 1 && orig[0] instanceof AST_SymbolLambda;\n    });\n\n    function is_func_expr(node) {\n        return node instanceof AST_Arrow || node instanceof AST_Function;\n    }\n\n    function is_lhs_read_only(lhs) {\n        if (lhs instanceof AST_This) return true;\n        if (lhs instanceof AST_SymbolRef) return lhs.definition().orig[0] instanceof AST_SymbolLambda;\n        if (lhs instanceof AST_PropAccess) {\n            lhs = lhs.expression;\n            if (lhs instanceof AST_SymbolRef) {\n                if (lhs.is_immutable()) return false;\n                lhs = lhs.fixed_value();\n            }\n            if (!lhs) return true;\n            if (lhs instanceof AST_RegExp) return false;\n            if (lhs instanceof AST_Constant) return true;\n            return is_lhs_read_only(lhs);\n        }\n        return false;\n    }\n\n    function is_ref_of(ref, type) {\n        if (!(ref instanceof AST_SymbolRef)) return false;\n        var orig = ref.definition().orig;\n        for (var i = orig.length; --i >= 0;) {\n            if (orig[i] instanceof type) return true;\n        }\n    }\n\n    function find_variable(compressor, name) {\n        var scope, i = 0;\n        while (scope = compressor.parent(i++)) {\n            if (scope instanceof AST_Scope) break;\n            if (scope instanceof AST_Catch && scope.argname) {\n                scope = scope.argname.definition().scope;\n                break;\n            }\n        }\n        return scope.find_variable(name);\n    }\n\n    function make_node(ctor, orig, props) {\n        if (!props) props = {};\n        if (orig) {\n            if (!props.start) props.start = orig.start;\n            if (!props.end) props.end = orig.end;\n        }\n        return new ctor(props);\n    }\n\n    function make_sequence(orig, expressions) {\n        if (expressions.length == 1) return expressions[0];\n        return make_node(AST_Sequence, orig, {\n            expressions: expressions.reduce(merge_sequence, [])\n        });\n    }\n\n    function make_node_from_constant(val, orig) {\n        switch (typeof val) {\n          case \"string\":\n            return make_node(AST_String, orig, {\n                value: val\n            });\n          case \"number\":\n            if (isNaN(val)) return make_node(AST_NaN, orig);\n            if (isFinite(val)) {\n                return 1 / val < 0 ? make_node(AST_UnaryPrefix, orig, {\n                    operator: \"-\",\n                    expression: make_node(AST_Number, orig, { value: -val })\n                }) : make_node(AST_Number, orig, { value: val });\n            }\n            return val < 0 ? make_node(AST_UnaryPrefix, orig, {\n                operator: \"-\",\n                expression: make_node(AST_Infinity, orig)\n            }) : make_node(AST_Infinity, orig);\n          case \"boolean\":\n            return make_node(val ? AST_True : AST_False, orig);\n          case \"undefined\":\n            return make_node(AST_Undefined, orig);\n          default:\n            if (val === null) {\n                return make_node(AST_Null, orig, { value: null });\n            }\n            if (val instanceof RegExp) {\n                return make_node(AST_RegExp, orig, { value: val });\n            }\n            throw new Error(string_template(\"Can't handle constant of type: {type}\", {\n                type: typeof val\n            }));\n        }\n    }\n\n    // we shouldn't compress (1,func)(something) to\n    // func(something) because that changes the meaning of\n    // the func (becomes lexical instead of global).\n    function maintain_this_binding(parent, orig, val) {\n        if (parent instanceof AST_UnaryPrefix && parent.operator == \"delete\"\n            || parent instanceof AST_Call && parent.expression === orig\n                && (val instanceof AST_PropAccess || val instanceof AST_SymbolRef && val.name == \"eval\")) {\n            return make_sequence(orig, [ make_node(AST_Number, orig, { value: 0 }), val ]);\n        }\n        return val;\n    }\n\n    function merge_sequence(array, node) {\n        if (node instanceof AST_Sequence) {\n            array.push.apply(array, node.expressions);\n        } else {\n            array.push(node);\n        }\n        return array;\n    }\n\n    function as_statement_array(thing) {\n        if (thing === null) return [];\n        if (thing instanceof AST_BlockStatement) return thing.body;\n        if (thing instanceof AST_EmptyStatement) return [];\n        if (thing instanceof AST_Statement) return [ thing ];\n        throw new Error(\"Can't convert thing to statement array\");\n    }\n\n    function is_empty(thing) {\n        if (thing === null) return true;\n        if (thing instanceof AST_EmptyStatement) return true;\n        if (thing instanceof AST_BlockStatement) return thing.body.length == 0;\n        return false;\n    }\n\n    function can_be_evicted_from_block(node) {\n        return !(\n            node instanceof AST_DefClass ||\n            node instanceof AST_Defun ||\n            node instanceof AST_Let ||\n            node instanceof AST_Const ||\n            node instanceof AST_Export ||\n            node instanceof AST_Import\n        );\n    }\n\n    function loop_body(x) {\n        if (x instanceof AST_IterationStatement) {\n            return x.body instanceof AST_BlockStatement ? x.body : x;\n        }\n        return x;\n    }\n\n    function is_iife_call(node) {\n        if (node.TYPE != \"Call\") return false;\n        return node.expression instanceof AST_Function || is_iife_call(node.expression);\n    }\n\n    function is_undeclared_ref(node) {\n        return node instanceof AST_SymbolRef && node.definition().undeclared;\n    }\n\n    var global_names = makePredicate(\"Array Boolean clearInterval clearTimeout console Date decodeURI decodeURIComponent encodeURI encodeURIComponent Error escape eval EvalError Function isFinite isNaN JSON Math Number parseFloat parseInt RangeError ReferenceError RegExp Object setInterval setTimeout String SyntaxError TypeError unescape URIError\");\n    AST_SymbolRef.DEFMETHOD(\"is_declared\", function(compressor) {\n        return !this.definition().undeclared\n            || compressor.option(\"unsafe\") && global_names(this.name);\n    });\n\n    var identifier_atom = makePredicate(\"Infinity NaN undefined\");\n    function is_identifier_atom(node) {\n        return node instanceof AST_Infinity\n            || node instanceof AST_NaN\n            || node instanceof AST_Undefined;\n    }\n\n    function tighten_body(statements, compressor) {\n        var in_loop, in_try;\n        var scope = compressor.find_parent(AST_Scope).get_defun_scope();\n        find_loop_scope_try();\n        var CHANGED, max_iter = 10;\n        do {\n            CHANGED = false;\n            eliminate_spurious_blocks(statements);\n            if (compressor.option(\"dead_code\")) {\n                eliminate_dead_code(statements, compressor);\n            }\n            if (compressor.option(\"if_return\")) {\n                handle_if_return(statements, compressor);\n            }\n            if (compressor.sequences_limit > 0) {\n                sequencesize(statements, compressor);\n                sequencesize_2(statements, compressor);\n            }\n            if (compressor.option(\"join_vars\")) {\n                join_consecutive_vars(statements);\n            }\n            if (compressor.option(\"collapse_vars\")) {\n                collapse(statements, compressor);\n            }\n        } while (CHANGED && max_iter-- > 0);\n\n        function find_loop_scope_try() {\n            var node = compressor.self(), level = 0;\n            do {\n                if (node instanceof AST_Catch || node instanceof AST_Finally) {\n                    level++;\n                } else if (node instanceof AST_IterationStatement) {\n                    in_loop = true;\n                } else if (node instanceof AST_Scope) {\n                    scope = node;\n                    break;\n                } else if (node instanceof AST_Try) {\n                    in_try = true;\n                }\n            } while (node = compressor.parent(level++));\n        }\n\n        // Search from right to left for assignment-like expressions:\n        // - `var a = x;`\n        // - `a = x;`\n        // - `++a`\n        // For each candidate, scan from left to right for first usage, then try\n        // to fold assignment into the site for compression.\n        // Will not attempt to collapse assignments into or past code blocks\n        // which are not sequentially executed, e.g. loops and conditionals.\n        function collapse(statements, compressor) {\n            if (scope.pinned()) return statements;\n            var args;\n            var candidates = [];\n            var stat_index = statements.length;\n            var scanner = new TreeTransformer(function(node, descend) {\n                if (abort) return node;\n                // Skip nodes before `candidate` as quickly as possible\n                if (!hit) {\n                    if (node !== hit_stack[hit_index]) return node;\n                    hit_index++;\n                    if (hit_index < hit_stack.length) return handle_custom_scan_order(node);\n                    hit = true;\n                    stop_after = find_stop(node, 0);\n                    if (stop_after === node) abort = true;\n                    return node;\n                }\n                // Stop immediately if these node types are encountered\n                var parent = scanner.parent();\n                if (node instanceof AST_Assign && node.operator != \"=\" && lhs.equivalent_to(node.left)\n                    || node instanceof AST_Await\n                    || node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)\n                    || node instanceof AST_Debugger\n                    || node instanceof AST_Destructuring\n                    || node instanceof AST_Expansion\n                       && node.expression instanceof AST_Symbol\n                       && node.expression.definition().references.length > 1\n                    || node instanceof AST_IterationStatement && !(node instanceof AST_For)\n                    || node instanceof AST_LoopControl\n                    || node instanceof AST_Try\n                    || node instanceof AST_With\n                    || node instanceof AST_Yield\n                    || parent instanceof AST_For && node !== parent.init\n                    || !replace_all\n                        && (node instanceof AST_SymbolRef && !node.is_declared(compressor))) {\n                    abort = true;\n                    return node;\n                }\n                // Stop only if candidate is found within conditional branches\n                if (!stop_if_hit && (!lhs_local || !replace_all)\n                    && (parent instanceof AST_Binary && lazy_op(parent.operator) && parent.left !== node\n                        || parent instanceof AST_Conditional && parent.condition !== node\n                        || parent instanceof AST_If && parent.condition !== node)) {\n                    stop_if_hit = parent;\n                }\n                // Replace variable with assignment when found\n                if (can_replace\n                    && !(node instanceof AST_SymbolDeclaration)\n                    && lhs.equivalent_to(node)) {\n                    if (stop_if_hit) {\n                        abort = true;\n                        return node;\n                    }\n                    if (is_lhs(node, parent)) {\n                        if (value_def) replaced++;\n                        return node;\n                    }\n                    CHANGED = abort = true;\n                    replaced++;\n                    compressor.info(\"Collapsing {name} [{file}:{line},{col}]\", {\n                        name: node.print_to_string(),\n                        file: node.start.file,\n                        line: node.start.line,\n                        col: node.start.col\n                    });\n                    if (candidate instanceof AST_UnaryPostfix) {\n                        return make_node(AST_UnaryPrefix, candidate, candidate);\n                    }\n                    if (candidate instanceof AST_VarDef) {\n                        if (value_def) {\n                            abort = false;\n                            return node;\n                        }\n                        var def = candidate.name.definition();\n                        var value = candidate.value;\n                        if (def.references.length - def.replaced == 1 && !compressor.exposed(def)) {\n                            def.replaced++;\n                            if (funarg && is_identifier_atom(value)) {\n                                return value.transform(compressor);\n                            } else {\n                                return maintain_this_binding(parent, node, value);\n                            }\n                        }\n                        return make_node(AST_Assign, candidate, {\n                            operator: \"=\",\n                            left: make_node(AST_SymbolRef, candidate.name, candidate.name),\n                            right: value\n                        });\n                    }\n                    candidate.write_only = false;\n                    return candidate;\n                }\n                // These node types have child nodes that execute sequentially,\n                // but are otherwise not safe to scan into or beyond them.\n                var sym;\n                if (node instanceof AST_Call\n                    || node instanceof AST_Exit\n                        && (side_effects || lhs instanceof AST_PropAccess || may_modify(lhs))\n                    || node instanceof AST_PropAccess\n                        && (side_effects || node.expression.may_throw_on_access(compressor))\n                    || node instanceof AST_SymbolRef\n                        && (lvalues[node.name] || side_effects && may_modify(node))\n                    || node instanceof AST_VarDef && node.value\n                        && (node.name.name in lvalues || side_effects && may_modify(node.name))\n                    || (sym = is_lhs(node.left, node))\n                        && (sym instanceof AST_PropAccess || sym.name in lvalues)\n                    || may_throw\n                        && (in_try ? node.has_side_effects(compressor) : side_effects_external(node))) {\n                    stop_after = node;\n                    if (node instanceof AST_Scope) abort = true;\n                }\n                return handle_custom_scan_order(node);\n            }, function(node) {\n                if (abort) return;\n                if (stop_after === node) abort = true;\n                if (stop_if_hit === node) stop_if_hit = null;\n            });\n            var multi_replacer = new TreeTransformer(function(node) {\n                if (abort) return node;\n                // Skip nodes before `candidate` as quickly as possible\n                if (!hit) {\n                    if (node !== hit_stack[hit_index]) return node;\n                    hit_index++;\n                    if (hit_index < hit_stack.length) return;\n                    hit = true;\n                    return node;\n                }\n                // Replace variable when found\n                if (node instanceof AST_SymbolRef\n                    && node.name == def.name) {\n                    if (!--replaced) abort = true;\n                    if (is_lhs(node, multi_replacer.parent())) return node;\n                    def.replaced++;\n                    value_def.replaced--;\n                    return candidate.value;\n                }\n                // Skip (non-executed) functions and (leading) default case in switch statements\n                if (node instanceof AST_Default || node instanceof AST_Scope) return node;\n            });\n            while (--stat_index >= 0) {\n                // Treat parameters as collapsible in IIFE, i.e.\n                //   function(a, b){ ... }(x());\n                // would be translated into equivalent assignments:\n                //   var a = x(), b = undefined;\n                if (stat_index == 0 && compressor.option(\"unused\")) extract_args();\n                // Find collapsible assignments\n                var hit_stack = [];\n                extract_candidates(statements[stat_index]);\n                while (candidates.length > 0) {\n                    hit_stack = candidates.pop();\n                    var hit_index = 0;\n                    var candidate = hit_stack[hit_stack.length - 1];\n                    var value_def = null;\n                    var stop_after = null;\n                    var stop_if_hit = null;\n                    var lhs = get_lhs(candidate);\n                    if (!lhs || is_lhs_read_only(lhs) || lhs.has_side_effects(compressor)) continue;\n                    // Locate symbols which may execute code outside of scanning range\n                    var lvalues = get_lvalues(candidate);\n                    var lhs_local = is_lhs_local(lhs);\n                    if (lhs instanceof AST_SymbolRef) lvalues[lhs.name] = false;\n                    var side_effects = value_has_side_effects(candidate);\n                    var replace_all = replace_all_symbols();\n                    var may_throw = candidate.may_throw(compressor);\n                    var funarg = candidate.name instanceof AST_SymbolFunarg;\n                    var hit = funarg;\n                    var abort = false, replaced = 0, can_replace = !args || !hit;\n                    if (!can_replace) {\n                        for (var j = compressor.self().argnames.lastIndexOf(candidate.name) + 1; !abort && j < args.length; j++) {\n                            args[j].transform(scanner);\n                        }\n                        can_replace = true;\n                    }\n                    for (var i = stat_index; !abort && i < statements.length; i++) {\n                        statements[i].transform(scanner);\n                    }\n                    if (value_def) {\n                        var def = candidate.name.definition();\n                        if (abort && def.references.length - def.replaced > replaced) replaced = false;\n                        else {\n                            abort = false;\n                            hit_index = 0;\n                            hit = funarg;\n                            for (var i = stat_index; !abort && i < statements.length; i++) {\n                                statements[i].transform(multi_replacer);\n                            }\n                            value_def.single_use = false;\n                        }\n                    }\n                    if (replaced && !remove_candidate(candidate)) statements.splice(stat_index, 1);\n                }\n            }\n\n            function handle_custom_scan_order(node) {\n                // Skip (non-executed) functions\n                if (node instanceof AST_Scope) return node;\n                // Scan case expressions first in a switch statement\n                if (node instanceof AST_Switch) {\n                    node.expression = node.expression.transform(scanner);\n                    for (var i = 0, len = node.body.length; !abort && i < len; i++) {\n                        var branch = node.body[i];\n                        if (branch instanceof AST_Case) {\n                            if (!hit) {\n                                if (branch !== hit_stack[hit_index]) continue;\n                                hit_index++;\n                            }\n                            branch.expression = branch.expression.transform(scanner);\n                            if (!replace_all) break;\n                        }\n                    }\n                    abort = true;\n                    return node;\n                }\n            }\n\n            function has_overlapping_symbol(fn, arg, fn_strict) {\n                var found = false, scan_this = !(fn instanceof AST_Arrow);\n                arg.walk(new TreeWalker(function(node, descend) {\n                    if (found) return true;\n                    if (node instanceof AST_SymbolRef && fn.variables.has(node.name)) {\n                        var s = node.definition().scope;\n                        if (s !== scope) while (s = s.parent_scope) {\n                            if (s === scope) return true;\n                        }\n                        return found = true;\n                    }\n                    if ((fn_strict || scan_this) && node instanceof AST_This) {\n                        return found = true;\n                    }\n                    if (node instanceof AST_Scope && !(node instanceof AST_Arrow)) {\n                        var prev = scan_this;\n                        scan_this = false;\n                        descend();\n                        scan_this = prev;\n                        return true;\n                    }\n                }));\n                return found;\n            }\n\n            function extract_args() {\n                var iife, fn = compressor.self();\n                if (is_func_expr(fn)\n                    && !fn.name\n                    && !fn.uses_arguments\n                    && !fn.pinned()\n                    && (iife = compressor.parent()) instanceof AST_Call\n                    && iife.expression === fn\n                    && all(iife.args, function(arg) {\n                        return !(arg instanceof AST_Expansion);\n                    })) {\n                    var fn_strict = compressor.has_directive(\"use strict\");\n                    if (fn_strict && !member(fn_strict, fn.body)) fn_strict = false;\n                    var len = fn.argnames.length;\n                    args = iife.args.slice(len);\n                    var names = Object.create(null);\n                    for (var i = len; --i >= 0;) {\n                        var sym = fn.argnames[i];\n                        var arg = iife.args[i];\n                        args.unshift(make_node(AST_VarDef, sym, {\n                            name: sym,\n                            value: arg\n                        }));\n                        if (sym.name in names) continue;\n                        names[sym.name] = true;\n                        if (sym instanceof AST_Expansion) {\n                            var elements = iife.args.slice(i);\n                            if (all(elements, function(arg) {\n                                return !has_overlapping_symbol(fn, arg, fn_strict);\n                            })) {\n                                candidates.unshift([ make_node(AST_VarDef, sym, {\n                                    name: sym.expression,\n                                    value: make_node(AST_Array, iife, {\n                                        elements: elements\n                                    })\n                                }) ]);\n                            }\n                        } else {\n                            if (!arg) {\n                                arg = make_node(AST_Undefined, sym).transform(compressor);\n                            } else if (arg instanceof AST_Lambda && arg.pinned()\n                                || has_overlapping_symbol(fn, arg, fn_strict)) {\n                                arg = null;\n                            }\n                            if (arg) candidates.unshift([ make_node(AST_VarDef, sym, {\n                                name: sym,\n                                value: arg\n                            }) ]);\n                        }\n                    }\n                }\n            }\n\n            function extract_candidates(expr) {\n                hit_stack.push(expr);\n                if (expr instanceof AST_Assign) {\n                    if (!expr.left.has_side_effects(compressor)) {\n                        candidates.push(hit_stack.slice());\n                    }\n                    extract_candidates(expr.right);\n                } else if (expr instanceof AST_Binary) {\n                    extract_candidates(expr.left);\n                    extract_candidates(expr.right);\n                } else if (expr instanceof AST_Call) {\n                    extract_candidates(expr.expression);\n                    expr.args.forEach(extract_candidates);\n                } else if (expr instanceof AST_Case) {\n                    extract_candidates(expr.expression);\n                } else if (expr instanceof AST_Conditional) {\n                    extract_candidates(expr.condition);\n                    extract_candidates(expr.consequent);\n                    extract_candidates(expr.alternative);\n                } else if (expr instanceof AST_Definitions\n                    && (compressor.option(\"unused\") || !(expr instanceof AST_Const))) {\n                    var len = expr.definitions.length;\n                    // limit number of trailing variable definitions for consideration\n                    var i = len - 200;\n                    if (i < 0) i = 0;\n                    for (; i < len; i++) {\n                        extract_candidates(expr.definitions[i]);\n                    }\n                } else if (expr instanceof AST_DWLoop) {\n                    extract_candidates(expr.condition);\n                    if (!(expr.body instanceof AST_Block)) {\n                        extract_candidates(expr.body);\n                    }\n                } else if (expr instanceof AST_Exit) {\n                    if (expr.value) extract_candidates(expr.value);\n                } else if (expr instanceof AST_For) {\n                    if (expr.init) extract_candidates(expr.init);\n                    if (expr.condition) extract_candidates(expr.condition);\n                    if (expr.step) extract_candidates(expr.step);\n                    if (!(expr.body instanceof AST_Block)) {\n                        extract_candidates(expr.body);\n                    }\n                } else if (expr instanceof AST_ForIn) {\n                    extract_candidates(expr.object);\n                    if (!(expr.body instanceof AST_Block)) {\n                        extract_candidates(expr.body);\n                    }\n                } else if (expr instanceof AST_If) {\n                    extract_candidates(expr.condition);\n                    if (!(expr.body instanceof AST_Block)) {\n                        extract_candidates(expr.body);\n                    }\n                    if (expr.alternative && !(expr.alternative instanceof AST_Block)) {\n                        extract_candidates(expr.alternative);\n                    }\n                } else if (expr instanceof AST_Sequence) {\n                    expr.expressions.forEach(extract_candidates);\n                } else if (expr instanceof AST_SimpleStatement) {\n                    extract_candidates(expr.body);\n                } else if (expr instanceof AST_Switch) {\n                    extract_candidates(expr.expression);\n                    expr.body.forEach(extract_candidates);\n                } else if (expr instanceof AST_Unary) {\n                    if (expr.operator == \"++\" || expr.operator == \"--\") {\n                        candidates.push(hit_stack.slice());\n                    }\n                } else if (expr instanceof AST_VarDef) {\n                    if (expr.value) {\n                        candidates.push(hit_stack.slice());\n                        extract_candidates(expr.value);\n                    }\n                }\n                hit_stack.pop();\n            }\n\n            function find_stop(node, level, write_only) {\n                var parent = scanner.parent(level);\n                if (parent instanceof AST_Assign) {\n                    if (write_only\n                        && !(parent.left instanceof AST_PropAccess\n                            || parent.left.name in lvalues)) {\n                        return find_stop(parent, level + 1, write_only);\n                    }\n                    return node;\n                }\n                if (parent instanceof AST_Binary) {\n                    if (write_only && (!lazy_op(parent.operator) || parent.left === node)) {\n                        return find_stop(parent, level + 1, write_only);\n                    }\n                    return node;\n                }\n                if (parent instanceof AST_Call) return node;\n                if (parent instanceof AST_Case) return node;\n                if (parent instanceof AST_Conditional) {\n                    if (write_only && parent.condition === node) {\n                        return find_stop(parent, level + 1, write_only);\n                    }\n                    return node;\n                }\n                if (parent instanceof AST_Definitions) {\n                    return find_stop(parent, level + 1, true);\n                }\n                if (parent instanceof AST_Exit) {\n                    return write_only ? find_stop(parent, level + 1, write_only) : node;\n                }\n                if (parent instanceof AST_If) {\n                    if (write_only && parent.condition === node) {\n                        return find_stop(parent, level + 1, write_only);\n                    }\n                    return node;\n                }\n                if (parent instanceof AST_IterationStatement) return node;\n                if (parent instanceof AST_Sequence) {\n                    return find_stop(parent, level + 1, parent.tail_node() !== node);\n                }\n                if (parent instanceof AST_SimpleStatement) {\n                    return find_stop(parent, level + 1, true);\n                }\n                if (parent instanceof AST_Switch) return node;\n                if (parent instanceof AST_VarDef) return node;\n                return null;\n            }\n\n            function mangleable_var(var_def) {\n                var value = var_def.value;\n                if (!(value instanceof AST_SymbolRef)) return;\n                if (value.name == \"arguments\") return;\n                var def = value.definition();\n                if (def.undeclared) return;\n                return value_def = def;\n            }\n\n            function get_lhs(expr) {\n                if (expr instanceof AST_VarDef && expr.name instanceof AST_SymbolDeclaration) {\n                    var def = expr.name.definition();\n                    if (!member(expr.name, def.orig)) return;\n                    var referenced = def.references.length - def.replaced;\n                    if (!referenced) return;\n                    var declared = def.orig.length - def.eliminated;\n                    if (declared > 1 && !(expr.name instanceof AST_SymbolFunarg)\n                        || (referenced > 1 ? mangleable_var(expr) : !compressor.exposed(def))) {\n                        return make_node(AST_SymbolRef, expr.name, expr.name);\n                    }\n                } else {\n                    var lhs = expr[expr instanceof AST_Assign ? \"left\" : \"expression\"];\n                    return !is_ref_of(lhs, AST_SymbolConst) && lhs;\n                }\n            }\n\n            function get_rvalue(expr) {\n                return expr[expr instanceof AST_Assign ? \"right\" : \"value\"];\n            }\n\n            function get_lvalues(expr) {\n                var lvalues = Object.create(null);\n                if (expr instanceof AST_Unary) return lvalues;\n                var tw = new TreeWalker(function(node, descend) {\n                    var sym = node;\n                    while (sym instanceof AST_PropAccess) sym = sym.expression;\n                    if (sym instanceof AST_SymbolRef || sym instanceof AST_This) {\n                        lvalues[sym.name] = lvalues[sym.name] || is_modified(compressor, tw, node, node, 0);\n                    }\n                });\n                get_rvalue(expr).walk(tw);\n                return lvalues;\n            }\n\n            function remove_candidate(expr) {\n                if (expr.name instanceof AST_SymbolFunarg) {\n                    var iife = compressor.parent(), argnames = compressor.self().argnames;\n                    var index = argnames.indexOf(expr.name);\n                    if (index < 0) {\n                        iife.args.length = Math.min(iife.args.length, argnames.length - 1);\n                    } else {\n                        var args = iife.args;\n                        if (args[index]) args[index] = make_node(AST_Number, args[index], {\n                            value: 0\n                        });\n                    }\n                    return true;\n                }\n                var found = false;\n                return statements[stat_index].transform(new TreeTransformer(function(node, descend, in_list) {\n                    if (found) return node;\n                    if (node === expr || node.body === expr) {\n                        found = true;\n                        if (node instanceof AST_VarDef) {\n                            node.value = null;\n                            return node;\n                        }\n                        return in_list ? MAP.skip : null;\n                    }\n                }, function(node) {\n                    if (node instanceof AST_Sequence) switch (node.expressions.length) {\n                      case 0: return null;\n                      case 1: return node.expressions[0];\n                    }\n                }));\n            }\n\n            function is_lhs_local(lhs) {\n                while (lhs instanceof AST_PropAccess) lhs = lhs.expression;\n                return lhs instanceof AST_SymbolRef\n                    && lhs.definition().scope === scope\n                    && !(in_loop\n                        && (lhs.name in lvalues\n                            || candidate instanceof AST_Unary\n                            || candidate instanceof AST_Assign && candidate.operator != \"=\"));\n            }\n\n            function value_has_side_effects(expr) {\n                if (expr instanceof AST_Unary) return false;\n                return get_rvalue(expr).has_side_effects(compressor);\n            }\n\n            function replace_all_symbols() {\n                if (side_effects) return false;\n                if (value_def) return true;\n                if (lhs instanceof AST_SymbolRef) {\n                    var def = lhs.definition();\n                    if (def.references.length - def.replaced == (candidate instanceof AST_VarDef ? 1 : 2)) {\n                        return true;\n                    }\n                }\n                return false;\n            }\n\n            function may_modify(sym) {\n                if (!sym.definition) return true; // AST_Destructuring\n                var def = sym.definition();\n                if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun) return false;\n                if (def.scope.get_defun_scope() !== scope) return true;\n                return !all(def.references, function(ref) {\n                    var s = ref.scope.get_defun_scope();\n                    // \"block\" scope within AST_Catch\n                    if (s.TYPE == \"Scope\") s = s.parent_scope;\n                    return s === scope;\n                });\n            }\n\n            function side_effects_external(node, lhs) {\n                if (node instanceof AST_Assign) return side_effects_external(node.left, true);\n                if (node instanceof AST_Unary) return side_effects_external(node.expression, true);\n                if (node instanceof AST_VarDef) return node.value && side_effects_external(node.value);\n                if (lhs) {\n                    if (node instanceof AST_Dot) return side_effects_external(node.expression, true);\n                    if (node instanceof AST_Sub) return side_effects_external(node.expression, true);\n                    if (node instanceof AST_SymbolRef) return node.definition().scope !== scope;\n                }\n                return false;\n            }\n        }\n\n        function eliminate_spurious_blocks(statements) {\n            var seen_dirs = [];\n            for (var i = 0; i < statements.length;) {\n                var stat = statements[i];\n                if (stat instanceof AST_BlockStatement && all(stat.body, can_be_evicted_from_block)) {\n                    CHANGED = true;\n                    eliminate_spurious_blocks(stat.body);\n                    [].splice.apply(statements, [i, 1].concat(stat.body));\n                    i += stat.body.length;\n                } else if (stat instanceof AST_EmptyStatement) {\n                    CHANGED = true;\n                    statements.splice(i, 1);\n                } else if (stat instanceof AST_Directive) {\n                    if (seen_dirs.indexOf(stat.value) < 0) {\n                        i++;\n                        seen_dirs.push(stat.value);\n                    } else {\n                        CHANGED = true;\n                        statements.splice(i, 1);\n                    }\n                } else i++;\n            }\n        }\n\n        function handle_if_return(statements, compressor) {\n            var self = compressor.self();\n            var multiple_if_returns = has_multiple_if_returns(statements);\n            var in_lambda = self instanceof AST_Lambda;\n            for (var i = statements.length; --i >= 0;) {\n                var stat = statements[i];\n                var j = next_index(i);\n                var next = statements[j];\n\n                if (in_lambda && !next && stat instanceof AST_Return) {\n                    if (!stat.value) {\n                        CHANGED = true;\n                        statements.splice(i, 1);\n                        continue;\n                    }\n                    if (stat.value instanceof AST_UnaryPrefix && stat.value.operator == \"void\") {\n                        CHANGED = true;\n                        statements[i] = make_node(AST_SimpleStatement, stat, {\n                            body: stat.value.expression\n                        });\n                        continue;\n                    }\n                }\n\n                if (stat instanceof AST_If) {\n                    var ab = aborts(stat.body);\n                    if (can_merge_flow(ab)) {\n                        if (ab.label) {\n                            remove(ab.label.thedef.references, ab);\n                        }\n                        CHANGED = true;\n                        stat = stat.clone();\n                        stat.condition = stat.condition.negate(compressor);\n                        var body = as_statement_array_with_return(stat.body, ab);\n                        stat.body = make_node(AST_BlockStatement, stat, {\n                            body: as_statement_array(stat.alternative).concat(extract_functions())\n                        });\n                        stat.alternative = make_node(AST_BlockStatement, stat, {\n                            body: body\n                        });\n                        statements[i] = stat.transform(compressor);\n                        continue;\n                    }\n\n                    var ab = aborts(stat.alternative);\n                    if (can_merge_flow(ab)) {\n                        if (ab.label) {\n                            remove(ab.label.thedef.references, ab);\n                        }\n                        CHANGED = true;\n                        stat = stat.clone();\n                        stat.body = make_node(AST_BlockStatement, stat.body, {\n                            body: as_statement_array(stat.body).concat(extract_functions())\n                        });\n                        var body = as_statement_array_with_return(stat.alternative, ab);\n                        stat.alternative = make_node(AST_BlockStatement, stat.alternative, {\n                            body: body\n                        });\n                        statements[i] = stat.transform(compressor);\n                        continue;\n                    }\n                }\n\n                if (stat instanceof AST_If && stat.body instanceof AST_Return) {\n                    var value = stat.body.value;\n                    //---\n                    // pretty silly case, but:\n                    // if (foo()) return; return; ==> foo(); return;\n                    if (!value && !stat.alternative\n                        && (in_lambda && !next || next instanceof AST_Return && !next.value)) {\n                        CHANGED = true;\n                        statements[i] = make_node(AST_SimpleStatement, stat.condition, {\n                            body: stat.condition\n                        });\n                        continue;\n                    }\n                    //---\n                    // if (foo()) return x; return y; ==> return foo() ? x : y;\n                    if (value && !stat.alternative && next instanceof AST_Return && next.value) {\n                        CHANGED = true;\n                        stat = stat.clone();\n                        stat.alternative = next;\n                        statements.splice(i, 1, stat.transform(compressor));\n                        statements.splice(j, 1);\n                        continue;\n                    }\n                    //---\n                    // if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;\n                    if (value && !stat.alternative\n                        && (!next && in_lambda && multiple_if_returns\n                            || next instanceof AST_Return)) {\n                        CHANGED = true;\n                        stat = stat.clone();\n                        stat.alternative = next || make_node(AST_Return, stat, {\n                            value: null\n                        });\n                        statements.splice(i, 1, stat.transform(compressor));\n                        if (next) statements.splice(j, 1);\n                        continue;\n                    }\n                    //---\n                    // if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;\n                    //\n                    // if sequences is not enabled, this can lead to an endless loop (issue #866).\n                    // however, with sequences on this helps producing slightly better output for\n                    // the example code.\n                    var prev = statements[prev_index(i)];\n                    if (compressor.option(\"sequences\") && in_lambda && !stat.alternative\n                        && prev instanceof AST_If && prev.body instanceof AST_Return\n                        && next_index(j) == statements.length && next instanceof AST_SimpleStatement) {\n                        CHANGED = true;\n                        stat = stat.clone();\n                        stat.alternative = make_node(AST_BlockStatement, next, {\n                            body: [\n                                next,\n                                make_node(AST_Return, next, {\n                                    value: null\n                                })\n                            ]\n                        });\n                        statements.splice(i, 1, stat.transform(compressor));\n                        statements.splice(j, 1);\n                        continue;\n                    }\n                }\n            }\n\n            function has_multiple_if_returns(statements) {\n                var n = 0;\n                for (var i = statements.length; --i >= 0;) {\n                    var stat = statements[i];\n                    if (stat instanceof AST_If && stat.body instanceof AST_Return) {\n                        if (++n > 1) return true;\n                    }\n                }\n                return false;\n            }\n\n            function is_return_void(value) {\n                return !value || value instanceof AST_UnaryPrefix && value.operator == \"void\";\n            }\n\n            function can_merge_flow(ab) {\n                if (!ab) return false;\n                for (var j = i + 1, len = statements.length; j < len; j++) {\n                    var stat = statements[j];\n                    if (stat instanceof AST_Const || stat instanceof AST_Let) return false;\n                }\n                var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;\n                return ab instanceof AST_Return && in_lambda && is_return_void(ab.value)\n                    || ab instanceof AST_Continue && self === loop_body(lct)\n                    || ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct;\n            }\n\n            function extract_functions() {\n                var tail = statements.slice(i + 1);\n                statements.length = i + 1;\n                return tail.filter(function(stat) {\n                    if (stat instanceof AST_Defun) {\n                        statements.push(stat);\n                        return false;\n                    }\n                    return true;\n                });\n            }\n\n            function as_statement_array_with_return(node, ab) {\n                var body = as_statement_array(node).slice(0, -1);\n                if (ab.value) {\n                    body.push(make_node(AST_SimpleStatement, ab.value, {\n                        body: ab.value.expression\n                    }));\n                }\n                return body;\n            }\n\n            function next_index(i) {\n                for (var j = i + 1, len = statements.length; j < len; j++) {\n                    var stat = statements[j];\n                    if (!(stat instanceof AST_Var && declarations_only(stat))) {\n                        break;\n                    }\n                }\n                return j;\n            }\n\n            function prev_index(i) {\n                for (var j = i; --j >= 0;) {\n                    var stat = statements[j];\n                    if (!(stat instanceof AST_Var && declarations_only(stat))) {\n                        break;\n                    }\n                }\n                return j;\n            }\n        }\n\n        function eliminate_dead_code(statements, compressor) {\n            var has_quit;\n            var self = compressor.self();\n            for (var i = 0, n = 0, len = statements.length; i < len; i++) {\n                var stat = statements[i];\n                if (stat instanceof AST_LoopControl) {\n                    var lct = compressor.loopcontrol_target(stat);\n                    if (stat instanceof AST_Break\n                            && !(lct instanceof AST_IterationStatement)\n                            && loop_body(lct) === self\n                        || stat instanceof AST_Continue\n                            && loop_body(lct) === self) {\n                        if (stat.label) {\n                            remove(stat.label.thedef.references, stat);\n                        }\n                    } else {\n                        statements[n++] = stat;\n                    }\n                } else {\n                    statements[n++] = stat;\n                }\n                if (aborts(stat)) {\n                    has_quit = statements.slice(i + 1);\n                    break;\n                }\n            }\n            statements.length = n;\n            CHANGED = n != len;\n            if (has_quit) has_quit.forEach(function(stat) {\n                extract_declarations_from_unreachable_code(compressor, stat, statements);\n            });\n        }\n\n        function declarations_only(node) {\n            return all(node.definitions, function(var_def) {\n                return !var_def.value;\n            });\n        }\n\n        function sequencesize(statements, compressor) {\n            if (statements.length < 2) return;\n            var seq = [], n = 0;\n            function push_seq() {\n                if (!seq.length) return;\n                var body = make_sequence(seq[0], seq);\n                statements[n++] = make_node(AST_SimpleStatement, body, { body: body });\n                seq = [];\n            }\n            for (var i = 0, len = statements.length; i < len; i++) {\n                var stat = statements[i];\n                if (stat instanceof AST_SimpleStatement) {\n                    if (seq.length >= compressor.sequences_limit) push_seq();\n                    var body = stat.body;\n                    if (seq.length > 0) body = body.drop_side_effect_free(compressor);\n                    if (body) merge_sequence(seq, body);\n                } else if (stat instanceof AST_Definitions && declarations_only(stat)\n                    || stat instanceof AST_Defun) {\n                    statements[n++] = stat;\n                } else {\n                    push_seq();\n                    statements[n++] = stat;\n                }\n            }\n            push_seq();\n            statements.length = n;\n            if (n != len) CHANGED = true;\n        }\n\n        function to_simple_statement(block, decls) {\n            if (!(block instanceof AST_BlockStatement)) return block;\n            var stat = null;\n            for (var i = 0, len = block.body.length; i < len; i++) {\n                var line = block.body[i];\n                if (line instanceof AST_Var && declarations_only(line)) {\n                    decls.push(line);\n                } else if (stat) {\n                    return false;\n                } else {\n                    stat = line;\n                }\n            }\n            return stat;\n        }\n\n        function sequencesize_2(statements, compressor) {\n            function cons_seq(right) {\n                n--;\n                CHANGED = true;\n                var left = prev.body;\n                return make_sequence(left, [ left, right ]).transform(compressor);\n            }\n            var n = 0, prev;\n            for (var i = 0; i < statements.length; i++) {\n                var stat = statements[i];\n                if (prev) {\n                    if (stat instanceof AST_Exit) {\n                        stat.value = cons_seq(stat.value || make_node(AST_Undefined, stat).transform(compressor));\n                    } else if (stat instanceof AST_For) {\n                        if (!(stat.init instanceof AST_Definitions)) {\n                            var abort = false;\n                            prev.body.walk(new TreeWalker(function(node) {\n                                if (abort || node instanceof AST_Scope) return true;\n                                if (node instanceof AST_Binary && node.operator == \"in\") {\n                                    abort = true;\n                                    return true;\n                                }\n                            }));\n                            if (!abort) {\n                                if (stat.init) stat.init = cons_seq(stat.init);\n                                else {\n                                    stat.init = prev.body;\n                                    n--;\n                                    CHANGED = true;\n                                }\n                            }\n                        }\n                    } else if (stat instanceof AST_ForIn) {\n                        if (!(stat.init instanceof AST_Const) && !(stat.init instanceof AST_Let)) {\n                            stat.object = cons_seq(stat.object);\n                        }\n                    } else if (stat instanceof AST_If) {\n                        stat.condition = cons_seq(stat.condition);\n                    } else if (stat instanceof AST_Switch) {\n                        stat.expression = cons_seq(stat.expression);\n                    } else if (stat instanceof AST_With) {\n                        stat.expression = cons_seq(stat.expression);\n                    }\n                }\n                if (compressor.option(\"conditionals\") && stat instanceof AST_If) {\n                    var decls = [];\n                    var body = to_simple_statement(stat.body, decls);\n                    var alt = to_simple_statement(stat.alternative, decls);\n                    if (body !== false && alt !== false && decls.length > 0) {\n                        var len = decls.length;\n                        decls.push(make_node(AST_If, stat, {\n                            condition: stat.condition,\n                            body: body || make_node(AST_EmptyStatement, stat.body),\n                            alternative: alt\n                        }));\n                        decls.unshift(n, 1);\n                        [].splice.apply(statements, decls);\n                        i += len;\n                        n += len + 1;\n                        prev = null;\n                        CHANGED = true;\n                        continue;\n                    }\n                }\n                statements[n++] = stat;\n                prev = stat instanceof AST_SimpleStatement ? stat : null;\n            }\n            statements.length = n;\n        }\n\n        function join_object_assignments(defn, body) {\n            if (!(defn instanceof AST_Definitions)) return;\n            var def = defn.definitions[defn.definitions.length - 1];\n            if (!(def.value instanceof AST_Object)) return;\n            var exprs;\n            if (body instanceof AST_Assign) {\n                exprs = [ body ];\n            } else if (body instanceof AST_Sequence) {\n                exprs = body.expressions.slice();\n            }\n            if (!exprs) return;\n            var trimmed = false;\n            do {\n                var node = exprs[0];\n                if (!(node instanceof AST_Assign)) break;\n                if (node.operator != \"=\") break;\n                if (!(node.left instanceof AST_PropAccess)) break;\n                var sym = node.left.expression;\n                if (!(sym instanceof AST_SymbolRef)) break;\n                if (def.name.name != sym.name) break;\n                if (!node.right.is_constant_expression(scope)) break;\n                var prop = node.left.property;\n                if (prop instanceof AST_Node) {\n                    prop = prop.evaluate(compressor);\n                }\n                if (prop instanceof AST_Node) break;\n                prop = \"\" + prop;\n                var diff = compressor.option(\"ecma\") < 6\n                    && compressor.has_directive(\"use strict\") ? function(node) {\n                    return node.key != prop && (node.key && node.key.name != prop);\n                } : function(node) {\n                    return node.key && node.key.name != prop;\n                };\n                if (!all(def.value.properties, diff)) break;\n                var p = def.value.properties.filter(function (p) { return p.key === prop; })[0];\n                if (!p) {\n                    def.value.properties.push(make_node(AST_ObjectKeyVal, node, {\n                        key: prop,\n                        value: node.right\n                    }));\n                } else {\n                    p.value = new AST_Sequence({\n                        start: p.start,\n                        expressions: [p.value.clone(), node.right.clone()],\n                        end: p.end\n                    });\n                }\n                exprs.shift();\n                trimmed = true;\n            } while (exprs.length);\n            return trimmed && exprs;\n        }\n\n        function join_consecutive_vars(statements) {\n            var defs;\n            for (var i = 0, j = -1, len = statements.length; i < len; i++) {\n                var stat = statements[i];\n                var prev = statements[j];\n                if (stat instanceof AST_Definitions) {\n                    if (prev && prev.TYPE == stat.TYPE) {\n                        prev.definitions = prev.definitions.concat(stat.definitions);\n                        CHANGED = true;\n                    } else if (defs && defs.TYPE == stat.TYPE && declarations_only(stat)) {\n                        defs.definitions = defs.definitions.concat(stat.definitions);\n                        CHANGED = true;\n                    } else {\n                        statements[++j] = stat;\n                        defs = stat;\n                    }\n                } else if (stat instanceof AST_Exit) {\n                    stat.value = extract_object_assignments(stat.value);\n                } else if (stat instanceof AST_For) {\n                    var exprs = join_object_assignments(prev, stat.init);\n                    if (exprs) {\n                        CHANGED = true;\n                        stat.init = exprs.length ? make_sequence(stat.init, exprs) : null;\n                        statements[++j] = stat;\n                    } else if (prev instanceof AST_Var && (!stat.init || stat.init.TYPE == prev.TYPE)) {\n                        if (stat.init) {\n                            prev.definitions = prev.definitions.concat(stat.init.definitions);\n                        }\n                        stat.init = prev;\n                        statements[j] = stat;\n                        CHANGED = true;\n                    } else if (defs && stat.init && defs.TYPE == stat.init.TYPE && declarations_only(stat.init)) {\n                        defs.definitions = defs.definitions.concat(stat.init.definitions);\n                        stat.init = null;\n                        statements[++j] = stat;\n                        CHANGED = true;\n                    } else {\n                        statements[++j] = stat;\n                    }\n                } else if (stat instanceof AST_ForIn) {\n                    stat.object = extract_object_assignments(stat.object);\n                } else if (stat instanceof AST_If) {\n                    stat.condition = extract_object_assignments(stat.condition);\n                } else if (stat instanceof AST_SimpleStatement) {\n                    var exprs = join_object_assignments(prev, stat.body);\n                    if (exprs) {\n                        CHANGED = true;\n                        if (!exprs.length) continue;\n                        stat.body = make_sequence(stat.body, exprs);\n                    }\n                    statements[++j] = stat;\n                } else if (stat instanceof AST_Switch) {\n                    stat.expression = extract_object_assignments(stat.expression);\n                } else if (stat instanceof AST_With) {\n                    stat.expression = extract_object_assignments(stat.expression);\n                } else {\n                    statements[++j] = stat;\n                }\n            }\n            statements.length = j + 1;\n\n            function extract_object_assignments(value) {\n                statements[++j] = stat;\n                var exprs = join_object_assignments(prev, value);\n                if (exprs) {\n                    CHANGED = true;\n                    if (exprs.length) {\n                        return make_sequence(value, exprs);\n                    } else if (value instanceof AST_Sequence) {\n                        return value.tail_node().left;\n                    } else {\n                        return value.left;\n                    }\n                }\n                return value;\n            }\n        }\n    }\n\n    function extract_declarations_from_unreachable_code(compressor, stat, target) {\n        if (!(stat instanceof AST_Defun)) {\n            compressor.warn(\"Dropping unreachable code [{file}:{line},{col}]\", stat.start);\n        }\n        stat.walk(new TreeWalker(function(node) {\n            if (node instanceof AST_Var) {\n                compressor.warn(\"Declarations in unreachable code! [{file}:{line},{col}]\", node.start);\n                node.remove_initializers();\n                target.push(node);\n                return true;\n            }\n            if (node instanceof AST_Defun && (node === stat || !compressor.has_directive(\"use strict\"))) {\n                target.push(node === stat ? node : make_node(AST_Var, node, {\n                    definitions: [\n                        make_node(AST_VarDef, node, {\n                            name: make_node(AST_SymbolVar, node.name, node.name),\n                            value: null\n                        })\n                    ]\n                }));\n                return true;\n            }\n            if (node instanceof AST_Scope) {\n                return true;\n            }\n        }));\n    }\n\n    function get_value(key) {\n        if (key instanceof AST_Constant) {\n            return key.getValue();\n        }\n        if (key instanceof AST_UnaryPrefix\n            && key.operator == \"void\"\n            && key.expression instanceof AST_Constant) {\n            return;\n        }\n        return key;\n    }\n\n    function is_undefined(node, compressor) {\n        return node.is_undefined\n            || node instanceof AST_Undefined\n            || node instanceof AST_UnaryPrefix\n                && node.operator == \"void\"\n                && !node.expression.has_side_effects(compressor);\n    }\n\n    // may_throw_on_access()\n    // returns true if this node may be null, undefined or contain `AST_Accessor`\n    (function(def_dot_throw) {\n        AST_Node.DEFMETHOD(\"may_throw_on_access\", function(compressor) {\n            return !compressor.option(\"pure_getters\")\n                || this._dot_throw(compressor);\n        });\n\n        function is_strict(compressor) {\n            return /strict/.test(compressor.option(\"pure_getters\"));\n        }\n\n        def_dot_throw(AST_Node, is_strict);\n        def_dot_throw(AST_Null, return_true);\n        def_dot_throw(AST_Undefined, return_true);\n        def_dot_throw(AST_Constant, return_false);\n        def_dot_throw(AST_Array, return_false);\n        def_dot_throw(AST_Object, function(compressor) {\n            if (!is_strict(compressor)) return false;\n            for (var i = this.properties.length; --i >=0;)\n                if (this.properties[i]._dot_throw(compressor)) return true;\n            return false;\n        });\n        def_dot_throw(AST_ObjectProperty, return_false);\n        def_dot_throw(AST_ObjectGetter, return_true);\n        def_dot_throw(AST_Expansion, function(compressor) {\n            return this.expression._dot_throw(compressor);\n        });\n        def_dot_throw(AST_Function, return_false);\n        def_dot_throw(AST_Arrow, return_false);\n        def_dot_throw(AST_UnaryPostfix, return_false);\n        def_dot_throw(AST_UnaryPrefix, function() {\n            return this.operator == \"void\";\n        });\n        def_dot_throw(AST_Binary, function(compressor) {\n            return (this.operator == \"&&\" || this.operator == \"||\")\n                && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor));\n        });\n        def_dot_throw(AST_Assign, function(compressor) {\n            return this.operator == \"=\"\n                && this.right._dot_throw(compressor);\n        });\n        def_dot_throw(AST_Conditional, function(compressor) {\n            return this.consequent._dot_throw(compressor)\n                || this.alternative._dot_throw(compressor);\n        });\n        def_dot_throw(AST_Dot, function(compressor) {\n            if (!is_strict(compressor)) return false;\n            if (this.expression instanceof AST_Function && this.property == \"prototype\") return false;\n            return true;\n        });\n        def_dot_throw(AST_Sequence, function(compressor) {\n            return this.tail_node()._dot_throw(compressor);\n        });\n        def_dot_throw(AST_SymbolRef, function(compressor) {\n            if (this.is_undefined) return true;\n            if (!is_strict(compressor)) return false;\n            if (is_undeclared_ref(this) && this.is_declared(compressor)) return false;\n            if (this.is_immutable()) return false;\n            var fixed = this.fixed_value();\n            return !fixed || fixed._dot_throw(compressor);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"_dot_throw\", func);\n    });\n\n    /* -----[ boolean/negation helpers ]----- */\n\n    // methods to determine whether an expression has a boolean result type\n    (function(def_is_boolean) {\n        var unary_bool = [ \"!\", \"delete\" ];\n        var binary_bool = [ \"in\", \"instanceof\", \"==\", \"!=\", \"===\", \"!==\", \"<\", \"<=\", \">=\", \">\" ];\n        def_is_boolean(AST_Node, return_false);\n        def_is_boolean(AST_UnaryPrefix, function() {\n            return member(this.operator, unary_bool);\n        });\n        def_is_boolean(AST_Binary, function() {\n            return member(this.operator, binary_bool)\n                || lazy_op(this.operator)\n                    && this.left.is_boolean()\n                    && this.right.is_boolean();\n        });\n        def_is_boolean(AST_Conditional, function() {\n            return this.consequent.is_boolean() && this.alternative.is_boolean();\n        });\n        def_is_boolean(AST_Assign, function() {\n            return this.operator == \"=\" && this.right.is_boolean();\n        });\n        def_is_boolean(AST_Sequence, function() {\n            return this.tail_node().is_boolean();\n        });\n        def_is_boolean(AST_True, return_true);\n        def_is_boolean(AST_False, return_true);\n    })(function(node, func) {\n        node.DEFMETHOD(\"is_boolean\", func);\n    });\n\n    // methods to determine if an expression has a numeric result type\n    (function(def_is_number) {\n        def_is_number(AST_Node, return_false);\n        def_is_number(AST_Number, return_true);\n        var unary = makePredicate(\"+ - ~ ++ --\");\n        def_is_number(AST_Unary, function() {\n            return unary(this.operator);\n        });\n        var binary = makePredicate(\"- * / % & | ^ << >> >>>\");\n        def_is_number(AST_Binary, function(compressor) {\n            return binary(this.operator) || this.operator == \"+\"\n                && this.left.is_number(compressor)\n                && this.right.is_number(compressor);\n        });\n        def_is_number(AST_Assign, function(compressor) {\n            return binary(this.operator.slice(0, -1))\n                || this.operator == \"=\" && this.right.is_number(compressor);\n        });\n        def_is_number(AST_Sequence, function(compressor) {\n            return this.tail_node().is_number(compressor);\n        });\n        def_is_number(AST_Conditional, function(compressor) {\n            return this.consequent.is_number(compressor) && this.alternative.is_number(compressor);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"is_number\", func);\n    });\n\n    // methods to determine if an expression has a string result type\n    (function(def_is_string) {\n        def_is_string(AST_Node, return_false);\n        def_is_string(AST_String, return_true);\n        def_is_string(AST_TemplateString, function() {\n            return this.segments.length === 1;\n        });\n        def_is_string(AST_UnaryPrefix, function() {\n            return this.operator == \"typeof\";\n        });\n        def_is_string(AST_Binary, function(compressor) {\n            return this.operator == \"+\" &&\n                (this.left.is_string(compressor) || this.right.is_string(compressor));\n        });\n        def_is_string(AST_Assign, function(compressor) {\n            return (this.operator == \"=\" || this.operator == \"+=\") && this.right.is_string(compressor);\n        });\n        def_is_string(AST_Sequence, function(compressor) {\n            return this.tail_node().is_string(compressor);\n        });\n        def_is_string(AST_Conditional, function(compressor) {\n            return this.consequent.is_string(compressor) && this.alternative.is_string(compressor);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"is_string\", func);\n    });\n\n    var lazy_op = makePredicate(\"&& ||\");\n    var unary_side_effects = makePredicate(\"delete ++ --\");\n\n    function is_lhs(node, parent) {\n        if (parent instanceof AST_Unary && unary_side_effects(parent.operator)) return parent.expression;\n        if (parent instanceof AST_Assign && parent.left === node) return node;\n    }\n\n    (function(def_find_defs) {\n        function to_node(value, orig) {\n            if (value instanceof AST_Node) return make_node(value.CTOR, orig, value);\n            if (Array.isArray(value)) return make_node(AST_Array, orig, {\n                elements: value.map(function(value) {\n                    return to_node(value, orig);\n                })\n            });\n            if (value && typeof value == \"object\") {\n                var props = [];\n                for (var key in value) if (HOP(value, key)) {\n                    props.push(make_node(AST_ObjectKeyVal, orig, {\n                        key: key,\n                        value: to_node(value[key], orig)\n                    }));\n                }\n                return make_node(AST_Object, orig, {\n                    properties: props\n                });\n            }\n            return make_node_from_constant(value, orig);\n        }\n\n        function warn(compressor, node) {\n            compressor.warn(\"global_defs \" + node.print_to_string() + \" redefined [{file}:{line},{col}]\", node.start);\n        }\n\n        AST_Toplevel.DEFMETHOD(\"resolve_defines\", function(compressor) {\n            if (!compressor.option(\"global_defs\")) return this;\n            this.figure_out_scope({ ie8: compressor.option(\"ie8\") });\n            return this.transform(new TreeTransformer(function(node) {\n                var def = node._find_defs(compressor, \"\");\n                if (!def) return;\n                var level = 0, child = node, parent;\n                while (parent = this.parent(level++)) {\n                    if (!(parent instanceof AST_PropAccess)) break;\n                    if (parent.expression !== child) break;\n                    child = parent;\n                }\n                if (is_lhs(child, parent)) {\n                    warn(compressor, node);\n                    return;\n                }\n                return def;\n            }));\n        });\n        def_find_defs(AST_Node, noop);\n        def_find_defs(AST_Dot, function(compressor, suffix) {\n            return this.expression._find_defs(compressor, \".\" + this.property + suffix);\n        });\n        def_find_defs(AST_SymbolDeclaration, function(compressor) {\n            if (!this.global()) return;\n            if (HOP(compressor.option(\"global_defs\"), this.name)) warn(compressor, this);\n        });\n        def_find_defs(AST_SymbolRef, function(compressor, suffix) {\n            if (!this.global()) return;\n            var defines = compressor.option(\"global_defs\");\n            var name = this.name + suffix;\n            if (HOP(defines, name)) return to_node(defines[name], this);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"_find_defs\", func);\n    });\n\n    function best_of_expression(ast1, ast2) {\n        return ast1.print_to_string().length >\n            ast2.print_to_string().length\n            ? ast2 : ast1;\n    }\n\n    function best_of_statement(ast1, ast2) {\n        return best_of_expression(make_node(AST_SimpleStatement, ast1, {\n            body: ast1\n        }), make_node(AST_SimpleStatement, ast2, {\n            body: ast2\n        })).body;\n    }\n\n    function best_of(compressor, ast1, ast2) {\n        return (first_in_statement(compressor) ? best_of_statement : best_of_expression)(ast1, ast2);\n    }\n\n    function convert_to_predicate(obj) {\n        for (var key in obj) {\n            obj[key] = makePredicate(obj[key]);\n        }\n    }\n\n    var object_fns = [\n        \"constructor\",\n        \"toString\",\n        \"valueOf\",\n    ];\n    var native_fns = {\n        Array: [\n            \"indexOf\",\n            \"join\",\n            \"lastIndexOf\",\n            \"slice\",\n        ].concat(object_fns),\n        Boolean: object_fns,\n        Function: object_fns,\n        Number: [\n            \"toExponential\",\n            \"toFixed\",\n            \"toPrecision\",\n        ].concat(object_fns),\n        Object: object_fns,\n        RegExp: [\n            \"test\",\n        ].concat(object_fns),\n        String: [\n            \"charAt\",\n            \"charCodeAt\",\n            \"concat\",\n            \"indexOf\",\n            \"italics\",\n            \"lastIndexOf\",\n            \"match\",\n            \"replace\",\n            \"search\",\n            \"slice\",\n            \"split\",\n            \"substr\",\n            \"substring\",\n            \"toLowerCase\",\n            \"toUpperCase\",\n            \"trim\",\n        ].concat(object_fns),\n    };\n    convert_to_predicate(native_fns);\n    var static_fns = {\n        Array: [\n            \"isArray\",\n        ],\n        Math: [\n            \"abs\",\n            \"acos\",\n            \"asin\",\n            \"atan\",\n            \"ceil\",\n            \"cos\",\n            \"exp\",\n            \"floor\",\n            \"log\",\n            \"round\",\n            \"sin\",\n            \"sqrt\",\n            \"tan\",\n            \"atan2\",\n            \"pow\",\n            \"max\",\n            \"min\",\n        ],\n        Number: [\n            \"isFinite\",\n            \"isNaN\",\n        ],\n        Object: [\n            \"create\",\n            \"getOwnPropertyDescriptor\",\n            \"getOwnPropertyNames\",\n            \"getPrototypeOf\",\n            \"isExtensible\",\n            \"isFrozen\",\n            \"isSealed\",\n            \"keys\",\n        ],\n        String: [\n            \"fromCharCode\",\n        ],\n    };\n    convert_to_predicate(static_fns);\n\n    // methods to evaluate a constant expression\n    (function(def_eval) {\n        // If the node has been successfully reduced to a constant,\n        // then its value is returned; otherwise the element itself\n        // is returned.\n        // They can be distinguished as constant value is never a\n        // descendant of AST_Node.\n        AST_Node.DEFMETHOD(\"evaluate\", function(compressor) {\n            if (!compressor.option(\"evaluate\")) return this;\n            var val = this._eval(compressor, 1);\n            if (!val || val instanceof RegExp) return val;\n            if (typeof val == \"function\" || typeof val == \"object\") return this;\n            return val;\n        });\n        var unaryPrefix = makePredicate(\"! ~ - + void\");\n        AST_Node.DEFMETHOD(\"is_constant\", function() {\n            // Accomodate when compress option evaluate=false\n            // as well as the common constant expressions !0 and -1\n            if (this instanceof AST_Constant) {\n                return !(this instanceof AST_RegExp);\n            } else {\n                return this instanceof AST_UnaryPrefix\n                    && this.expression instanceof AST_Constant\n                    && unaryPrefix(this.operator);\n            }\n        });\n        def_eval(AST_Statement, function() {\n            throw new Error(string_template(\"Cannot evaluate a statement [{file}:{line},{col}]\", this.start));\n        });\n        def_eval(AST_Lambda, return_this);\n        def_eval(AST_Class, return_this);\n        def_eval(AST_Node, return_this);\n        def_eval(AST_Constant, function() {\n            return this.getValue();\n        });\n        def_eval(AST_TemplateString, function() {\n            if (this.segments.length !== 1) return this;\n            return this.segments[0].value;\n        });\n        def_eval(AST_Function, function(compressor) {\n            if (compressor.option(\"unsafe\")) {\n                var fn = function() {};\n                fn.node = this;\n                fn.toString = function() {\n                    return this.node.print_to_string();\n                };\n                return fn;\n            }\n            return this;\n        });\n        def_eval(AST_Array, function(compressor, depth) {\n            if (compressor.option(\"unsafe\")) {\n                var elements = [];\n                for (var i = 0, len = this.elements.length; i < len; i++) {\n                    var element = this.elements[i];\n                    var value = element._eval(compressor, depth);\n                    if (element === value) return this;\n                    elements.push(value);\n                }\n                return elements;\n            }\n            return this;\n        });\n        def_eval(AST_Object, function(compressor, depth) {\n            if (compressor.option(\"unsafe\")) {\n                var val = {};\n                for (var i = 0, len = this.properties.length; i < len; i++) {\n                    var prop = this.properties[i];\n                    if (prop instanceof AST_Expansion) return this;\n                    var key = prop.key;\n                    if (key instanceof AST_Symbol) {\n                        key = key.name;\n                    } else if (key instanceof AST_Node) {\n                        key = key._eval(compressor, depth);\n                        if (key === prop.key) return this;\n                    }\n                    if (typeof Object.prototype[key] === \"function\") {\n                        return this;\n                    }\n                    if (prop.value instanceof AST_Function) continue;\n                    val[key] = prop.value._eval(compressor, depth);\n                    if (val[key] === prop.value) return this;\n                }\n                return val;\n            }\n            return this;\n        });\n        var non_converting_unary = makePredicate(\"! typeof void\");\n        def_eval(AST_UnaryPrefix, function(compressor, depth) {\n            var e = this.expression;\n            // Function would be evaluated to an array and so typeof would\n            // incorrectly return 'object'. Hence making is a special case.\n            if (compressor.option(\"typeofs\")\n                && this.operator == \"typeof\"\n                && (e instanceof AST_Lambda\n                    || e instanceof AST_SymbolRef\n                        && e.fixed_value() instanceof AST_Lambda)) {\n                return typeof function() {};\n            }\n            if (!non_converting_unary(this.operator)) depth++;\n            e = e._eval(compressor, depth);\n            if (e === this.expression) return this;\n            switch (this.operator) {\n              case \"!\": return !e;\n              case \"typeof\":\n                // typeof <RegExp> returns \"object\" or \"function\" on different platforms\n                // so cannot evaluate reliably\n                if (e instanceof RegExp) return this;\n                return typeof e;\n              case \"void\": return void e;\n              case \"~\": return ~e;\n              case \"-\": return -e;\n              case \"+\": return +e;\n            }\n            return this;\n        });\n        var non_converting_binary = makePredicate(\"&& || === !==\");\n        def_eval(AST_Binary, function(compressor, depth) {\n            if (!non_converting_binary(this.operator)) depth++;\n            var left = this.left._eval(compressor, depth);\n            if (left === this.left) return this;\n            var right = this.right._eval(compressor, depth);\n            if (right === this.right) return this;\n            var result;\n            switch (this.operator) {\n              case \"&&\"  : result = left &&  right; break;\n              case \"||\"  : result = left ||  right; break;\n              case \"|\"   : result = left |   right; break;\n              case \"&\"   : result = left &   right; break;\n              case \"^\"   : result = left ^   right; break;\n              case \"+\"   : result = left +   right; break;\n              case \"*\"   : result = left *   right; break;\n              case \"**\"  : result = Math.pow(left, right); break;\n              case \"/\"   : result = left /   right; break;\n              case \"%\"   : result = left %   right; break;\n              case \"-\"   : result = left -   right; break;\n              case \"<<\"  : result = left <<  right; break;\n              case \">>\"  : result = left >>  right; break;\n              case \">>>\" : result = left >>> right; break;\n              case \"==\"  : result = left ==  right; break;\n              case \"===\" : result = left === right; break;\n              case \"!=\"  : result = left !=  right; break;\n              case \"!==\" : result = left !== right; break;\n              case \"<\"   : result = left <   right; break;\n              case \"<=\"  : result = left <=  right; break;\n              case \">\"   : result = left >   right; break;\n              case \">=\"  : result = left >=  right; break;\n              default:\n                  return this;\n            }\n            if (isNaN(result) && compressor.find_parent(AST_With)) {\n                // leave original expression as is\n                return this;\n            }\n            return result;\n        });\n        def_eval(AST_Conditional, function(compressor, depth) {\n            var condition = this.condition._eval(compressor, depth);\n            if (condition === this.condition) return this;\n            var node = condition ? this.consequent : this.alternative;\n            var value = node._eval(compressor, depth);\n            return value === node ? this : value;\n        });\n        def_eval(AST_SymbolRef, function(compressor, depth) {\n            var fixed = this.fixed_value();\n            if (!fixed) return this;\n            var value;\n            if (HOP(fixed, \"_eval\")) {\n                value = fixed._eval();\n            } else {\n                this._eval = return_this;\n                value = fixed._eval(compressor, depth);\n                delete this._eval;\n                if (value === fixed) return this;\n                fixed._eval = function() {\n                    return value;\n                };\n            }\n            if (value && typeof value == \"object\") {\n                var escaped = this.definition().escaped;\n                if (escaped && depth > escaped) return this;\n            }\n            return value;\n        });\n        var global_objs = {\n            Array: Array,\n            Math: Math,\n            Number: Number,\n            Object: Object,\n            String: String,\n        };\n        var static_values = {\n            Math: [\n                \"E\",\n                \"LN10\",\n                \"LN2\",\n                \"LOG2E\",\n                \"LOG10E\",\n                \"PI\",\n                \"SQRT1_2\",\n                \"SQRT2\",\n            ],\n            Number: [\n                \"MAX_VALUE\",\n                \"MIN_VALUE\",\n                \"NaN\",\n                \"NEGATIVE_INFINITY\",\n                \"POSITIVE_INFINITY\",\n            ],\n        };\n        convert_to_predicate(static_values);\n        def_eval(AST_PropAccess, function(compressor, depth) {\n            if (compressor.option(\"unsafe\")) {\n                var key = this.property;\n                if (key instanceof AST_Node) {\n                    key = key._eval(compressor, depth);\n                    if (key === this.property) return this;\n                }\n                var exp = this.expression;\n                var val;\n                if (is_undeclared_ref(exp)) {\n\n                    var aa;\n                    var first_arg = exp.name === \"hasOwnProperty\"\n                        && key === \"call\"\n                        && (aa = compressor.parent() && compressor.parent().args)\n                        && (aa && aa[0]\n                        && aa[0].evaluate(compressor));\n\n                    first_arg = first_arg instanceof AST_Dot ? first_arg.expression : first_arg;\n\n                    if (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared) {\n                        return this.clone();\n                    }\n                    if (!(static_values[exp.name] || return_false)(key)) return this;\n                    val = global_objs[exp.name];\n                } else {\n                    val = exp._eval(compressor, depth + 1);\n                    if (!val || val === exp || !HOP(val, key)) return this;\n                    if (typeof val == \"function\") switch (key) {\n                      case \"name\":\n                        return val.node.name ? val.node.name.name : \"\";\n                      case \"length\":\n                        return val.node.argnames.length;\n                      default:\n                        return this;\n                    }\n                }\n                return val[key];\n            }\n            return this;\n        });\n        def_eval(AST_Call, function(compressor, depth) {\n            var exp = this.expression;\n            if (compressor.option(\"unsafe\") && exp instanceof AST_PropAccess) {\n                var key = exp.property;\n                if (key instanceof AST_Node) {\n                    key = key._eval(compressor, depth);\n                    if (key === exp.property) return this;\n                }\n                var val;\n                var e = exp.expression;\n                if (is_undeclared_ref(e)) {\n                    var first_arg =\n                        e.name === \"hasOwnProperty\" &&\n                        key === \"call\" &&\n                        (this.args[0] && this.args[0].evaluate(compressor));\n\n                    first_arg = first_arg instanceof AST_Dot ? first_arg.expression : first_arg;\n\n                    if ((first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)) {\n                        return this.clone();\n                    }\n                    if (!(static_fns[e.name] || return_false)(key)) return this;\n                    val = global_objs[e.name];\n                } else {\n                    val = e._eval(compressor, depth + 1);\n                    if (val === e || !(val && native_fns[val.constructor.name] || return_false)(key)) return this;\n                }\n                var args = [];\n                for (var i = 0, len = this.args.length; i < len; i++) {\n                    var arg = this.args[i];\n                    var value = arg._eval(compressor, depth);\n                    if (arg === value) return this;\n                    args.push(value);\n                }\n                try {\n                    return val[key].apply(val, args);\n                } catch (ex) {\n                    compressor.warn(\"Error evaluating {code} [{file}:{line},{col}]\", {\n                        code: this.print_to_string(),\n                        file: this.start.file,\n                        line: this.start.line,\n                        col: this.start.col\n                    });\n                }\n            }\n            return this;\n        });\n        def_eval(AST_New, return_this);\n    })(function(node, func) {\n        node.DEFMETHOD(\"_eval\", func);\n    });\n\n    // method to negate an expression\n    (function(def_negate) {\n        function basic_negation(exp) {\n            return make_node(AST_UnaryPrefix, exp, {\n                operator: \"!\",\n                expression: exp\n            });\n        }\n        function best(orig, alt, first_in_statement) {\n            var negated = basic_negation(orig);\n            if (first_in_statement) {\n                var stat = make_node(AST_SimpleStatement, alt, {\n                    body: alt\n                });\n                return best_of_expression(negated, stat) === stat ? alt : negated;\n            }\n            return best_of_expression(negated, alt);\n        }\n        def_negate(AST_Node, function() {\n            return basic_negation(this);\n        });\n        def_negate(AST_Statement, function() {\n            throw new Error(\"Cannot negate a statement\");\n        });\n        def_negate(AST_Function, function() {\n            return basic_negation(this);\n        });\n        def_negate(AST_Arrow, function() {\n            return basic_negation(this);\n        });\n        def_negate(AST_UnaryPrefix, function() {\n            if (this.operator == \"!\")\n                return this.expression;\n            return basic_negation(this);\n        });\n        def_negate(AST_Sequence, function(compressor) {\n            var expressions = this.expressions.slice();\n            expressions.push(expressions.pop().negate(compressor));\n            return make_sequence(this, expressions);\n        });\n        def_negate(AST_Conditional, function(compressor, first_in_statement) {\n            var self = this.clone();\n            self.consequent = self.consequent.negate(compressor);\n            self.alternative = self.alternative.negate(compressor);\n            return best(this, self, first_in_statement);\n        });\n        def_negate(AST_Binary, function(compressor, first_in_statement) {\n            var self = this.clone(), op = this.operator;\n            if (compressor.option(\"unsafe_comps\")) {\n                switch (op) {\n                  case \"<=\" : self.operator = \">\"  ; return self;\n                  case \"<\"  : self.operator = \">=\" ; return self;\n                  case \">=\" : self.operator = \"<\"  ; return self;\n                  case \">\"  : self.operator = \"<=\" ; return self;\n                }\n            }\n            switch (op) {\n              case \"==\" : self.operator = \"!=\"; return self;\n              case \"!=\" : self.operator = \"==\"; return self;\n              case \"===\": self.operator = \"!==\"; return self;\n              case \"!==\": self.operator = \"===\"; return self;\n              case \"&&\":\n                self.operator = \"||\";\n                self.left = self.left.negate(compressor, first_in_statement);\n                self.right = self.right.negate(compressor);\n                return best(this, self, first_in_statement);\n              case \"||\":\n                self.operator = \"&&\";\n                self.left = self.left.negate(compressor, first_in_statement);\n                self.right = self.right.negate(compressor);\n                return best(this, self, first_in_statement);\n            }\n            return basic_negation(this);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"negate\", function(compressor, first_in_statement) {\n            return func.call(this, compressor, first_in_statement);\n        });\n    });\n\n    var global_pure_fns = makePredicate(\"Boolean decodeURI decodeURIComponent Date encodeURI encodeURIComponent Error escape EvalError isFinite isNaN Number Object parseFloat parseInt RangeError ReferenceError String SyntaxError TypeError unescape URIError\");\n    AST_Call.DEFMETHOD(\"is_expr_pure\", function(compressor) {\n        if (compressor.option(\"unsafe\")) {\n            var expr = this.expression;\n            var first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor));\n            if (\n                expr.expression && expr.expression.name === \"hasOwnProperty\" &&\n                (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)\n            ) {\n                return false;\n            }\n            if (is_undeclared_ref(expr) && global_pure_fns(expr.name)) return true;\n            if (expr instanceof AST_Dot\n                && is_undeclared_ref(expr.expression)\n                && (static_fns.hasOwnProperty(expr.expression.name) && static_fns[expr.expression.name] || return_false)(expr.property)) {\n                return true;\n            }\n        }\n        return this.pure || !compressor.pure_funcs(this);\n    });\n    AST_Node.DEFMETHOD(\"is_call_pure\", return_false);\n    AST_Dot.DEFMETHOD(\"is_call_pure\", function(compressor) {\n        if (!compressor.option(\"unsafe\")) return;\n        var expr = this.expression;\n        var fns = return_false;\n        if (expr instanceof AST_Array) {\n            fns = native_fns.Array;\n        } else if (expr.is_boolean()) {\n            fns = native_fns.Boolean;\n        } else if (expr.is_number(compressor)) {\n            fns = native_fns.Number;\n        } else if (expr instanceof AST_RegExp) {\n            fns = native_fns.RegExp;\n        } else if (expr.is_string(compressor)) {\n            fns = native_fns.String;\n        } else if (!this.may_throw_on_access(compressor)) {\n            fns = native_fns.Object;\n        }\n        return fns(this.property);\n    });\n\n    // determine if expression has side effects\n    (function(def_has_side_effects) {\n        def_has_side_effects(AST_Node, return_true);\n\n        def_has_side_effects(AST_EmptyStatement, return_false);\n        def_has_side_effects(AST_Constant, return_false);\n        def_has_side_effects(AST_This, return_false);\n\n        function any(list, compressor) {\n            for (var i = list.length; --i >= 0;)\n                if (list[i].has_side_effects(compressor))\n                    return true;\n            return false;\n        }\n\n        def_has_side_effects(AST_Block, function(compressor) {\n            return any(this.body, compressor);\n        });\n        def_has_side_effects(AST_Call, function(compressor) {\n            if (!this.is_expr_pure(compressor)\n                && (!this.expression.is_call_pure(compressor)\n                    || this.expression.has_side_effects(compressor))) {\n                return true;\n            }\n            return any(this.args, compressor);\n        });\n        def_has_side_effects(AST_Switch, function(compressor) {\n            return this.expression.has_side_effects(compressor)\n                || any(this.body, compressor);\n        });\n        def_has_side_effects(AST_Case, function(compressor) {\n            return this.expression.has_side_effects(compressor)\n                || any(this.body, compressor);\n        });\n        def_has_side_effects(AST_Try, function(compressor) {\n            return any(this.body, compressor)\n                || this.bcatch && this.bcatch.has_side_effects(compressor)\n                || this.bfinally && this.bfinally.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_If, function(compressor) {\n            return this.condition.has_side_effects(compressor)\n                || this.body && this.body.has_side_effects(compressor)\n                || this.alternative && this.alternative.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_LabeledStatement, function(compressor) {\n            return this.body.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_SimpleStatement, function(compressor) {\n            return this.body.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_Lambda, return_false);\n        def_has_side_effects(AST_Class, return_false);\n        def_has_side_effects(AST_DefClass, return_true);\n        def_has_side_effects(AST_Binary, function(compressor) {\n            return this.left.has_side_effects(compressor)\n                || this.right.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_Assign, return_true);\n        def_has_side_effects(AST_Conditional, function(compressor) {\n            return this.condition.has_side_effects(compressor)\n                || this.consequent.has_side_effects(compressor)\n                || this.alternative.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_Unary, function(compressor) {\n            return unary_side_effects(this.operator)\n                || this.expression.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_SymbolRef, function(compressor) {\n            return !this.is_declared(compressor);\n        });\n        def_has_side_effects(AST_SymbolDeclaration, return_false);\n        def_has_side_effects(AST_Object, function(compressor) {\n            return any(this.properties, compressor);\n        });\n        def_has_side_effects(AST_ObjectProperty, function(compressor) {\n            if (this.key instanceof AST_ObjectKeyVal &&\n                    this.key.has_side_effects(compressor))\n                return true;\n            return this.value.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_Array, function(compressor) {\n            return any(this.elements, compressor);\n        });\n        def_has_side_effects(AST_Dot, function(compressor) {\n            return this.expression.may_throw_on_access(compressor)\n                || this.expression.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_Sub, function(compressor) {\n            return this.expression.may_throw_on_access(compressor)\n                || this.expression.has_side_effects(compressor)\n                || this.property.has_side_effects(compressor);\n        });\n        def_has_side_effects(AST_Sequence, function(compressor) {\n            return any(this.expressions, compressor);\n        });\n        def_has_side_effects(AST_Definitions, function(compressor) {\n            return any(this.definitions, compressor);\n        });\n        def_has_side_effects(AST_VarDef, function(compressor) {\n            return this.value;\n        });\n        def_has_side_effects(AST_TemplateSegment, return_false);\n        def_has_side_effects(AST_TemplateString, function(compressor) {\n            return any(this.segments, compressor);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"has_side_effects\", func);\n    });\n\n    // determine if expression may throw\n    (function(def_may_throw) {\n        def_may_throw(AST_Node, return_true);\n\n        def_may_throw(AST_Class, return_false);\n        def_may_throw(AST_Constant, return_false);\n        def_may_throw(AST_EmptyStatement, return_false);\n        def_may_throw(AST_Lambda, return_false);\n        def_may_throw(AST_SymbolDeclaration, return_false);\n        def_may_throw(AST_This, return_false);\n\n        function any(list, compressor) {\n            for (var i = list.length; --i >= 0;)\n                if (list[i].may_throw(compressor))\n                    return true;\n            return false;\n        }\n\n        def_may_throw(AST_Array, function(compressor) {\n            return any(this.elements, compressor);\n        });\n        def_may_throw(AST_Assign, function(compressor) {\n            if (this.right.may_throw(compressor)) return true;\n            if (!compressor.has_directive(\"use strict\")\n                && this.operator == \"=\"\n                && this.left instanceof AST_SymbolRef) {\n                return false;\n            }\n            return this.left.may_throw(compressor);\n        });\n        def_may_throw(AST_Binary, function(compressor) {\n            return this.left.may_throw(compressor)\n                || this.right.may_throw(compressor);\n        });\n        def_may_throw(AST_Block, function(compressor) {\n            return any(this.body, compressor);\n        });\n        def_may_throw(AST_Call, function(compressor) {\n            if (any(this.args, compressor)) return true;\n            if (this.is_expr_pure(compressor)) return false;\n            if (this.expression.may_throw(compressor)) return true;\n            return !(this.expression instanceof AST_Lambda)\n                || any(this.expression.body, compressor);\n        });\n        def_may_throw(AST_Case, function(compressor) {\n            return this.expression.may_throw(compressor)\n                || any(this.body, compressor);\n        });\n        def_may_throw(AST_Conditional, function(compressor) {\n            return this.condition.may_throw(compressor)\n                || this.consequent.may_throw(compressor)\n                || this.alternative.may_throw(compressor);\n        });\n        def_may_throw(AST_Definitions, function(compressor) {\n            return any(this.definitions, compressor);\n        });\n        def_may_throw(AST_Dot, function(compressor) {\n            return this.expression.may_throw_on_access(compressor)\n                || this.expression.may_throw(compressor);\n        });\n        def_may_throw(AST_If, function(compressor) {\n            return this.condition.may_throw(compressor)\n                || this.body && this.body.may_throw(compressor)\n                || this.alternative && this.alternative.may_throw(compressor);\n        });\n        def_may_throw(AST_LabeledStatement, function(compressor) {\n            return this.body.may_throw(compressor);\n        });\n        def_may_throw(AST_Object, function(compressor) {\n            return any(this.properties, compressor);\n        });\n        def_may_throw(AST_ObjectProperty, function(compressor) {\n            return this.value.may_throw(compressor);\n        });\n        def_may_throw(AST_Return, function(compressor) {\n            return this.value && this.value.may_throw(compressor);\n        });\n        def_may_throw(AST_Sequence, function(compressor) {\n            return any(this.expressions, compressor);\n        });\n        def_may_throw(AST_SimpleStatement, function(compressor) {\n            return this.body.may_throw(compressor);\n        });\n        def_may_throw(AST_Sub, function(compressor) {\n            return this.expression.may_throw_on_access(compressor)\n                || this.expression.may_throw(compressor)\n                || this.property.may_throw(compressor);\n        });\n        def_may_throw(AST_Switch, function(compressor) {\n            return this.expression.may_throw(compressor)\n                || any(this.body, compressor);\n        });\n        def_may_throw(AST_SymbolRef, function(compressor) {\n            return !this.is_declared(compressor);\n        });\n        def_may_throw(AST_Try, function(compressor) {\n            return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)\n                || this.bfinally && this.bfinally.may_throw(compressor);\n        });\n        def_may_throw(AST_Unary, function(compressor) {\n            if (this.operator == \"typeof\" && this.expression instanceof AST_SymbolRef)\n                return false;\n            return this.expression.may_throw(compressor);\n        });\n        def_may_throw(AST_VarDef, function(compressor) {\n            if (!this.value) return false;\n            return this.value.may_throw(compressor);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"may_throw\", func);\n    });\n\n    // determine if expression is constant\n    (function(def_is_constant_expression) {\n        function all(list) {\n            for (var i = list.length; --i >= 0;)\n                if (!list[i].is_constant_expression())\n                    return false;\n            return true;\n        }\n\n        function all_refs_local(scope) {\n            var self = this;\n            var result = true;\n            self.walk(new TreeWalker(function(node) {\n                if (!result) return true;\n                if (node instanceof AST_SymbolRef) {\n                    if (self.inlined) {\n                        result = false;\n                        return true;\n                    }\n                    var def = node.definition();\n                    if (member(def, self.enclosed)\n                        && !self.variables.has(def.name)) {\n                        if (scope) {\n                            var scope_def = scope.find_variable(node);\n                            if (def.undeclared ? !scope_def : scope_def === def) {\n                                result = \"f\";\n                                return true;\n                            }\n                        }\n                        result = false;\n                    }\n                    return true;\n                }\n                if (node instanceof AST_This && self instanceof AST_Arrow) {\n                    result = false;\n                    return true;\n                }\n            }));\n            return result;\n        }\n\n        def_is_constant_expression(AST_Node, return_false);\n        def_is_constant_expression(AST_Constant, return_true);\n        def_is_constant_expression(AST_Class, function(scope) {\n            var self = this;\n            if (self.extends && !self.extends.is_constant_expression(scope)) {\n                return false;\n            }\n            return all_refs_local.call(self, scope);\n        });\n        def_is_constant_expression(AST_Lambda, all_refs_local);\n        def_is_constant_expression(AST_Unary, function() {\n            return this.expression.is_constant_expression();\n        });\n        def_is_constant_expression(AST_Binary, function() {\n            return this.left.is_constant_expression() && this.right.is_constant_expression();\n        });\n        def_is_constant_expression(AST_Array, function() {\n            return all(this.elements);\n        });\n        def_is_constant_expression(AST_Object, function() {\n            return all(this.properties);\n        });\n        def_is_constant_expression(AST_ObjectProperty, function() {\n            return !(this.key instanceof AST_Node) && this.value.is_constant_expression();\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"is_constant_expression\", func);\n    });\n\n    // tell me if a statement aborts\n    function aborts(thing) {\n        return thing && thing.aborts();\n    }\n    (function(def) {\n        def(AST_Statement, return_null);\n        def(AST_Jump, return_this);\n        function block_aborts() {\n            for (var i = 0; i < this.body.length; i++) {\n                if (aborts(this.body[i])) {\n                    return this.body[i];\n                }\n            }\n            return null;\n        }\n        def(AST_Import, function() { return null; });\n        def(AST_BlockStatement, block_aborts);\n        def(AST_SwitchBranch, block_aborts);\n        def(AST_If, function() {\n            return this.alternative && aborts(this.body) && aborts(this.alternative) && this;\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"aborts\", func);\n    });\n\n    /* -----[ optimizers ]----- */\n\n    var directives = [\"use asm\", \"use strict\"];\n    def_optimize(AST_Directive, function(self, compressor) {\n        if (compressor.option(\"directives\")\n            && (!member(self.value, directives) || compressor.has_directive(self.value) !== self)) {\n            return make_node(AST_EmptyStatement, self);\n        }\n        return self;\n    });\n\n    def_optimize(AST_Debugger, function(self, compressor) {\n        if (compressor.option(\"drop_debugger\"))\n            return make_node(AST_EmptyStatement, self);\n        return self;\n    });\n\n    def_optimize(AST_LabeledStatement, function(self, compressor) {\n        if (self.body instanceof AST_Break\n            && compressor.loopcontrol_target(self.body) === self.body) {\n            return make_node(AST_EmptyStatement, self);\n        }\n        return self.label.references.length == 0 ? self.body : self;\n    });\n\n    def_optimize(AST_Block, function(self, compressor) {\n        tighten_body(self.body, compressor);\n        return self;\n    });\n\n    function can_be_extracted_from_if_block(node) {\n        return !(\n            node instanceof AST_Const ||\n            node instanceof AST_Let ||\n            node instanceof AST_Class\n        );\n    }\n\n    def_optimize(AST_BlockStatement, function(self, compressor) {\n        tighten_body(self.body, compressor);\n        switch (self.body.length) {\n          case 1:\n            if (!compressor.has_directive(\"use strict\")\n                && compressor.parent() instanceof AST_If\n                && can_be_extracted_from_if_block(self.body[0])\n                || can_be_evicted_from_block(self.body[0])) {\n                return self.body[0];\n            }\n            break;\n          case 0: return make_node(AST_EmptyStatement, self);\n        }\n        return self;\n    });\n\n    function opt_AST_Lambda(self, compressor) {\n        tighten_body(self.body, compressor);\n        if (compressor.option(\"side_effects\")\n            && self.body.length == 1\n            && self.body[0] === compressor.has_directive(\"use strict\")) {\n            self.body.length = 0;\n        }\n        return self;\n    }\n    def_optimize(AST_Lambda, opt_AST_Lambda);\n\n    AST_Scope.DEFMETHOD(\"drop_unused\", function(compressor) {\n        if (!compressor.option(\"unused\")) return;\n        if (compressor.has_directive(\"use asm\")) return;\n        var self = this;\n        if (self.pinned()) return;\n        var drop_funcs = !(self instanceof AST_Toplevel) || compressor.toplevel.funcs;\n        var drop_vars = !(self instanceof AST_Toplevel) || compressor.toplevel.vars;\n        var assign_as_unused = /keep_assign/.test(compressor.option(\"unused\")) ? return_false : function(node) {\n            if (node instanceof AST_Assign && (node.write_only || node.operator == \"=\")) {\n                return node.left;\n            }\n            if (node instanceof AST_Unary && node.write_only) return node.expression;\n        };\n        var in_use = [];\n        var in_use_ids = Object.create(null); // avoid expensive linear scans of in_use\n        var fixed_ids = Object.create(null);\n        if (self instanceof AST_Toplevel && compressor.top_retain) {\n            self.variables.each(function(def) {\n                if (compressor.top_retain(def) && !(def.id in in_use_ids)) {\n                    in_use_ids[def.id] = true;\n                    in_use.push(def);\n                }\n            });\n        }\n        var var_defs_by_id = new Dictionary();\n        var initializations = new Dictionary();\n        var destructuring_value = null;\n        // pass 1: find out which symbols are directly used in\n        // this scope (not in nested scopes).\n        var scope = this;\n        var tw = new TreeWalker(function(node, descend) {\n            if (node instanceof AST_Lambda && node.uses_arguments && !tw.has_directive(\"use strict\")) {\n                node.argnames.forEach(function(argname) {\n                    if (!(argname instanceof AST_SymbolDeclaration)) return;\n                    var def = argname.definition();\n                    if (!(def.id in in_use_ids)) {\n                        in_use_ids[def.id] = true;\n                        in_use.push(def);\n                    }\n                });\n            }\n            if (node === self) return;\n            if (node instanceof AST_Defun || node instanceof AST_DefClass) {\n                var node_def = node.name.definition();\n                var in_export = tw.parent() instanceof AST_Export;\n                if (in_export || !drop_funcs && scope === self) {\n                    if (node_def.global && !(node_def.id in in_use_ids)) {\n                        in_use_ids[node_def.id] = true;\n                        in_use.push(node_def);\n                    }\n                }\n                initializations.add(node_def.id, node);\n                return true; // don't go in nested scopes\n            }\n            if (node instanceof AST_SymbolFunarg && scope === self) {\n                var_defs_by_id.add(node.definition().id, node);\n            }\n            if (node instanceof AST_Definitions && scope === self) {\n                var in_export = tw.parent() instanceof AST_Export;\n                node.definitions.forEach(function(def) {\n                    if (def.name instanceof AST_SymbolVar) {\n                        var_defs_by_id.add(def.name.definition().id, def);\n                    }\n                    if (in_export || !drop_vars) {\n                        def.name.walk(new TreeWalker(function(node) {\n                            if (node instanceof AST_SymbolDeclaration) {\n                                var def = node.definition();\n                                if ((in_export || def.global) && !(def.id in in_use_ids)) {\n                                    in_use_ids[def.id] = true;\n                                    in_use.push(def);\n                                }\n                            }\n                        }));\n                    }\n                    if (def.value) {\n                        if (def.name instanceof AST_Destructuring) {\n                            var destructuring_cache = destructuring_value;\n                            destructuring_value = def.value;\n                            def.walk(tw);\n                            destructuring_value = destructuring_cache;\n                        } else {\n                            var node_def = def.name.definition();\n                            initializations.add(node_def.id, def.value);\n                            if (!node_def.chained && def.name.fixed_value() === def.value) {\n                                fixed_ids[node_def.id] = def;\n                            }\n                        }\n                        if (def.value.has_side_effects(compressor)) {\n                            def.value.walk(tw);\n                        }\n                    }\n                });\n                return true;\n            }\n            if (node.destructuring && destructuring_value) {\n                initializations.add(node.name, destructuring_value);\n            }\n            return scan_ref_scoped(node, descend);\n        });\n        self.walk(tw);\n        // pass 2: for every used symbol we need to walk its\n        // initialization code to figure out if it uses other\n        // symbols (that may not be in_use).\n        tw = new TreeWalker(scan_ref_scoped);\n        for (var i = 0; i < in_use.length; i++) {\n            var init = initializations.get(in_use[i].id);\n            if (init) init.forEach(function(init) {\n                init.walk(tw);\n            });\n        }\n        // pass 3: we should drop declarations not in_use\n        var tt = new TreeTransformer(\n            function before(node, descend, in_list) {\n                var parent = tt.parent();\n                if (drop_vars) {\n                    var sym = assign_as_unused(node);\n                    if (sym instanceof AST_SymbolRef) {\n                        var def = sym.definition();\n                        var in_use = def.id in in_use_ids;\n                        if (node instanceof AST_Assign) {\n                            if (!in_use || def.id in fixed_ids && fixed_ids[def.id] !== node) {\n                                return maintain_this_binding(parent, node, node.right.transform(tt));\n                            }\n                        } else if (!in_use) return make_node(AST_Number, node, {\n                            value: 0\n                        });\n                    }\n                }\n                if (scope !== self) return;\n                var def;\n                if (node.name\n                    && (node instanceof AST_ClassExpression\n                        && !keep_name(compressor.option(\"keep_classnames\"), (def = node.name.definition()).name)\n                    || node instanceof AST_Function\n                        && !keep_name(compressor.option(\"keep_fnames\"), (def = node.name.definition()).name))) {\n                    // any declarations with same name will overshadow\n                    // name of this anonymous function and can therefore\n                    // never be used anywhere\n                    if (!(def.id in in_use_ids) || def.orig.length > 1) node.name = null;\n                }\n                if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {\n                    var trim = !compressor.option(\"keep_fargs\");\n                    for (var a = node.argnames, i = a.length; --i >= 0;) {\n                        var sym = a[i];\n                        if (sym instanceof AST_Expansion) {\n                            sym = sym.expression;\n                        }\n                        if (sym instanceof AST_DefaultAssign) {\n                            sym = sym.left;\n                        }\n                        // Do not drop destructuring arguments.\n                        // They constitute a type assertion, so dropping\n                        // them would stop that TypeError which would happen\n                        // if someone called it with an incorrectly formatted\n                        // parameter.\n                        if (!(sym instanceof AST_Destructuring) && !(sym.definition().id in in_use_ids)) {\n                            sym.__unused = true;\n                            if (trim) {\n                                a.pop();\n                                compressor[sym.unreferenced() ? \"warn\" : \"info\"](\"Dropping unused function argument {name} [{file}:{line},{col}]\", template(sym));\n                            }\n                        } else {\n                            trim = false;\n                        }\n                    }\n                }\n                if ((node instanceof AST_Defun || node instanceof AST_DefClass) && node !== self) {\n                    var def = node.name.definition();\n                    var keep = (def.id in in_use_ids) || !drop_funcs && def.global;\n                    if (!keep) {\n                        compressor[node.name.unreferenced() ? \"warn\" : \"info\"](\"Dropping unused function {name} [{file}:{line},{col}]\", template(node.name));\n                        def.eliminated++;\n                        return make_node(AST_EmptyStatement, node);\n                    }\n                }\n                if (node instanceof AST_Definitions && !(parent instanceof AST_ForIn && parent.init === node)) {\n                    var drop_block = !(parent instanceof AST_Toplevel) && !(node instanceof AST_Var);\n                    // place uninitialized names at the start\n                    var body = [], head = [], tail = [];\n                    // for unused names whose initialization has\n                    // side effects, we can cascade the init. code\n                    // into the next one, or next statement.\n                    var side_effects = [];\n                    node.definitions.forEach(function(def) {\n                        if (def.value) def.value = def.value.transform(tt);\n                        var is_destructure = def.name instanceof AST_Destructuring;\n                        var sym = is_destructure\n                            ? new SymbolDef(null, { name: \"<destructure>\" }) /* fake SymbolDef */\n                            : def.name.definition();\n                        if (drop_block && sym.global) return tail.push(def);\n                        if (!(drop_vars || drop_block)\n                            || is_destructure\n                                && (def.name.names.length\n                                    || def.name.is_array\n                                    || compressor.option(\"pure_getters\") != true)\n                            || sym.id in in_use_ids) {\n                            if (def.value && sym.id in fixed_ids && fixed_ids[sym.id] !== def) {\n                                def.value = def.value.drop_side_effect_free(compressor);\n                            }\n                            if (def.name instanceof AST_SymbolVar) {\n                                var var_defs = var_defs_by_id.get(sym.id);\n                                if (var_defs.length > 1 && (!def.value || sym.orig.indexOf(def.name) > sym.eliminated)) {\n                                    compressor.warn(\"Dropping duplicated definition of variable {name} [{file}:{line},{col}]\", template(def.name));\n                                    if (def.value) {\n                                        var ref = make_node(AST_SymbolRef, def.name, def.name);\n                                        sym.references.push(ref);\n                                        var assign = make_node(AST_Assign, def, {\n                                            operator: \"=\",\n                                            left: ref,\n                                            right: def.value\n                                        });\n                                        if (fixed_ids[sym.id] === def) {\n                                            fixed_ids[sym.id] = assign;\n                                        }\n                                        side_effects.push(assign.transform(tt));\n                                    }\n                                    remove(var_defs, def);\n                                    sym.eliminated++;\n                                    return;\n                                }\n                            }\n                            if (def.value) {\n                                if (side_effects.length > 0) {\n                                    if (tail.length > 0) {\n                                        side_effects.push(def.value);\n                                        def.value = make_sequence(def.value, side_effects);\n                                    } else {\n                                        body.push(make_node(AST_SimpleStatement, node, {\n                                            body: make_sequence(node, side_effects)\n                                        }));\n                                    }\n                                    side_effects = [];\n                                }\n                                tail.push(def);\n                            } else {\n                                head.push(def);\n                            }\n                        } else if (sym.orig[0] instanceof AST_SymbolCatch) {\n                            var value = def.value && def.value.drop_side_effect_free(compressor);\n                            if (value) side_effects.push(value);\n                            def.value = null;\n                            head.push(def);\n                        } else {\n                            var value = def.value && def.value.drop_side_effect_free(compressor);\n                            if (value) {\n                                if (!is_destructure) compressor.warn(\"Side effects in initialization of unused variable {name} [{file}:{line},{col}]\", template(def.name));\n                                side_effects.push(value);\n                            } else {\n                                if (!is_destructure) compressor[def.name.unreferenced() ? \"warn\" : \"info\"](\"Dropping unused variable {name} [{file}:{line},{col}]\", template(def.name));\n                            }\n                            sym.eliminated++;\n                        }\n                    });\n                    if (head.length > 0 || tail.length > 0) {\n                        node.definitions = head.concat(tail);\n                        body.push(node);\n                    }\n                    if (side_effects.length > 0) {\n                        body.push(make_node(AST_SimpleStatement, node, {\n                            body: make_sequence(node, side_effects)\n                        }));\n                    }\n                    switch (body.length) {\n                      case 0:\n                        return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);\n                      case 1:\n                        return body[0];\n                      default:\n                        return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {\n                            body: body\n                        });\n                    }\n                }\n                // certain combination of unused name + side effect leads to:\n                //    https://github.com/mishoo/UglifyJS2/issues/44\n                //    https://github.com/mishoo/UglifyJS2/issues/1830\n                //    https://github.com/mishoo/UglifyJS2/issues/1838\n                // that's an invalid AST.\n                // We fix it at this stage by moving the `var` outside the `for`.\n                if (node instanceof AST_For) {\n                    descend(node, this);\n                    var block;\n                    if (node.init instanceof AST_BlockStatement) {\n                        block = node.init;\n                        node.init = block.body.pop();\n                        block.body.push(node);\n                    }\n                    if (node.init instanceof AST_SimpleStatement) {\n                        node.init = node.init.body;\n                    } else if (is_empty(node.init)) {\n                        node.init = null;\n                    }\n                    return !block ? node : in_list ? MAP.splice(block.body) : block;\n                }\n                if (node instanceof AST_LabeledStatement && node.body instanceof AST_For) {\n                    descend(node, this);\n                    if (node.body instanceof AST_BlockStatement) {\n                        var block = node.body;\n                        node.body = block.body.pop();\n                        block.body.push(node);\n                        return in_list ? MAP.splice(block.body) : block;\n                    }\n                    return node;\n                }\n                if (node instanceof AST_BlockStatement) {\n                    descend(node, this);\n                    if (in_list && all(node.body, can_be_evicted_from_block)) {\n                        return MAP.splice(node.body);\n                    }\n                    return node;\n                }\n                if (node instanceof AST_Scope) {\n                    var save_scope = scope;\n                    scope = node;\n                    descend(node, this);\n                    scope = save_scope;\n                    return node;\n                }\n\n                function template(sym) {\n                    return {\n                        name : sym.name,\n                        file : sym.start.file,\n                        line : sym.start.line,\n                        col  : sym.start.col\n                    };\n                }\n            }\n        );\n        self.transform(tt);\n\n        function scan_ref_scoped(node, descend) {\n            var node_def, sym = assign_as_unused(node);\n            if (sym instanceof AST_SymbolRef\n                && !is_ref_of(node.left, AST_SymbolBlockDeclaration)\n                && self.variables.get(sym.name) === (node_def = sym.definition())) {\n                if (node instanceof AST_Assign) {\n                    node.right.walk(tw);\n                    if (!node_def.chained && node.left.fixed_value() === node.right) {\n                        fixed_ids[node_def.id] = node;\n                    }\n                }\n                return true;\n            }\n            if (node instanceof AST_SymbolRef) {\n                node_def = node.definition();\n                if (!(node_def.id in in_use_ids)) {\n                    in_use_ids[node_def.id] = true;\n                    in_use.push(node_def);\n                    if (node_def = node_def.redefined()) {\n                        in_use_ids[node_def.id] = true;\n                        in_use.push(node_def);\n                    }\n                }\n                return true;\n            }\n            if (node instanceof AST_Scope) {\n                var save_scope = scope;\n                scope = node;\n                descend();\n                scope = save_scope;\n                return true;\n            }\n        }\n    });\n\n    AST_Scope.DEFMETHOD(\"hoist_declarations\", function(compressor) {\n        var self = this;\n        if (compressor.has_directive(\"use asm\")) return self;\n        // Hoisting makes no sense in an arrow func\n        if (!Array.isArray(self.body)) return self;\n\n        var hoist_funs = compressor.option(\"hoist_funs\");\n        var hoist_vars = compressor.option(\"hoist_vars\");\n\n        if (hoist_funs || hoist_vars) {\n            var dirs = [];\n            var hoisted = [];\n            var vars = new Dictionary(), vars_found = 0, var_decl = 0;\n            // let's count var_decl first, we seem to waste a lot of\n            // space if we hoist `var` when there's only one.\n            self.walk(new TreeWalker(function(node) {\n                if (node instanceof AST_Scope && node !== self)\n                    return true;\n                if (node instanceof AST_Var) {\n                    ++var_decl;\n                    return true;\n                }\n            }));\n            hoist_vars = hoist_vars && var_decl > 1;\n            var tt = new TreeTransformer(\n                function before(node) {\n                    if (node !== self) {\n                        if (node instanceof AST_Directive) {\n                            dirs.push(node);\n                            return make_node(AST_EmptyStatement, node);\n                        }\n                        if (hoist_funs && node instanceof AST_Defun\n                            && !(tt.parent() instanceof AST_Export)\n                            && tt.parent() === self) {\n                            hoisted.push(node);\n                            return make_node(AST_EmptyStatement, node);\n                        }\n                        if (hoist_vars && node instanceof AST_Var) {\n                            node.definitions.forEach(function(def) {\n                                if (def.name instanceof AST_Destructuring) return;\n                                vars.set(def.name.name, def);\n                                ++vars_found;\n                            });\n                            var seq = node.to_assignments(compressor);\n                            var p = tt.parent();\n                            if (p instanceof AST_ForIn && p.init === node) {\n                                if (seq == null) {\n                                    var def = node.definitions[0].name;\n                                    return make_node(AST_SymbolRef, def, def);\n                                }\n                                return seq;\n                            }\n                            if (p instanceof AST_For && p.init === node) {\n                                return seq;\n                            }\n                            if (!seq) return make_node(AST_EmptyStatement, node);\n                            return make_node(AST_SimpleStatement, node, {\n                                body: seq\n                            });\n                        }\n                        if (node instanceof AST_Scope)\n                            return node; // to avoid descending in nested scopes\n                    }\n                }\n            );\n            self = self.transform(tt);\n            if (vars_found > 0) {\n                // collect only vars which don't show up in self's arguments list\n                var defs = [];\n                vars.each(function(def, name) {\n                    if (self instanceof AST_Lambda\n                        && find_if(function(x) { return x.name == def.name.name; },\n                                   self.args_as_names())) {\n                        vars.del(name);\n                    } else {\n                        def = def.clone();\n                        def.value = null;\n                        defs.push(def);\n                        vars.set(name, def);\n                    }\n                });\n                if (defs.length > 0) {\n                    // try to merge in assignments\n                    for (var i = 0; i < self.body.length;) {\n                        if (self.body[i] instanceof AST_SimpleStatement) {\n                            var expr = self.body[i].body, sym, assign;\n                            if (expr instanceof AST_Assign\n                                && expr.operator == \"=\"\n                                && (sym = expr.left) instanceof AST_Symbol\n                                && vars.has(sym.name)\n                            ) {\n                                var def = vars.get(sym.name);\n                                if (def.value) break;\n                                def.value = expr.right;\n                                remove(defs, def);\n                                defs.push(def);\n                                self.body.splice(i, 1);\n                                continue;\n                            }\n                            if (expr instanceof AST_Sequence\n                                && (assign = expr.expressions[0]) instanceof AST_Assign\n                                && assign.operator == \"=\"\n                                && (sym = assign.left) instanceof AST_Symbol\n                                && vars.has(sym.name)\n                            ) {\n                                var def = vars.get(sym.name);\n                                if (def.value) break;\n                                def.value = assign.right;\n                                remove(defs, def);\n                                defs.push(def);\n                                self.body[i].body = make_sequence(expr, expr.expressions.slice(1));\n                                continue;\n                            }\n                        }\n                        if (self.body[i] instanceof AST_EmptyStatement) {\n                            self.body.splice(i, 1);\n                            continue;\n                        }\n                        if (self.body[i] instanceof AST_BlockStatement) {\n                            var tmp = [ i, 1 ].concat(self.body[i].body);\n                            self.body.splice.apply(self.body, tmp);\n                            continue;\n                        }\n                        break;\n                    }\n                    defs = make_node(AST_Var, self, {\n                        definitions: defs\n                    });\n                    hoisted.push(defs);\n                }\n            }\n            self.body = dirs.concat(hoisted, self.body);\n        }\n        return self;\n    });\n\n    AST_Scope.DEFMETHOD(\"var_names\", function varNames() {\n        var var_names = this._var_names;\n        if (!var_names) {\n            const isParentScopeAvailable = this.parent_scope && !this.parent_scope instanceof AST_Toplevel;\n            this._var_names = var_names = isParentScopeAvailable ? varNames.call(this.parent_scope) : Object.create(null);\n            this.enclosed.forEach(function(def) {\n                var_names[def.name] = true;\n            });\n            this.variables.each(function(def, name) {\n                var_names[name] = true;\n            });\n        }\n        return var_names;\n    });\n\n    AST_Scope.DEFMETHOD(\"make_var_name\", function(prefix) {\n        var var_names = this.var_names();\n        prefix = prefix.replace(/(?:^[^a-z_$]|[^a-z0-9_$])/ig, \"_\");\n        var name = prefix;\n        for (var i = 0; var_names[name]; i++) name = prefix + \"$\" + i;\n        var_names[name] = true;\n        return name;\n    });\n\n    AST_Scope.DEFMETHOD(\"hoist_properties\", function(compressor) {\n        var self = this;\n        if (!compressor.option(\"hoist_props\") || compressor.has_directive(\"use asm\")) return self;\n        var top_retain = self instanceof AST_Toplevel && compressor.top_retain || return_false;\n        var defs_by_id = Object.create(null);\n        var tt = new TreeTransformer(function(node, descend) {\n            if (node instanceof AST_Definitions && tt.parent() instanceof AST_Export) return node;\n            if (node instanceof AST_VarDef) {\n                var sym = node.name, def, value;\n                if (sym.scope === self\n                    && (def = sym.definition()).escaped != 1\n                    && !def.assignments\n                    && !def.direct_access\n                    && !def.single_use\n                    && !compressor.exposed(def)\n                    && !top_retain(def)\n                    && (value = sym.fixed_value()) === node.value\n                    && value instanceof AST_Object) {\n                    descend(node, this);\n                    var defs = new Dictionary();\n                    var assignments = [];\n                    value.properties.forEach(function(prop) {\n                        assignments.push(make_node(AST_VarDef, node, {\n                            name: make_sym(prop.key),\n                            value: prop.value\n                        }));\n                    });\n                    defs_by_id[def.id] = defs;\n                    return MAP.splice(assignments);\n                }\n            }\n            if (node instanceof AST_PropAccess && node.expression instanceof AST_SymbolRef) {\n                var defs = defs_by_id[node.expression.definition().id];\n                if (defs) {\n                    var def = defs.get(get_value(node.property));\n                    var sym = make_node(AST_SymbolRef, node, {\n                        name: def.name,\n                        scope: node.expression.scope,\n                        thedef: def\n                    });\n                    sym.reference({});\n                    return sym;\n                }\n            }\n\n            function make_sym(key) {\n                var new_var = make_node(sym.CTOR, sym, {\n                    name: self.make_var_name(sym.name + \"_\" + key),\n                    scope: self\n                });\n                var def = self.def_variable(new_var);\n                defs.set(key, def);\n                self.enclosed.push(def);\n                return new_var;\n            }\n        });\n        return self.transform(tt);\n    });\n\n    // drop_side_effect_free()\n    // remove side-effect-free parts which only affects return value\n    (function(def_drop_side_effect_free) {\n        // Drop side-effect-free elements from an array of expressions.\n        // Returns an array of expressions with side-effects or null\n        // if all elements were dropped. Note: original array may be\n        // returned if nothing changed.\n        function trim(nodes, compressor, first_in_statement) {\n            var len = nodes.length;\n            if (!len) return null;\n            var ret = [], changed = false;\n            for (var i = 0; i < len; i++) {\n                var node = nodes[i].drop_side_effect_free(compressor, first_in_statement);\n                changed |= node !== nodes[i];\n                if (node) {\n                    ret.push(node);\n                    first_in_statement = false;\n                }\n            }\n            return changed ? ret.length ? ret : null : nodes;\n        }\n\n        def_drop_side_effect_free(AST_Node, return_this);\n        def_drop_side_effect_free(AST_Constant, return_null);\n        def_drop_side_effect_free(AST_This, return_null);\n        def_drop_side_effect_free(AST_Call, function(compressor, first_in_statement) {\n            if (!this.is_expr_pure(compressor)) {\n                if (this.expression.is_call_pure(compressor)) {\n                    var exprs = this.args.slice();\n                    exprs.unshift(this.expression.expression);\n                    exprs = trim(exprs, compressor, first_in_statement);\n                    return exprs && make_sequence(this, exprs);\n                }\n                if (is_func_expr(this.expression)\n                    && (!this.expression.name || !this.expression.name.definition().references.length)) {\n                    var node = this.clone();\n                    node.expression.process_expression(false, compressor);\n                    return node;\n                }\n                return this;\n            }\n            if (this.pure) {\n                compressor.warn(\"Dropping __PURE__ call [{file}:{line},{col}]\", this.start);\n            }\n            var args = trim(this.args, compressor, first_in_statement);\n            return args && make_sequence(this, args);\n        });\n        def_drop_side_effect_free(AST_Accessor, return_null);\n        def_drop_side_effect_free(AST_Function, return_null);\n        def_drop_side_effect_free(AST_Arrow, return_null);\n        def_drop_side_effect_free(AST_ClassExpression, return_null);\n        def_drop_side_effect_free(AST_Binary, function(compressor, first_in_statement) {\n            var right = this.right.drop_side_effect_free(compressor);\n            if (!right) return this.left.drop_side_effect_free(compressor, first_in_statement);\n            if (lazy_op(this.operator)) {\n                if (right === this.right) return this;\n                var node = this.clone();\n                node.right = right;\n                return node;\n            } else {\n                var left = this.left.drop_side_effect_free(compressor, first_in_statement);\n                if (!left) return this.right.drop_side_effect_free(compressor, first_in_statement);\n                return make_sequence(this, [ left, right ]);\n            }\n        });\n        def_drop_side_effect_free(AST_Assign, function(compressor) {\n            var left = this.left;\n            if (left.has_side_effects(compressor)\n                || compressor.has_directive(\"use strict\")\n                    && left instanceof AST_PropAccess\n                    && left.expression.is_constant()) {\n                return this;\n            }\n            this.write_only = true;\n            while (left instanceof AST_PropAccess) {\n                left = left.expression;\n            }\n            if (left.is_constant_expression(compressor.find_parent(AST_Scope))) {\n                return this.right.drop_side_effect_free(compressor);\n            }\n            return this;\n        });\n        def_drop_side_effect_free(AST_Conditional, function(compressor) {\n            var consequent = this.consequent.drop_side_effect_free(compressor);\n            var alternative = this.alternative.drop_side_effect_free(compressor);\n            if (consequent === this.consequent && alternative === this.alternative) return this;\n            if (!consequent) return alternative ? make_node(AST_Binary, this, {\n                operator: \"||\",\n                left: this.condition,\n                right: alternative\n            }) : this.condition.drop_side_effect_free(compressor);\n            if (!alternative) return make_node(AST_Binary, this, {\n                operator: \"&&\",\n                left: this.condition,\n                right: consequent\n            });\n            var node = this.clone();\n            node.consequent = consequent;\n            node.alternative = alternative;\n            return node;\n        });\n        def_drop_side_effect_free(AST_Unary, function(compressor, first_in_statement) {\n            if (unary_side_effects(this.operator)) {\n                this.write_only = !this.expression.has_side_effects(compressor);\n                return this;\n            }\n            if (this.operator == \"typeof\" && this.expression instanceof AST_SymbolRef) return null;\n            var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);\n            if (first_in_statement && expression && is_iife_call(expression)) {\n                if (expression === this.expression && this.operator == \"!\") return this;\n                return expression.negate(compressor, first_in_statement);\n            }\n            return expression;\n        });\n        def_drop_side_effect_free(AST_SymbolRef, function(compressor) {\n            return this.is_declared(compressor) ? null : this;\n        });\n        def_drop_side_effect_free(AST_Object, function(compressor, first_in_statement) {\n            var values = trim(this.properties, compressor, first_in_statement);\n            return values && make_sequence(this, values);\n        });\n        def_drop_side_effect_free(AST_ObjectProperty, function(compressor, first_in_statement) {\n            return this.value.drop_side_effect_free(compressor, first_in_statement);\n        });\n        def_drop_side_effect_free(AST_Array, function(compressor, first_in_statement) {\n            var values = trim(this.elements, compressor, first_in_statement);\n            return values && make_sequence(this, values);\n        });\n        def_drop_side_effect_free(AST_Dot, function(compressor, first_in_statement) {\n            if (this.expression.may_throw_on_access(compressor)) return this;\n            return this.expression.drop_side_effect_free(compressor, first_in_statement);\n        });\n        def_drop_side_effect_free(AST_Sub, function(compressor, first_in_statement) {\n            if (this.expression.may_throw_on_access(compressor)) return this;\n            var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);\n            if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);\n            var property = this.property.drop_side_effect_free(compressor);\n            if (!property) return expression;\n            return make_sequence(this, [ expression, property ]);\n        });\n        def_drop_side_effect_free(AST_Sequence, function(compressor) {\n            var last = this.tail_node();\n            var expr = last.drop_side_effect_free(compressor);\n            if (expr === last) return this;\n            var expressions = this.expressions.slice(0, -1);\n            if (expr) expressions.push(expr);\n            return make_sequence(this, expressions);\n        });\n        def_drop_side_effect_free(AST_Expansion, function(compressor, first_in_statement) {\n            return this.expression.drop_side_effect_free(compressor, first_in_statement);\n        });\n        def_drop_side_effect_free(AST_TemplateSegment, return_null);\n        def_drop_side_effect_free(AST_TemplateString, function(compressor) {\n            var values = trim(this.segments, compressor, first_in_statement);\n            return values && make_sequence(this, values);\n        });\n    })(function(node, func) {\n        node.DEFMETHOD(\"drop_side_effect_free\", func);\n    });\n\n    var pure_prop_access_globals = [\n        \"Number\",\n        \"String\",\n        \"Array\",\n        \"Object\",\n        \"Function\",\n        \"Promise\",\n        \"global\",\n        \"window\",\n        \"document\",\n        \"location\"\n    ];\n    def_optimize(AST_SimpleStatement, function(self, compressor) {\n        if (self.body instanceof AST_SymbolRef && pure_prop_access_globals.indexOf(self.body.name) !== -1) {\n            return make_node(AST_EmptyStatement, self);\n        }\n        if (compressor.option(\"side_effects\")) {\n            var body = self.body;\n            var node = body.drop_side_effect_free(compressor, true);\n            if (!node) {\n                compressor.warn(\"Dropping side-effect-free statement [{file}:{line},{col}]\", self.start);\n                return make_node(AST_EmptyStatement, self);\n            }\n            if (node !== body) {\n                return make_node(AST_SimpleStatement, self, { body: node });\n            }\n        }\n        return self;\n    });\n\n    def_optimize(AST_While, function(self, compressor) {\n        return compressor.option(\"loops\") ? make_node(AST_For, self, self).optimize(compressor) : self;\n    });\n\n    function has_break_or_continue(loop, parent) {\n        var found = false;\n        var tw = new TreeWalker(function(node) {\n            if (found || node instanceof AST_Scope) return true;\n            if (node instanceof AST_LoopControl && tw.loopcontrol_target(node) === loop) {\n                return found = true;\n            }\n        });\n        if (parent instanceof AST_LabeledStatement) tw.push(parent);\n        tw.push(loop);\n        loop.body.walk(tw);\n        return found;\n    }\n\n    def_optimize(AST_Do, function(self, compressor) {\n        if (!compressor.option(\"loops\")) return self;\n        var cond = self.condition.tail_node().evaluate(compressor);\n        if (!(cond instanceof AST_Node)) {\n            if (cond) return make_node(AST_For, self, {\n                body: make_node(AST_BlockStatement, self.body, {\n                    body: [\n                        self.body,\n                        make_node(AST_SimpleStatement, self.condition, {\n                            body: self.condition\n                        })\n                    ]\n                })\n            }).optimize(compressor);\n            if (!has_break_or_continue(self, compressor.parent())) {\n                return make_node(AST_BlockStatement, self.body, {\n                    body: [\n                        self.body,\n                        make_node(AST_SimpleStatement, self.condition, {\n                            body: self.condition\n                        })\n                    ]\n                }).optimize(compressor);\n            }\n        }\n        return self;\n    });\n\n    function if_break_in_loop(self, compressor) {\n        var first = self.body instanceof AST_BlockStatement ? self.body.body[0] : self.body;\n        if (compressor.option(\"dead_code\") && is_break(first)) {\n            var body = [];\n            if (self.init instanceof AST_Statement) {\n                body.push(self.init);\n            } else if (self.init) {\n                body.push(make_node(AST_SimpleStatement, self.init, {\n                    body: self.init\n                }));\n            }\n            if (self.condition) {\n                body.push(make_node(AST_SimpleStatement, self.condition, {\n                    body: self.condition\n                }));\n            }\n            extract_declarations_from_unreachable_code(compressor, self.body, body);\n            return make_node(AST_BlockStatement, self, {\n                body: body\n            });\n        }\n        if (first instanceof AST_If) {\n            if (is_break(first.body)) {\n                if (self.condition) {\n                    self.condition = make_node(AST_Binary, self.condition, {\n                        left: self.condition,\n                        operator: \"&&\",\n                        right: first.condition.negate(compressor),\n                    });\n                } else {\n                    self.condition = first.condition.negate(compressor);\n                }\n                drop_it(first.alternative);\n            } else if (is_break(first.alternative)) {\n                if (self.condition) {\n                    self.condition = make_node(AST_Binary, self.condition, {\n                        left: self.condition,\n                        operator: \"&&\",\n                        right: first.condition,\n                    });\n                } else {\n                    self.condition = first.condition;\n                }\n                drop_it(first.body);\n            }\n        }\n        return self;\n\n        function is_break(node) {\n            return node instanceof AST_Break\n                && compressor.loopcontrol_target(node) === compressor.self();\n        }\n\n        function drop_it(rest) {\n            rest = as_statement_array(rest);\n            if (self.body instanceof AST_BlockStatement) {\n                self.body = self.body.clone();\n                self.body.body = rest.concat(self.body.body.slice(1));\n                self.body = self.body.transform(compressor);\n            } else {\n                self.body = make_node(AST_BlockStatement, self.body, {\n                    body: rest\n                }).transform(compressor);\n            }\n            self = if_break_in_loop(self, compressor);\n        }\n    }\n\n    def_optimize(AST_For, function(self, compressor) {\n        if (!compressor.option(\"loops\")) return self;\n        if (compressor.option(\"side_effects\") && self.init) {\n            self.init = self.init.drop_side_effect_free(compressor);\n        }\n        if (self.condition) {\n            var cond = self.condition.evaluate(compressor);\n            if (!(cond instanceof AST_Node)) {\n                if (cond) self.condition = null;\n                else if (!compressor.option(\"dead_code\")) {\n                    var orig = self.condition;\n                    self.condition = make_node_from_constant(cond, self.condition);\n                    self.condition = best_of_expression(self.condition.transform(compressor), orig);\n                }\n            }\n            if (compressor.option(\"dead_code\")) {\n                if (cond instanceof AST_Node) cond = self.condition.tail_node().evaluate(compressor);\n                if (!cond) {\n                    var body = [];\n                    extract_declarations_from_unreachable_code(compressor, self.body, body);\n                    if (self.init instanceof AST_Statement) {\n                        body.push(self.init);\n                    } else if (self.init) {\n                        body.push(make_node(AST_SimpleStatement, self.init, {\n                            body: self.init\n                        }));\n                    }\n                    body.push(make_node(AST_SimpleStatement, self.condition, {\n                        body: self.condition\n                    }));\n                    return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);\n                }\n            }\n        }\n        return if_break_in_loop(self, compressor);\n    });\n\n    def_optimize(AST_If, function(self, compressor) {\n        if (is_empty(self.alternative)) self.alternative = null;\n\n        if (!compressor.option(\"conditionals\")) return self;\n        // if condition can be statically determined, warn and drop\n        // one of the blocks.  note, statically determined implies\n        // “has no side effects”; also it doesn't work for cases like\n        // `x && true`, though it probably should.\n        var cond = self.condition.evaluate(compressor);\n        if (!compressor.option(\"dead_code\") && !(cond instanceof AST_Node)) {\n            var orig = self.condition;\n            self.condition = make_node_from_constant(cond, orig);\n            self.condition = best_of_expression(self.condition.transform(compressor), orig);\n        }\n        if (compressor.option(\"dead_code\")) {\n            if (cond instanceof AST_Node) cond = self.condition.tail_node().evaluate(compressor);\n            if (!cond) {\n                compressor.warn(\"Condition always false [{file}:{line},{col}]\", self.condition.start);\n                var body = [];\n                extract_declarations_from_unreachable_code(compressor, self.body, body);\n                body.push(make_node(AST_SimpleStatement, self.condition, {\n                    body: self.condition\n                }));\n                if (self.alternative) body.push(self.alternative);\n                return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);\n            } else if (!(cond instanceof AST_Node)) {\n                compressor.warn(\"Condition always true [{file}:{line},{col}]\", self.condition.start);\n                var body = [];\n                if (self.alternative) {\n                    extract_declarations_from_unreachable_code(compressor, self.alternative, body);\n                }\n                body.push(make_node(AST_SimpleStatement, self.condition, {\n                    body: self.condition\n                }));\n                body.push(self.body);\n                return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);\n            }\n        }\n        var negated = self.condition.negate(compressor);\n        var self_condition_length = self.condition.print_to_string().length;\n        var negated_length = negated.print_to_string().length;\n        var negated_is_best = negated_length < self_condition_length;\n        if (self.alternative && negated_is_best) {\n            negated_is_best = false; // because we already do the switch here.\n            // no need to swap values of self_condition_length and negated_length\n            // here because they are only used in an equality comparison later on.\n            self.condition = negated;\n            var tmp = self.body;\n            self.body = self.alternative || make_node(AST_EmptyStatement, self);\n            self.alternative = tmp;\n        }\n        if (is_empty(self.body) && is_empty(self.alternative)) {\n            return make_node(AST_SimpleStatement, self.condition, {\n                body: self.condition.clone()\n            }).optimize(compressor);\n        }\n        if (self.body instanceof AST_SimpleStatement\n            && self.alternative instanceof AST_SimpleStatement) {\n            return make_node(AST_SimpleStatement, self, {\n                body: make_node(AST_Conditional, self, {\n                    condition   : self.condition,\n                    consequent  : self.body.body,\n                    alternative : self.alternative.body\n                })\n            }).optimize(compressor);\n        }\n        if (is_empty(self.alternative) && self.body instanceof AST_SimpleStatement) {\n            if (self_condition_length === negated_length && !negated_is_best\n                && self.condition instanceof AST_Binary && self.condition.operator == \"||\") {\n                // although the code length of self.condition and negated are the same,\n                // negated does not require additional surrounding parentheses.\n                // see https://github.com/mishoo/UglifyJS2/issues/979\n                negated_is_best = true;\n            }\n            if (negated_is_best) return make_node(AST_SimpleStatement, self, {\n                body: make_node(AST_Binary, self, {\n                    operator : \"||\",\n                    left     : negated,\n                    right    : self.body.body\n                })\n            }).optimize(compressor);\n            return make_node(AST_SimpleStatement, self, {\n                body: make_node(AST_Binary, self, {\n                    operator : \"&&\",\n                    left     : self.condition,\n                    right    : self.body.body\n                })\n            }).optimize(compressor);\n        }\n        if (self.body instanceof AST_EmptyStatement\n            && self.alternative instanceof AST_SimpleStatement) {\n            return make_node(AST_SimpleStatement, self, {\n                body: make_node(AST_Binary, self, {\n                    operator : \"||\",\n                    left     : self.condition,\n                    right    : self.alternative.body\n                })\n            }).optimize(compressor);\n        }\n        if (self.body instanceof AST_Exit\n            && self.alternative instanceof AST_Exit\n            && self.body.TYPE == self.alternative.TYPE) {\n            return make_node(self.body.CTOR, self, {\n                value: make_node(AST_Conditional, self, {\n                    condition   : self.condition,\n                    consequent  : self.body.value || make_node(AST_Undefined, self.body),\n                    alternative : self.alternative.value || make_node(AST_Undefined, self.alternative)\n                }).transform(compressor)\n            }).optimize(compressor);\n        }\n        if (self.body instanceof AST_If\n            && !self.body.alternative\n            && !self.alternative) {\n            self = make_node(AST_If, self, {\n                condition: make_node(AST_Binary, self.condition, {\n                    operator: \"&&\",\n                    left: self.condition,\n                    right: self.body.condition\n                }),\n                body: self.body.body,\n                alternative: null\n            });\n        }\n        if (aborts(self.body)) {\n            if (self.alternative) {\n                var alt = self.alternative;\n                self.alternative = null;\n                return make_node(AST_BlockStatement, self, {\n                    body: [ self, alt ]\n                }).optimize(compressor);\n            }\n        }\n        if (aborts(self.alternative)) {\n            var body = self.body;\n            self.body = self.alternative;\n            self.condition = negated_is_best ? negated : self.condition.negate(compressor);\n            self.alternative = null;\n            return make_node(AST_BlockStatement, self, {\n                body: [ self, body ]\n            }).optimize(compressor);\n        }\n        return self;\n    });\n\n    def_optimize(AST_Switch, function(self, compressor) {\n        if (!compressor.option(\"switches\")) return self;\n        var branch;\n        var value = self.expression.evaluate(compressor);\n        if (!(value instanceof AST_Node)) {\n            var orig = self.expression;\n            self.expression = make_node_from_constant(value, orig);\n            self.expression = best_of_expression(self.expression.transform(compressor), orig);\n        }\n        if (!compressor.option(\"dead_code\")) return self;\n        if (value instanceof AST_Node) {\n            value = self.expression.tail_node().evaluate(compressor);\n        }\n        var decl = [];\n        var body = [];\n        var default_branch;\n        var exact_match;\n        for (var i = 0, len = self.body.length; i < len && !exact_match; i++) {\n            branch = self.body[i];\n            if (branch instanceof AST_Default) {\n                if (!default_branch) {\n                    default_branch = branch;\n                } else {\n                    eliminate_branch(branch, body[body.length - 1]);\n                }\n            } else if (!(value instanceof AST_Node)) {\n                var exp = branch.expression.evaluate(compressor);\n                if (!(exp instanceof AST_Node) && exp !== value) {\n                    eliminate_branch(branch, body[body.length - 1]);\n                    continue;\n                }\n                if (exp instanceof AST_Node) exp = branch.expression.tail_node().evaluate(compressor);\n                if (exp === value) {\n                    exact_match = branch;\n                    if (default_branch) {\n                        var default_index = body.indexOf(default_branch);\n                        body.splice(default_index, 1);\n                        eliminate_branch(default_branch, body[default_index - 1]);\n                        default_branch = null;\n                    }\n                }\n            }\n            if (aborts(branch)) {\n                var prev = body[body.length - 1];\n                if (aborts(prev) && prev.body.length == branch.body.length\n                    && make_node(AST_BlockStatement, prev, prev).equivalent_to(make_node(AST_BlockStatement, branch, branch))) {\n                    prev.body = [];\n                }\n            }\n            body.push(branch);\n        }\n        while (i < len) eliminate_branch(self.body[i++], body[body.length - 1]);\n        if (body.length > 0) {\n            body[0].body = decl.concat(body[0].body);\n        }\n        self.body = body;\n        while (branch = body[body.length - 1]) {\n            var stat = branch.body[branch.body.length - 1];\n            if (stat instanceof AST_Break && compressor.loopcontrol_target(stat) === self)\n                branch.body.pop();\n            if (branch.body.length || branch instanceof AST_Case\n                && (default_branch || branch.expression.has_side_effects(compressor))) break;\n            if (body.pop() === default_branch) default_branch = null;\n        }\n        if (body.length == 0) {\n            return make_node(AST_BlockStatement, self, {\n                body: decl.concat(make_node(AST_SimpleStatement, self.expression, {\n                    body: self.expression\n                }))\n            }).optimize(compressor);\n        }\n        if (body.length == 1 && (body[0] === exact_match || body[0] === default_branch)) {\n            var has_break = false;\n            var tw = new TreeWalker(function(node) {\n                if (has_break\n                    || node instanceof AST_Lambda\n                    || node instanceof AST_SimpleStatement) return true;\n                if (node instanceof AST_Break && tw.loopcontrol_target(node) === self)\n                    has_break = true;\n            });\n            self.walk(tw);\n            if (!has_break) {\n                var statements = body[0].body.slice();\n                var exp = body[0].expression;\n                if (exp) statements.unshift(make_node(AST_SimpleStatement, exp, {\n                    body: exp\n                }));\n                statements.unshift(make_node(AST_SimpleStatement, self.expression, {\n                    body:self.expression\n                }));\n                return make_node(AST_BlockStatement, self, {\n                    body: statements\n                }).optimize(compressor);\n            }\n        }\n        return self;\n\n        function eliminate_branch(branch, prev) {\n            if (prev && !aborts(prev)) {\n                prev.body = prev.body.concat(branch.body);\n            } else {\n                extract_declarations_from_unreachable_code(compressor, branch, decl);\n            }\n        }\n    });\n\n    def_optimize(AST_Try, function(self, compressor) {\n        tighten_body(self.body, compressor);\n        if (self.bcatch && self.bfinally && all(self.bfinally.body, is_empty)) self.bfinally = null;\n        if (compressor.option(\"dead_code\") && all(self.body, is_empty)) {\n            var body = [];\n            if (self.bcatch) {\n                extract_declarations_from_unreachable_code(compressor, self.bcatch, body);\n                body.forEach(function(stat) {\n                    if (!(stat instanceof AST_Definitions)) return;\n                    stat.definitions.forEach(function(var_def) {\n                        var def = var_def.name.definition().redefined();\n                        if (!def) return;\n                        var_def.name = var_def.name.clone();\n                        var_def.name.thedef = def;\n                    });\n                });\n            }\n            if (self.bfinally) body = body.concat(self.bfinally.body);\n            return make_node(AST_BlockStatement, self, {\n                body: body\n            }).optimize(compressor);\n        }\n        return self;\n    });\n\n    AST_Definitions.DEFMETHOD(\"remove_initializers\", function() {\n        var decls = [];\n        this.definitions.forEach(function(def) {\n            if (def.name instanceof AST_SymbolDeclaration) {\n                def.value = null;\n                decls.push(def);\n            } else def.name.walk(new TreeWalker(function(node) {\n                if (node instanceof AST_SymbolDeclaration) {\n                    decls.push(make_node(AST_VarDef, def, {\n                        name: node,\n                        value: null\n                    }));\n                }\n            }));\n        });\n        this.definitions = decls;\n    });\n\n    AST_Definitions.DEFMETHOD(\"to_assignments\", function(compressor) {\n        var reduce_vars = compressor.option(\"reduce_vars\");\n        var assignments = this.definitions.reduce(function(a, def) {\n            if (def.value && !(def.name instanceof AST_Destructuring)) {\n                var name = make_node(AST_SymbolRef, def.name, def.name);\n                a.push(make_node(AST_Assign, def, {\n                    operator : \"=\",\n                    left     : name,\n                    right    : def.value\n                }));\n                if (reduce_vars) name.definition().fixed = false;\n            } else if (def.value) {\n                // Because it's a destructuring, do not turn into an assignment.\n                var varDef = make_node(AST_VarDef, def, {\n                    name: def.name,\n                    value: def.value\n                });\n                var var_ = make_node(AST_Var, def, {\n                    definitions: [ varDef ]\n                });\n                a.push(var_);\n            }\n            def = def.name.definition();\n            def.eliminated++;\n            def.replaced--;\n            return a;\n        }, []);\n        if (assignments.length == 0) return null;\n        return make_sequence(this, assignments);\n    });\n\n    def_optimize(AST_Definitions, function(self, compressor) {\n        if (self.definitions.length == 0)\n            return make_node(AST_EmptyStatement, self);\n        return self;\n    });\n\n    def_optimize(AST_Import, function(self, compressor) {\n        return self;\n    });\n\n    function retain_top_func(fn, compressor) {\n        return compressor.top_retain\n            && fn instanceof AST_Defun\n            && fn._top\n            && fn.name\n            && compressor.top_retain(fn.name);\n    }\n\n    def_optimize(AST_Call, function(self, compressor) {\n        var exp = self.expression;\n        var fn = exp;\n        inline_array_like_spread(self, compressor, self.args);\n        var simple_args = all(self.args, function(arg) {\n            return !(arg instanceof AST_Expansion);\n        });\n        if (compressor.option(\"reduce_vars\") && fn instanceof AST_SymbolRef) {\n            fn = fn.fixed_value();\n            if (retain_top_func(fn, compressor)) fn = exp;\n        }\n        var is_func = fn instanceof AST_Lambda;\n        if (compressor.option(\"unused\")\n            && simple_args\n            && is_func\n            && !fn.uses_arguments\n            && !fn.pinned()) {\n            var pos = 0, last = 0;\n            for (var i = 0, len = self.args.length; i < len; i++) {\n                if (fn.argnames[i] instanceof AST_Expansion) {\n                    if (fn.argnames[i].expression.__unused) while (i < len) {\n                        var node = self.args[i++].drop_side_effect_free(compressor);\n                        if (node) {\n                            self.args[pos++] = node;\n                        }\n                    } else while (i < len) {\n                        self.args[pos++] = self.args[i++];\n                    }\n                    last = pos;\n                    break;\n                }\n                var trim = i >= fn.argnames.length;\n                if (trim || fn.argnames[i].__unused) {\n                    var node = self.args[i].drop_side_effect_free(compressor);\n                    if (node) {\n                        self.args[pos++] = node;\n                    } else if (!trim) {\n                        self.args[pos++] = make_node(AST_Number, self.args[i], {\n                            value: 0\n                        });\n                        continue;\n                    }\n                } else {\n                    self.args[pos++] = self.args[i];\n                }\n                last = pos;\n            }\n            self.args.length = last;\n        }\n        if (compressor.option(\"unsafe\")) {\n            if (is_undeclared_ref(exp)) switch (exp.name) {\n              case \"Array\":\n                if (self.args.length != 1) {\n                    return make_node(AST_Array, self, {\n                        elements: self.args\n                    }).optimize(compressor);\n                }\n                break;\n              case \"Object\":\n                if (self.args.length == 0) {\n                    return make_node(AST_Object, self, {\n                        properties: []\n                    });\n                }\n                break;\n              case \"String\":\n                if (self.args.length == 0) return make_node(AST_String, self, {\n                    value: \"\"\n                });\n                if (self.args.length <= 1) return make_node(AST_Binary, self, {\n                    left: self.args[0],\n                    operator: \"+\",\n                    right: make_node(AST_String, self, { value: \"\" })\n                }).optimize(compressor);\n                break;\n              case \"Number\":\n                if (self.args.length == 0) return make_node(AST_Number, self, {\n                    value: 0\n                });\n                if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, {\n                    expression: self.args[0],\n                    operator: \"+\"\n                }).optimize(compressor);\n              case \"Boolean\":\n                if (self.args.length == 0) return make_node(AST_False, self);\n                if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, {\n                    expression: make_node(AST_UnaryPrefix, self, {\n                        expression: self.args[0],\n                        operator: \"!\"\n                    }),\n                    operator: \"!\"\n                }).optimize(compressor);\n                break;\n              case \"RegExp\":\n                var params = [];\n                if (all(self.args, function(arg) {\n                    var value = arg.evaluate(compressor);\n                    params.unshift(value);\n                    return arg !== value;\n                })) {\n                    try {\n                        return best_of(compressor, self, make_node(AST_RegExp, self, {\n                            value: RegExp.apply(RegExp, params),\n                        }));\n                    } catch (ex) {\n                        compressor.warn(\"Error converting {expr} [{file}:{line},{col}]\", {\n                            expr: self.print_to_string(),\n                            file: self.start.file,\n                            line: self.start.line,\n                            col: self.start.col\n                        });\n                    }\n                }\n                break;\n            } else if (exp instanceof AST_Dot) switch(exp.property) {\n              case \"toString\":\n                if (self.args.length == 0 && !exp.expression.may_throw_on_access(compressor)) {\n                    return make_node(AST_Binary, self, {\n                        left: make_node(AST_String, self, { value: \"\" }),\n                        operator: \"+\",\n                        right: exp.expression\n                    }).optimize(compressor);\n                }\n                break;\n              case \"join\":\n                if (exp.expression instanceof AST_Array) EXIT: {\n                    var separator;\n                    if (self.args.length > 0) {\n                        separator = self.args[0].evaluate(compressor);\n                        if (separator === self.args[0]) break EXIT; // not a constant\n                    }\n                    var elements = [];\n                    var consts = [];\n                    for (var i = 0, len = exp.expression.elements.length; i < len; i++) {\n                        var el = exp.expression.elements[i];\n                        if (el instanceof AST_Expansion) break EXIT;\n                        var value = el.evaluate(compressor);\n                        if (value !== el) {\n                            consts.push(value);\n                        } else {\n                            if (consts.length > 0) {\n                                elements.push(make_node(AST_String, self, {\n                                    value: consts.join(separator)\n                                }));\n                                consts.length = 0;\n                            }\n                            elements.push(el);\n                        }\n                    }\n                    if (consts.length > 0) {\n                        elements.push(make_node(AST_String, self, {\n                            value: consts.join(separator)\n                        }));\n                    }\n                    if (elements.length == 0) return make_node(AST_String, self, { value: \"\" });\n                    if (elements.length == 1) {\n                        if (elements[0].is_string(compressor)) {\n                            return elements[0];\n                        }\n                        return make_node(AST_Binary, elements[0], {\n                            operator : \"+\",\n                            left     : make_node(AST_String, self, { value: \"\" }),\n                            right    : elements[0]\n                        });\n                    }\n                    if (separator == \"\") {\n                        var first;\n                        if (elements[0].is_string(compressor)\n                            || elements[1].is_string(compressor)) {\n                            first = elements.shift();\n                        } else {\n                            first = make_node(AST_String, self, { value: \"\" });\n                        }\n                        return elements.reduce(function(prev, el) {\n                            return make_node(AST_Binary, el, {\n                                operator : \"+\",\n                                left     : prev,\n                                right    : el\n                            });\n                        }, first).optimize(compressor);\n                    }\n                    // need this awkward cloning to not affect original element\n                    // best_of will decide which one to get through.\n                    var node = self.clone();\n                    node.expression = node.expression.clone();\n                    node.expression.expression = node.expression.expression.clone();\n                    node.expression.expression.elements = elements;\n                    return best_of(compressor, self, node);\n                }\n                break;\n              case \"charAt\":\n                if (exp.expression.is_string(compressor)) {\n                    var arg = self.args[0];\n                    var index = arg ? arg.evaluate(compressor) : 0;\n                    if (index !== arg) {\n                        return make_node(AST_Sub, exp, {\n                            expression: exp.expression,\n                            property: make_node_from_constant(index | 0, arg || exp)\n                        }).optimize(compressor);\n                    }\n                }\n                break;\n              case \"apply\":\n                if (self.args.length == 2 && self.args[1] instanceof AST_Array) {\n                    var args = self.args[1].elements.slice();\n                    args.unshift(self.args[0]);\n                    return make_node(AST_Call, self, {\n                        expression: make_node(AST_Dot, exp, {\n                            expression: exp.expression,\n                            property: \"call\"\n                        }),\n                        args: args\n                    }).optimize(compressor);\n                }\n                break;\n              case \"call\":\n                var func = exp.expression;\n                if (func instanceof AST_SymbolRef) {\n                    func = func.fixed_value();\n                }\n                if (func instanceof AST_Lambda && !func.contains_this()) {\n                    return (self.args.length ? make_sequence(this, [\n                        self.args[0],\n                        make_node(AST_Call, self, {\n                            expression: exp.expression,\n                            args: self.args.slice(1)\n                        })\n                    ]) : make_node(AST_Call, self, {\n                        expression: exp.expression,\n                        args: []\n                    })).optimize(compressor);\n                }\n                break;\n            }\n        }\n        if (compressor.option(\"unsafe_Function\")\n            && is_undeclared_ref(exp)\n            && exp.name == \"Function\") {\n            // new Function() => function(){}\n            if (self.args.length == 0) return make_node(AST_Function, self, {\n                argnames: [],\n                body: []\n            }).optimize(compressor);\n            if (all(self.args, function(x) {\n                return x instanceof AST_String;\n            })) {\n                // quite a corner-case, but we can handle it:\n                //   https://github.com/mishoo/UglifyJS2/issues/203\n                // if the code argument is a constant, then we can minify it.\n                try {\n                    var code = \"n(function(\" + self.args.slice(0, -1).map(function(arg) {\n                        return arg.value;\n                    }).join(\",\") + \"){\" + self.args[self.args.length - 1].value + \"})\";\n                    var ast = parse(code);\n                    var mangle = { ie8: compressor.option(\"ie8\") };\n                    ast.figure_out_scope(mangle);\n                    var comp = new Compressor(compressor.options);\n                    ast = ast.transform(comp);\n                    ast.figure_out_scope(mangle);\n                    base54.reset();\n                    ast.compute_char_frequency(mangle);\n                    ast.mangle_names(mangle);\n                    var fun;\n                    ast.walk(new TreeWalker(function(node) {\n                        if (fun) return true;\n                        if (is_func_expr(node)) {\n                            fun = node;\n                            return true;\n                        }\n                    }));\n                    if (fun.body instanceof AST_Node) {\n                        fun.body = [\n                            make_node(AST_Return, fun.body, {\n                                value: fun.body\n                            })\n                        ];\n                    }\n                    var code = OutputStream();\n                    AST_BlockStatement.prototype._codegen.call(fun, fun, code);\n                    self.args = [\n                        make_node(AST_String, self, {\n                            value: fun.argnames.map(function(arg) {\n                                return arg.print_to_string();\n                            }).join(\",\")\n                        }),\n                        make_node(AST_String, self.args[self.args.length - 1], {\n                            value: code.get().replace(/^{|}$/g, \"\")\n                        })\n                    ];\n                    return self;\n                } catch (ex) {\n                    if (ex instanceof JS_Parse_Error) {\n                        compressor.warn(\"Error parsing code passed to new Function [{file}:{line},{col}]\", self.args[self.args.length - 1].start);\n                        compressor.warn(ex.toString());\n                    } else {\n                        throw ex;\n                    }\n                }\n            }\n        }\n        var stat = is_func && fn.body;\n        if (stat instanceof AST_Node) {\n            stat = make_node(AST_Return, stat, {\n                value: stat\n            });\n        } else if (stat) {\n            stat = stat[0];\n        }\n        var is_regular_func = is_func && !fn.is_generator && !fn.async;\n        var can_inline = compressor.option(\"inline\") && !self.is_expr_pure(compressor);\n        if (can_inline && stat instanceof AST_Return && is_regular_func) {\n            var value = stat.value;\n            if (!value || value.is_constant_expression()) {\n                if (value) {\n                    value = value.clone(true);\n                } else {\n                    value = make_node(AST_Undefined, self);\n                }\n                var args = self.args.concat(value);\n                return make_sequence(self, args).optimize(compressor);\n            }\n        }\n        if (is_regular_func) {\n            var def, value, scope, in_loop, level = -1;\n            if (can_inline\n                && simple_args\n                && !fn.uses_arguments\n                && !fn.pinned()\n                && !(compressor.parent() instanceof AST_Class)\n                && !(fn.name && fn instanceof AST_Function)\n                && (!(compressor.find_parent(AST_Lambda) instanceof AST_Arrow)\n                    || fn.argnames.length == 0\n                        && (fn.body instanceof AST_Node || fn.body.length == 1))\n                && (value = can_flatten_body(stat))\n                && (exp === fn\n                    || compressor.option(\"unused\")\n                        && (def = exp.definition()).references.length == 1\n                        && !recursive_ref(compressor, def)\n                        && fn.is_constant_expression(exp.scope))\n                && !self.pure\n                && !fn.contains_this()\n                && can_inject_symbols()\n                && !(scope instanceof AST_Class)) {\n                fn._squeezed = true;\n                return make_sequence(self, flatten_fn()).optimize(compressor);\n            }\n            if (compressor.option(\"side_effects\") && !(fn.body instanceof AST_Node) && all(fn.body, is_empty)) {\n                var args = self.args.concat(make_node(AST_Undefined, self));\n                return make_sequence(self, args).optimize(compressor);\n            }\n        }\n        if (compressor.option(\"negate_iife\")\n            && compressor.parent() instanceof AST_SimpleStatement\n            && is_iife_call(self)) {\n            return self.negate(compressor, true);\n        }\n        var ev = self.evaluate(compressor);\n        if (ev !== self) {\n            ev = make_node_from_constant(ev, self).optimize(compressor);\n            return best_of(compressor, ev, self);\n        }\n        return self;\n\n        function return_value(stat) {\n            if (!stat) return make_node(AST_Undefined, self);\n            if (stat instanceof AST_Return) {\n                if (!stat.value) return make_node(AST_Undefined, self);\n                return stat.value.clone(true);\n            }\n            if (stat instanceof AST_SimpleStatement) {\n                return make_node(AST_UnaryPrefix, stat, {\n                    operator: \"void\",\n                    expression: stat.body.clone(true)\n                });\n            }\n        }\n\n        function can_flatten_body(stat) {\n            var body = fn.body instanceof AST_Node ? [ fn.body ] : fn.body;\n            var len = body.length;\n            if (compressor.option(\"inline\") < 3) {\n                return len == 1 && return_value(stat);\n            }\n            stat = null;\n            for (var i = 0; i < len; i++) {\n                var line = body[i];\n                if (line instanceof AST_Var) {\n                    if (stat && !all(line.definitions, function(var_def) {\n                        return !var_def.value;\n                    })) {\n                        return false;\n                    }\n                } else if (stat) {\n                    return false;\n                } else {\n                    stat = line;\n                }\n            }\n            return return_value(stat);\n        }\n\n        function can_inject_args(block_scoped, safe_to_inject) {\n            for (var i = 0, len = fn.argnames.length; i < len; i++) {\n                var arg = fn.argnames[i];\n                if (arg instanceof AST_DefaultAssign) {\n                    if (arg.left.__unused) continue;\n                    return false;\n                }\n                if (arg instanceof AST_Destructuring) return false;\n                if (arg instanceof AST_Expansion) {\n                    if (arg.expression.__unused) continue;\n                    return false;\n                }\n                if (arg.__unused) continue;\n                if (!safe_to_inject\n                    || block_scoped[arg.name]\n                    || identifier_atom(arg.name)\n                    || scope.var_names()[arg.name]) {\n                    return false;\n                }\n                if (in_loop) in_loop.push(arg.definition());\n            }\n            return true;\n        }\n\n        function can_inject_vars(block_scoped, safe_to_inject) {\n            var len = fn.body.length;\n            for (var i = 0; i < len; i++) {\n                var stat = fn.body[i];\n                if (!(stat instanceof AST_Var)) continue;\n                if (!safe_to_inject) return false;\n                for (var j = stat.definitions.length; --j >= 0;) {\n                    var name = stat.definitions[j].name;\n                    if (name instanceof AST_Destructuring\n                        || block_scoped[name.name]\n                        || identifier_atom(name.name)\n                        || scope.var_names()[name.name]) {\n                        return false;\n                    }\n                    if (in_loop) in_loop.push(name.definition());\n                }\n            }\n            return true;\n        }\n\n        function can_inject_symbols() {\n            var block_scoped = Object.create(null);\n            do {\n                scope = compressor.parent(++level);\n                if (scope.is_block_scope() && !(compressor.parent(level - 1) instanceof AST_Scope)) {\n                    if (scope.block_scope) {\n                        // TODO this is sometimes undefined during compression.\n                        // But it should always have a value!\n                        scope.block_scope.variables.each(function (variable) {\n                            block_scoped[variable.name] = true;\n                        });\n                    }\n                }\n                if (scope instanceof AST_Catch) {\n                    if (scope.argname) {\n                        block_scoped[scope.argname.name] = true;\n                    }\n                } else if (scope instanceof AST_IterationStatement) {\n                    in_loop = [];\n                } else if (scope instanceof AST_SymbolRef) {\n                    if (scope.fixed_value() instanceof AST_Scope) return false;\n                }\n            } while (!(scope instanceof AST_Scope) || scope instanceof AST_Arrow);\n            var safe_to_inject = !(scope instanceof AST_Toplevel) || compressor.toplevel.vars;\n            var inline = compressor.option(\"inline\");\n            if (!can_inject_vars(block_scoped, inline >= 3 && safe_to_inject)) return false;\n            if (!can_inject_args(block_scoped, inline >= 2 && safe_to_inject)) return false;\n            return !in_loop || in_loop.length == 0 || !is_reachable(fn, in_loop);\n        }\n\n        function append_var(decls, expressions, name, value) {\n            var def = name.definition();\n            scope.variables.set(name.name, def);\n            scope.enclosed.push(def);\n            if (!scope.var_names()[name.name]) {\n                scope.var_names()[name.name] = true;\n                decls.push(make_node(AST_VarDef, name, {\n                    name: name,\n                    value: null\n                }));\n            }\n            var sym = make_node(AST_SymbolRef, name, name);\n            def.references.push(sym);\n            if (value) expressions.push(make_node(AST_Assign, self, {\n                operator: \"=\",\n                left: sym,\n                right: value.clone()\n            }));\n        }\n\n        function flatten_args(decls, expressions) {\n            var len = fn.argnames.length;\n            for (var i = self.args.length; --i >= len;) {\n                expressions.push(self.args[i]);\n            }\n            for (i = len; --i >= 0;) {\n                var name = fn.argnames[i];\n                var value = self.args[i];\n                if (name.__unused || !name.name || scope.var_names()[name.name]) {\n                    if (value) expressions.push(value);\n                } else {\n                    var symbol = make_node(AST_SymbolVar, name, name);\n                    name.definition().orig.push(symbol);\n                    if (!value && in_loop) value = make_node(AST_Undefined, self);\n                    append_var(decls, expressions, symbol, value);\n                }\n            }\n            decls.reverse();\n            expressions.reverse();\n        }\n\n        function flatten_vars(decls, expressions) {\n            var pos = expressions.length;\n            for (var i = 0, lines = fn.body.length; i < lines; i++) {\n                var stat = fn.body[i];\n                if (!(stat instanceof AST_Var)) continue;\n                for (var j = 0, defs = stat.definitions.length; j < defs; j++) {\n                    var var_def = stat.definitions[j];\n                    var name = var_def.name;\n                    append_var(decls, expressions, name, var_def.value);\n                    if (in_loop && all(fn.argnames, function(argname) {\n                        return argname.name != name.name;\n                    })) {\n                        var def = fn.variables.get(name.name);\n                        var sym = make_node(AST_SymbolRef, name, name);\n                        def.references.push(sym);\n                        expressions.splice(pos++, 0, make_node(AST_Assign, var_def, {\n                            operator: \"=\",\n                            left: sym,\n                            right: make_node(AST_Undefined, name)\n                        }));\n                    }\n                }\n            }\n        }\n\n        function flatten_fn() {\n            var decls = [];\n            var expressions = [];\n            flatten_args(decls, expressions);\n            flatten_vars(decls, expressions);\n            expressions.push(value);\n            if (decls.length) {\n                i = scope.body.indexOf(compressor.parent(level - 1)) + 1;\n                scope.body.splice(i, 0, make_node(AST_Var, fn, {\n                    definitions: decls\n                }));\n            }\n            return expressions;\n        }\n    });\n\n    def_optimize(AST_New, function(self, compressor) {\n        const {args, expression: exp} = self;\n\n        if (compressor.option(\"unsafe\") && is_undeclared_ref(exp)) {\n            if ([\"Object\", \"RegExp\", \"Function\", \"Error\"].includes(exp.name))\n                return make_node(AST_Call, self, self).transform(compressor);\n\n            if (exp.name === \"Array\" && args.length < 2) {\n                if (args.length === 0 || args[0].value === 0) return new AST_Array;\n\n                if (args[0].value > 11) {\n                    return make_node(AST_Call, self, self).transform(compressor);\n                }\n\n                const elements = [];\n                for (let i = 0; i < self.args[0].value; i++) elements.push(new AST_Hole);\n\n                return new AST_Array({elements});\n            }\n        }\n\n        return self;\n    });\n\n    def_optimize(AST_Sequence, function(self, compressor) {\n        if (!compressor.option(\"side_effects\")) return self;\n        var expressions = [];\n        filter_for_side_effects();\n        var end = expressions.length - 1;\n        trim_right_for_undefined();\n        if (end == 0) {\n            self = maintain_this_binding(compressor.parent(), compressor.self(), expressions[0]);\n            if (!(self instanceof AST_Sequence)) self = self.optimize(compressor);\n            return self;\n        }\n        self.expressions = expressions;\n        return self;\n\n        function filter_for_side_effects() {\n            var first = first_in_statement(compressor);\n            var last = self.expressions.length - 1;\n            self.expressions.forEach(function(expr, index) {\n                if (index < last) expr = expr.drop_side_effect_free(compressor, first);\n                if (expr) {\n                    merge_sequence(expressions, expr);\n                    first = false;\n                }\n            });\n        }\n\n        function trim_right_for_undefined() {\n            while (end > 0 && is_undefined(expressions[end], compressor)) end--;\n            if (end < expressions.length - 1) {\n                expressions[end] = make_node(AST_UnaryPrefix, self, {\n                    operator   : \"void\",\n                    expression : expressions[end]\n                });\n                expressions.length = end + 1;\n            }\n        }\n    });\n\n    AST_Unary.DEFMETHOD(\"lift_sequences\", function(compressor) {\n        if (compressor.option(\"sequences\")) {\n            if (this.expression instanceof AST_Sequence) {\n                var x = this.expression.expressions.slice();\n                var e = this.clone();\n                e.expression = x.pop();\n                x.push(e);\n                return make_sequence(this, x).optimize(compressor);\n            }\n        }\n        return this;\n    });\n\n    def_optimize(AST_UnaryPostfix, function(self, compressor) {\n        return self.lift_sequences(compressor);\n    });\n\n    def_optimize(AST_UnaryPrefix, function(self, compressor) {\n        var e = self.expression;\n        if (self.operator == \"delete\"\n            && !(e instanceof AST_SymbolRef\n                || e instanceof AST_PropAccess\n                || is_identifier_atom(e))) {\n            if (e instanceof AST_Sequence) {\n                e = e.expressions.slice();\n                e.push(make_node(AST_True, self));\n                return make_sequence(self, e).optimize(compressor);\n            }\n            return make_sequence(self, [ e, make_node(AST_True, self) ]).optimize(compressor);\n        }\n        var seq = self.lift_sequences(compressor);\n        if (seq !== self) {\n            return seq;\n        }\n        if (compressor.option(\"side_effects\") && self.operator == \"void\") {\n            e = e.drop_side_effect_free(compressor);\n            if (e) {\n                self.expression = e;\n                return self;\n            } else {\n                return make_node(AST_Undefined, self).optimize(compressor);\n            }\n        }\n        if (compressor.in_boolean_context()) {\n            switch (self.operator) {\n              case \"!\":\n                if (e instanceof AST_UnaryPrefix && e.operator == \"!\") {\n                    // !!foo ==> foo, if we're in boolean context\n                    return e.expression;\n                }\n                if (e instanceof AST_Binary) {\n                    self = best_of(compressor, self, e.negate(compressor, first_in_statement(compressor)));\n                }\n                break;\n              case \"typeof\":\n                // typeof always returns a non-empty string, thus it's\n                // always true in booleans\n                compressor.warn(\"Boolean expression always true [{file}:{line},{col}]\", self.start);\n                return (e instanceof AST_SymbolRef ? make_node(AST_True, self) : make_sequence(self, [\n                    e,\n                    make_node(AST_True, self)\n                ])).optimize(compressor);\n            }\n        }\n        if (self.operator == \"-\" && e instanceof AST_Infinity) {\n            e = e.transform(compressor);\n        }\n        if (e instanceof AST_Binary\n            && (self.operator == \"+\" || self.operator == \"-\")\n            && (e.operator == \"*\" || e.operator == \"/\" || e.operator == \"%\")) {\n            return make_node(AST_Binary, self, {\n                operator: e.operator,\n                left: make_node(AST_UnaryPrefix, e.left, {\n                    operator: self.operator,\n                    expression: e.left\n                }),\n                right: e.right\n            });\n        }\n        // avoids infinite recursion of numerals\n        if (self.operator != \"-\"\n            || !(e instanceof AST_Number || e instanceof AST_Infinity)) {\n            var ev = self.evaluate(compressor);\n            if (ev !== self) {\n                ev = make_node_from_constant(ev, self).optimize(compressor);\n                return best_of(compressor, ev, self);\n            }\n        }\n        return self;\n    });\n\n    AST_Binary.DEFMETHOD(\"lift_sequences\", function(compressor) {\n        if (compressor.option(\"sequences\")) {\n            if (this.left instanceof AST_Sequence) {\n                var x = this.left.expressions.slice();\n                var e = this.clone();\n                e.left = x.pop();\n                x.push(e);\n                return make_sequence(this, x).optimize(compressor);\n            }\n            if (this.right instanceof AST_Sequence && !this.left.has_side_effects(compressor)) {\n                var assign = this.operator == \"=\" && this.left instanceof AST_SymbolRef;\n                var x = this.right.expressions;\n                var last = x.length - 1;\n                for (var i = 0; i < last; i++) {\n                    if (!assign && x[i].has_side_effects(compressor)) break;\n                }\n                if (i == last) {\n                    x = x.slice();\n                    var e = this.clone();\n                    e.right = x.pop();\n                    x.push(e);\n                    return make_sequence(this, x).optimize(compressor);\n                } else if (i > 0) {\n                    var e = this.clone();\n                    e.right = make_sequence(this.right, x.slice(i));\n                    x = x.slice(0, i);\n                    x.push(e);\n                    return make_sequence(this, x).optimize(compressor);\n                }\n            }\n        }\n        return this;\n    });\n\n    var commutativeOperators = makePredicate(\"== === != !== * & | ^\");\n    function is_object(node) {\n        return node instanceof AST_Array\n            || node instanceof AST_Lambda\n            || node instanceof AST_Object\n            || node instanceof AST_Class;\n    }\n\n    def_optimize(AST_Binary, function(self, compressor) {\n        function reversible() {\n            return self.left.is_constant()\n                || self.right.is_constant()\n                || !self.left.has_side_effects(compressor)\n                    && !self.right.has_side_effects(compressor);\n        }\n        function reverse(op) {\n            if (reversible()) {\n                if (op) self.operator = op;\n                var tmp = self.left;\n                self.left = self.right;\n                self.right = tmp;\n            }\n        }\n        if (commutativeOperators(self.operator)) {\n            if (self.right.is_constant()\n                && !self.left.is_constant()) {\n                // if right is a constant, whatever side effects the\n                // left side might have could not influence the\n                // result.  hence, force switch.\n\n                if (!(self.left instanceof AST_Binary\n                      && PRECEDENCE[self.left.operator] >= PRECEDENCE[self.operator])) {\n                    reverse();\n                }\n            }\n        }\n        self = self.lift_sequences(compressor);\n        if (compressor.option(\"comparisons\")) switch (self.operator) {\n          case \"===\":\n          case \"!==\":\n            var is_strict_comparison = true;\n            if ((self.left.is_string(compressor) && self.right.is_string(compressor)) ||\n                (self.left.is_number(compressor) && self.right.is_number(compressor)) ||\n                (self.left.is_boolean() && self.right.is_boolean()) ||\n                self.left.equivalent_to(self.right)) {\n                self.operator = self.operator.substr(0, 2);\n            }\n            // XXX: intentionally falling down to the next case\n          case \"==\":\n          case \"!=\":\n            // void 0 == x => null == x\n            if (!is_strict_comparison && is_undefined(self.left, compressor)) {\n                self.left = make_node(AST_Null, self.left);\n            } else if (compressor.option(\"typeofs\")\n                // \"undefined\" == typeof x => undefined === x\n                && self.left instanceof AST_String\n                && self.left.value == \"undefined\"\n                && self.right instanceof AST_UnaryPrefix\n                && self.right.operator == \"typeof\") {\n                var expr = self.right.expression;\n                if (expr instanceof AST_SymbolRef ? expr.is_declared(compressor)\n                    : !(expr instanceof AST_PropAccess && compressor.option(\"ie8\"))) {\n                    self.right = expr;\n                    self.left = make_node(AST_Undefined, self.left).optimize(compressor);\n                    if (self.operator.length == 2) self.operator += \"=\";\n                }\n            } else if (self.left instanceof AST_SymbolRef\n                // obj !== obj => false\n                && self.right instanceof AST_SymbolRef\n                && self.left.definition() === self.right.definition()\n                && is_object(self.left.fixed_value())) {\n                return make_node(self.operator[0] == \"=\" ? AST_True : AST_False, self);\n            }\n            break;\n          case \"&&\":\n          case \"||\":\n            var lhs = self.left;\n            if (lhs.operator == self.operator) {\n                lhs = lhs.right;\n            }\n            if (lhs instanceof AST_Binary\n                && lhs.operator == (self.operator == \"&&\" ? \"!==\" : \"===\")\n                && self.right instanceof AST_Binary\n                && lhs.operator == self.right.operator\n                && (is_undefined(lhs.left, compressor) && self.right.left instanceof AST_Null\n                    || lhs.left instanceof AST_Null && is_undefined(self.right.left, compressor))\n                && !lhs.right.has_side_effects(compressor)\n                && lhs.right.equivalent_to(self.right.right)) {\n                var combined = make_node(AST_Binary, self, {\n                    operator: lhs.operator.slice(0, -1),\n                    left: make_node(AST_Null, self),\n                    right: lhs.right\n                });\n                if (lhs !== self.left) {\n                    combined = make_node(AST_Binary, self, {\n                        operator: self.operator,\n                        left: self.left.left,\n                        right: combined\n                    });\n                }\n                return combined;\n            }\n            break;\n        }\n        if (self.operator == \"+\" && compressor.in_boolean_context()) {\n            var ll = self.left.evaluate(compressor);\n            var rr = self.right.evaluate(compressor);\n            if (ll && typeof ll == \"string\") {\n                compressor.warn(\"+ in boolean context always true [{file}:{line},{col}]\", self.start);\n                return make_sequence(self, [\n                    self.right,\n                    make_node(AST_True, self)\n                ]).optimize(compressor);\n            }\n            if (rr && typeof rr == \"string\") {\n                compressor.warn(\"+ in boolean context always true [{file}:{line},{col}]\", self.start);\n                return make_sequence(self, [\n                    self.left,\n                    make_node(AST_True, self)\n                ]).optimize(compressor);\n            }\n        }\n        if (compressor.option(\"comparisons\") && self.is_boolean()) {\n            if (!(compressor.parent() instanceof AST_Binary)\n                || compressor.parent() instanceof AST_Assign) {\n                var negated = make_node(AST_UnaryPrefix, self, {\n                    operator: \"!\",\n                    expression: self.negate(compressor, first_in_statement(compressor))\n                });\n                self = best_of(compressor, self, negated);\n            }\n            if (compressor.option(\"unsafe_comps\")) {\n                switch (self.operator) {\n                  case \"<\": reverse(\">\"); break;\n                  case \"<=\": reverse(\">=\"); break;\n                }\n            }\n        }\n        if (self.operator == \"+\") {\n            if (self.right instanceof AST_String\n                && self.right.getValue() == \"\"\n                && self.left.is_string(compressor)) {\n                return self.left;\n            }\n            if (self.left instanceof AST_String\n                && self.left.getValue() == \"\"\n                && self.right.is_string(compressor)) {\n                return self.right;\n            }\n            if (self.left instanceof AST_Binary\n                && self.left.operator == \"+\"\n                && self.left.left instanceof AST_String\n                && self.left.left.getValue() == \"\"\n                && self.right.is_string(compressor)) {\n                self.left = self.left.right;\n                return self.transform(compressor);\n            }\n        }\n        if (compressor.option(\"evaluate\")) {\n            switch (self.operator) {\n              case \"&&\":\n                var ll = self.left.truthy ? true : self.left.falsy ? false : self.left.evaluate(compressor);\n                if (!ll) {\n                    compressor.warn(\"Condition left of && always false [{file}:{line},{col}]\", self.start);\n                    return maintain_this_binding(compressor.parent(), compressor.self(), self.left).optimize(compressor);\n                } else if (!(ll instanceof AST_Node)) {\n                    compressor.warn(\"Condition left of && always true [{file}:{line},{col}]\", self.start);\n                    return make_sequence(self, [ self.left, self.right ]).optimize(compressor);\n                }\n                var rr = self.right.evaluate(compressor);\n                if (!rr) {\n                    if (compressor.in_boolean_context()) {\n                        compressor.warn(\"Boolean && always false [{file}:{line},{col}]\", self.start);\n                        return make_sequence(self, [\n                            self.left,\n                            make_node(AST_False, self)\n                        ]).optimize(compressor);\n                    } else self.falsy = true;\n                } else if (!(rr instanceof AST_Node)) {\n                    var parent = compressor.parent();\n                    if (parent.operator == \"&&\" && parent.left === compressor.self() || compressor.in_boolean_context()) {\n                        compressor.warn(\"Dropping side-effect-free && [{file}:{line},{col}]\", self.start);\n                        return self.left.optimize(compressor);\n                    }\n                }\n                // x || false && y ---> x ? y : false\n                if (self.left.operator == \"||\") {\n                    var lr = self.left.right.evaluate(compressor);\n                    if (!lr) return make_node(AST_Conditional, self, {\n                        condition: self.left.left,\n                        consequent: self.right,\n                        alternative: self.left.right\n                    }).optimize(compressor);\n                }\n                break;\n              case \"||\":\n                var ll = self.left.truthy ? true : self.left.falsy ? false : self.left.evaluate(compressor);\n                if (!ll) {\n                    compressor.warn(\"Condition left of || always false [{file}:{line},{col}]\", self.start);\n                    return make_sequence(self, [ self.left, self.right ]).optimize(compressor);\n                } else if (!(ll instanceof AST_Node)) {\n                    compressor.warn(\"Condition left of || always true [{file}:{line},{col}]\", self.start);\n                    return maintain_this_binding(compressor.parent(), compressor.self(), self.left).optimize(compressor);\n                }\n                var rr = self.right.evaluate(compressor);\n                if (!rr) {\n                    var parent = compressor.parent();\n                    if (parent.operator == \"||\" && parent.left === compressor.self() || compressor.in_boolean_context()) {\n                        compressor.warn(\"Dropping side-effect-free || [{file}:{line},{col}]\", self.start);\n                        return self.left.optimize(compressor);\n                    }\n                } else if (!(rr instanceof AST_Node)) {\n                    if (compressor.in_boolean_context()) {\n                        compressor.warn(\"Boolean || always true [{file}:{line},{col}]\", self.start);\n                        return make_sequence(self, [\n                            self.left,\n                            make_node(AST_True, self)\n                        ]).optimize(compressor);\n                    } else self.truthy = true;\n                }\n                if (self.left.operator == \"&&\") {\n                    var lr = self.left.right.evaluate(compressor);\n                    if (lr && !(lr instanceof AST_Node)) return make_node(AST_Conditional, self, {\n                        condition: self.left.left,\n                        consequent: self.left.right,\n                        alternative: self.right\n                    }).optimize(compressor);\n                }\n                break;\n            }\n            var associative = true;\n            switch (self.operator) {\n              case \"+\":\n                // \"foo\" + (\"bar\" + x) => \"foobar\" + x\n                if (self.left instanceof AST_Constant\n                    && self.right instanceof AST_Binary\n                    && self.right.operator == \"+\"\n                    && self.right.left instanceof AST_Constant\n                    && self.right.is_string(compressor)) {\n                    self = make_node(AST_Binary, self, {\n                        operator: \"+\",\n                        left: make_node(AST_String, self.left, {\n                            value: \"\" + self.left.getValue() + self.right.left.getValue(),\n                            start: self.left.start,\n                            end: self.right.left.end\n                        }),\n                        right: self.right.right\n                    });\n                }\n                // (x + \"foo\") + \"bar\" => x + \"foobar\"\n                if (self.right instanceof AST_Constant\n                    && self.left instanceof AST_Binary\n                    && self.left.operator == \"+\"\n                    && self.left.right instanceof AST_Constant\n                    && self.left.is_string(compressor)) {\n                    self = make_node(AST_Binary, self, {\n                        operator: \"+\",\n                        left: self.left.left,\n                        right: make_node(AST_String, self.right, {\n                            value: \"\" + self.left.right.getValue() + self.right.getValue(),\n                            start: self.left.right.start,\n                            end: self.right.end\n                        })\n                    });\n                }\n                // (x + \"foo\") + (\"bar\" + y) => (x + \"foobar\") + y\n                if (self.left instanceof AST_Binary\n                    && self.left.operator == \"+\"\n                    && self.left.is_string(compressor)\n                    && self.left.right instanceof AST_Constant\n                    && self.right instanceof AST_Binary\n                    && self.right.operator == \"+\"\n                    && self.right.left instanceof AST_Constant\n                    && self.right.is_string(compressor)) {\n                    self = make_node(AST_Binary, self, {\n                        operator: \"+\",\n                        left: make_node(AST_Binary, self.left, {\n                            operator: \"+\",\n                            left: self.left.left,\n                            right: make_node(AST_String, self.left.right, {\n                                value: \"\" + self.left.right.getValue() + self.right.left.getValue(),\n                                start: self.left.right.start,\n                                end: self.right.left.end\n                            })\n                        }),\n                        right: self.right.right\n                    });\n                }\n                // a + -b => a - b\n                if (self.right instanceof AST_UnaryPrefix\n                    && self.right.operator == \"-\"\n                    && self.left.is_number(compressor)) {\n                    self = make_node(AST_Binary, self, {\n                        operator: \"-\",\n                        left: self.left,\n                        right: self.right.expression\n                    });\n                    break;\n                }\n                // -a + b => b - a\n                if (self.left instanceof AST_UnaryPrefix\n                    && self.left.operator == \"-\"\n                    && reversible()\n                    && self.right.is_number(compressor)) {\n                    self = make_node(AST_Binary, self, {\n                        operator: \"-\",\n                        left: self.right,\n                        right: self.left.expression\n                    });\n                    break;\n                }\n              case \"*\":\n                associative = compressor.option(\"unsafe_math\");\n              case \"&\":\n              case \"|\":\n              case \"^\":\n                // a + +b => +b + a\n                if (self.left.is_number(compressor)\n                    && self.right.is_number(compressor)\n                    && reversible()\n                    && !(self.left instanceof AST_Binary\n                        && self.left.operator != self.operator\n                        && PRECEDENCE[self.left.operator] >= PRECEDENCE[self.operator])) {\n                    var reversed = make_node(AST_Binary, self, {\n                        operator: self.operator,\n                        left: self.right,\n                        right: self.left\n                    });\n                    if (self.right instanceof AST_Constant\n                        && !(self.left instanceof AST_Constant)) {\n                        self = best_of(compressor, reversed, self);\n                    } else {\n                        self = best_of(compressor, self, reversed);\n                    }\n                }\n                if (associative && self.is_number(compressor)) {\n                    // a + (b + c) => (a + b) + c\n                    if (self.right instanceof AST_Binary\n                        && self.right.operator == self.operator) {\n                        self = make_node(AST_Binary, self, {\n                            operator: self.operator,\n                            left: make_node(AST_Binary, self.left, {\n                                operator: self.operator,\n                                left: self.left,\n                                right: self.right.left,\n                                start: self.left.start,\n                                end: self.right.left.end\n                            }),\n                            right: self.right.right\n                        });\n                    }\n                    // (n + 2) + 3 => 5 + n\n                    // (2 * n) * 3 => 6 + n\n                    if (self.right instanceof AST_Constant\n                        && self.left instanceof AST_Binary\n                        && self.left.operator == self.operator) {\n                        if (self.left.left instanceof AST_Constant) {\n                            self = make_node(AST_Binary, self, {\n                                operator: self.operator,\n                                left: make_node(AST_Binary, self.left, {\n                                    operator: self.operator,\n                                    left: self.left.left,\n                                    right: self.right,\n                                    start: self.left.left.start,\n                                    end: self.right.end\n                                }),\n                                right: self.left.right\n                            });\n                        } else if (self.left.right instanceof AST_Constant) {\n                            self = make_node(AST_Binary, self, {\n                                operator: self.operator,\n                                left: make_node(AST_Binary, self.left, {\n                                    operator: self.operator,\n                                    left: self.left.right,\n                                    right: self.right,\n                                    start: self.left.right.start,\n                                    end: self.right.end\n                                }),\n                                right: self.left.left\n                            });\n                        }\n                    }\n                    // (a | 1) | (2 | d) => (3 | a) | b\n                    if (self.left instanceof AST_Binary\n                        && self.left.operator == self.operator\n                        && self.left.right instanceof AST_Constant\n                        && self.right instanceof AST_Binary\n                        && self.right.operator == self.operator\n                        && self.right.left instanceof AST_Constant) {\n                        self = make_node(AST_Binary, self, {\n                            operator: self.operator,\n                            left: make_node(AST_Binary, self.left, {\n                                operator: self.operator,\n                                left: make_node(AST_Binary, self.left.left, {\n                                    operator: self.operator,\n                                    left: self.left.right,\n                                    right: self.right.left,\n                                    start: self.left.right.start,\n                                    end: self.right.left.end\n                                }),\n                                right: self.left.left\n                            }),\n                            right: self.right.right\n                        });\n                    }\n                }\n            }\n        }\n        // x && (y && z)  ==>  x && y && z\n        // x || (y || z)  ==>  x || y || z\n        // x + (\"y\" + z)  ==>  x + \"y\" + z\n        // \"x\" + (y + \"z\")==>  \"x\" + y + \"z\"\n        if (self.right instanceof AST_Binary\n            && self.right.operator == self.operator\n            && (lazy_op(self.operator)\n                || (self.operator == \"+\"\n                    && (self.right.left.is_string(compressor)\n                        || (self.left.is_string(compressor)\n                            && self.right.right.is_string(compressor)))))\n        ) {\n            self.left = make_node(AST_Binary, self.left, {\n                operator : self.operator,\n                left     : self.left,\n                right    : self.right.left\n            });\n            self.right = self.right.right;\n            return self.transform(compressor);\n        }\n        var ev = self.evaluate(compressor);\n        if (ev !== self) {\n            ev = make_node_from_constant(ev, self).optimize(compressor);\n            return best_of(compressor, ev, self);\n        }\n        return self;\n    });\n\n    def_optimize(AST_SymbolExport, function(self, compressor) {\n        return self;\n    });\n\n    function recursive_ref(compressor, def) {\n        var node;\n        for (var i = 0; node = compressor.parent(i); i++) {\n            if (node instanceof AST_Lambda) {\n                var name = node.name;\n                if (name && name.definition() === def) break;\n            }\n        }\n        return node;\n    }\n\n    function within_array_or_object_literal(compressor) {\n        var node, level = 0;\n        while (node = compressor.parent(level++)) {\n            if (node instanceof AST_Statement) return false;\n            if (node instanceof AST_Array\n                || node instanceof AST_ObjectKeyVal\n                || node instanceof AST_Object) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    def_optimize(AST_SymbolRef, function(self, compressor) {\n        if (!compressor.option(\"ie8\")\n            && is_undeclared_ref(self)\n            && (!self.scope.uses_with || !compressor.find_parent(AST_With))) {\n            switch (self.name) {\n              case \"undefined\":\n                return make_node(AST_Undefined, self).optimize(compressor);\n              case \"NaN\":\n                return make_node(AST_NaN, self).optimize(compressor);\n              case \"Infinity\":\n                return make_node(AST_Infinity, self).optimize(compressor);\n            }\n        }\n        var parent = compressor.parent();\n        if (compressor.option(\"reduce_vars\") && is_lhs(self, parent) !== self) {\n            var d = self.definition();\n            if (compressor.top_retain && d.global && compressor.top_retain(d)) {\n                d.fixed = false;\n                d.should_replace = false;\n                d.single_use = false;\n                return self;\n            }\n            var fixed = self.fixed_value();\n            var single_use = d.single_use\n                && !(parent instanceof AST_Call && parent.is_expr_pure(compressor));\n            if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {\n                if (retain_top_func(fixed, compressor)) {\n                    single_use = false;\n                } else if (d.scope !== self.scope\n                    && (!compressor.option(\"reduce_funcs\") && fixed instanceof AST_Lambda\n                        || d.escaped == 1\n                        || fixed.inlined\n                        || within_array_or_object_literal(compressor))) {\n                    single_use = false;\n                } else if (recursive_ref(compressor, d)) {\n                    single_use = false;\n                } else if (d.scope !== self.scope || d.orig[0] instanceof AST_SymbolFunarg) {\n                    single_use = fixed.is_constant_expression(self.scope);\n                    if (single_use == \"f\") {\n                        var scope = self.scope;\n                        do {\n                            if (scope instanceof AST_Defun || is_func_expr(scope)) {\n                                scope.inlined = true;\n                            }\n                        } while (scope = scope.parent_scope);\n                    }\n                }\n            }\n            if (single_use && fixed) {\n                if (fixed instanceof AST_DefClass) {\n                    fixed = make_node(AST_ClassExpression, fixed, fixed);\n                }\n                if (fixed instanceof AST_Defun) {\n                    fixed._squeezed = true;\n                    fixed = make_node(AST_Function, fixed, fixed);\n                }\n                var value;\n                if (d.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {\n                    value = fixed.clone(true);\n                    var defun_def = value.name.definition();\n                    var lambda_def = value.variables.get(value.name.name);\n                    var name = lambda_def && lambda_def.orig[0];\n                    if (!(name instanceof AST_SymbolLambda)) {\n                        name = make_node(AST_SymbolLambda, value.name, value.name);\n                        name.scope = value;\n                        value.name = name;\n                        lambda_def = value.def_function(name);\n                    }\n                    value.walk(new TreeWalker(function(node) {\n                        if (node instanceof AST_SymbolRef && node.definition() === defun_def) {\n                            node.thedef = lambda_def;\n                            lambda_def.references.push(node);\n                        }\n                    }));\n                } else {\n                    value = fixed.optimize(compressor);\n                    if (value === fixed) value = fixed.clone(true);\n                }\n                return value;\n            }\n            if (fixed && d.should_replace === undefined) {\n                var init;\n                if (fixed instanceof AST_This) {\n                    if (!(d.orig[0] instanceof AST_SymbolFunarg)\n                        && all(d.references, function(ref) {\n                            return d.scope === ref.scope;\n                        })) {\n                        init = fixed;\n                    }\n                } else {\n                    var ev = fixed.evaluate(compressor);\n                    if (ev !== fixed && (compressor.option(\"unsafe_regexp\") || !(ev instanceof RegExp))) {\n                        init = make_node_from_constant(ev, fixed);\n                    }\n                }\n                if (init) {\n                    var value_length = init.optimize(compressor).print_to_string().length;\n                    var fn;\n                    if (has_symbol_ref(fixed)) {\n                        fn = function() {\n                            var result = init.optimize(compressor);\n                            return result === init ? result.clone(true) : result;\n                        };\n                    } else {\n                        value_length = Math.min(value_length, fixed.print_to_string().length);\n                        fn = function() {\n                            var result = best_of_expression(init.optimize(compressor), fixed);\n                            return result === init || result === fixed ? result.clone(true) : result;\n                        };\n                    }\n                    var name_length = d.name.length;\n                    var overhead = 0;\n                    if (compressor.option(\"unused\") && !compressor.exposed(d)) {\n                        overhead = (name_length + 2 + value_length) / (d.references.length - d.assignments);\n                    }\n                    d.should_replace = value_length <= name_length + overhead ? fn : false;\n                } else {\n                    d.should_replace = false;\n                }\n            }\n            if (d.should_replace) {\n                return d.should_replace();\n            }\n        }\n        return self;\n\n        function has_symbol_ref(value) {\n            var found;\n            value.walk(new TreeWalker(function(node) {\n                if (node instanceof AST_SymbolRef) found = true;\n                if (found) return true;\n            }));\n            return found;\n        }\n    });\n\n    function is_atomic(lhs, self) {\n        return lhs instanceof AST_SymbolRef || lhs.TYPE === self.TYPE;\n    }\n\n    def_optimize(AST_Undefined, function(self, compressor) {\n        if (compressor.option(\"unsafe_undefined\")) {\n            var undef = find_variable(compressor, \"undefined\");\n            if (undef) {\n                var ref = make_node(AST_SymbolRef, self, {\n                    name   : \"undefined\",\n                    scope  : undef.scope,\n                    thedef : undef\n                });\n                ref.is_undefined = true;\n                return ref;\n            }\n        }\n        var lhs = is_lhs(compressor.self(), compressor.parent());\n        if (lhs && is_atomic(lhs, self)) return self;\n        return make_node(AST_UnaryPrefix, self, {\n            operator: \"void\",\n            expression: make_node(AST_Number, self, {\n                value: 0\n            })\n        });\n    });\n\n    def_optimize(AST_Infinity, function(self, compressor) {\n        var lhs = is_lhs(compressor.self(), compressor.parent());\n        if (lhs && is_atomic(lhs, self)) return self;\n        if (compressor.option(\"keep_infinity\")\n            && !(lhs && !is_atomic(lhs, self))\n            && !find_variable(compressor, \"Infinity\"))\n            return self;\n        return make_node(AST_Binary, self, {\n            operator: \"/\",\n            left: make_node(AST_Number, self, {\n                value: 1\n            }),\n            right: make_node(AST_Number, self, {\n                value: 0\n            })\n        });\n    });\n\n    def_optimize(AST_NaN, function(self, compressor) {\n        var lhs = is_lhs(compressor.self(), compressor.parent());\n        if (lhs && !is_atomic(lhs, self)\n            || find_variable(compressor, \"NaN\")) {\n            return make_node(AST_Binary, self, {\n                operator: \"/\",\n                left: make_node(AST_Number, self, {\n                    value: 0\n                }),\n                right: make_node(AST_Number, self, {\n                    value: 0\n                })\n            });\n        }\n        return self;\n    });\n\n    function is_reachable(self, defs) {\n        var reachable = false;\n        var find_ref = new TreeWalker(function(node) {\n            if (reachable) return true;\n            if (node instanceof AST_SymbolRef && member(node.definition(), defs)) {\n                return reachable = true;\n            }\n        });\n        var scan_scope = new TreeWalker(function(node) {\n            if (reachable) return true;\n            if (node instanceof AST_Scope && node !== self) {\n                var parent = scan_scope.parent();\n                if (parent instanceof AST_Call && parent.expression === node) return;\n                node.walk(find_ref);\n                return true;\n            }\n        });\n        self.walk(scan_scope);\n        return reachable;\n    }\n\n    var ASSIGN_OPS = [ \"+\", \"-\", \"/\", \"*\", \"%\", \">>\", \"<<\", \">>>\", \"|\", \"^\", \"&\" ];\n    var ASSIGN_OPS_COMMUTATIVE = [ \"*\", \"|\", \"^\", \"&\" ];\n    def_optimize(AST_Assign, function(self, compressor) {\n        var def;\n        if (compressor.option(\"dead_code\")\n            && self.left instanceof AST_SymbolRef\n            && (def = self.left.definition()).scope === compressor.find_parent(AST_Lambda)) {\n            var level = 0, node, parent = self;\n            do {\n                node = parent;\n                parent = compressor.parent(level++);\n                if (parent instanceof AST_Exit) {\n                    if (in_try(level, parent)) break;\n                    if (is_reachable(def.scope, [ def ])) break;\n                    if (self.operator == \"=\") return self.right;\n                    def.fixed = false;\n                    return make_node(AST_Binary, self, {\n                        operator: self.operator.slice(0, -1),\n                        left: self.left,\n                        right: self.right\n                    }).optimize(compressor);\n                }\n            } while (parent instanceof AST_Binary && parent.right === node\n                || parent instanceof AST_Sequence && parent.tail_node() === node);\n        }\n        self = self.lift_sequences(compressor);\n        if (self.operator == \"=\" && self.left instanceof AST_SymbolRef && self.right instanceof AST_Binary) {\n            // x = expr1 OP expr2\n            if (self.right.left instanceof AST_SymbolRef\n                && self.right.left.name == self.left.name\n                && member(self.right.operator, ASSIGN_OPS)) {\n                // x = x - 2  --->  x -= 2\n                self.operator = self.right.operator + \"=\";\n                self.right = self.right.right;\n            } else if (self.right.right instanceof AST_SymbolRef\n                && self.right.right.name == self.left.name\n                && member(self.right.operator, ASSIGN_OPS_COMMUTATIVE)\n                && !self.right.left.has_side_effects(compressor)) {\n                // x = 2 & x  --->  x &= 2\n                self.operator = self.right.operator + \"=\";\n                self.right = self.right.left;\n            }\n        }\n        return self;\n\n        function in_try(level, node) {\n            var right = self.right;\n            self.right = make_node(AST_Null, right);\n            var may_throw = node.may_throw(compressor);\n            self.right = right;\n            var scope = self.left.definition().scope;\n            var parent;\n            while ((parent = compressor.parent(level++)) !== scope) {\n                if (parent instanceof AST_Try) {\n                    if (parent.bfinally) return true;\n                    if (may_throw && parent.bcatch) return true;\n                }\n            }\n        }\n    });\n\n    def_optimize(AST_DefaultAssign, function(self, compressor) {\n        if (!compressor.option(\"evaluate\")) {\n            return self;\n        }\n        var evaluateRight = self.right.evaluate(compressor);\n\n        // `[x = undefined] = foo` ---> `[x] = foo`\n        if (evaluateRight === undefined) {\n            self = self.left;\n        } else if (evaluateRight !== self.right) {\n            evaluateRight = make_node_from_constant(evaluateRight, self.right);\n            self.right = best_of_expression(evaluateRight, self.right);\n        }\n\n        return self;\n    });\n\n    def_optimize(AST_Conditional, function(self, compressor) {\n        if (!compressor.option(\"conditionals\")) return self;\n        // This looks like lift_sequences(), should probably be under \"sequences\"\n        if (self.condition instanceof AST_Sequence) {\n            var expressions = self.condition.expressions.slice();\n            self.condition = expressions.pop();\n            expressions.push(self);\n            return make_sequence(self, expressions);\n        }\n        var cond = self.condition.evaluate(compressor);\n        if (cond !== self.condition) {\n            if (cond) {\n                compressor.warn(\"Condition always true [{file}:{line},{col}]\", self.start);\n                return maintain_this_binding(compressor.parent(), compressor.self(), self.consequent);\n            } else {\n                compressor.warn(\"Condition always false [{file}:{line},{col}]\", self.start);\n                return maintain_this_binding(compressor.parent(), compressor.self(), self.alternative);\n            }\n        }\n        var negated = cond.negate(compressor, first_in_statement(compressor));\n        if (best_of(compressor, cond, negated) === negated) {\n            self = make_node(AST_Conditional, self, {\n                condition: negated,\n                consequent: self.alternative,\n                alternative: self.consequent\n            });\n        }\n        var condition = self.condition;\n        var consequent = self.consequent;\n        var alternative = self.alternative;\n        // x?x:y --> x||y\n        if (condition instanceof AST_SymbolRef\n            && consequent instanceof AST_SymbolRef\n            && condition.definition() === consequent.definition()) {\n            return make_node(AST_Binary, self, {\n                operator: \"||\",\n                left: condition,\n                right: alternative\n            });\n        }\n        // if (foo) exp = something; else exp = something_else;\n        //                   |\n        //                   v\n        // exp = foo ? something : something_else;\n        if (consequent instanceof AST_Assign\n            && alternative instanceof AST_Assign\n            && consequent.operator == alternative.operator\n            && consequent.left.equivalent_to(alternative.left)\n            && (!self.condition.has_side_effects(compressor)\n                || consequent.operator == \"=\"\n                    && !consequent.left.has_side_effects(compressor))) {\n            return make_node(AST_Assign, self, {\n                operator: consequent.operator,\n                left: consequent.left,\n                right: make_node(AST_Conditional, self, {\n                    condition: self.condition,\n                    consequent: consequent.right,\n                    alternative: alternative.right\n                })\n            });\n        }\n        // x ? y(a) : y(b) --> y(x ? a : b)\n        var arg_index;\n        if (consequent instanceof AST_Call\n            && alternative.TYPE === consequent.TYPE\n            && consequent.args.length > 0\n            && consequent.args.length == alternative.args.length\n            && consequent.expression.equivalent_to(alternative.expression)\n            && !self.condition.has_side_effects(compressor)\n            && !consequent.expression.has_side_effects(compressor)\n            && typeof (arg_index = single_arg_diff()) == \"number\") {\n            var node = consequent.clone();\n            node.args[arg_index] = make_node(AST_Conditional, self, {\n                condition: self.condition,\n                consequent: consequent.args[arg_index],\n                alternative: alternative.args[arg_index]\n            });\n            return node;\n        }\n        // x?y?z:a:a --> x&&y?z:a\n        if (consequent instanceof AST_Conditional\n            && consequent.alternative.equivalent_to(alternative)) {\n            return make_node(AST_Conditional, self, {\n                condition: make_node(AST_Binary, self, {\n                    left: self.condition,\n                    operator: \"&&\",\n                    right: consequent.condition\n                }),\n                consequent: consequent.consequent,\n                alternative: alternative\n            });\n        }\n        // x ? y : y --> x, y\n        if (consequent.equivalent_to(alternative)) {\n            return make_sequence(self, [\n                self.condition,\n                consequent\n            ]).optimize(compressor);\n        }\n        // x ? y || z : z --> x && y || z\n        if (consequent instanceof AST_Binary\n            && consequent.operator == \"||\"\n            && consequent.right.equivalent_to(alternative)) {\n            return make_node(AST_Binary, self, {\n                operator: \"||\",\n                left: make_node(AST_Binary, self, {\n                    operator: \"&&\",\n                    left: self.condition,\n                    right: consequent.left\n                }),\n                right: alternative\n            }).optimize(compressor);\n        }\n        var in_bool = compressor.in_boolean_context();\n        if (is_true(self.consequent)) {\n            if (is_false(self.alternative)) {\n                // c ? true : false ---> !!c\n                return booleanize(self.condition);\n            }\n            // c ? true : x ---> !!c || x\n            return make_node(AST_Binary, self, {\n                operator: \"||\",\n                left: booleanize(self.condition),\n                right: self.alternative\n            });\n        }\n        if (is_false(self.consequent)) {\n            if (is_true(self.alternative)) {\n                // c ? false : true ---> !c\n                return booleanize(self.condition.negate(compressor));\n            }\n            // c ? false : x ---> !c && x\n            return make_node(AST_Binary, self, {\n                operator: \"&&\",\n                left: booleanize(self.condition.negate(compressor)),\n                right: self.alternative\n            });\n        }\n        if (is_true(self.alternative)) {\n            // c ? x : true ---> !c || x\n            return make_node(AST_Binary, self, {\n                operator: \"||\",\n                left: booleanize(self.condition.negate(compressor)),\n                right: self.consequent\n            });\n        }\n        if (is_false(self.alternative)) {\n            // c ? x : false ---> !!c && x\n            return make_node(AST_Binary, self, {\n                operator: \"&&\",\n                left: booleanize(self.condition),\n                right: self.consequent\n            });\n        }\n\n        return self;\n\n        function booleanize(node) {\n            if (node.is_boolean()) return node;\n            // !!expression\n            return make_node(AST_UnaryPrefix, node, {\n                operator: \"!\",\n                expression: node.negate(compressor)\n            });\n        }\n\n        // AST_True or !0\n        function is_true(node) {\n            return node instanceof AST_True\n                || in_bool\n                    && node instanceof AST_Constant\n                    && node.getValue()\n                || (node instanceof AST_UnaryPrefix\n                    && node.operator == \"!\"\n                    && node.expression instanceof AST_Constant\n                    && !node.expression.getValue());\n        }\n        // AST_False or !1\n        function is_false(node) {\n            return node instanceof AST_False\n                || in_bool\n                    && node instanceof AST_Constant\n                    && !node.getValue()\n                || (node instanceof AST_UnaryPrefix\n                    && node.operator == \"!\"\n                    && node.expression instanceof AST_Constant\n                    && node.expression.getValue());\n        }\n\n        function single_arg_diff() {\n            var a = consequent.args;\n            var b = alternative.args;\n            for (var i = 0, len = a.length; i < len; i++) {\n                if (a[i] instanceof AST_Expansion) return;\n                if (!a[i].equivalent_to(b[i])) {\n                    if (b[i] instanceof AST_Expansion) return;\n                    for (var j = i + 1; j < len; j++) {\n                        if (a[j] instanceof AST_Expansion) return;\n                        if (!a[j].equivalent_to(b[j])) return;\n                    }\n                    return i;\n                }\n            }\n        }\n    });\n\n    def_optimize(AST_Boolean, function(self, compressor) {\n        if (compressor.in_boolean_context()) return make_node(AST_Number, self, {\n            value: +self.value\n        });\n        var p = compressor.parent();\n        if (compressor.option(\"booleans_as_integers\")) {\n            if (p instanceof AST_Binary && (p.operator == \"===\" || p.operator == \"!==\")) {\n                p.operator = p.operator.replace(/=$/, \"\");\n            }\n            return make_node(AST_Number, self, {\n                value: +self.value\n            });\n        }\n        if (compressor.option(\"booleans\")) {\n            if (p instanceof AST_Binary && (p.operator == \"==\"\n                                            || p.operator == \"!=\")) {\n                compressor.warn(\"Non-strict equality against boolean: {operator} {value} [{file}:{line},{col}]\", {\n                    operator : p.operator,\n                    value    : self.value,\n                    file     : p.start.file,\n                    line     : p.start.line,\n                    col      : p.start.col,\n                });\n                return make_node(AST_Number, self, {\n                    value: +self.value\n                });\n            }\n            return make_node(AST_UnaryPrefix, self, {\n                operator: \"!\",\n                expression: make_node(AST_Number, self, {\n                    value: 1 - self.value\n                })\n            });\n        }\n        return self;\n    });\n\n    function safe_to_flatten(value, compressor) {\n        if (value instanceof AST_SymbolRef) {\n            value = value.fixed_value();\n        }\n        if (!value) return false;\n        return !(value instanceof AST_Lambda || value instanceof AST_Class)\n            || compressor.parent() instanceof AST_New\n            || !value.contains_this();\n    }\n\n    def_optimize(AST_Sub, function(self, compressor) {\n        var expr = self.expression;\n        var prop = self.property;\n        if (compressor.option(\"properties\")) {\n            var key = prop.evaluate(compressor);\n            if (key !== prop) {\n                if (typeof key == \"string\") {\n                    if (key == \"undefined\") {\n                        key = undefined;\n                    } else {\n                        var value = parseFloat(key);\n                        if (value.toString() == key) {\n                            key = value;\n                        }\n                    }\n                }\n                prop = self.property = best_of_expression(prop, make_node_from_constant(key, prop).transform(compressor));\n                var property = \"\" + key;\n                if (is_identifier_string(property)\n                    && property.length <= prop.print_to_string().length + 1) {\n                    return make_node(AST_Dot, self, {\n                        expression: expr,\n                        property: property\n                    }).optimize(compressor);\n                }\n            }\n        }\n        var fn;\n        OPT_ARGUMENTS: if (compressor.option(\"arguments\")\n            && expr instanceof AST_SymbolRef\n            && expr.name == \"arguments\"\n            && expr.definition().orig.length == 1\n            && (fn = expr.scope) instanceof AST_Lambda\n            && fn.uses_arguments\n            && !(fn instanceof AST_Arrow)\n            && prop instanceof AST_Number) {\n            var index = prop.getValue();\n            var params = Object.create(null);\n            var argnames = fn.argnames;\n            for (var n = 0; n < argnames.length; n++) {\n                if (!(argnames[n] instanceof AST_SymbolFunarg)) {\n                    break OPT_ARGUMENTS; // destructuring parameter - bail\n                }\n                var param = argnames[n].name;\n                if (param in params) {\n                    break OPT_ARGUMENTS; // duplicate parameter - bail\n                }\n                params[param] = true;\n            }\n            var argname = fn.argnames[index];\n            if (argname && compressor.has_directive(\"use strict\")) {\n                var def = argname.definition();\n                if (!compressor.option(\"reduce_vars\") || def.assignments || def.orig.length > 1) {\n                    argname = null;\n                }\n            } else if (!argname && !compressor.option(\"keep_fargs\") && index < fn.argnames.length + 5) {\n                while (index >= fn.argnames.length) {\n                    argname = make_node(AST_SymbolFunarg, fn, {\n                        name: fn.make_var_name(\"argument_\" + fn.argnames.length),\n                        scope: fn\n                    });\n                    fn.argnames.push(argname);\n                    fn.enclosed.push(fn.def_variable(argname));\n                }\n            }\n            if (argname) {\n                var sym = make_node(AST_SymbolRef, self, argname);\n                sym.reference({});\n                delete argname.__unused;\n                return sym;\n            }\n        }\n        if (is_lhs(self, compressor.parent())) return self;\n        if (key !== prop) {\n            var sub = self.flatten_object(property, compressor);\n            if (sub) {\n                expr = self.expression = sub.expression;\n                prop = self.property = sub.property;\n            }\n        }\n        if (compressor.option(\"properties\") && compressor.option(\"side_effects\")\n            && prop instanceof AST_Number && expr instanceof AST_Array) {\n            var index = prop.getValue();\n            var elements = expr.elements;\n            var retValue = elements[index];\n            FLATTEN: if (safe_to_flatten(retValue, compressor)) {\n                var flatten = true;\n                var values = [];\n                for (var i = elements.length; --i > index;) {\n                    var value = elements[i].drop_side_effect_free(compressor);\n                    if (value) {\n                        values.unshift(value);\n                        if (flatten && value.has_side_effects(compressor)) flatten = false;\n                    }\n                }\n                if (retValue instanceof AST_Expansion) break FLATTEN;\n                retValue = retValue instanceof AST_Hole ? make_node(AST_Undefined, retValue) : retValue;\n                if (!flatten) values.unshift(retValue);\n                while (--i >= 0) {\n                    var value = elements[i];\n                    if (value instanceof AST_Expansion) break FLATTEN;\n                    value = value.drop_side_effect_free(compressor);\n                    if (value) values.unshift(value);\n                    else index--;\n                }\n                if (flatten) {\n                    values.push(retValue);\n                    return make_sequence(self, values).optimize(compressor);\n                } else return make_node(AST_Sub, self, {\n                    expression: make_node(AST_Array, expr, {\n                        elements: values\n                    }),\n                    property: make_node(AST_Number, prop, {\n                        value: index\n                    })\n                });\n            }\n        }\n        var ev = self.evaluate(compressor);\n        if (ev !== self) {\n            ev = make_node_from_constant(ev, self).optimize(compressor);\n            return best_of(compressor, ev, self);\n        }\n        return self;\n    });\n\n    AST_Lambda.DEFMETHOD(\"contains_this\", function() {\n        var result;\n        var self = this;\n        self.walk(new TreeWalker(function(node) {\n            if (result) return true;\n            if (node instanceof AST_This) return result = true;\n            if (node !== self && node instanceof AST_Scope && !(node instanceof AST_Arrow)) return true;\n        }));\n        return result;\n    });\n\n    AST_PropAccess.DEFMETHOD(\"flatten_object\", function(key, compressor) {\n        if (!compressor.option(\"properties\")) return;\n        var arrows = compressor.option(\"unsafe_arrows\") && compressor.option(\"ecma\") >= 6;\n        var expr = this.expression;\n        if (expr instanceof AST_Object) {\n            var props = expr.properties;\n            for (var i = props.length; --i >= 0;) {\n                var prop = props[i];\n                if (\"\" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {\n                    if (!all(props, function(prop) {\n                        return prop instanceof AST_ObjectKeyVal\n                            || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;\n                    })) break;\n                    if (!safe_to_flatten(prop.value, compressor)) break;\n                    return make_node(AST_Sub, this, {\n                        expression: make_node(AST_Array, expr, {\n                            elements: props.map(function(prop) {\n                                var v = prop.value;\n                                if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);\n                                var k = prop.key;\n                                if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {\n                                    return make_sequence(prop, [ k, v ]);\n                                }\n                                return v;\n                            })\n                        }),\n                        property: make_node(AST_Number, this, {\n                            value: i\n                        })\n                    });\n                }\n            }\n        }\n    });\n\n    def_optimize(AST_Dot, function(self, compressor) {\n        if (self.property == \"arguments\" || self.property == \"caller\") {\n            compressor.warn(\"Function.prototype.{prop} not supported [{file}:{line},{col}]\", {\n                prop: self.property,\n                file: self.start.file,\n                line: self.start.line,\n                col: self.start.col\n            });\n        }\n        if (is_lhs(self, compressor.parent())) return self;\n        if (compressor.option(\"unsafe_proto\")\n            && self.expression instanceof AST_Dot\n            && self.expression.property == \"prototype\") {\n            var exp = self.expression.expression;\n            if (is_undeclared_ref(exp)) switch (exp.name) {\n              case \"Array\":\n                self.expression = make_node(AST_Array, self.expression, {\n                    elements: []\n                });\n                break;\n              case \"Function\":\n                self.expression = make_node(AST_Function, self.expression, {\n                    argnames: [],\n                    body: []\n                });\n                break;\n              case \"Number\":\n                self.expression = make_node(AST_Number, self.expression, {\n                    value: 0\n                });\n                break;\n              case \"Object\":\n                self.expression = make_node(AST_Object, self.expression, {\n                    properties: []\n                });\n                break;\n              case \"RegExp\":\n                self.expression = make_node(AST_RegExp, self.expression, {\n                    value: /t/\n                });\n                break;\n              case \"String\":\n                self.expression = make_node(AST_String, self.expression, {\n                    value: \"\"\n                });\n                break;\n            }\n        }\n        var sub = self.flatten_object(self.property, compressor);\n        if (sub) return sub.optimize(compressor);\n        var ev = self.evaluate(compressor);\n        if (ev !== self) {\n            ev = make_node_from_constant(ev, self).optimize(compressor);\n            return best_of(compressor, ev, self);\n        }\n        return self;\n    });\n\n    function literals_in_boolean_context(self, compressor) {\n        if (compressor.in_boolean_context()) {\n            return best_of(compressor, self, make_sequence(self, [\n                self,\n                make_node(AST_True, self)\n            ]).optimize(compressor));\n        }\n        return self;\n    }\n\n    function inline_array_like_spread(self, compressor, elements) {\n        for (var i = 0; i < elements.length; i++) {\n            var el = elements[i];\n            if (el instanceof AST_Expansion) {\n                var expr = el.expression;\n                if ( expr instanceof AST_Array) {\n                    elements.splice.apply(elements, [i, 1].concat(expr.elements));\n                    // Step back one, as the element at i is now new.\n                    i--;\n                }\n                // In array-like spread, spreading a non-iterable value is TypeError.\n                // We therefore can’t optimize anything else, unlike with object spread.\n            }\n        }\n        return self;\n    }\n\n    def_optimize(AST_Array, function(self, compressor) {\n        var optimized = literals_in_boolean_context(self, compressor);\n        if (optimized !== self) {\n            return optimized;\n        }\n        return inline_array_like_spread(self, compressor, self.elements);\n    });\n\n    def_optimize(AST_Object, function(self, compressor) {\n        var optimized = literals_in_boolean_context(self, compressor);\n        if (optimized !== self) {\n            return optimized;\n        }\n        var props = self.properties;\n        for (var i = 0; i < props.length; i++) {\n            var prop = props[i];\n            if (prop instanceof AST_Expansion) {\n                var expr = prop.expression;\n                if (expr instanceof AST_Object) {\n                    props.splice.apply(props, [i, 1].concat(prop.expression.properties));\n                    // Step back one, as the property at i is now new.\n                    i--;\n                } else if (expr instanceof AST_Constant\n                    && !(expr instanceof AST_String)) {\n                    // Unlike array-like spread, in object spread, spreading a\n                    // non-iterable value silently does nothing; it is thus safe\n                    // to remove. AST_String is the only iterable AST_Constant.\n                    props.splice(i, 1);\n                }\n            }\n        }\n        return self;\n    });\n\n    def_optimize(AST_RegExp, literals_in_boolean_context);\n\n    def_optimize(AST_Return, function(self, compressor) {\n        if (self.value && is_undefined(self.value, compressor)) {\n            self.value = null;\n        }\n        return self;\n    });\n\n    def_optimize(AST_Arrow, function(self, compressor) {\n        if (!(self.body instanceof AST_Node)) {\n            self = opt_AST_Lambda(self, compressor);\n        }\n        if (compressor.option(\"arrows\")\n            && self.body.length == 1\n            && self.body[0] instanceof AST_Return) {\n            var value = self.body[0].value;\n            self.body = value ? value : [];\n        }\n        return self;\n    });\n\n    def_optimize(AST_Function, function(self, compressor) {\n        self = opt_AST_Lambda(self, compressor);\n        if (compressor.option(\"unsafe_arrows\")\n            && compressor.option(\"ecma\") >= 6\n            && !self.name\n            && !self.is_generator\n            && !self.uses_arguments\n            && !self.pinned()) {\n            var has_special_symbol = false;\n            self.walk(new TreeWalker(function(node) {\n                if (has_special_symbol) return true;\n                if (node instanceof AST_This) {\n                    has_special_symbol = true;\n                    return true;\n                }\n            }));\n            if (!has_special_symbol) return make_node(AST_Arrow, self, self).optimize(compressor);\n        }\n        return self;\n    });\n\n    def_optimize(AST_Class, function(self, compressor) {\n        // HACK to avoid compress failure.\n        // AST_Class is not really an AST_Scope/AST_Block as it lacks a body.\n        return self;\n    });\n\n    def_optimize(AST_Yield, function(self, compressor) {\n        if (self.expression && !self.is_star && is_undefined(self.expression, compressor)) {\n            self.expression = null;\n        }\n        return self;\n    });\n\n    def_optimize(AST_TemplateString, function(self, compressor) {\n        if (!compressor.option(\"evaluate\")\n        || compressor.parent() instanceof AST_PrefixedTemplateString)\n            return self;\n\n        var segments = [];\n        for (var i = 0; i < self.segments.length; i++) {\n            var segment = self.segments[i];\n            if (segment instanceof AST_Node) {\n                var result = segment.evaluate(compressor);\n                // Evaluate to constant value\n                // Constant value shorter than ${segment}\n                if (result !== segment && (result + \"\").length <= segment.print_to_string().length + \"${}\".length) {\n                    // There should always be a previous and next segment if segment is a node\n                    segments[segments.length - 1].value = segments[segments.length - 1].value + result + self.segments[++i].value;\n                    continue;\n                }\n            }\n            segments.push(segment);\n        }\n        self.segments = segments;\n\n        return segments.length == 1 ? make_node(AST_String, self, segments[0]) : self;\n    });\n\n    def_optimize(AST_PrefixedTemplateString, function(self, compressor) {\n        return self;\n    });\n\n    // [\"p\"]:1 ---> p:1\n    // [42]:1 ---> 42:1\n    function lift_key(self, compressor) {\n        if (!compressor.option(\"computed_props\")) return self;\n        // save a comparison in the typical case\n        if (!(self.key instanceof AST_Constant)) return self;\n        // whitelist acceptable props as not all AST_Constants are true constants\n        if (self.key instanceof AST_String || self.key instanceof AST_Number) {\n            if (self.key.value === \"__proto__\") return self;\n            if (self.key.value == \"constructor\"\n                && compressor.parent() instanceof AST_Class) return self;\n            if (self instanceof AST_ObjectKeyVal) {\n                self.key = self.key.value;\n            } else {\n                self.key = make_node(AST_SymbolMethod, self.key, {\n                    name: self.key.value\n                });\n            }\n        }\n        return self;\n    }\n\n    def_optimize(AST_ObjectProperty, lift_key);\n\n    def_optimize(AST_ConciseMethod, function(self, compressor) {\n        lift_key(self, compressor);\n        // p(){return x;} ---> p:()=>x\n        if (compressor.option(\"arrows\")\n            && compressor.parent() instanceof AST_Object\n            && !self.is_generator\n            && !self.value.uses_arguments\n            && !self.value.pinned()\n            && self.value.body.length == 1\n            && self.value.body[0] instanceof AST_Return\n            && self.value.body[0].value\n            && !self.value.contains_this()) {\n            var arrow = make_node(AST_Arrow, self.value, self.value);\n            arrow.async = self.async;\n            arrow.is_generator = self.is_generator;\n            return make_node(AST_ObjectKeyVal, self, {\n                key: self.key instanceof AST_SymbolMethod ? self.key.name : self.key,\n                value: arrow,\n                quote: self.quote,\n            });\n        }\n        return self;\n    });\n\n    def_optimize(AST_ObjectKeyVal, function(self, compressor) {\n        lift_key(self, compressor);\n        // p:function(){} ---> p(){}\n        // p:function*(){} ---> *p(){}\n        // p:async function(){} ---> async p(){}\n        // p:()=>{} ---> p(){}\n        // p:async()=>{} ---> async p(){}\n        var unsafe_methods = compressor.option(\"unsafe_methods\");\n        if (unsafe_methods\n            && compressor.option(\"ecma\") >= 6\n            && (!(unsafe_methods instanceof RegExp) || unsafe_methods.test(self.key + \"\"))) {\n            var key = self.key;\n            var value = self.value;\n            var is_arrow_with_block = value instanceof AST_Arrow\n                && Array.isArray(value.body)\n                && !value.contains_this();\n            if ((is_arrow_with_block || value instanceof AST_Function) && !value.name) {\n                return make_node(AST_ConciseMethod, self, {\n                    async: value.async,\n                    is_generator: value.is_generator,\n                    key: key instanceof AST_Node ? key : make_node(AST_SymbolMethod, self, {\n                        name: key,\n                    }),\n                    value: make_node(AST_Accessor, value, value),\n                    quote: self.quote,\n                });\n            }\n        }\n        return self;\n    });\n\n    def_optimize(AST_Destructuring, function(self, compressor) {\n        if (compressor.option(\"pure_getters\") == true\n            && compressor.option(\"unused\")\n            && !self.is_array\n            && Array.isArray(self.names)\n            && !is_destructuring_export_decl(compressor)) {\n            var keep = [];\n            for (var i = 0; i < self.names.length; i++) {\n                var elem = self.names[i];\n                if (!(elem instanceof AST_ObjectKeyVal\n                    && typeof elem.key == \"string\"\n                    && elem.value instanceof AST_SymbolDeclaration\n                    && !should_retain(compressor, elem.value.definition()))) {\n                    keep.push(elem);\n                }\n            }\n            if (keep.length != self.names.length) {\n                self.names = keep;\n            }\n        }\n        return self;\n\n        function is_destructuring_export_decl(compressor) {\n            var ancestors = [/^VarDef$/, /^(Const|Let|Var)$/, /^Export$/];\n            for (var a = 0, p = 0, len = ancestors.length; a < len; p++) {\n                var parent = compressor.parent(p);\n                if (!parent) return false;\n                if (a === 0 && parent.TYPE == \"Destructuring\") continue;\n                if (!ancestors[a].test(parent.TYPE)) {\n                    return false;\n                }\n                a++;\n            }\n            return true;\n        }\n\n        function should_retain(compressor, def) {\n            if (def.references.length) return true;\n            if (!def.global) return false;\n            if (compressor.toplevel.vars) {\n                 if (compressor.top_retain) {\n                     return compressor.top_retain(def);\n                 }\n                 return false;\n            }\n            return true;\n        }\n    });\n})();\n\nexport {\n    Compressor,\n};\n","export var domprops = [\n    \"$&\",\n    \"$'\",\n    \"$*\",\n    \"$+\",\n    \"$1\",\n    \"$2\",\n    \"$3\",\n    \"$4\",\n    \"$5\",\n    \"$6\",\n    \"$7\",\n    \"$8\",\n    \"$9\",\n    \"$_\",\n    \"$`\",\n    \"$input\",\n    \"@@iterator\",\n    \"ABORT_ERR\",\n    \"ACTIVE\",\n    \"ACTIVE_ATTRIBUTES\",\n    \"ACTIVE_TEXTURE\",\n    \"ACTIVE_UNIFORMS\",\n    \"ADDITION\",\n    \"ALIASED_LINE_WIDTH_RANGE\",\n    \"ALIASED_POINT_SIZE_RANGE\",\n    \"ALLOW_KEYBOARD_INPUT\",\n    \"ALLPASS\",\n    \"ALPHA\",\n    \"ALPHA_BITS\",\n    \"ALT_MASK\",\n    \"ALWAYS\",\n    \"ANY_TYPE\",\n    \"ANY_UNORDERED_NODE_TYPE\",\n    \"ARRAY_BUFFER\",\n    \"ARRAY_BUFFER_BINDING\",\n    \"ATTACHED_SHADERS\",\n    \"ATTRIBUTE_NODE\",\n    \"AT_TARGET\",\n    \"AddSearchProvider\",\n    \"AnalyserNode\",\n    \"AnimationEvent\",\n    \"AnonXMLHttpRequest\",\n    \"ApplicationCache\",\n    \"ApplicationCacheErrorEvent\",\n    \"Array\",\n    \"ArrayBuffer\",\n    \"Attr\",\n    \"Audio\",\n    \"AudioBuffer\",\n    \"AudioBufferSourceNode\",\n    \"AudioContext\",\n    \"AudioDestinationNode\",\n    \"AudioListener\",\n    \"AudioNode\",\n    \"AudioParam\",\n    \"AudioProcessingEvent\",\n    \"AudioStreamTrack\",\n    \"AutocompleteErrorEvent\",\n    \"BACK\",\n    \"BAD_BOUNDARYPOINTS_ERR\",\n    \"BANDPASS\",\n    \"BLEND\",\n    \"BLEND_COLOR\",\n    \"BLEND_DST_ALPHA\",\n    \"BLEND_DST_RGB\",\n    \"BLEND_EQUATION\",\n    \"BLEND_EQUATION_ALPHA\",\n    \"BLEND_EQUATION_RGB\",\n    \"BLEND_SRC_ALPHA\",\n    \"BLEND_SRC_RGB\",\n    \"BLUE_BITS\",\n    \"BLUR\",\n    \"BOOL\",\n    \"BOOLEAN_TYPE\",\n    \"BOOL_VEC2\",\n    \"BOOL_VEC3\",\n    \"BOOL_VEC4\",\n    \"BOTH\",\n    \"BROWSER_DEFAULT_WEBGL\",\n    \"BUBBLING_PHASE\",\n    \"BUFFER_SIZE\",\n    \"BUFFER_USAGE\",\n    \"BYTE\",\n    \"BYTES_PER_ELEMENT\",\n    \"BarProp\",\n    \"BaseHref\",\n    \"BatteryManager\",\n    \"BeforeLoadEvent\",\n    \"BeforeUnloadEvent\",\n    \"BiquadFilterNode\",\n    \"Blob\",\n    \"BlobEvent\",\n    \"Boolean\",\n    \"CAPTURING_PHASE\",\n    \"CCW\",\n    \"CDATASection\",\n    \"CDATA_SECTION_NODE\",\n    \"CHANGE\",\n    \"CHARSET_RULE\",\n    \"CHECKING\",\n    \"CLAMP_TO_EDGE\",\n    \"CLICK\",\n    \"CLOSED\",\n    \"CLOSING\",\n    \"COLOR_ATTACHMENT0\",\n    \"COLOR_BUFFER_BIT\",\n    \"COLOR_CLEAR_VALUE\",\n    \"COLOR_WRITEMASK\",\n    \"COMMENT_NODE\",\n    \"COMPILE_STATUS\",\n    \"COMPRESSED_RGBA_S3TC_DXT1_EXT\",\n    \"COMPRESSED_RGBA_S3TC_DXT3_EXT\",\n    \"COMPRESSED_RGBA_S3TC_DXT5_EXT\",\n    \"COMPRESSED_RGB_S3TC_DXT1_EXT\",\n    \"COMPRESSED_TEXTURE_FORMATS\",\n    \"CONNECTING\",\n    \"CONSTANT_ALPHA\",\n    \"CONSTANT_COLOR\",\n    \"CONSTRAINT_ERR\",\n    \"CONTEXT_LOST_WEBGL\",\n    \"CONTROL_MASK\",\n    \"COUNTER_STYLE_RULE\",\n    \"CSS\",\n    \"CSS2Properties\",\n    \"CSSCharsetRule\",\n    \"CSSConditionRule\",\n    \"CSSCounterStyleRule\",\n    \"CSSFontFaceRule\",\n    \"CSSFontFeatureValuesRule\",\n    \"CSSGroupingRule\",\n    \"CSSImportRule\",\n    \"CSSKeyframeRule\",\n    \"CSSKeyframesRule\",\n    \"CSSMediaRule\",\n    \"CSSMozDocumentRule\",\n    \"CSSNameSpaceRule\",\n    \"CSSPageRule\",\n    \"CSSPrimitiveValue\",\n    \"CSSRule\",\n    \"CSSRuleList\",\n    \"CSSStyleDeclaration\",\n    \"CSSStyleRule\",\n    \"CSSStyleSheet\",\n    \"CSSSupportsRule\",\n    \"CSSUnknownRule\",\n    \"CSSValue\",\n    \"CSSValueList\",\n    \"CSSVariablesDeclaration\",\n    \"CSSVariablesRule\",\n    \"CSSViewportRule\",\n    \"CSS_ATTR\",\n    \"CSS_CM\",\n    \"CSS_COUNTER\",\n    \"CSS_CUSTOM\",\n    \"CSS_DEG\",\n    \"CSS_DIMENSION\",\n    \"CSS_EMS\",\n    \"CSS_EXS\",\n    \"CSS_FILTER_BLUR\",\n    \"CSS_FILTER_BRIGHTNESS\",\n    \"CSS_FILTER_CONTRAST\",\n    \"CSS_FILTER_CUSTOM\",\n    \"CSS_FILTER_DROP_SHADOW\",\n    \"CSS_FILTER_GRAYSCALE\",\n    \"CSS_FILTER_HUE_ROTATE\",\n    \"CSS_FILTER_INVERT\",\n    \"CSS_FILTER_OPACITY\",\n    \"CSS_FILTER_REFERENCE\",\n    \"CSS_FILTER_SATURATE\",\n    \"CSS_FILTER_SEPIA\",\n    \"CSS_GRAD\",\n    \"CSS_HZ\",\n    \"CSS_IDENT\",\n    \"CSS_IN\",\n    \"CSS_INHERIT\",\n    \"CSS_KHZ\",\n    \"CSS_MATRIX\",\n    \"CSS_MATRIX3D\",\n    \"CSS_MM\",\n    \"CSS_MS\",\n    \"CSS_NUMBER\",\n    \"CSS_PC\",\n    \"CSS_PERCENTAGE\",\n    \"CSS_PERSPECTIVE\",\n    \"CSS_PRIMITIVE_VALUE\",\n    \"CSS_PT\",\n    \"CSS_PX\",\n    \"CSS_RAD\",\n    \"CSS_RECT\",\n    \"CSS_RGBCOLOR\",\n    \"CSS_ROTATE\",\n    \"CSS_ROTATE3D\",\n    \"CSS_ROTATEX\",\n    \"CSS_ROTATEY\",\n    \"CSS_ROTATEZ\",\n    \"CSS_S\",\n    \"CSS_SCALE\",\n    \"CSS_SCALE3D\",\n    \"CSS_SCALEX\",\n    \"CSS_SCALEY\",\n    \"CSS_SCALEZ\",\n    \"CSS_SKEW\",\n    \"CSS_SKEWX\",\n    \"CSS_SKEWY\",\n    \"CSS_STRING\",\n    \"CSS_TRANSLATE\",\n    \"CSS_TRANSLATE3D\",\n    \"CSS_TRANSLATEX\",\n    \"CSS_TRANSLATEY\",\n    \"CSS_TRANSLATEZ\",\n    \"CSS_UNKNOWN\",\n    \"CSS_URI\",\n    \"CSS_VALUE_LIST\",\n    \"CSS_VH\",\n    \"CSS_VMAX\",\n    \"CSS_VMIN\",\n    \"CSS_VW\",\n    \"CULL_FACE\",\n    \"CULL_FACE_MODE\",\n    \"CURRENT_PROGRAM\",\n    \"CURRENT_VERTEX_ATTRIB\",\n    \"CUSTOM\",\n    \"CW\",\n    \"CanvasGradient\",\n    \"CanvasPattern\",\n    \"CanvasRenderingContext2D\",\n    \"CaretPosition\",\n    \"ChannelMergerNode\",\n    \"ChannelSplitterNode\",\n    \"CharacterData\",\n    \"ClientRect\",\n    \"ClientRectList\",\n    \"Clipboard\",\n    \"ClipboardEvent\",\n    \"CloseEvent\",\n    \"Collator\",\n    \"CommandEvent\",\n    \"Comment\",\n    \"CompositionEvent\",\n    \"Console\",\n    \"Controllers\",\n    \"ConvolverNode\",\n    \"Counter\",\n    \"Crypto\",\n    \"CryptoKey\",\n    \"CustomEvent\",\n    \"DATABASE_ERR\",\n    \"DATA_CLONE_ERR\",\n    \"DATA_ERR\",\n    \"DBLCLICK\",\n    \"DECR\",\n    \"DECR_WRAP\",\n    \"DELETE_STATUS\",\n    \"DEPTH_ATTACHMENT\",\n    \"DEPTH_BITS\",\n    \"DEPTH_BUFFER_BIT\",\n    \"DEPTH_CLEAR_VALUE\",\n    \"DEPTH_COMPONENT\",\n    \"DEPTH_COMPONENT16\",\n    \"DEPTH_FUNC\",\n    \"DEPTH_RANGE\",\n    \"DEPTH_STENCIL\",\n    \"DEPTH_STENCIL_ATTACHMENT\",\n    \"DEPTH_TEST\",\n    \"DEPTH_WRITEMASK\",\n    \"DIRECTION_DOWN\",\n    \"DIRECTION_LEFT\",\n    \"DIRECTION_RIGHT\",\n    \"DIRECTION_UP\",\n    \"DISABLED\",\n    \"DISPATCH_REQUEST_ERR\",\n    \"DITHER\",\n    \"DOCUMENT_FRAGMENT_NODE\",\n    \"DOCUMENT_NODE\",\n    \"DOCUMENT_POSITION_CONTAINED_BY\",\n    \"DOCUMENT_POSITION_CONTAINS\",\n    \"DOCUMENT_POSITION_DISCONNECTED\",\n    \"DOCUMENT_POSITION_FOLLOWING\",\n    \"DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC\",\n    \"DOCUMENT_POSITION_PRECEDING\",\n    \"DOCUMENT_TYPE_NODE\",\n    \"DOMCursor\",\n    \"DOMError\",\n    \"DOMException\",\n    \"DOMImplementation\",\n    \"DOMImplementationLS\",\n    \"DOMMatrix\",\n    \"DOMMatrixReadOnly\",\n    \"DOMParser\",\n    \"DOMPoint\",\n    \"DOMPointReadOnly\",\n    \"DOMQuad\",\n    \"DOMRect\",\n    \"DOMRectList\",\n    \"DOMRectReadOnly\",\n    \"DOMRequest\",\n    \"DOMSTRING_SIZE_ERR\",\n    \"DOMSettableTokenList\",\n    \"DOMStringList\",\n    \"DOMStringMap\",\n    \"DOMTokenList\",\n    \"DOMTransactionEvent\",\n    \"DOM_DELTA_LINE\",\n    \"DOM_DELTA_PAGE\",\n    \"DOM_DELTA_PIXEL\",\n    \"DOM_INPUT_METHOD_DROP\",\n    \"DOM_INPUT_METHOD_HANDWRITING\",\n    \"DOM_INPUT_METHOD_IME\",\n    \"DOM_INPUT_METHOD_KEYBOARD\",\n    \"DOM_INPUT_METHOD_MULTIMODAL\",\n    \"DOM_INPUT_METHOD_OPTION\",\n    \"DOM_INPUT_METHOD_PASTE\",\n    \"DOM_INPUT_METHOD_SCRIPT\",\n    \"DOM_INPUT_METHOD_UNKNOWN\",\n    \"DOM_INPUT_METHOD_VOICE\",\n    \"DOM_KEY_LOCATION_JOYSTICK\",\n    \"DOM_KEY_LOCATION_LEFT\",\n    \"DOM_KEY_LOCATION_MOBILE\",\n    \"DOM_KEY_LOCATION_NUMPAD\",\n    \"DOM_KEY_LOCATION_RIGHT\",\n    \"DOM_KEY_LOCATION_STANDARD\",\n    \"DOM_VK_0\",\n    \"DOM_VK_1\",\n    \"DOM_VK_2\",\n    \"DOM_VK_3\",\n    \"DOM_VK_4\",\n    \"DOM_VK_5\",\n    \"DOM_VK_6\",\n    \"DOM_VK_7\",\n    \"DOM_VK_8\",\n    \"DOM_VK_9\",\n    \"DOM_VK_A\",\n    \"DOM_VK_ACCEPT\",\n    \"DOM_VK_ADD\",\n    \"DOM_VK_ALT\",\n    \"DOM_VK_ALTGR\",\n    \"DOM_VK_AMPERSAND\",\n    \"DOM_VK_ASTERISK\",\n    \"DOM_VK_AT\",\n    \"DOM_VK_ATTN\",\n    \"DOM_VK_B\",\n    \"DOM_VK_BACKSPACE\",\n    \"DOM_VK_BACK_QUOTE\",\n    \"DOM_VK_BACK_SLASH\",\n    \"DOM_VK_BACK_SPACE\",\n    \"DOM_VK_C\",\n    \"DOM_VK_CANCEL\",\n    \"DOM_VK_CAPS_LOCK\",\n    \"DOM_VK_CIRCUMFLEX\",\n    \"DOM_VK_CLEAR\",\n    \"DOM_VK_CLOSE_BRACKET\",\n    \"DOM_VK_CLOSE_CURLY_BRACKET\",\n    \"DOM_VK_CLOSE_PAREN\",\n    \"DOM_VK_COLON\",\n    \"DOM_VK_COMMA\",\n    \"DOM_VK_CONTEXT_MENU\",\n    \"DOM_VK_CONTROL\",\n    \"DOM_VK_CONVERT\",\n    \"DOM_VK_CRSEL\",\n    \"DOM_VK_CTRL\",\n    \"DOM_VK_D\",\n    \"DOM_VK_DECIMAL\",\n    \"DOM_VK_DELETE\",\n    \"DOM_VK_DIVIDE\",\n    \"DOM_VK_DOLLAR\",\n    \"DOM_VK_DOUBLE_QUOTE\",\n    \"DOM_VK_DOWN\",\n    \"DOM_VK_E\",\n    \"DOM_VK_EISU\",\n    \"DOM_VK_END\",\n    \"DOM_VK_ENTER\",\n    \"DOM_VK_EQUALS\",\n    \"DOM_VK_EREOF\",\n    \"DOM_VK_ESCAPE\",\n    \"DOM_VK_EXCLAMATION\",\n    \"DOM_VK_EXECUTE\",\n    \"DOM_VK_EXSEL\",\n    \"DOM_VK_F\",\n    \"DOM_VK_F1\",\n    \"DOM_VK_F10\",\n    \"DOM_VK_F11\",\n    \"DOM_VK_F12\",\n    \"DOM_VK_F13\",\n    \"DOM_VK_F14\",\n    \"DOM_VK_F15\",\n    \"DOM_VK_F16\",\n    \"DOM_VK_F17\",\n    \"DOM_VK_F18\",\n    \"DOM_VK_F19\",\n    \"DOM_VK_F2\",\n    \"DOM_VK_F20\",\n    \"DOM_VK_F21\",\n    \"DOM_VK_F22\",\n    \"DOM_VK_F23\",\n    \"DOM_VK_F24\",\n    \"DOM_VK_F25\",\n    \"DOM_VK_F26\",\n    \"DOM_VK_F27\",\n    \"DOM_VK_F28\",\n    \"DOM_VK_F29\",\n    \"DOM_VK_F3\",\n    \"DOM_VK_F30\",\n    \"DOM_VK_F31\",\n    \"DOM_VK_F32\",\n    \"DOM_VK_F33\",\n    \"DOM_VK_F34\",\n    \"DOM_VK_F35\",\n    \"DOM_VK_F36\",\n    \"DOM_VK_F4\",\n    \"DOM_VK_F5\",\n    \"DOM_VK_F6\",\n    \"DOM_VK_F7\",\n    \"DOM_VK_F8\",\n    \"DOM_VK_F9\",\n    \"DOM_VK_FINAL\",\n    \"DOM_VK_FRONT\",\n    \"DOM_VK_G\",\n    \"DOM_VK_GREATER_THAN\",\n    \"DOM_VK_H\",\n    \"DOM_VK_HANGUL\",\n    \"DOM_VK_HANJA\",\n    \"DOM_VK_HASH\",\n    \"DOM_VK_HELP\",\n    \"DOM_VK_HK_TOGGLE\",\n    \"DOM_VK_HOME\",\n    \"DOM_VK_HYPHEN_MINUS\",\n    \"DOM_VK_I\",\n    \"DOM_VK_INSERT\",\n    \"DOM_VK_J\",\n    \"DOM_VK_JUNJA\",\n    \"DOM_VK_K\",\n    \"DOM_VK_KANA\",\n    \"DOM_VK_KANJI\",\n    \"DOM_VK_L\",\n    \"DOM_VK_LEFT\",\n    \"DOM_VK_LEFT_TAB\",\n    \"DOM_VK_LESS_THAN\",\n    \"DOM_VK_M\",\n    \"DOM_VK_META\",\n    \"DOM_VK_MODECHANGE\",\n    \"DOM_VK_MULTIPLY\",\n    \"DOM_VK_N\",\n    \"DOM_VK_NONCONVERT\",\n    \"DOM_VK_NUMPAD0\",\n    \"DOM_VK_NUMPAD1\",\n    \"DOM_VK_NUMPAD2\",\n    \"DOM_VK_NUMPAD3\",\n    \"DOM_VK_NUMPAD4\",\n    \"DOM_VK_NUMPAD5\",\n    \"DOM_VK_NUMPAD6\",\n    \"DOM_VK_NUMPAD7\",\n    \"DOM_VK_NUMPAD8\",\n    \"DOM_VK_NUMPAD9\",\n    \"DOM_VK_NUM_LOCK\",\n    \"DOM_VK_O\",\n    \"DOM_VK_OEM_1\",\n    \"DOM_VK_OEM_102\",\n    \"DOM_VK_OEM_2\",\n    \"DOM_VK_OEM_3\",\n    \"DOM_VK_OEM_4\",\n    \"DOM_VK_OEM_5\",\n    \"DOM_VK_OEM_6\",\n    \"DOM_VK_OEM_7\",\n    \"DOM_VK_OEM_8\",\n    \"DOM_VK_OEM_COMMA\",\n    \"DOM_VK_OEM_MINUS\",\n    \"DOM_VK_OEM_PERIOD\",\n    \"DOM_VK_OEM_PLUS\",\n    \"DOM_VK_OPEN_BRACKET\",\n    \"DOM_VK_OPEN_CURLY_BRACKET\",\n    \"DOM_VK_OPEN_PAREN\",\n    \"DOM_VK_P\",\n    \"DOM_VK_PA1\",\n    \"DOM_VK_PAGEDOWN\",\n    \"DOM_VK_PAGEUP\",\n    \"DOM_VK_PAGE_DOWN\",\n    \"DOM_VK_PAGE_UP\",\n    \"DOM_VK_PAUSE\",\n    \"DOM_VK_PERCENT\",\n    \"DOM_VK_PERIOD\",\n    \"DOM_VK_PIPE\",\n    \"DOM_VK_PLAY\",\n    \"DOM_VK_PLUS\",\n    \"DOM_VK_PRINT\",\n    \"DOM_VK_PRINTSCREEN\",\n    \"DOM_VK_PROCESSKEY\",\n    \"DOM_VK_PROPERITES\",\n    \"DOM_VK_Q\",\n    \"DOM_VK_QUESTION_MARK\",\n    \"DOM_VK_QUOTE\",\n    \"DOM_VK_R\",\n    \"DOM_VK_REDO\",\n    \"DOM_VK_RETURN\",\n    \"DOM_VK_RIGHT\",\n    \"DOM_VK_S\",\n    \"DOM_VK_SCROLL_LOCK\",\n    \"DOM_VK_SELECT\",\n    \"DOM_VK_SEMICOLON\",\n    \"DOM_VK_SEPARATOR\",\n    \"DOM_VK_SHIFT\",\n    \"DOM_VK_SLASH\",\n    \"DOM_VK_SLEEP\",\n    \"DOM_VK_SPACE\",\n    \"DOM_VK_SUBTRACT\",\n    \"DOM_VK_T\",\n    \"DOM_VK_TAB\",\n    \"DOM_VK_TILDE\",\n    \"DOM_VK_U\",\n    \"DOM_VK_UNDERSCORE\",\n    \"DOM_VK_UNDO\",\n    \"DOM_VK_UNICODE\",\n    \"DOM_VK_UP\",\n    \"DOM_VK_V\",\n    \"DOM_VK_VOLUME_DOWN\",\n    \"DOM_VK_VOLUME_MUTE\",\n    \"DOM_VK_VOLUME_UP\",\n    \"DOM_VK_W\",\n    \"DOM_VK_WIN\",\n    \"DOM_VK_WINDOW\",\n    \"DOM_VK_WIN_ICO_00\",\n    \"DOM_VK_WIN_ICO_CLEAR\",\n    \"DOM_VK_WIN_ICO_HELP\",\n    \"DOM_VK_WIN_OEM_ATTN\",\n    \"DOM_VK_WIN_OEM_AUTO\",\n    \"DOM_VK_WIN_OEM_BACKTAB\",\n    \"DOM_VK_WIN_OEM_CLEAR\",\n    \"DOM_VK_WIN_OEM_COPY\",\n    \"DOM_VK_WIN_OEM_CUSEL\",\n    \"DOM_VK_WIN_OEM_ENLW\",\n    \"DOM_VK_WIN_OEM_FINISH\",\n    \"DOM_VK_WIN_OEM_FJ_JISHO\",\n    \"DOM_VK_WIN_OEM_FJ_LOYA\",\n    \"DOM_VK_WIN_OEM_FJ_MASSHOU\",\n    \"DOM_VK_WIN_OEM_FJ_ROYA\",\n    \"DOM_VK_WIN_OEM_FJ_TOUROKU\",\n    \"DOM_VK_WIN_OEM_JUMP\",\n    \"DOM_VK_WIN_OEM_PA1\",\n    \"DOM_VK_WIN_OEM_PA2\",\n    \"DOM_VK_WIN_OEM_PA3\",\n    \"DOM_VK_WIN_OEM_RESET\",\n    \"DOM_VK_WIN_OEM_WSCTRL\",\n    \"DOM_VK_X\",\n    \"DOM_VK_XF86XK_ADD_FAVORITE\",\n    \"DOM_VK_XF86XK_APPLICATION_LEFT\",\n    \"DOM_VK_XF86XK_APPLICATION_RIGHT\",\n    \"DOM_VK_XF86XK_AUDIO_CYCLE_TRACK\",\n    \"DOM_VK_XF86XK_AUDIO_FORWARD\",\n    \"DOM_VK_XF86XK_AUDIO_LOWER_VOLUME\",\n    \"DOM_VK_XF86XK_AUDIO_MEDIA\",\n    \"DOM_VK_XF86XK_AUDIO_MUTE\",\n    \"DOM_VK_XF86XK_AUDIO_NEXT\",\n    \"DOM_VK_XF86XK_AUDIO_PAUSE\",\n    \"DOM_VK_XF86XK_AUDIO_PLAY\",\n    \"DOM_VK_XF86XK_AUDIO_PREV\",\n    \"DOM_VK_XF86XK_AUDIO_RAISE_VOLUME\",\n    \"DOM_VK_XF86XK_AUDIO_RANDOM_PLAY\",\n    \"DOM_VK_XF86XK_AUDIO_RECORD\",\n    \"DOM_VK_XF86XK_AUDIO_REPEAT\",\n    \"DOM_VK_XF86XK_AUDIO_REWIND\",\n    \"DOM_VK_XF86XK_AUDIO_STOP\",\n    \"DOM_VK_XF86XK_AWAY\",\n    \"DOM_VK_XF86XK_BACK\",\n    \"DOM_VK_XF86XK_BACK_FORWARD\",\n    \"DOM_VK_XF86XK_BATTERY\",\n    \"DOM_VK_XF86XK_BLUE\",\n    \"DOM_VK_XF86XK_BLUETOOTH\",\n    \"DOM_VK_XF86XK_BOOK\",\n    \"DOM_VK_XF86XK_BRIGHTNESS_ADJUST\",\n    \"DOM_VK_XF86XK_CALCULATOR\",\n    \"DOM_VK_XF86XK_CALENDAR\",\n    \"DOM_VK_XF86XK_CD\",\n    \"DOM_VK_XF86XK_CLOSE\",\n    \"DOM_VK_XF86XK_COMMUNITY\",\n    \"DOM_VK_XF86XK_CONTRAST_ADJUST\",\n    \"DOM_VK_XF86XK_COPY\",\n    \"DOM_VK_XF86XK_CUT\",\n    \"DOM_VK_XF86XK_CYCLE_ANGLE\",\n    \"DOM_VK_XF86XK_DISPLAY\",\n    \"DOM_VK_XF86XK_DOCUMENTS\",\n    \"DOM_VK_XF86XK_DOS\",\n    \"DOM_VK_XF86XK_EJECT\",\n    \"DOM_VK_XF86XK_EXCEL\",\n    \"DOM_VK_XF86XK_EXPLORER\",\n    \"DOM_VK_XF86XK_FAVORITES\",\n    \"DOM_VK_XF86XK_FINANCE\",\n    \"DOM_VK_XF86XK_FORWARD\",\n    \"DOM_VK_XF86XK_FRAME_BACK\",\n    \"DOM_VK_XF86XK_FRAME_FORWARD\",\n    \"DOM_VK_XF86XK_GAME\",\n    \"DOM_VK_XF86XK_GO\",\n    \"DOM_VK_XF86XK_GREEN\",\n    \"DOM_VK_XF86XK_HIBERNATE\",\n    \"DOM_VK_XF86XK_HISTORY\",\n    \"DOM_VK_XF86XK_HOME_PAGE\",\n    \"DOM_VK_XF86XK_HOT_LINKS\",\n    \"DOM_VK_XF86XK_I_TOUCH\",\n    \"DOM_VK_XF86XK_KBD_BRIGHTNESS_DOWN\",\n    \"DOM_VK_XF86XK_KBD_BRIGHTNESS_UP\",\n    \"DOM_VK_XF86XK_KBD_LIGHT_ON_OFF\",\n    \"DOM_VK_XF86XK_LAUNCH0\",\n    \"DOM_VK_XF86XK_LAUNCH1\",\n    \"DOM_VK_XF86XK_LAUNCH2\",\n    \"DOM_VK_XF86XK_LAUNCH3\",\n    \"DOM_VK_XF86XK_LAUNCH4\",\n    \"DOM_VK_XF86XK_LAUNCH5\",\n    \"DOM_VK_XF86XK_LAUNCH6\",\n    \"DOM_VK_XF86XK_LAUNCH7\",\n    \"DOM_VK_XF86XK_LAUNCH8\",\n    \"DOM_VK_XF86XK_LAUNCH9\",\n    \"DOM_VK_XF86XK_LAUNCH_A\",\n    \"DOM_VK_XF86XK_LAUNCH_B\",\n    \"DOM_VK_XF86XK_LAUNCH_C\",\n    \"DOM_VK_XF86XK_LAUNCH_D\",\n    \"DOM_VK_XF86XK_LAUNCH_E\",\n    \"DOM_VK_XF86XK_LAUNCH_F\",\n    \"DOM_VK_XF86XK_LIGHT_BULB\",\n    \"DOM_VK_XF86XK_LOG_OFF\",\n    \"DOM_VK_XF86XK_MAIL\",\n    \"DOM_VK_XF86XK_MAIL_FORWARD\",\n    \"DOM_VK_XF86XK_MARKET\",\n    \"DOM_VK_XF86XK_MEETING\",\n    \"DOM_VK_XF86XK_MEMO\",\n    \"DOM_VK_XF86XK_MENU_KB\",\n    \"DOM_VK_XF86XK_MENU_PB\",\n    \"DOM_VK_XF86XK_MESSENGER\",\n    \"DOM_VK_XF86XK_MON_BRIGHTNESS_DOWN\",\n    \"DOM_VK_XF86XK_MON_BRIGHTNESS_UP\",\n    \"DOM_VK_XF86XK_MUSIC\",\n    \"DOM_VK_XF86XK_MY_COMPUTER\",\n    \"DOM_VK_XF86XK_MY_SITES\",\n    \"DOM_VK_XF86XK_NEW\",\n    \"DOM_VK_XF86XK_NEWS\",\n    \"DOM_VK_XF86XK_OFFICE_HOME\",\n    \"DOM_VK_XF86XK_OPEN\",\n    \"DOM_VK_XF86XK_OPEN_URL\",\n    \"DOM_VK_XF86XK_OPTION\",\n    \"DOM_VK_XF86XK_PASTE\",\n    \"DOM_VK_XF86XK_PHONE\",\n    \"DOM_VK_XF86XK_PICTURES\",\n    \"DOM_VK_XF86XK_POWER_DOWN\",\n    \"DOM_VK_XF86XK_POWER_OFF\",\n    \"DOM_VK_XF86XK_RED\",\n    \"DOM_VK_XF86XK_REFRESH\",\n    \"DOM_VK_XF86XK_RELOAD\",\n    \"DOM_VK_XF86XK_REPLY\",\n    \"DOM_VK_XF86XK_ROCKER_DOWN\",\n    \"DOM_VK_XF86XK_ROCKER_ENTER\",\n    \"DOM_VK_XF86XK_ROCKER_UP\",\n    \"DOM_VK_XF86XK_ROTATE_WINDOWS\",\n    \"DOM_VK_XF86XK_ROTATION_KB\",\n    \"DOM_VK_XF86XK_ROTATION_PB\",\n    \"DOM_VK_XF86XK_SAVE\",\n    \"DOM_VK_XF86XK_SCREEN_SAVER\",\n    \"DOM_VK_XF86XK_SCROLL_CLICK\",\n    \"DOM_VK_XF86XK_SCROLL_DOWN\",\n    \"DOM_VK_XF86XK_SCROLL_UP\",\n    \"DOM_VK_XF86XK_SEARCH\",\n    \"DOM_VK_XF86XK_SEND\",\n    \"DOM_VK_XF86XK_SHOP\",\n    \"DOM_VK_XF86XK_SPELL\",\n    \"DOM_VK_XF86XK_SPLIT_SCREEN\",\n    \"DOM_VK_XF86XK_STANDBY\",\n    \"DOM_VK_XF86XK_START\",\n    \"DOM_VK_XF86XK_STOP\",\n    \"DOM_VK_XF86XK_SUBTITLE\",\n    \"DOM_VK_XF86XK_SUPPORT\",\n    \"DOM_VK_XF86XK_SUSPEND\",\n    \"DOM_VK_XF86XK_TASK_PANE\",\n    \"DOM_VK_XF86XK_TERMINAL\",\n    \"DOM_VK_XF86XK_TIME\",\n    \"DOM_VK_XF86XK_TOOLS\",\n    \"DOM_VK_XF86XK_TOP_MENU\",\n    \"DOM_VK_XF86XK_TO_DO_LIST\",\n    \"DOM_VK_XF86XK_TRAVEL\",\n    \"DOM_VK_XF86XK_USER1KB\",\n    \"DOM_VK_XF86XK_USER2KB\",\n    \"DOM_VK_XF86XK_USER_PB\",\n    \"DOM_VK_XF86XK_UWB\",\n    \"DOM_VK_XF86XK_VENDOR_HOME\",\n    \"DOM_VK_XF86XK_VIDEO\",\n    \"DOM_VK_XF86XK_VIEW\",\n    \"DOM_VK_XF86XK_WAKE_UP\",\n    \"DOM_VK_XF86XK_WEB_CAM\",\n    \"DOM_VK_XF86XK_WHEEL_BUTTON\",\n    \"DOM_VK_XF86XK_WLAN\",\n    \"DOM_VK_XF86XK_WORD\",\n    \"DOM_VK_XF86XK_WWW\",\n    \"DOM_VK_XF86XK_XFER\",\n    \"DOM_VK_XF86XK_YELLOW\",\n    \"DOM_VK_XF86XK_ZOOM_IN\",\n    \"DOM_VK_XF86XK_ZOOM_OUT\",\n    \"DOM_VK_Y\",\n    \"DOM_VK_Z\",\n    \"DOM_VK_ZOOM\",\n    \"DONE\",\n    \"DONT_CARE\",\n    \"DOWNLOADING\",\n    \"DRAGDROP\",\n    \"DST_ALPHA\",\n    \"DST_COLOR\",\n    \"DYNAMIC_DRAW\",\n    \"DataChannel\",\n    \"DataTransfer\",\n    \"DataTransferItem\",\n    \"DataTransferItemList\",\n    \"DataView\",\n    \"Date\",\n    \"DateTimeFormat\",\n    \"DelayNode\",\n    \"DesktopNotification\",\n    \"DesktopNotificationCenter\",\n    \"DeviceLightEvent\",\n    \"DeviceMotionEvent\",\n    \"DeviceOrientationEvent\",\n    \"DeviceProximityEvent\",\n    \"DeviceStorage\",\n    \"DeviceStorageChangeEvent\",\n    \"Document\",\n    \"DocumentFragment\",\n    \"DocumentType\",\n    \"DragEvent\",\n    \"DynamicsCompressorNode\",\n    \"E\",\n    \"ELEMENT_ARRAY_BUFFER\",\n    \"ELEMENT_ARRAY_BUFFER_BINDING\",\n    \"ELEMENT_NODE\",\n    \"EMPTY\",\n    \"ENCODING_ERR\",\n    \"ENDED\",\n    \"END_TO_END\",\n    \"END_TO_START\",\n    \"ENTITY_NODE\",\n    \"ENTITY_REFERENCE_NODE\",\n    \"EPSILON\",\n    \"EQUAL\",\n    \"EQUALPOWER\",\n    \"ERROR\",\n    \"EXPONENTIAL_DISTANCE\",\n    \"Element\",\n    \"ElementQuery\",\n    \"Entity\",\n    \"EntityReference\",\n    \"Error\",\n    \"ErrorEvent\",\n    \"EvalError\",\n    \"Event\",\n    \"EventException\",\n    \"EventSource\",\n    \"EventTarget\",\n    \"External\",\n    \"FASTEST\",\n    \"FIDOSDK\",\n    \"FILTER_ACCEPT\",\n    \"FILTER_INTERRUPT\",\n    \"FILTER_REJECT\",\n    \"FILTER_SKIP\",\n    \"FINISHED_STATE\",\n    \"FIRST_ORDERED_NODE_TYPE\",\n    \"FLOAT\",\n    \"FLOAT_MAT2\",\n    \"FLOAT_MAT3\",\n    \"FLOAT_MAT4\",\n    \"FLOAT_VEC2\",\n    \"FLOAT_VEC3\",\n    \"FLOAT_VEC4\",\n    \"FOCUS\",\n    \"FONT_FACE_RULE\",\n    \"FONT_FEATURE_VALUES_RULE\",\n    \"FRAGMENT_SHADER\",\n    \"FRAGMENT_SHADER_DERIVATIVE_HINT_OES\",\n    \"FRAMEBUFFER\",\n    \"FRAMEBUFFER_ATTACHMENT_OBJECT_NAME\",\n    \"FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE\",\n    \"FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE\",\n    \"FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL\",\n    \"FRAMEBUFFER_BINDING\",\n    \"FRAMEBUFFER_COMPLETE\",\n    \"FRAMEBUFFER_INCOMPLETE_ATTACHMENT\",\n    \"FRAMEBUFFER_INCOMPLETE_DIMENSIONS\",\n    \"FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\",\n    \"FRAMEBUFFER_UNSUPPORTED\",\n    \"FRONT\",\n    \"FRONT_AND_BACK\",\n    \"FRONT_FACE\",\n    \"FUNC_ADD\",\n    \"FUNC_REVERSE_SUBTRACT\",\n    \"FUNC_SUBTRACT\",\n    \"Feed\",\n    \"FeedEntry\",\n    \"File\",\n    \"FileError\",\n    \"FileList\",\n    \"FileReader\",\n    \"FindInPage\",\n    \"Float32Array\",\n    \"Float64Array\",\n    \"FocusEvent\",\n    \"FontFace\",\n    \"FormData\",\n    \"Function\",\n    \"GENERATE_MIPMAP_HINT\",\n    \"GEQUAL\",\n    \"GREATER\",\n    \"GREEN_BITS\",\n    \"GainNode\",\n    \"Gamepad\",\n    \"GamepadButton\",\n    \"GamepadEvent\",\n    \"GestureEvent\",\n    \"HAVE_CURRENT_DATA\",\n    \"HAVE_ENOUGH_DATA\",\n    \"HAVE_FUTURE_DATA\",\n    \"HAVE_METADATA\",\n    \"HAVE_NOTHING\",\n    \"HEADERS_RECEIVED\",\n    \"HIDDEN\",\n    \"HIERARCHY_REQUEST_ERR\",\n    \"HIGHPASS\",\n    \"HIGHSHELF\",\n    \"HIGH_FLOAT\",\n    \"HIGH_INT\",\n    \"HORIZONTAL\",\n    \"HORIZONTAL_AXIS\",\n    \"HRTF\",\n    \"HTMLAllCollection\",\n    \"HTMLAnchorElement\",\n    \"HTMLAppletElement\",\n    \"HTMLAreaElement\",\n    \"HTMLAudioElement\",\n    \"HTMLBRElement\",\n    \"HTMLBaseElement\",\n    \"HTMLBaseFontElement\",\n    \"HTMLBlockquoteElement\",\n    \"HTMLBodyElement\",\n    \"HTMLButtonElement\",\n    \"HTMLCanvasElement\",\n    \"HTMLCollection\",\n    \"HTMLCommandElement\",\n    \"HTMLContentElement\",\n    \"HTMLDListElement\",\n    \"HTMLDataElement\",\n    \"HTMLDataListElement\",\n    \"HTMLDetailsElement\",\n    \"HTMLDialogElement\",\n    \"HTMLDirectoryElement\",\n    \"HTMLDivElement\",\n    \"HTMLDocument\",\n    \"HTMLElement\",\n    \"HTMLEmbedElement\",\n    \"HTMLFieldSetElement\",\n    \"HTMLFontElement\",\n    \"HTMLFormControlsCollection\",\n    \"HTMLFormElement\",\n    \"HTMLFrameElement\",\n    \"HTMLFrameSetElement\",\n    \"HTMLHRElement\",\n    \"HTMLHeadElement\",\n    \"HTMLHeadingElement\",\n    \"HTMLHtmlElement\",\n    \"HTMLIFrameElement\",\n    \"HTMLImageElement\",\n    \"HTMLInputElement\",\n    \"HTMLIsIndexElement\",\n    \"HTMLKeygenElement\",\n    \"HTMLLIElement\",\n    \"HTMLLabelElement\",\n    \"HTMLLegendElement\",\n    \"HTMLLinkElement\",\n    \"HTMLMapElement\",\n    \"HTMLMarqueeElement\",\n    \"HTMLMediaElement\",\n    \"HTMLMenuElement\",\n    \"HTMLMenuItemElement\",\n    \"HTMLMetaElement\",\n    \"HTMLMeterElement\",\n    \"HTMLModElement\",\n    \"HTMLOListElement\",\n    \"HTMLObjectElement\",\n    \"HTMLOptGroupElement\",\n    \"HTMLOptionElement\",\n    \"HTMLOptionsCollection\",\n    \"HTMLOutputElement\",\n    \"HTMLParagraphElement\",\n    \"HTMLParamElement\",\n    \"HTMLPictureElement\",\n    \"HTMLPreElement\",\n    \"HTMLProgressElement\",\n    \"HTMLPropertiesCollection\",\n    \"HTMLQuoteElement\",\n    \"HTMLScriptElement\",\n    \"HTMLSelectElement\",\n    \"HTMLShadowElement\",\n    \"HTMLSourceElement\",\n    \"HTMLSpanElement\",\n    \"HTMLStyleElement\",\n    \"HTMLTableCaptionElement\",\n    \"HTMLTableCellElement\",\n    \"HTMLTableColElement\",\n    \"HTMLTableElement\",\n    \"HTMLTableRowElement\",\n    \"HTMLTableSectionElement\",\n    \"HTMLTemplateElement\",\n    \"HTMLTextAreaElement\",\n    \"HTMLTimeElement\",\n    \"HTMLTitleElement\",\n    \"HTMLTrackElement\",\n    \"HTMLUListElement\",\n    \"HTMLUnknownElement\",\n    \"HTMLVideoElement\",\n    \"HashChangeEvent\",\n    \"Headers\",\n    \"History\",\n    \"ICE_CHECKING\",\n    \"ICE_CLOSED\",\n    \"ICE_COMPLETED\",\n    \"ICE_CONNECTED\",\n    \"ICE_FAILED\",\n    \"ICE_GATHERING\",\n    \"ICE_WAITING\",\n    \"IDBCursor\",\n    \"IDBCursorWithValue\",\n    \"IDBDatabase\",\n    \"IDBDatabaseException\",\n    \"IDBFactory\",\n    \"IDBFileHandle\",\n    \"IDBFileRequest\",\n    \"IDBIndex\",\n    \"IDBKeyRange\",\n    \"IDBMutableFile\",\n    \"IDBObjectStore\",\n    \"IDBOpenDBRequest\",\n    \"IDBRequest\",\n    \"IDBTransaction\",\n    \"IDBVersionChangeEvent\",\n    \"IDLE\",\n    \"IMPLEMENTATION_COLOR_READ_FORMAT\",\n    \"IMPLEMENTATION_COLOR_READ_TYPE\",\n    \"IMPORT_RULE\",\n    \"INCR\",\n    \"INCR_WRAP\",\n    \"INDEX_SIZE_ERR\",\n    \"INT\",\n    \"INT_VEC2\",\n    \"INT_VEC3\",\n    \"INT_VEC4\",\n    \"INUSE_ATTRIBUTE_ERR\",\n    \"INVALID_ACCESS_ERR\",\n    \"INVALID_CHARACTER_ERR\",\n    \"INVALID_ENUM\",\n    \"INVALID_EXPRESSION_ERR\",\n    \"INVALID_FRAMEBUFFER_OPERATION\",\n    \"INVALID_MODIFICATION_ERR\",\n    \"INVALID_NODE_TYPE_ERR\",\n    \"INVALID_OPERATION\",\n    \"INVALID_STATE_ERR\",\n    \"INVALID_VALUE\",\n    \"INVERSE_DISTANCE\",\n    \"INVERT\",\n    \"IceCandidate\",\n    \"Image\",\n    \"ImageBitmap\",\n    \"ImageData\",\n    \"Infinity\",\n    \"InputEvent\",\n    \"InputMethodContext\",\n    \"InstallTrigger\",\n    \"Int16Array\",\n    \"Int32Array\",\n    \"Int8Array\",\n    \"Intent\",\n    \"InternalError\",\n    \"Intl\",\n    \"IsSearchProviderInstalled\",\n    \"Iterator\",\n    \"JSON\",\n    \"KEEP\",\n    \"KEYDOWN\",\n    \"KEYFRAMES_RULE\",\n    \"KEYFRAME_RULE\",\n    \"KEYPRESS\",\n    \"KEYUP\",\n    \"KeyEvent\",\n    \"KeyboardEvent\",\n    \"LENGTHADJUST_SPACING\",\n    \"LENGTHADJUST_SPACINGANDGLYPHS\",\n    \"LENGTHADJUST_UNKNOWN\",\n    \"LEQUAL\",\n    \"LESS\",\n    \"LINEAR\",\n    \"LINEAR_DISTANCE\",\n    \"LINEAR_MIPMAP_LINEAR\",\n    \"LINEAR_MIPMAP_NEAREST\",\n    \"LINES\",\n    \"LINE_LOOP\",\n    \"LINE_STRIP\",\n    \"LINE_WIDTH\",\n    \"LINK_STATUS\",\n    \"LIVE\",\n    \"LN10\",\n    \"LN2\",\n    \"LOADED\",\n    \"LOADING\",\n    \"LOG10E\",\n    \"LOG2E\",\n    \"LOWPASS\",\n    \"LOWSHELF\",\n    \"LOW_FLOAT\",\n    \"LOW_INT\",\n    \"LSException\",\n    \"LSParserFilter\",\n    \"LUMINANCE\",\n    \"LUMINANCE_ALPHA\",\n    \"LocalMediaStream\",\n    \"Location\",\n    \"MAX_COMBINED_TEXTURE_IMAGE_UNITS\",\n    \"MAX_CUBE_MAP_TEXTURE_SIZE\",\n    \"MAX_FRAGMENT_UNIFORM_VECTORS\",\n    \"MAX_RENDERBUFFER_SIZE\",\n    \"MAX_SAFE_INTEGER\",\n    \"MAX_TEXTURE_IMAGE_UNITS\",\n    \"MAX_TEXTURE_MAX_ANISOTROPY_EXT\",\n    \"MAX_TEXTURE_SIZE\",\n    \"MAX_VALUE\",\n    \"MAX_VARYING_VECTORS\",\n    \"MAX_VERTEX_ATTRIBS\",\n    \"MAX_VERTEX_TEXTURE_IMAGE_UNITS\",\n    \"MAX_VERTEX_UNIFORM_VECTORS\",\n    \"MAX_VIEWPORT_DIMS\",\n    \"MEDIA_ERR_ABORTED\",\n    \"MEDIA_ERR_DECODE\",\n    \"MEDIA_ERR_ENCRYPTED\",\n    \"MEDIA_ERR_NETWORK\",\n    \"MEDIA_ERR_SRC_NOT_SUPPORTED\",\n    \"MEDIA_KEYERR_CLIENT\",\n    \"MEDIA_KEYERR_DOMAIN\",\n    \"MEDIA_KEYERR_HARDWARECHANGE\",\n    \"MEDIA_KEYERR_OUTPUT\",\n    \"MEDIA_KEYERR_SERVICE\",\n    \"MEDIA_KEYERR_UNKNOWN\",\n    \"MEDIA_RULE\",\n    \"MEDIUM_FLOAT\",\n    \"MEDIUM_INT\",\n    \"META_MASK\",\n    \"MIN_SAFE_INTEGER\",\n    \"MIN_VALUE\",\n    \"MIRRORED_REPEAT\",\n    \"MODE_ASYNCHRONOUS\",\n    \"MODE_SYNCHRONOUS\",\n    \"MODIFICATION\",\n    \"MOUSEDOWN\",\n    \"MOUSEDRAG\",\n    \"MOUSEMOVE\",\n    \"MOUSEOUT\",\n    \"MOUSEOVER\",\n    \"MOUSEUP\",\n    \"MOZ_KEYFRAMES_RULE\",\n    \"MOZ_KEYFRAME_RULE\",\n    \"MOZ_SOURCE_CURSOR\",\n    \"MOZ_SOURCE_ERASER\",\n    \"MOZ_SOURCE_KEYBOARD\",\n    \"MOZ_SOURCE_MOUSE\",\n    \"MOZ_SOURCE_PEN\",\n    \"MOZ_SOURCE_TOUCH\",\n    \"MOZ_SOURCE_UNKNOWN\",\n    \"MSGESTURE_FLAG_BEGIN\",\n    \"MSGESTURE_FLAG_CANCEL\",\n    \"MSGESTURE_FLAG_END\",\n    \"MSGESTURE_FLAG_INERTIA\",\n    \"MSGESTURE_FLAG_NONE\",\n    \"MSPOINTER_TYPE_MOUSE\",\n    \"MSPOINTER_TYPE_PEN\",\n    \"MSPOINTER_TYPE_TOUCH\",\n    \"MS_ASYNC_CALLBACK_STATUS_ASSIGN_DELEGATE\",\n    \"MS_ASYNC_CALLBACK_STATUS_CANCEL\",\n    \"MS_ASYNC_CALLBACK_STATUS_CHOOSEANY\",\n    \"MS_ASYNC_CALLBACK_STATUS_ERROR\",\n    \"MS_ASYNC_CALLBACK_STATUS_JOIN\",\n    \"MS_ASYNC_OP_STATUS_CANCELED\",\n    \"MS_ASYNC_OP_STATUS_ERROR\",\n    \"MS_ASYNC_OP_STATUS_SUCCESS\",\n    \"MS_MANIPULATION_STATE_ACTIVE\",\n    \"MS_MANIPULATION_STATE_CANCELLED\",\n    \"MS_MANIPULATION_STATE_COMMITTED\",\n    \"MS_MANIPULATION_STATE_DRAGGING\",\n    \"MS_MANIPULATION_STATE_INERTIA\",\n    \"MS_MANIPULATION_STATE_PRESELECT\",\n    \"MS_MANIPULATION_STATE_SELECTING\",\n    \"MS_MANIPULATION_STATE_STOPPED\",\n    \"MS_MEDIA_ERR_ENCRYPTED\",\n    \"MS_MEDIA_KEYERR_CLIENT\",\n    \"MS_MEDIA_KEYERR_DOMAIN\",\n    \"MS_MEDIA_KEYERR_HARDWARECHANGE\",\n    \"MS_MEDIA_KEYERR_OUTPUT\",\n    \"MS_MEDIA_KEYERR_SERVICE\",\n    \"MS_MEDIA_KEYERR_UNKNOWN\",\n    \"Map\",\n    \"Math\",\n    \"MediaController\",\n    \"MediaDevices\",\n    \"MediaElementAudioSourceNode\",\n    \"MediaEncryptedEvent\",\n    \"MediaError\",\n    \"MediaKeyError\",\n    \"MediaKeyEvent\",\n    \"MediaKeyMessageEvent\",\n    \"MediaKeyNeededEvent\",\n    \"MediaKeySession\",\n    \"MediaKeyStatusMap\",\n    \"MediaKeySystemAccess\",\n    \"MediaKeys\",\n    \"MediaList\",\n    \"MediaQueryList\",\n    \"MediaQueryListEvent\",\n    \"MediaRecorder\",\n    \"MediaSource\",\n    \"MediaStream\",\n    \"MediaStreamAudioDestinationNode\",\n    \"MediaStreamAudioSourceNode\",\n    \"MediaStreamEvent\",\n    \"MediaStreamTrack\",\n    \"MediaStreamTrackEvent\",\n    \"MessageChannel\",\n    \"MessageEvent\",\n    \"MessagePort\",\n    \"Methods\",\n    \"MimeType\",\n    \"MimeTypeArray\",\n    \"MouseEvent\",\n    \"MouseScrollEvent\",\n    \"MozAnimation\",\n    \"MozAnimationDelay\",\n    \"MozAnimationDirection\",\n    \"MozAnimationDuration\",\n    \"MozAnimationFillMode\",\n    \"MozAnimationIterationCount\",\n    \"MozAnimationName\",\n    \"MozAnimationPlayState\",\n    \"MozAnimationTimingFunction\",\n    \"MozAppearance\",\n    \"MozBackfaceVisibility\",\n    \"MozBinding\",\n    \"MozBorderBottomColors\",\n    \"MozBorderEnd\",\n    \"MozBorderEndColor\",\n    \"MozBorderEndStyle\",\n    \"MozBorderEndWidth\",\n    \"MozBorderImage\",\n    \"MozBorderLeftColors\",\n    \"MozBorderRightColors\",\n    \"MozBorderStart\",\n    \"MozBorderStartColor\",\n    \"MozBorderStartStyle\",\n    \"MozBorderStartWidth\",\n    \"MozBorderTopColors\",\n    \"MozBoxAlign\",\n    \"MozBoxDirection\",\n    \"MozBoxFlex\",\n    \"MozBoxOrdinalGroup\",\n    \"MozBoxOrient\",\n    \"MozBoxPack\",\n    \"MozBoxSizing\",\n    \"MozCSSKeyframeRule\",\n    \"MozCSSKeyframesRule\",\n    \"MozColumnCount\",\n    \"MozColumnFill\",\n    \"MozColumnGap\",\n    \"MozColumnRule\",\n    \"MozColumnRuleColor\",\n    \"MozColumnRuleStyle\",\n    \"MozColumnRuleWidth\",\n    \"MozColumnWidth\",\n    \"MozColumns\",\n    \"MozContactChangeEvent\",\n    \"MozFloatEdge\",\n    \"MozFontFeatureSettings\",\n    \"MozFontLanguageOverride\",\n    \"MozForceBrokenImageIcon\",\n    \"MozHyphens\",\n    \"MozImageRegion\",\n    \"MozMarginEnd\",\n    \"MozMarginStart\",\n    \"MozMmsEvent\",\n    \"MozMmsMessage\",\n    \"MozMobileMessageThread\",\n    \"MozOSXFontSmoothing\",\n    \"MozOrient\",\n    \"MozOutlineRadius\",\n    \"MozOutlineRadiusBottomleft\",\n    \"MozOutlineRadiusBottomright\",\n    \"MozOutlineRadiusTopleft\",\n    \"MozOutlineRadiusTopright\",\n    \"MozPaddingEnd\",\n    \"MozPaddingStart\",\n    \"MozPerspective\",\n    \"MozPerspectiveOrigin\",\n    \"MozPowerManager\",\n    \"MozSettingsEvent\",\n    \"MozSmsEvent\",\n    \"MozSmsMessage\",\n    \"MozStackSizing\",\n    \"MozTabSize\",\n    \"MozTextAlignLast\",\n    \"MozTextDecorationColor\",\n    \"MozTextDecorationLine\",\n    \"MozTextDecorationStyle\",\n    \"MozTextSizeAdjust\",\n    \"MozTransform\",\n    \"MozTransformOrigin\",\n    \"MozTransformStyle\",\n    \"MozTransition\",\n    \"MozTransitionDelay\",\n    \"MozTransitionDuration\",\n    \"MozTransitionProperty\",\n    \"MozTransitionTimingFunction\",\n    \"MozUserFocus\",\n    \"MozUserInput\",\n    \"MozUserModify\",\n    \"MozUserSelect\",\n    \"MozWindowDragging\",\n    \"MozWindowShadow\",\n    \"MutationEvent\",\n    \"MutationObserver\",\n    \"MutationRecord\",\n    \"NAMESPACE_ERR\",\n    \"NAMESPACE_RULE\",\n    \"NEAREST\",\n    \"NEAREST_MIPMAP_LINEAR\",\n    \"NEAREST_MIPMAP_NEAREST\",\n    \"NEGATIVE_INFINITY\",\n    \"NETWORK_EMPTY\",\n    \"NETWORK_ERR\",\n    \"NETWORK_IDLE\",\n    \"NETWORK_LOADED\",\n    \"NETWORK_LOADING\",\n    \"NETWORK_NO_SOURCE\",\n    \"NEVER\",\n    \"NEW\",\n    \"NEXT\",\n    \"NEXT_NO_DUPLICATE\",\n    \"NICEST\",\n    \"NODE_AFTER\",\n    \"NODE_BEFORE\",\n    \"NODE_BEFORE_AND_AFTER\",\n    \"NODE_INSIDE\",\n    \"NONE\",\n    \"NON_TRANSIENT_ERR\",\n    \"NOTATION_NODE\",\n    \"NOTCH\",\n    \"NOTEQUAL\",\n    \"NOT_ALLOWED_ERR\",\n    \"NOT_FOUND_ERR\",\n    \"NOT_READABLE_ERR\",\n    \"NOT_SUPPORTED_ERR\",\n    \"NO_DATA_ALLOWED_ERR\",\n    \"NO_ERR\",\n    \"NO_ERROR\",\n    \"NO_MODIFICATION_ALLOWED_ERR\",\n    \"NUMBER_TYPE\",\n    \"NUM_COMPRESSED_TEXTURE_FORMATS\",\n    \"NaN\",\n    \"NamedNodeMap\",\n    \"Navigator\",\n    \"NearbyLinks\",\n    \"NetworkInformation\",\n    \"Node\",\n    \"NodeFilter\",\n    \"NodeIterator\",\n    \"NodeList\",\n    \"Notation\",\n    \"Notification\",\n    \"NotifyPaintEvent\",\n    \"Number\",\n    \"NumberFormat\",\n    \"OBSOLETE\",\n    \"ONE\",\n    \"ONE_MINUS_CONSTANT_ALPHA\",\n    \"ONE_MINUS_CONSTANT_COLOR\",\n    \"ONE_MINUS_DST_ALPHA\",\n    \"ONE_MINUS_DST_COLOR\",\n    \"ONE_MINUS_SRC_ALPHA\",\n    \"ONE_MINUS_SRC_COLOR\",\n    \"OPEN\",\n    \"OPENED\",\n    \"OPENING\",\n    \"ORDERED_NODE_ITERATOR_TYPE\",\n    \"ORDERED_NODE_SNAPSHOT_TYPE\",\n    \"OUT_OF_MEMORY\",\n    \"Object\",\n    \"OfflineAudioCompletionEvent\",\n    \"OfflineAudioContext\",\n    \"OfflineResourceList\",\n    \"Option\",\n    \"OscillatorNode\",\n    \"OverflowEvent\",\n    \"PACK_ALIGNMENT\",\n    \"PAGE_RULE\",\n    \"PARSE_ERR\",\n    \"PATHSEG_ARC_ABS\",\n    \"PATHSEG_ARC_REL\",\n    \"PATHSEG_CLOSEPATH\",\n    \"PATHSEG_CURVETO_CUBIC_ABS\",\n    \"PATHSEG_CURVETO_CUBIC_REL\",\n    \"PATHSEG_CURVETO_CUBIC_SMOOTH_ABS\",\n    \"PATHSEG_CURVETO_CUBIC_SMOOTH_REL\",\n    \"PATHSEG_CURVETO_QUADRATIC_ABS\",\n    \"PATHSEG_CURVETO_QUADRATIC_REL\",\n    \"PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS\",\n    \"PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL\",\n    \"PATHSEG_LINETO_ABS\",\n    \"PATHSEG_LINETO_HORIZONTAL_ABS\",\n    \"PATHSEG_LINETO_HORIZONTAL_REL\",\n    \"PATHSEG_LINETO_REL\",\n    \"PATHSEG_LINETO_VERTICAL_ABS\",\n    \"PATHSEG_LINETO_VERTICAL_REL\",\n    \"PATHSEG_MOVETO_ABS\",\n    \"PATHSEG_MOVETO_REL\",\n    \"PATHSEG_UNKNOWN\",\n    \"PATH_EXISTS_ERR\",\n    \"PEAKING\",\n    \"PERMISSION_DENIED\",\n    \"PERSISTENT\",\n    \"PI\",\n    \"PLAYING_STATE\",\n    \"POINTS\",\n    \"POLYGON_OFFSET_FACTOR\",\n    \"POLYGON_OFFSET_FILL\",\n    \"POLYGON_OFFSET_UNITS\",\n    \"POSITION_UNAVAILABLE\",\n    \"POSITIVE_INFINITY\",\n    \"PREV\",\n    \"PREV_NO_DUPLICATE\",\n    \"PROCESSING_INSTRUCTION_NODE\",\n    \"PageChangeEvent\",\n    \"PageTransitionEvent\",\n    \"PaintRequest\",\n    \"PaintRequestList\",\n    \"PannerNode\",\n    \"Path2D\",\n    \"Performance\",\n    \"PerformanceEntry\",\n    \"PerformanceMark\",\n    \"PerformanceMeasure\",\n    \"PerformanceNavigation\",\n    \"PerformanceResourceTiming\",\n    \"PerformanceTiming\",\n    \"PeriodicWave\",\n    \"Plugin\",\n    \"PluginArray\",\n    \"PopStateEvent\",\n    \"PopupBlockedEvent\",\n    \"ProcessingInstruction\",\n    \"ProgressEvent\",\n    \"Promise\",\n    \"PropertyNodeList\",\n    \"Proxy\",\n    \"PushManager\",\n    \"PushSubscription\",\n    \"Q\",\n    \"QUOTA_ERR\",\n    \"QUOTA_EXCEEDED_ERR\",\n    \"QueryInterface\",\n    \"READ_ONLY\",\n    \"READ_ONLY_ERR\",\n    \"READ_WRITE\",\n    \"RED_BITS\",\n    \"REMOVAL\",\n    \"RENDERBUFFER\",\n    \"RENDERBUFFER_ALPHA_SIZE\",\n    \"RENDERBUFFER_BINDING\",\n    \"RENDERBUFFER_BLUE_SIZE\",\n    \"RENDERBUFFER_DEPTH_SIZE\",\n    \"RENDERBUFFER_GREEN_SIZE\",\n    \"RENDERBUFFER_HEIGHT\",\n    \"RENDERBUFFER_INTERNAL_FORMAT\",\n    \"RENDERBUFFER_RED_SIZE\",\n    \"RENDERBUFFER_STENCIL_SIZE\",\n    \"RENDERBUFFER_WIDTH\",\n    \"RENDERER\",\n    \"RENDERING_INTENT_ABSOLUTE_COLORIMETRIC\",\n    \"RENDERING_INTENT_AUTO\",\n    \"RENDERING_INTENT_PERCEPTUAL\",\n    \"RENDERING_INTENT_RELATIVE_COLORIMETRIC\",\n    \"RENDERING_INTENT_SATURATION\",\n    \"RENDERING_INTENT_UNKNOWN\",\n    \"REPEAT\",\n    \"REPLACE\",\n    \"RGB\",\n    \"RGB565\",\n    \"RGB5_A1\",\n    \"RGBA\",\n    \"RGBA4\",\n    \"RGBColor\",\n    \"ROTATION_CLOCKWISE\",\n    \"ROTATION_COUNTERCLOCKWISE\",\n    \"RTCDataChannelEvent\",\n    \"RTCIceCandidate\",\n    \"RTCPeerConnectionIceEvent\",\n    \"RTCRtpReceiver\",\n    \"RTCRtpSender\",\n    \"RTCSessionDescription\",\n    \"RTCStatsReport\",\n    \"RadioNodeList\",\n    \"Range\",\n    \"RangeError\",\n    \"RangeException\",\n    \"RecordErrorEvent\",\n    \"Rect\",\n    \"ReferenceError\",\n    \"RegExp\",\n    \"Request\",\n    \"Response\",\n    \"SAMPLER_2D\",\n    \"SAMPLER_CUBE\",\n    \"SAMPLES\",\n    \"SAMPLE_ALPHA_TO_COVERAGE\",\n    \"SAMPLE_BUFFERS\",\n    \"SAMPLE_COVERAGE\",\n    \"SAMPLE_COVERAGE_INVERT\",\n    \"SAMPLE_COVERAGE_VALUE\",\n    \"SAWTOOTH\",\n    \"SCHEDULED_STATE\",\n    \"SCISSOR_BOX\",\n    \"SCISSOR_TEST\",\n    \"SCROLL_PAGE_DOWN\",\n    \"SCROLL_PAGE_UP\",\n    \"SDP_ANSWER\",\n    \"SDP_OFFER\",\n    \"SDP_PRANSWER\",\n    \"SECURITY_ERR\",\n    \"SELECT\",\n    \"SERIALIZE_ERR\",\n    \"SEVERITY_ERROR\",\n    \"SEVERITY_FATAL_ERROR\",\n    \"SEVERITY_WARNING\",\n    \"SHADER_COMPILER\",\n    \"SHADER_TYPE\",\n    \"SHADING_LANGUAGE_VERSION\",\n    \"SHIFT_MASK\",\n    \"SHORT\",\n    \"SHOWING\",\n    \"SHOW_ALL\",\n    \"SHOW_ATTRIBUTE\",\n    \"SHOW_CDATA_SECTION\",\n    \"SHOW_COMMENT\",\n    \"SHOW_DOCUMENT\",\n    \"SHOW_DOCUMENT_FRAGMENT\",\n    \"SHOW_DOCUMENT_TYPE\",\n    \"SHOW_ELEMENT\",\n    \"SHOW_ENTITY\",\n    \"SHOW_ENTITY_REFERENCE\",\n    \"SHOW_NOTATION\",\n    \"SHOW_PROCESSING_INSTRUCTION\",\n    \"SHOW_TEXT\",\n    \"SINE\",\n    \"SOUNDFIELD\",\n    \"SQLException\",\n    \"SQRT1_2\",\n    \"SQRT2\",\n    \"SQUARE\",\n    \"SRC_ALPHA\",\n    \"SRC_ALPHA_SATURATE\",\n    \"SRC_COLOR\",\n    \"START_TO_END\",\n    \"START_TO_START\",\n    \"STATIC_DRAW\",\n    \"STENCIL_ATTACHMENT\",\n    \"STENCIL_BACK_FAIL\",\n    \"STENCIL_BACK_FUNC\",\n    \"STENCIL_BACK_PASS_DEPTH_FAIL\",\n    \"STENCIL_BACK_PASS_DEPTH_PASS\",\n    \"STENCIL_BACK_REF\",\n    \"STENCIL_BACK_VALUE_MASK\",\n    \"STENCIL_BACK_WRITEMASK\",\n    \"STENCIL_BITS\",\n    \"STENCIL_BUFFER_BIT\",\n    \"STENCIL_CLEAR_VALUE\",\n    \"STENCIL_FAIL\",\n    \"STENCIL_FUNC\",\n    \"STENCIL_INDEX\",\n    \"STENCIL_INDEX8\",\n    \"STENCIL_PASS_DEPTH_FAIL\",\n    \"STENCIL_PASS_DEPTH_PASS\",\n    \"STENCIL_REF\",\n    \"STENCIL_TEST\",\n    \"STENCIL_VALUE_MASK\",\n    \"STENCIL_WRITEMASK\",\n    \"STREAM_DRAW\",\n    \"STRING_TYPE\",\n    \"STYLE_RULE\",\n    \"SUBPIXEL_BITS\",\n    \"SUPPORTS_RULE\",\n    \"SVGAElement\",\n    \"SVGAltGlyphDefElement\",\n    \"SVGAltGlyphElement\",\n    \"SVGAltGlyphItemElement\",\n    \"SVGAngle\",\n    \"SVGAnimateColorElement\",\n    \"SVGAnimateElement\",\n    \"SVGAnimateMotionElement\",\n    \"SVGAnimateTransformElement\",\n    \"SVGAnimatedAngle\",\n    \"SVGAnimatedBoolean\",\n    \"SVGAnimatedEnumeration\",\n    \"SVGAnimatedInteger\",\n    \"SVGAnimatedLength\",\n    \"SVGAnimatedLengthList\",\n    \"SVGAnimatedNumber\",\n    \"SVGAnimatedNumberList\",\n    \"SVGAnimatedPreserveAspectRatio\",\n    \"SVGAnimatedRect\",\n    \"SVGAnimatedString\",\n    \"SVGAnimatedTransformList\",\n    \"SVGAnimationElement\",\n    \"SVGCircleElement\",\n    \"SVGClipPathElement\",\n    \"SVGColor\",\n    \"SVGComponentTransferFunctionElement\",\n    \"SVGCursorElement\",\n    \"SVGDefsElement\",\n    \"SVGDescElement\",\n    \"SVGDiscardElement\",\n    \"SVGDocument\",\n    \"SVGElement\",\n    \"SVGElementInstance\",\n    \"SVGElementInstanceList\",\n    \"SVGEllipseElement\",\n    \"SVGException\",\n    \"SVGFEBlendElement\",\n    \"SVGFEColorMatrixElement\",\n    \"SVGFEComponentTransferElement\",\n    \"SVGFECompositeElement\",\n    \"SVGFEConvolveMatrixElement\",\n    \"SVGFEDiffuseLightingElement\",\n    \"SVGFEDisplacementMapElement\",\n    \"SVGFEDistantLightElement\",\n    \"SVGFEDropShadowElement\",\n    \"SVGFEFloodElement\",\n    \"SVGFEFuncAElement\",\n    \"SVGFEFuncBElement\",\n    \"SVGFEFuncGElement\",\n    \"SVGFEFuncRElement\",\n    \"SVGFEGaussianBlurElement\",\n    \"SVGFEImageElement\",\n    \"SVGFEMergeElement\",\n    \"SVGFEMergeNodeElement\",\n    \"SVGFEMorphologyElement\",\n    \"SVGFEOffsetElement\",\n    \"SVGFEPointLightElement\",\n    \"SVGFESpecularLightingElement\",\n    \"SVGFESpotLightElement\",\n    \"SVGFETileElement\",\n    \"SVGFETurbulenceElement\",\n    \"SVGFilterElement\",\n    \"SVGFontElement\",\n    \"SVGFontFaceElement\",\n    \"SVGFontFaceFormatElement\",\n    \"SVGFontFaceNameElement\",\n    \"SVGFontFaceSrcElement\",\n    \"SVGFontFaceUriElement\",\n    \"SVGForeignObjectElement\",\n    \"SVGGElement\",\n    \"SVGGeometryElement\",\n    \"SVGGlyphElement\",\n    \"SVGGlyphRefElement\",\n    \"SVGGradientElement\",\n    \"SVGGraphicsElement\",\n    \"SVGHKernElement\",\n    \"SVGImageElement\",\n    \"SVGLength\",\n    \"SVGLengthList\",\n    \"SVGLineElement\",\n    \"SVGLinearGradientElement\",\n    \"SVGMPathElement\",\n    \"SVGMarkerElement\",\n    \"SVGMaskElement\",\n    \"SVGMatrix\",\n    \"SVGMetadataElement\",\n    \"SVGMissingGlyphElement\",\n    \"SVGNumber\",\n    \"SVGNumberList\",\n    \"SVGPaint\",\n    \"SVGPathElement\",\n    \"SVGPathSeg\",\n    \"SVGPathSegArcAbs\",\n    \"SVGPathSegArcRel\",\n    \"SVGPathSegClosePath\",\n    \"SVGPathSegCurvetoCubicAbs\",\n    \"SVGPathSegCurvetoCubicRel\",\n    \"SVGPathSegCurvetoCubicSmoothAbs\",\n    \"SVGPathSegCurvetoCubicSmoothRel\",\n    \"SVGPathSegCurvetoQuadraticAbs\",\n    \"SVGPathSegCurvetoQuadraticRel\",\n    \"SVGPathSegCurvetoQuadraticSmoothAbs\",\n    \"SVGPathSegCurvetoQuadraticSmoothRel\",\n    \"SVGPathSegLinetoAbs\",\n    \"SVGPathSegLinetoHorizontalAbs\",\n    \"SVGPathSegLinetoHorizontalRel\",\n    \"SVGPathSegLinetoRel\",\n    \"SVGPathSegLinetoVerticalAbs\",\n    \"SVGPathSegLinetoVerticalRel\",\n    \"SVGPathSegList\",\n    \"SVGPathSegMovetoAbs\",\n    \"SVGPathSegMovetoRel\",\n    \"SVGPatternElement\",\n    \"SVGPoint\",\n    \"SVGPointList\",\n    \"SVGPolygonElement\",\n    \"SVGPolylineElement\",\n    \"SVGPreserveAspectRatio\",\n    \"SVGRadialGradientElement\",\n    \"SVGRect\",\n    \"SVGRectElement\",\n    \"SVGRenderingIntent\",\n    \"SVGSVGElement\",\n    \"SVGScriptElement\",\n    \"SVGSetElement\",\n    \"SVGStopElement\",\n    \"SVGStringList\",\n    \"SVGStyleElement\",\n    \"SVGSwitchElement\",\n    \"SVGSymbolElement\",\n    \"SVGTRefElement\",\n    \"SVGTSpanElement\",\n    \"SVGTextContentElement\",\n    \"SVGTextElement\",\n    \"SVGTextPathElement\",\n    \"SVGTextPositioningElement\",\n    \"SVGTitleElement\",\n    \"SVGTransform\",\n    \"SVGTransformList\",\n    \"SVGUnitTypes\",\n    \"SVGUseElement\",\n    \"SVGVKernElement\",\n    \"SVGViewElement\",\n    \"SVGViewSpec\",\n    \"SVGZoomAndPan\",\n    \"SVGZoomEvent\",\n    \"SVG_ANGLETYPE_DEG\",\n    \"SVG_ANGLETYPE_GRAD\",\n    \"SVG_ANGLETYPE_RAD\",\n    \"SVG_ANGLETYPE_UNKNOWN\",\n    \"SVG_ANGLETYPE_UNSPECIFIED\",\n    \"SVG_CHANNEL_A\",\n    \"SVG_CHANNEL_B\",\n    \"SVG_CHANNEL_G\",\n    \"SVG_CHANNEL_R\",\n    \"SVG_CHANNEL_UNKNOWN\",\n    \"SVG_COLORTYPE_CURRENTCOLOR\",\n    \"SVG_COLORTYPE_RGBCOLOR\",\n    \"SVG_COLORTYPE_RGBCOLOR_ICCCOLOR\",\n    \"SVG_COLORTYPE_UNKNOWN\",\n    \"SVG_EDGEMODE_DUPLICATE\",\n    \"SVG_EDGEMODE_NONE\",\n    \"SVG_EDGEMODE_UNKNOWN\",\n    \"SVG_EDGEMODE_WRAP\",\n    \"SVG_FEBLEND_MODE_COLOR\",\n    \"SVG_FEBLEND_MODE_COLOR_BURN\",\n    \"SVG_FEBLEND_MODE_COLOR_DODGE\",\n    \"SVG_FEBLEND_MODE_DARKEN\",\n    \"SVG_FEBLEND_MODE_DIFFERENCE\",\n    \"SVG_FEBLEND_MODE_EXCLUSION\",\n    \"SVG_FEBLEND_MODE_HARD_LIGHT\",\n    \"SVG_FEBLEND_MODE_HUE\",\n    \"SVG_FEBLEND_MODE_LIGHTEN\",\n    \"SVG_FEBLEND_MODE_LUMINOSITY\",\n    \"SVG_FEBLEND_MODE_MULTIPLY\",\n    \"SVG_FEBLEND_MODE_NORMAL\",\n    \"SVG_FEBLEND_MODE_OVERLAY\",\n    \"SVG_FEBLEND_MODE_SATURATION\",\n    \"SVG_FEBLEND_MODE_SCREEN\",\n    \"SVG_FEBLEND_MODE_SOFT_LIGHT\",\n    \"SVG_FEBLEND_MODE_UNKNOWN\",\n    \"SVG_FECOLORMATRIX_TYPE_HUEROTATE\",\n    \"SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA\",\n    \"SVG_FECOLORMATRIX_TYPE_MATRIX\",\n    \"SVG_FECOLORMATRIX_TYPE_SATURATE\",\n    \"SVG_FECOLORMATRIX_TYPE_UNKNOWN\",\n    \"SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE\",\n    \"SVG_FECOMPONENTTRANSFER_TYPE_GAMMA\",\n    \"SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY\",\n    \"SVG_FECOMPONENTTRANSFER_TYPE_LINEAR\",\n    \"SVG_FECOMPONENTTRANSFER_TYPE_TABLE\",\n    \"SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN\",\n    \"SVG_FECOMPOSITE_OPERATOR_ARITHMETIC\",\n    \"SVG_FECOMPOSITE_OPERATOR_ATOP\",\n    \"SVG_FECOMPOSITE_OPERATOR_IN\",\n    \"SVG_FECOMPOSITE_OPERATOR_OUT\",\n    \"SVG_FECOMPOSITE_OPERATOR_OVER\",\n    \"SVG_FECOMPOSITE_OPERATOR_UNKNOWN\",\n    \"SVG_FECOMPOSITE_OPERATOR_XOR\",\n    \"SVG_INVALID_VALUE_ERR\",\n    \"SVG_LENGTHTYPE_CM\",\n    \"SVG_LENGTHTYPE_EMS\",\n    \"SVG_LENGTHTYPE_EXS\",\n    \"SVG_LENGTHTYPE_IN\",\n    \"SVG_LENGTHTYPE_MM\",\n    \"SVG_LENGTHTYPE_NUMBER\",\n    \"SVG_LENGTHTYPE_PC\",\n    \"SVG_LENGTHTYPE_PERCENTAGE\",\n    \"SVG_LENGTHTYPE_PT\",\n    \"SVG_LENGTHTYPE_PX\",\n    \"SVG_LENGTHTYPE_UNKNOWN\",\n    \"SVG_MARKERUNITS_STROKEWIDTH\",\n    \"SVG_MARKERUNITS_UNKNOWN\",\n    \"SVG_MARKERUNITS_USERSPACEONUSE\",\n    \"SVG_MARKER_ORIENT_ANGLE\",\n    \"SVG_MARKER_ORIENT_AUTO\",\n    \"SVG_MARKER_ORIENT_UNKNOWN\",\n    \"SVG_MASKTYPE_ALPHA\",\n    \"SVG_MASKTYPE_LUMINANCE\",\n    \"SVG_MATRIX_NOT_INVERTABLE\",\n    \"SVG_MEETORSLICE_MEET\",\n    \"SVG_MEETORSLICE_SLICE\",\n    \"SVG_MEETORSLICE_UNKNOWN\",\n    \"SVG_MORPHOLOGY_OPERATOR_DILATE\",\n    \"SVG_MORPHOLOGY_OPERATOR_ERODE\",\n    \"SVG_MORPHOLOGY_OPERATOR_UNKNOWN\",\n    \"SVG_PAINTTYPE_CURRENTCOLOR\",\n    \"SVG_PAINTTYPE_NONE\",\n    \"SVG_PAINTTYPE_RGBCOLOR\",\n    \"SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR\",\n    \"SVG_PAINTTYPE_UNKNOWN\",\n    \"SVG_PAINTTYPE_URI\",\n    \"SVG_PAINTTYPE_URI_CURRENTCOLOR\",\n    \"SVG_PAINTTYPE_URI_NONE\",\n    \"SVG_PAINTTYPE_URI_RGBCOLOR\",\n    \"SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR\",\n    \"SVG_PRESERVEASPECTRATIO_NONE\",\n    \"SVG_PRESERVEASPECTRATIO_UNKNOWN\",\n    \"SVG_PRESERVEASPECTRATIO_XMAXYMAX\",\n    \"SVG_PRESERVEASPECTRATIO_XMAXYMID\",\n    \"SVG_PRESERVEASPECTRATIO_XMAXYMIN\",\n    \"SVG_PRESERVEASPECTRATIO_XMIDYMAX\",\n    \"SVG_PRESERVEASPECTRATIO_XMIDYMID\",\n    \"SVG_PRESERVEASPECTRATIO_XMIDYMIN\",\n    \"SVG_PRESERVEASPECTRATIO_XMINYMAX\",\n    \"SVG_PRESERVEASPECTRATIO_XMINYMID\",\n    \"SVG_PRESERVEASPECTRATIO_XMINYMIN\",\n    \"SVG_SPREADMETHOD_PAD\",\n    \"SVG_SPREADMETHOD_REFLECT\",\n    \"SVG_SPREADMETHOD_REPEAT\",\n    \"SVG_SPREADMETHOD_UNKNOWN\",\n    \"SVG_STITCHTYPE_NOSTITCH\",\n    \"SVG_STITCHTYPE_STITCH\",\n    \"SVG_STITCHTYPE_UNKNOWN\",\n    \"SVG_TRANSFORM_MATRIX\",\n    \"SVG_TRANSFORM_ROTATE\",\n    \"SVG_TRANSFORM_SCALE\",\n    \"SVG_TRANSFORM_SKEWX\",\n    \"SVG_TRANSFORM_SKEWY\",\n    \"SVG_TRANSFORM_TRANSLATE\",\n    \"SVG_TRANSFORM_UNKNOWN\",\n    \"SVG_TURBULENCE_TYPE_FRACTALNOISE\",\n    \"SVG_TURBULENCE_TYPE_TURBULENCE\",\n    \"SVG_TURBULENCE_TYPE_UNKNOWN\",\n    \"SVG_UNIT_TYPE_OBJECTBOUNDINGBOX\",\n    \"SVG_UNIT_TYPE_UNKNOWN\",\n    \"SVG_UNIT_TYPE_USERSPACEONUSE\",\n    \"SVG_WRONG_TYPE_ERR\",\n    \"SVG_ZOOMANDPAN_DISABLE\",\n    \"SVG_ZOOMANDPAN_MAGNIFY\",\n    \"SVG_ZOOMANDPAN_UNKNOWN\",\n    \"SYNTAX_ERR\",\n    \"SavedPages\",\n    \"Screen\",\n    \"ScreenOrientation\",\n    \"Script\",\n    \"ScriptProcessorNode\",\n    \"ScrollAreaEvent\",\n    \"SecurityPolicyViolationEvent\",\n    \"Selection\",\n    \"ServiceWorker\",\n    \"ServiceWorkerContainer\",\n    \"ServiceWorkerRegistration\",\n    \"SessionDescription\",\n    \"Set\",\n    \"ShadowRoot\",\n    \"SharedWorker\",\n    \"SimpleGestureEvent\",\n    \"SpeechSynthesisEvent\",\n    \"SpeechSynthesisUtterance\",\n    \"StopIteration\",\n    \"Storage\",\n    \"StorageEvent\",\n    \"String\",\n    \"StyleSheet\",\n    \"StyleSheetList\",\n    \"SubtleCrypto\",\n    \"Symbol\",\n    \"SyntaxError\",\n    \"TEMPORARY\",\n    \"TEXTPATH_METHODTYPE_ALIGN\",\n    \"TEXTPATH_METHODTYPE_STRETCH\",\n    \"TEXTPATH_METHODTYPE_UNKNOWN\",\n    \"TEXTPATH_SPACINGTYPE_AUTO\",\n    \"TEXTPATH_SPACINGTYPE_EXACT\",\n    \"TEXTPATH_SPACINGTYPE_UNKNOWN\",\n    \"TEXTURE\",\n    \"TEXTURE0\",\n    \"TEXTURE1\",\n    \"TEXTURE10\",\n    \"TEXTURE11\",\n    \"TEXTURE12\",\n    \"TEXTURE13\",\n    \"TEXTURE14\",\n    \"TEXTURE15\",\n    \"TEXTURE16\",\n    \"TEXTURE17\",\n    \"TEXTURE18\",\n    \"TEXTURE19\",\n    \"TEXTURE2\",\n    \"TEXTURE20\",\n    \"TEXTURE21\",\n    \"TEXTURE22\",\n    \"TEXTURE23\",\n    \"TEXTURE24\",\n    \"TEXTURE25\",\n    \"TEXTURE26\",\n    \"TEXTURE27\",\n    \"TEXTURE28\",\n    \"TEXTURE29\",\n    \"TEXTURE3\",\n    \"TEXTURE30\",\n    \"TEXTURE31\",\n    \"TEXTURE4\",\n    \"TEXTURE5\",\n    \"TEXTURE6\",\n    \"TEXTURE7\",\n    \"TEXTURE8\",\n    \"TEXTURE9\",\n    \"TEXTURE_2D\",\n    \"TEXTURE_BINDING_2D\",\n    \"TEXTURE_BINDING_CUBE_MAP\",\n    \"TEXTURE_CUBE_MAP\",\n    \"TEXTURE_CUBE_MAP_NEGATIVE_X\",\n    \"TEXTURE_CUBE_MAP_NEGATIVE_Y\",\n    \"TEXTURE_CUBE_MAP_NEGATIVE_Z\",\n    \"TEXTURE_CUBE_MAP_POSITIVE_X\",\n    \"TEXTURE_CUBE_MAP_POSITIVE_Y\",\n    \"TEXTURE_CUBE_MAP_POSITIVE_Z\",\n    \"TEXTURE_MAG_FILTER\",\n    \"TEXTURE_MAX_ANISOTROPY_EXT\",\n    \"TEXTURE_MIN_FILTER\",\n    \"TEXTURE_WRAP_S\",\n    \"TEXTURE_WRAP_T\",\n    \"TEXT_NODE\",\n    \"TIMEOUT\",\n    \"TIMEOUT_ERR\",\n    \"TOO_LARGE_ERR\",\n    \"TRANSACTION_INACTIVE_ERR\",\n    \"TRIANGLE\",\n    \"TRIANGLES\",\n    \"TRIANGLE_FAN\",\n    \"TRIANGLE_STRIP\",\n    \"TYPE_BACK_FORWARD\",\n    \"TYPE_ERR\",\n    \"TYPE_MISMATCH_ERR\",\n    \"TYPE_NAVIGATE\",\n    \"TYPE_RELOAD\",\n    \"TYPE_RESERVED\",\n    \"Text\",\n    \"TextDecoder\",\n    \"TextEncoder\",\n    \"TextEvent\",\n    \"TextMetrics\",\n    \"TextTrack\",\n    \"TextTrackCue\",\n    \"TextTrackCueList\",\n    \"TextTrackList\",\n    \"TimeEvent\",\n    \"TimeRanges\",\n    \"Touch\",\n    \"TouchEvent\",\n    \"TouchList\",\n    \"TrackEvent\",\n    \"TransitionEvent\",\n    \"TreeWalker\",\n    \"TypeError\",\n    \"UIEvent\",\n    \"UNCACHED\",\n    \"UNKNOWN_ERR\",\n    \"UNKNOWN_RULE\",\n    \"UNMASKED_RENDERER_WEBGL\",\n    \"UNMASKED_VENDOR_WEBGL\",\n    \"UNORDERED_NODE_ITERATOR_TYPE\",\n    \"UNORDERED_NODE_SNAPSHOT_TYPE\",\n    \"UNPACK_ALIGNMENT\",\n    \"UNPACK_COLORSPACE_CONVERSION_WEBGL\",\n    \"UNPACK_FLIP_Y_WEBGL\",\n    \"UNPACK_PREMULTIPLY_ALPHA_WEBGL\",\n    \"UNSCHEDULED_STATE\",\n    \"UNSENT\",\n    \"UNSIGNED_BYTE\",\n    \"UNSIGNED_INT\",\n    \"UNSIGNED_SHORT\",\n    \"UNSIGNED_SHORT_4_4_4_4\",\n    \"UNSIGNED_SHORT_5_5_5_1\",\n    \"UNSIGNED_SHORT_5_6_5\",\n    \"UNSPECIFIED_EVENT_TYPE_ERR\",\n    \"UPDATEREADY\",\n    \"URIError\",\n    \"URL\",\n    \"URLSearchParams\",\n    \"URLUnencoded\",\n    \"URL_MISMATCH_ERR\",\n    \"UTC\",\n    \"Uint16Array\",\n    \"Uint32Array\",\n    \"Uint8Array\",\n    \"Uint8ClampedArray\",\n    \"UserMessageHandler\",\n    \"UserMessageHandlersNamespace\",\n    \"UserProximityEvent\",\n    \"VALIDATE_STATUS\",\n    \"VALIDATION_ERR\",\n    \"VARIABLES_RULE\",\n    \"VENDOR\",\n    \"VERSION\",\n    \"VERSION_CHANGE\",\n    \"VERSION_ERR\",\n    \"VERTEX_ATTRIB_ARRAY_BUFFER_BINDING\",\n    \"VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE\",\n    \"VERTEX_ATTRIB_ARRAY_ENABLED\",\n    \"VERTEX_ATTRIB_ARRAY_NORMALIZED\",\n    \"VERTEX_ATTRIB_ARRAY_POINTER\",\n    \"VERTEX_ATTRIB_ARRAY_SIZE\",\n    \"VERTEX_ATTRIB_ARRAY_STRIDE\",\n    \"VERTEX_ATTRIB_ARRAY_TYPE\",\n    \"VERTEX_SHADER\",\n    \"VERTICAL\",\n    \"VERTICAL_AXIS\",\n    \"VER_ERR\",\n    \"VIEWPORT\",\n    \"VIEWPORT_RULE\",\n    \"VTTCue\",\n    \"VTTRegion\",\n    \"ValidityState\",\n    \"VideoStreamTrack\",\n    \"WEBKIT_FILTER_RULE\",\n    \"WEBKIT_KEYFRAMES_RULE\",\n    \"WEBKIT_KEYFRAME_RULE\",\n    \"WEBKIT_REGION_RULE\",\n    \"WRONG_DOCUMENT_ERR\",\n    \"WaveShaperNode\",\n    \"WeakMap\",\n    \"WeakSet\",\n    \"WebGLActiveInfo\",\n    \"WebGLBuffer\",\n    \"WebGLContextEvent\",\n    \"WebGLFramebuffer\",\n    \"WebGLProgram\",\n    \"WebGLRenderbuffer\",\n    \"WebGLRenderingContext\",\n    \"WebGLShader\",\n    \"WebGLShaderPrecisionFormat\",\n    \"WebGLTexture\",\n    \"WebGLUniformLocation\",\n    \"WebGLVertexArray\",\n    \"WebKitAnimationEvent\",\n    \"WebKitBlobBuilder\",\n    \"WebKitCSSFilterRule\",\n    \"WebKitCSSFilterValue\",\n    \"WebKitCSSKeyframeRule\",\n    \"WebKitCSSKeyframesRule\",\n    \"WebKitCSSMatrix\",\n    \"WebKitCSSRegionRule\",\n    \"WebKitCSSTransformValue\",\n    \"WebKitDataCue\",\n    \"WebKitGamepad\",\n    \"WebKitMediaKeyError\",\n    \"WebKitMediaKeyMessageEvent\",\n    \"WebKitMediaKeySession\",\n    \"WebKitMediaKeys\",\n    \"WebKitMediaSource\",\n    \"WebKitMutationObserver\",\n    \"WebKitNamespace\",\n    \"WebKitPlaybackTargetAvailabilityEvent\",\n    \"WebKitPoint\",\n    \"WebKitShadowRoot\",\n    \"WebKitSourceBuffer\",\n    \"WebKitSourceBufferList\",\n    \"WebKitTransitionEvent\",\n    \"WebSocket\",\n    \"WheelEvent\",\n    \"Window\",\n    \"Worker\",\n    \"XMLDocument\",\n    \"XMLHttpRequest\",\n    \"XMLHttpRequestEventTarget\",\n    \"XMLHttpRequestException\",\n    \"XMLHttpRequestProgressEvent\",\n    \"XMLHttpRequestUpload\",\n    \"XMLSerializer\",\n    \"XMLStylesheetProcessingInstruction\",\n    \"XPathEvaluator\",\n    \"XPathException\",\n    \"XPathExpression\",\n    \"XPathNSResolver\",\n    \"XPathResult\",\n    \"XSLTProcessor\",\n    \"ZERO\",\n    \"_XD0M_\",\n    \"_YD0M_\",\n    \"__defineGetter__\",\n    \"__defineSetter__\",\n    \"__lookupGetter__\",\n    \"__lookupSetter__\",\n    \"__opera\",\n    \"__proto__\",\n    \"_browserjsran\",\n    \"a\",\n    \"aLink\",\n    \"abbr\",\n    \"abort\",\n    \"abs\",\n    \"absolute\",\n    \"acceleration\",\n    \"accelerationIncludingGravity\",\n    \"accelerator\",\n    \"accept\",\n    \"acceptCharset\",\n    \"acceptNode\",\n    \"accessKey\",\n    \"accessKeyLabel\",\n    \"accuracy\",\n    \"acos\",\n    \"acosh\",\n    \"action\",\n    \"actionURL\",\n    \"active\",\n    \"activeCues\",\n    \"activeElement\",\n    \"activeSourceBuffers\",\n    \"activeSourceCount\",\n    \"activeTexture\",\n    \"add\",\n    \"addBehavior\",\n    \"addCandidate\",\n    \"addColorStop\",\n    \"addCue\",\n    \"addElement\",\n    \"addEventListener\",\n    \"addFilter\",\n    \"addFromString\",\n    \"addFromUri\",\n    \"addIceCandidate\",\n    \"addImport\",\n    \"addListener\",\n    \"addNamed\",\n    \"addPageRule\",\n    \"addPath\",\n    \"addPointer\",\n    \"addRange\",\n    \"addRegion\",\n    \"addRule\",\n    \"addSearchEngine\",\n    \"addSourceBuffer\",\n    \"addStream\",\n    \"addTextTrack\",\n    \"addTrack\",\n    \"addWakeLockListener\",\n    \"addedNodes\",\n    \"additionalName\",\n    \"additiveSymbols\",\n    \"addons\",\n    \"adoptNode\",\n    \"adr\",\n    \"advance\",\n    \"alert\",\n    \"algorithm\",\n    \"align\",\n    \"align-content\",\n    \"align-items\",\n    \"align-self\",\n    \"alignContent\",\n    \"alignItems\",\n    \"alignSelf\",\n    \"alignmentBaseline\",\n    \"alinkColor\",\n    \"all\",\n    \"allowFullscreen\",\n    \"allowedDirections\",\n    \"alpha\",\n    \"alt\",\n    \"altGraphKey\",\n    \"altHtml\",\n    \"altKey\",\n    \"altLeft\",\n    \"altitude\",\n    \"altitudeAccuracy\",\n    \"amplitude\",\n    \"ancestorOrigins\",\n    \"anchor\",\n    \"anchorNode\",\n    \"anchorOffset\",\n    \"anchors\",\n    \"angle\",\n    \"animVal\",\n    \"animate\",\n    \"animatedInstanceRoot\",\n    \"animatedNormalizedPathSegList\",\n    \"animatedPathSegList\",\n    \"animatedPoints\",\n    \"animation\",\n    \"animation-delay\",\n    \"animation-direction\",\n    \"animation-duration\",\n    \"animation-fill-mode\",\n    \"animation-iteration-count\",\n    \"animation-name\",\n    \"animation-play-state\",\n    \"animation-timing-function\",\n    \"animationDelay\",\n    \"animationDirection\",\n    \"animationDuration\",\n    \"animationFillMode\",\n    \"animationIterationCount\",\n    \"animationName\",\n    \"animationPlayState\",\n    \"animationStartTime\",\n    \"animationTimingFunction\",\n    \"animationsPaused\",\n    \"anniversary\",\n    \"app\",\n    \"appCodeName\",\n    \"appMinorVersion\",\n    \"appName\",\n    \"appNotifications\",\n    \"appVersion\",\n    \"append\",\n    \"appendBuffer\",\n    \"appendChild\",\n    \"appendData\",\n    \"appendItem\",\n    \"appendMedium\",\n    \"appendNamed\",\n    \"appendRule\",\n    \"appendStream\",\n    \"appendWindowEnd\",\n    \"appendWindowStart\",\n    \"applets\",\n    \"applicationCache\",\n    \"apply\",\n    \"applyElement\",\n    \"arc\",\n    \"arcTo\",\n    \"archive\",\n    \"areas\",\n    \"arguments\",\n    \"arrayBuffer\",\n    \"asin\",\n    \"asinh\",\n    \"assert\",\n    \"assign\",\n    \"async\",\n    \"atEnd\",\n    \"atan\",\n    \"atan2\",\n    \"atanh\",\n    \"atob\",\n    \"attachEvent\",\n    \"attachShader\",\n    \"attachments\",\n    \"attack\",\n    \"attrChange\",\n    \"attrName\",\n    \"attributeName\",\n    \"attributeNamespace\",\n    \"attributes\",\n    \"audioTracks\",\n    \"autoIncrement\",\n    \"autobuffer\",\n    \"autocapitalize\",\n    \"autocomplete\",\n    \"autocorrect\",\n    \"autofocus\",\n    \"autoplay\",\n    \"availHeight\",\n    \"availLeft\",\n    \"availTop\",\n    \"availWidth\",\n    \"availability\",\n    \"available\",\n    \"aversion\",\n    \"axes\",\n    \"axis\",\n    \"azimuth\",\n    \"b\",\n    \"back\",\n    \"backface-visibility\",\n    \"backfaceVisibility\",\n    \"background\",\n    \"background-attachment\",\n    \"background-blend-mode\",\n    \"background-clip\",\n    \"background-color\",\n    \"background-image\",\n    \"background-origin\",\n    \"background-position\",\n    \"background-repeat\",\n    \"background-size\",\n    \"backgroundAttachment\",\n    \"backgroundBlendMode\",\n    \"backgroundClip\",\n    \"backgroundColor\",\n    \"backgroundImage\",\n    \"backgroundOrigin\",\n    \"backgroundPosition\",\n    \"backgroundPositionX\",\n    \"backgroundPositionY\",\n    \"backgroundRepeat\",\n    \"backgroundSize\",\n    \"badInput\",\n    \"balance\",\n    \"baseFrequencyX\",\n    \"baseFrequencyY\",\n    \"baseNode\",\n    \"baseOffset\",\n    \"baseURI\",\n    \"baseVal\",\n    \"baselineShift\",\n    \"battery\",\n    \"bday\",\n    \"beginElement\",\n    \"beginElementAt\",\n    \"beginPath\",\n    \"behavior\",\n    \"behaviorCookie\",\n    \"behaviorPart\",\n    \"behaviorUrns\",\n    \"beta\",\n    \"bezierCurveTo\",\n    \"bgColor\",\n    \"bgProperties\",\n    \"bias\",\n    \"big\",\n    \"binaryType\",\n    \"bind\",\n    \"bindAttribLocation\",\n    \"bindBuffer\",\n    \"bindFramebuffer\",\n    \"bindRenderbuffer\",\n    \"bindTexture\",\n    \"blendColor\",\n    \"blendEquation\",\n    \"blendEquationSeparate\",\n    \"blendFunc\",\n    \"blendFuncSeparate\",\n    \"blink\",\n    \"blob\",\n    \"blockDirection\",\n    \"blue\",\n    \"blur\",\n    \"body\",\n    \"bodyUsed\",\n    \"bold\",\n    \"bookmarks\",\n    \"booleanValue\",\n    \"border\",\n    \"border-bottom\",\n    \"border-bottom-color\",\n    \"border-bottom-left-radius\",\n    \"border-bottom-right-radius\",\n    \"border-bottom-style\",\n    \"border-bottom-width\",\n    \"border-collapse\",\n    \"border-color\",\n    \"border-image\",\n    \"border-image-outset\",\n    \"border-image-repeat\",\n    \"border-image-slice\",\n    \"border-image-source\",\n    \"border-image-width\",\n    \"border-left\",\n    \"border-left-color\",\n    \"border-left-style\",\n    \"border-left-width\",\n    \"border-radius\",\n    \"border-right\",\n    \"border-right-color\",\n    \"border-right-style\",\n    \"border-right-width\",\n    \"border-spacing\",\n    \"border-style\",\n    \"border-top\",\n    \"border-top-color\",\n    \"border-top-left-radius\",\n    \"border-top-right-radius\",\n    \"border-top-style\",\n    \"border-top-width\",\n    \"border-width\",\n    \"borderBottom\",\n    \"borderBottomColor\",\n    \"borderBottomLeftRadius\",\n    \"borderBottomRightRadius\",\n    \"borderBottomStyle\",\n    \"borderBottomWidth\",\n    \"borderCollapse\",\n    \"borderColor\",\n    \"borderColorDark\",\n    \"borderColorLight\",\n    \"borderImage\",\n    \"borderImageOutset\",\n    \"borderImageRepeat\",\n    \"borderImageSlice\",\n    \"borderImageSource\",\n    \"borderImageWidth\",\n    \"borderLeft\",\n    \"borderLeftColor\",\n    \"borderLeftStyle\",\n    \"borderLeftWidth\",\n    \"borderRadius\",\n    \"borderRight\",\n    \"borderRightColor\",\n    \"borderRightStyle\",\n    \"borderRightWidth\",\n    \"borderSpacing\",\n    \"borderStyle\",\n    \"borderTop\",\n    \"borderTopColor\",\n    \"borderTopLeftRadius\",\n    \"borderTopRightRadius\",\n    \"borderTopStyle\",\n    \"borderTopWidth\",\n    \"borderWidth\",\n    \"bottom\",\n    \"bottomMargin\",\n    \"bound\",\n    \"boundElements\",\n    \"boundingClientRect\",\n    \"boundingHeight\",\n    \"boundingLeft\",\n    \"boundingTop\",\n    \"boundingWidth\",\n    \"bounds\",\n    \"box-decoration-break\",\n    \"box-shadow\",\n    \"box-sizing\",\n    \"boxDecorationBreak\",\n    \"boxShadow\",\n    \"boxSizing\",\n    \"breakAfter\",\n    \"breakBefore\",\n    \"breakInside\",\n    \"browserLanguage\",\n    \"btoa\",\n    \"bubbles\",\n    \"buffer\",\n    \"bufferData\",\n    \"bufferDepth\",\n    \"bufferSize\",\n    \"bufferSubData\",\n    \"buffered\",\n    \"bufferedAmount\",\n    \"buildID\",\n    \"buildNumber\",\n    \"button\",\n    \"buttonID\",\n    \"buttons\",\n    \"byteLength\",\n    \"byteOffset\",\n    \"c\",\n    \"call\",\n    \"caller\",\n    \"canBeFormatted\",\n    \"canBeMounted\",\n    \"canBeShared\",\n    \"canHaveChildren\",\n    \"canHaveHTML\",\n    \"canPlayType\",\n    \"cancel\",\n    \"cancelAnimationFrame\",\n    \"cancelBubble\",\n    \"cancelScheduledValues\",\n    \"cancelable\",\n    \"candidate\",\n    \"canvas\",\n    \"caption\",\n    \"caption-side\",\n    \"captionSide\",\n    \"captureEvents\",\n    \"captureStackTrace\",\n    \"caretPositionFromPoint\",\n    \"caretRangeFromPoint\",\n    \"cast\",\n    \"catch\",\n    \"category\",\n    \"cbrt\",\n    \"cd\",\n    \"ceil\",\n    \"cellIndex\",\n    \"cellPadding\",\n    \"cellSpacing\",\n    \"cells\",\n    \"ch\",\n    \"chOff\",\n    \"chain\",\n    \"challenge\",\n    \"changedTouches\",\n    \"channel\",\n    \"channelCount\",\n    \"channelCountMode\",\n    \"channelInterpretation\",\n    \"char\",\n    \"charAt\",\n    \"charCode\",\n    \"charCodeAt\",\n    \"charIndex\",\n    \"characterSet\",\n    \"charging\",\n    \"chargingTime\",\n    \"charset\",\n    \"checkEnclosure\",\n    \"checkFramebufferStatus\",\n    \"checkIntersection\",\n    \"checkValidity\",\n    \"checked\",\n    \"childElementCount\",\n    \"childNodes\",\n    \"children\",\n    \"chrome\",\n    \"ciphertext\",\n    \"cite\",\n    \"classList\",\n    \"className\",\n    \"classid\",\n    \"clear\",\n    \"clearAttributes\",\n    \"clearColor\",\n    \"clearData\",\n    \"clearDepth\",\n    \"clearImmediate\",\n    \"clearInterval\",\n    \"clearMarks\",\n    \"clearMeasures\",\n    \"clearParameters\",\n    \"clearRect\",\n    \"clearResourceTimings\",\n    \"clearShadow\",\n    \"clearStencil\",\n    \"clearTimeout\",\n    \"clearWatch\",\n    \"click\",\n    \"clickCount\",\n    \"clientHeight\",\n    \"clientInformation\",\n    \"clientLeft\",\n    \"clientRect\",\n    \"clientRects\",\n    \"clientTop\",\n    \"clientWidth\",\n    \"clientX\",\n    \"clientY\",\n    \"clip\",\n    \"clip-path\",\n    \"clip-rule\",\n    \"clipBottom\",\n    \"clipLeft\",\n    \"clipPath\",\n    \"clipPathUnits\",\n    \"clipRight\",\n    \"clipRule\",\n    \"clipTop\",\n    \"clipboardData\",\n    \"clone\",\n    \"cloneContents\",\n    \"cloneNode\",\n    \"cloneRange\",\n    \"close\",\n    \"closePath\",\n    \"closed\",\n    \"closest\",\n    \"clz\",\n    \"clz32\",\n    \"cmp\",\n    \"code\",\n    \"codeBase\",\n    \"codePointAt\",\n    \"codeType\",\n    \"colSpan\",\n    \"collapse\",\n    \"collapseToEnd\",\n    \"collapseToStart\",\n    \"collapsed\",\n    \"collect\",\n    \"colno\",\n    \"color\",\n    \"color-interpolation\",\n    \"color-interpolation-filters\",\n    \"colorDepth\",\n    \"colorInterpolation\",\n    \"colorInterpolationFilters\",\n    \"colorMask\",\n    \"colorType\",\n    \"cols\",\n    \"columnCount\",\n    \"columnFill\",\n    \"columnGap\",\n    \"columnNumber\",\n    \"columnRule\",\n    \"columnRuleColor\",\n    \"columnRuleStyle\",\n    \"columnRuleWidth\",\n    \"columnSpan\",\n    \"columnWidth\",\n    \"columns\",\n    \"command\",\n    \"commitPreferences\",\n    \"commonAncestorContainer\",\n    \"compact\",\n    \"compareBoundaryPoints\",\n    \"compareDocumentPosition\",\n    \"compareEndPoints\",\n    \"compareNode\",\n    \"comparePoint\",\n    \"compatMode\",\n    \"compatible\",\n    \"compile\",\n    \"compileShader\",\n    \"complete\",\n    \"componentFromPoint\",\n    \"compositionEndOffset\",\n    \"compositionStartOffset\",\n    \"compressedTexImage2D\",\n    \"compressedTexSubImage2D\",\n    \"concat\",\n    \"conditionText\",\n    \"coneInnerAngle\",\n    \"coneOuterAngle\",\n    \"coneOuterGain\",\n    \"confirm\",\n    \"confirmComposition\",\n    \"confirmSiteSpecificTrackingException\",\n    \"confirmWebWideTrackingException\",\n    \"connect\",\n    \"connectEnd\",\n    \"connectStart\",\n    \"connected\",\n    \"connection\",\n    \"connectionSpeed\",\n    \"console\",\n    \"consolidate\",\n    \"constrictionActive\",\n    \"constructor\",\n    \"contactID\",\n    \"contains\",\n    \"containsNode\",\n    \"content\",\n    \"contentDocument\",\n    \"contentEditable\",\n    \"contentOverflow\",\n    \"contentScriptType\",\n    \"contentStyleType\",\n    \"contentType\",\n    \"contentWindow\",\n    \"context\",\n    \"contextMenu\",\n    \"contextmenu\",\n    \"continue\",\n    \"continuous\",\n    \"control\",\n    \"controller\",\n    \"controls\",\n    \"convertToSpecifiedUnits\",\n    \"cookie\",\n    \"cookieEnabled\",\n    \"coords\",\n    \"copyFromChannel\",\n    \"copyTexImage2D\",\n    \"copyTexSubImage2D\",\n    \"copyToChannel\",\n    \"copyWithin\",\n    \"correspondingElement\",\n    \"correspondingUseElement\",\n    \"cos\",\n    \"cosh\",\n    \"count\",\n    \"counter-increment\",\n    \"counter-reset\",\n    \"counterIncrement\",\n    \"counterReset\",\n    \"cpuClass\",\n    \"cpuSleepAllowed\",\n    \"create\",\n    \"createAnalyser\",\n    \"createAnswer\",\n    \"createAttribute\",\n    \"createAttributeNS\",\n    \"createBiquadFilter\",\n    \"createBuffer\",\n    \"createBufferSource\",\n    \"createCDATASection\",\n    \"createCSSStyleSheet\",\n    \"createCaption\",\n    \"createChannelMerger\",\n    \"createChannelSplitter\",\n    \"createComment\",\n    \"createContextualFragment\",\n    \"createControlRange\",\n    \"createConvolver\",\n    \"createDTMFSender\",\n    \"createDataChannel\",\n    \"createDelay\",\n    \"createDelayNode\",\n    \"createDocument\",\n    \"createDocumentFragment\",\n    \"createDocumentType\",\n    \"createDynamicsCompressor\",\n    \"createElement\",\n    \"createElementNS\",\n    \"createEntityReference\",\n    \"createEvent\",\n    \"createEventObject\",\n    \"createExpression\",\n    \"createFramebuffer\",\n    \"createFunction\",\n    \"createGain\",\n    \"createGainNode\",\n    \"createHTMLDocument\",\n    \"createImageBitmap\",\n    \"createImageData\",\n    \"createIndex\",\n    \"createJavaScriptNode\",\n    \"createLinearGradient\",\n    \"createMediaElementSource\",\n    \"createMediaKeys\",\n    \"createMediaStreamDestination\",\n    \"createMediaStreamSource\",\n    \"createMutableFile\",\n    \"createNSResolver\",\n    \"createNodeIterator\",\n    \"createNotification\",\n    \"createObjectStore\",\n    \"createObjectURL\",\n    \"createOffer\",\n    \"createOscillator\",\n    \"createPanner\",\n    \"createPattern\",\n    \"createPeriodicWave\",\n    \"createPopup\",\n    \"createProcessingInstruction\",\n    \"createProgram\",\n    \"createRadialGradient\",\n    \"createRange\",\n    \"createRangeCollection\",\n    \"createRenderbuffer\",\n    \"createSVGAngle\",\n    \"createSVGLength\",\n    \"createSVGMatrix\",\n    \"createSVGNumber\",\n    \"createSVGPathSegArcAbs\",\n    \"createSVGPathSegArcRel\",\n    \"createSVGPathSegClosePath\",\n    \"createSVGPathSegCurvetoCubicAbs\",\n    \"createSVGPathSegCurvetoCubicRel\",\n    \"createSVGPathSegCurvetoCubicSmoothAbs\",\n    \"createSVGPathSegCurvetoCubicSmoothRel\",\n    \"createSVGPathSegCurvetoQuadraticAbs\",\n    \"createSVGPathSegCurvetoQuadraticRel\",\n    \"createSVGPathSegCurvetoQuadraticSmoothAbs\",\n    \"createSVGPathSegCurvetoQuadraticSmoothRel\",\n    \"createSVGPathSegLinetoAbs\",\n    \"createSVGPathSegLinetoHorizontalAbs\",\n    \"createSVGPathSegLinetoHorizontalRel\",\n    \"createSVGPathSegLinetoRel\",\n    \"createSVGPathSegLinetoVerticalAbs\",\n    \"createSVGPathSegLinetoVerticalRel\",\n    \"createSVGPathSegMovetoAbs\",\n    \"createSVGPathSegMovetoRel\",\n    \"createSVGPoint\",\n    \"createSVGRect\",\n    \"createSVGTransform\",\n    \"createSVGTransformFromMatrix\",\n    \"createScriptProcessor\",\n    \"createSession\",\n    \"createShader\",\n    \"createShadowRoot\",\n    \"createStereoPanner\",\n    \"createStyleSheet\",\n    \"createTBody\",\n    \"createTFoot\",\n    \"createTHead\",\n    \"createTextNode\",\n    \"createTextRange\",\n    \"createTexture\",\n    \"createTouch\",\n    \"createTouchList\",\n    \"createTreeWalker\",\n    \"createWaveShaper\",\n    \"creationTime\",\n    \"crossOrigin\",\n    \"crypto\",\n    \"csi\",\n    \"cssFloat\",\n    \"cssRules\",\n    \"cssText\",\n    \"cssValueType\",\n    \"ctrlKey\",\n    \"ctrlLeft\",\n    \"cues\",\n    \"cullFace\",\n    \"currentNode\",\n    \"currentPage\",\n    \"currentScale\",\n    \"currentScript\",\n    \"currentSrc\",\n    \"currentState\",\n    \"currentStyle\",\n    \"currentTarget\",\n    \"currentTime\",\n    \"currentTranslate\",\n    \"currentView\",\n    \"cursor\",\n    \"curve\",\n    \"customError\",\n    \"cx\",\n    \"cy\",\n    \"d\",\n    \"data\",\n    \"dataFld\",\n    \"dataFormatAs\",\n    \"dataPageSize\",\n    \"dataSrc\",\n    \"dataTransfer\",\n    \"database\",\n    \"dataset\",\n    \"dateTime\",\n    \"db\",\n    \"debug\",\n    \"debuggerEnabled\",\n    \"declare\",\n    \"decode\",\n    \"decodeAudioData\",\n    \"decodingInfo\",\n    \"decodeURI\",\n    \"decodeURIComponent\",\n    \"decrypt\",\n    \"default\",\n    \"defaultCharset\",\n    \"defaultChecked\",\n    \"defaultMuted\",\n    \"defaultPlaybackRate\",\n    \"defaultPrevented\",\n    \"defaultSelected\",\n    \"defaultStatus\",\n    \"defaultURL\",\n    \"defaultValue\",\n    \"defaultView\",\n    \"defaultstatus\",\n    \"defer\",\n    \"defineMagicFunction\",\n    \"defineMagicVariable\",\n    \"defineProperties\",\n    \"defineProperty\",\n    \"delayTime\",\n    \"delete\",\n    \"deleteBuffer\",\n    \"deleteCaption\",\n    \"deleteCell\",\n    \"deleteContents\",\n    \"deleteData\",\n    \"deleteDatabase\",\n    \"deleteFramebuffer\",\n    \"deleteFromDocument\",\n    \"deleteIndex\",\n    \"deleteMedium\",\n    \"deleteObjectStore\",\n    \"deleteProgram\",\n    \"deleteRenderbuffer\",\n    \"deleteRow\",\n    \"deleteRule\",\n    \"deleteShader\",\n    \"deleteTFoot\",\n    \"deleteTHead\",\n    \"deleteTexture\",\n    \"deliverChangeRecords\",\n    \"delivery\",\n    \"deliveryInfo\",\n    \"deliveryStatus\",\n    \"deliveryTimestamp\",\n    \"delta\",\n    \"deltaMode\",\n    \"deltaX\",\n    \"deltaY\",\n    \"deltaZ\",\n    \"depthFunc\",\n    \"depthMask\",\n    \"depthRange\",\n    \"deriveBits\",\n    \"deriveKey\",\n    \"description\",\n    \"deselectAll\",\n    \"designMode\",\n    \"destination\",\n    \"destinationURL\",\n    \"detach\",\n    \"detachEvent\",\n    \"detachShader\",\n    \"detail\",\n    \"detune\",\n    \"devicePixelRatio\",\n    \"deviceXDPI\",\n    \"deviceYDPI\",\n    \"diffuseConstant\",\n    \"digest\",\n    \"dimensions\",\n    \"dir\",\n    \"dirName\",\n    \"direction\",\n    \"dirxml\",\n    \"disable\",\n    \"disableVertexAttribArray\",\n    \"disabled\",\n    \"dischargingTime\",\n    \"disconnect\",\n    \"dispatchEvent\",\n    \"display\",\n    \"distanceModel\",\n    \"divisor\",\n    \"djsapi\",\n    \"djsproxy\",\n    \"doImport\",\n    \"doNotTrack\",\n    \"doScroll\",\n    \"doctype\",\n    \"document\",\n    \"documentElement\",\n    \"documentMode\",\n    \"documentURI\",\n    \"dolphin\",\n    \"dolphinGameCenter\",\n    \"dolphininfo\",\n    \"dolphinmeta\",\n    \"domComplete\",\n    \"domContentLoadedEventEnd\",\n    \"domContentLoadedEventStart\",\n    \"domInteractive\",\n    \"domLoading\",\n    \"domain\",\n    \"domainLookupEnd\",\n    \"domainLookupStart\",\n    \"dominant-baseline\",\n    \"dominantBaseline\",\n    \"done\",\n    \"dopplerFactor\",\n    \"download\",\n    \"dragDrop\",\n    \"draggable\",\n    \"drawArrays\",\n    \"drawArraysInstancedANGLE\",\n    \"drawCustomFocusRing\",\n    \"drawElements\",\n    \"drawElementsInstancedANGLE\",\n    \"drawFocusIfNeeded\",\n    \"drawImage\",\n    \"drawImageFromRect\",\n    \"drawSystemFocusRing\",\n    \"drawingBufferHeight\",\n    \"drawingBufferWidth\",\n    \"dropEffect\",\n    \"droppedVideoFrames\",\n    \"dropzone\",\n    \"dump\",\n    \"duplicate\",\n    \"duration\",\n    \"dvname\",\n    \"dvnum\",\n    \"dx\",\n    \"dy\",\n    \"dynsrc\",\n    \"e\",\n    \"edgeMode\",\n    \"effectAllowed\",\n    \"elapsedTime\",\n    \"elementFromPoint\",\n    \"elements\",\n    \"elevation\",\n    \"ellipse\",\n    \"email\",\n    \"embeds\",\n    \"empty\",\n    \"empty-cells\",\n    \"emptyCells\",\n    \"enable\",\n    \"enableBackground\",\n    \"enableStyleSheetsForSet\",\n    \"enableVertexAttribArray\",\n    \"enabled\",\n    \"enabledPlugin\",\n    \"encode\",\n    \"encodeURI\",\n    \"encodeURIComponent\",\n    \"encoding\",\n    \"encrypt\",\n    \"enctype\",\n    \"end\",\n    \"endContainer\",\n    \"endElement\",\n    \"endElementAt\",\n    \"endOfStream\",\n    \"endOffset\",\n    \"endTime\",\n    \"ended\",\n    \"endsWith\",\n    \"entities\",\n    \"entries\",\n    \"entryType\",\n    \"enumerate\",\n    \"enumerateEditable\",\n    \"error\",\n    \"errorCode\",\n    \"escape\",\n    \"eval\",\n    \"evaluate\",\n    \"event\",\n    \"eventPhase\",\n    \"every\",\n    \"exception\",\n    \"exec\",\n    \"execCommand\",\n    \"execCommandShowHelp\",\n    \"execScript\",\n    \"exitFullscreen\",\n    \"exitPointerLock\",\n    \"exp\",\n    \"expand\",\n    \"expandEntityReferences\",\n    \"expando\",\n    \"expansion\",\n    \"expiryDate\",\n    \"explicitOriginalTarget\",\n    \"expm1\",\n    \"exponent\",\n    \"exponentialRampToValueAtTime\",\n    \"exportKey\",\n    \"extend\",\n    \"extensions\",\n    \"extentNode\",\n    \"extentOffset\",\n    \"external\",\n    \"externalResourcesRequired\",\n    \"extractContents\",\n    \"extractable\",\n    \"f\",\n    \"face\",\n    \"factoryReset\",\n    \"fallback\",\n    \"familyName\",\n    \"farthestViewportElement\",\n    \"fastSeek\",\n    \"fatal\",\n    \"fetch\",\n    \"fetchStart\",\n    \"fftSize\",\n    \"fgColor\",\n    \"fileCreatedDate\",\n    \"fileHandle\",\n    \"fileModifiedDate\",\n    \"fileName\",\n    \"fileSize\",\n    \"fileUpdatedDate\",\n    \"filename\",\n    \"files\",\n    \"fill\",\n    \"fill-opacity\",\n    \"fill-rule\",\n    \"fillOpacity\",\n    \"fillRect\",\n    \"fillRule\",\n    \"fillStyle\",\n    \"fillText\",\n    \"filter\",\n    \"filterResX\",\n    \"filterResY\",\n    \"filterUnits\",\n    \"filters\",\n    \"finally\",\n    \"find\",\n    \"findIndex\",\n    \"findRule\",\n    \"findText\",\n    \"finish\",\n    \"fireEvent\",\n    \"firstChild\",\n    \"firstElementChild\",\n    \"firstPage\",\n    \"fixed\",\n    \"flex\",\n    \"flex-basis\",\n    \"flex-direction\",\n    \"flex-flow\",\n    \"flex-grow\",\n    \"flex-shrink\",\n    \"flex-wrap\",\n    \"flexBasis\",\n    \"flexDirection\",\n    \"flexFlow\",\n    \"flexGrow\",\n    \"flexShrink\",\n    \"flexWrap\",\n    \"flipX\",\n    \"flipY\",\n    \"float\",\n    \"flood-color\",\n    \"flood-opacity\",\n    \"floodColor\",\n    \"floodOpacity\",\n    \"floor\",\n    \"flush\",\n    \"focus\",\n    \"focusNode\",\n    \"focusOffset\",\n    \"font\",\n    \"font-family\",\n    \"font-feature-settings\",\n    \"font-kerning\",\n    \"font-language-override\",\n    \"font-size\",\n    \"font-size-adjust\",\n    \"font-stretch\",\n    \"font-style\",\n    \"font-synthesis\",\n    \"font-variant\",\n    \"font-variant-alternates\",\n    \"font-variant-caps\",\n    \"font-variant-east-asian\",\n    \"font-variant-ligatures\",\n    \"font-variant-numeric\",\n    \"font-variant-position\",\n    \"font-weight\",\n    \"fontFamily\",\n    \"fontFeatureSettings\",\n    \"fontKerning\",\n    \"fontLanguageOverride\",\n    \"fontSize\",\n    \"fontSizeAdjust\",\n    \"fontSmoothingEnabled\",\n    \"fontStretch\",\n    \"fontStyle\",\n    \"fontSynthesis\",\n    \"fontVariant\",\n    \"fontVariantAlternates\",\n    \"fontVariantCaps\",\n    \"fontVariantEastAsian\",\n    \"fontVariantLigatures\",\n    \"fontVariantNumeric\",\n    \"fontVariantPosition\",\n    \"fontWeight\",\n    \"fontcolor\",\n    \"fonts\",\n    \"fontsize\",\n    \"for\",\n    \"forEach\",\n    \"forceRedraw\",\n    \"form\",\n    \"formAction\",\n    \"formEnctype\",\n    \"formMethod\",\n    \"formNoValidate\",\n    \"formTarget\",\n    \"format\",\n    \"forms\",\n    \"forward\",\n    \"fr\",\n    \"frame\",\n    \"frameBorder\",\n    \"frameElement\",\n    \"frameSpacing\",\n    \"framebufferRenderbuffer\",\n    \"framebufferTexture2D\",\n    \"frames\",\n    \"freeSpace\",\n    \"freeze\",\n    \"frequency\",\n    \"frequencyBinCount\",\n    \"from\",\n    \"fromCharCode\",\n    \"fromCodePoint\",\n    \"fromElement\",\n    \"frontFace\",\n    \"fround\",\n    \"fullScreen\",\n    \"fullscreenElement\",\n    \"fullscreenEnabled\",\n    \"fx\",\n    \"fy\",\n    \"gain\",\n    \"gamepad\",\n    \"gamma\",\n    \"genderIdentity\",\n    \"generateKey\",\n    \"generateMipmap\",\n    \"generateRequest\",\n    \"geolocation\",\n    \"gestureObject\",\n    \"get\",\n    \"getActiveAttrib\",\n    \"getActiveUniform\",\n    \"getAdjacentText\",\n    \"getAll\",\n    \"getAllResponseHeaders\",\n    \"getAsFile\",\n    \"getAsString\",\n    \"getAttachedShaders\",\n    \"getAttribLocation\",\n    \"getAttribute\",\n    \"getAttributeNS\",\n    \"getAttributeNode\",\n    \"getAttributeNodeNS\",\n    \"getAudioTracks\",\n    \"getBBox\",\n    \"getBattery\",\n    \"getBlob\",\n    \"getBookmark\",\n    \"getBoundingClientRect\",\n    \"getBufferParameter\",\n    \"getByteFrequencyData\",\n    \"getByteTimeDomainData\",\n    \"getCSSCanvasContext\",\n    \"getCTM\",\n    \"getCandidateWindowClientRect\",\n    \"getChannelData\",\n    \"getCharNumAtPosition\",\n    \"getClientRect\",\n    \"getClientRects\",\n    \"getCompositionAlternatives\",\n    \"getComputedStyle\",\n    \"getComputedTextLength\",\n    \"getConfiguration\",\n    \"getContext\",\n    \"getContextAttributes\",\n    \"getCounterValue\",\n    \"getCueAsHTML\",\n    \"getCueById\",\n    \"getCurrentPosition\",\n    \"getCurrentTime\",\n    \"getData\",\n    \"getDatabaseNames\",\n    \"getDate\",\n    \"getDay\",\n    \"getDefaultComputedStyle\",\n    \"getDestinationInsertionPoints\",\n    \"getDistributedNodes\",\n    \"getEditable\",\n    \"getElementById\",\n    \"getElementsByClassName\",\n    \"getElementsByName\",\n    \"getElementsByTagName\",\n    \"getElementsByTagNameNS\",\n    \"getEnclosureList\",\n    \"getEndPositionOfChar\",\n    \"getEntries\",\n    \"getEntriesByName\",\n    \"getEntriesByType\",\n    \"getError\",\n    \"getExtension\",\n    \"getExtentOfChar\",\n    \"getFeature\",\n    \"getFile\",\n    \"getFloat32\",\n    \"getFloat64\",\n    \"getFloatFrequencyData\",\n    \"getFloatTimeDomainData\",\n    \"getFloatValue\",\n    \"getFramebufferAttachmentParameter\",\n    \"getFrequencyResponse\",\n    \"getFullYear\",\n    \"getGamepads\",\n    \"getHours\",\n    \"getImageData\",\n    \"getInt16\",\n    \"getInt32\",\n    \"getInt8\",\n    \"getIntersectionList\",\n    \"getItem\",\n    \"getItems\",\n    \"getKey\",\n    \"getLineDash\",\n    \"getLocalStreams\",\n    \"getMarks\",\n    \"getMatchedCSSRules\",\n    \"getMeasures\",\n    \"getMetadata\",\n    \"getMilliseconds\",\n    \"getMinutes\",\n    \"getModifierState\",\n    \"getMonth\",\n    \"getNamedItem\",\n    \"getNamedItemNS\",\n    \"getNotifier\",\n    \"getNumberOfChars\",\n    \"getOverrideHistoryNavigationMode\",\n    \"getOverrideStyle\",\n    \"getOwnPropertyDescriptor\",\n    \"getOwnPropertyNames\",\n    \"getOwnPropertySymbols\",\n    \"getParameter\",\n    \"getPathSegAtLength\",\n    \"getPointAtLength\",\n    \"getPreference\",\n    \"getPreferenceDefault\",\n    \"getPresentationAttribute\",\n    \"getPreventDefault\",\n    \"getProgramInfoLog\",\n    \"getProgramParameter\",\n    \"getPropertyCSSValue\",\n    \"getPropertyPriority\",\n    \"getPropertyShorthand\",\n    \"getPropertyValue\",\n    \"getPrototypeOf\",\n    \"getRGBColorValue\",\n    \"getRandomValues\",\n    \"getRangeAt\",\n    \"getReceivers\",\n    \"getRectValue\",\n    \"getRegistration\",\n    \"getRemoteStreams\",\n    \"getRenderbufferParameter\",\n    \"getResponseHeader\",\n    \"getRoot\",\n    \"getRotationOfChar\",\n    \"getSVGDocument\",\n    \"getScreenCTM\",\n    \"getSeconds\",\n    \"getSelection\",\n    \"getSenders\",\n    \"getShaderInfoLog\",\n    \"getShaderParameter\",\n    \"getShaderPrecisionFormat\",\n    \"getShaderSource\",\n    \"getSimpleDuration\",\n    \"getSiteIcons\",\n    \"getSources\",\n    \"getSpeculativeParserUrls\",\n    \"getStartPositionOfChar\",\n    \"getStartTime\",\n    \"getStats\",\n    \"getStorageUpdates\",\n    \"getStreamById\",\n    \"getStringValue\",\n    \"getSubStringLength\",\n    \"getSubscription\",\n    \"getSupportedExtensions\",\n    \"getTexParameter\",\n    \"getTime\",\n    \"getTimezoneOffset\",\n    \"getTotalLength\",\n    \"getTrackById\",\n    \"getTracks\",\n    \"getTransformToElement\",\n    \"getUTCDate\",\n    \"getUTCDay\",\n    \"getUTCFullYear\",\n    \"getUTCHours\",\n    \"getUTCMilliseconds\",\n    \"getUTCMinutes\",\n    \"getUTCMonth\",\n    \"getUTCSeconds\",\n    \"getUint16\",\n    \"getUint32\",\n    \"getUint8\",\n    \"getUniform\",\n    \"getUniformLocation\",\n    \"getUserMedia\",\n    \"getValues\",\n    \"getVarDate\",\n    \"getVariableValue\",\n    \"getVertexAttrib\",\n    \"getVertexAttribOffset\",\n    \"getVideoPlaybackQuality\",\n    \"getVideoTracks\",\n    \"getWakeLockState\",\n    \"getYear\",\n    \"givenName\",\n    \"global\",\n    \"globalAlpha\",\n    \"globalCompositeOperation\",\n    \"glyphOrientationHorizontal\",\n    \"glyphOrientationVertical\",\n    \"glyphRef\",\n    \"go\",\n    \"gradientTransform\",\n    \"gradientUnits\",\n    \"grammars\",\n    \"green\",\n    \"group\",\n    \"groupCollapsed\",\n    \"groupEnd\",\n    \"hardwareConcurrency\",\n    \"has\",\n    \"hasAttribute\",\n    \"hasAttributeNS\",\n    \"hasAttributes\",\n    \"hasChildNodes\",\n    \"hasComposition\",\n    \"hasExtension\",\n    \"hasFeature\",\n    \"hasFocus\",\n    \"hasLayout\",\n    \"hasOwnProperty\",\n    \"hash\",\n    \"head\",\n    \"headers\",\n    \"heading\",\n    \"height\",\n    \"hidden\",\n    \"hide\",\n    \"hideFocus\",\n    \"high\",\n    \"hint\",\n    \"history\",\n    \"honorificPrefix\",\n    \"honorificSuffix\",\n    \"horizontalOverflow\",\n    \"host\",\n    \"hostname\",\n    \"href\",\n    \"hreflang\",\n    \"hspace\",\n    \"html5TagCheckInerface\",\n    \"htmlFor\",\n    \"htmlText\",\n    \"httpEquiv\",\n    \"hwTimestamp\",\n    \"hypot\",\n    \"iccId\",\n    \"iceConnectionState\",\n    \"iceGatheringState\",\n    \"icon\",\n    \"id\",\n    \"identifier\",\n    \"identity\",\n    \"ignoreBOM\",\n    \"ignoreCase\",\n    \"image-orientation\",\n    \"image-rendering\",\n    \"imageOrientation\",\n    \"imageRendering\",\n    \"images\",\n    \"ime-mode\",\n    \"imeMode\",\n    \"implementation\",\n    \"importKey\",\n    \"importNode\",\n    \"importStylesheet\",\n    \"imports\",\n    \"impp\",\n    \"imul\",\n    \"in1\",\n    \"in2\",\n    \"inBandMetadataTrackDispatchType\",\n    \"inRange\",\n    \"includes\",\n    \"incremental\",\n    \"indeterminate\",\n    \"index\",\n    \"indexNames\",\n    \"indexOf\",\n    \"indexedDB\",\n    \"inertiaDestinationX\",\n    \"inertiaDestinationY\",\n    \"info\",\n    \"init\",\n    \"initAnimationEvent\",\n    \"initBeforeLoadEvent\",\n    \"initClipboardEvent\",\n    \"initCloseEvent\",\n    \"initCommandEvent\",\n    \"initCompositionEvent\",\n    \"initCustomEvent\",\n    \"initData\",\n    \"initDeviceMotionEvent\",\n    \"initDeviceOrientationEvent\",\n    \"initDragEvent\",\n    \"initErrorEvent\",\n    \"initEvent\",\n    \"initFocusEvent\",\n    \"initGestureEvent\",\n    \"initHashChangeEvent\",\n    \"initKeyEvent\",\n    \"initKeyboardEvent\",\n    \"initMSManipulationEvent\",\n    \"initMessageEvent\",\n    \"initMouseEvent\",\n    \"initMouseScrollEvent\",\n    \"initMouseWheelEvent\",\n    \"initMutationEvent\",\n    \"initNSMouseEvent\",\n    \"initOverflowEvent\",\n    \"initPageEvent\",\n    \"initPageTransitionEvent\",\n    \"initPointerEvent\",\n    \"initPopStateEvent\",\n    \"initProgressEvent\",\n    \"initScrollAreaEvent\",\n    \"initSimpleGestureEvent\",\n    \"initStorageEvent\",\n    \"initTextEvent\",\n    \"initTimeEvent\",\n    \"initTouchEvent\",\n    \"initTransitionEvent\",\n    \"initUIEvent\",\n    \"initWebKitAnimationEvent\",\n    \"initWebKitTransitionEvent\",\n    \"initWebKitWheelEvent\",\n    \"initWheelEvent\",\n    \"initialTime\",\n    \"initialize\",\n    \"initiatorType\",\n    \"inner\",\n    \"innerHTML\",\n    \"innerHeight\",\n    \"innerText\",\n    \"innerWidth\",\n    \"input\",\n    \"inputBuffer\",\n    \"inputEncoding\",\n    \"inputMethod\",\n    \"insertAdjacentElement\",\n    \"insertAdjacentHTML\",\n    \"insertAdjacentText\",\n    \"insertBefore\",\n    \"insertCell\",\n    \"insertData\",\n    \"insertItemBefore\",\n    \"insertNode\",\n    \"insertRow\",\n    \"insertRule\",\n    \"instanceRoot\",\n    \"intercept\",\n    \"interimResults\",\n    \"internalSubset\",\n    \"intersectsNode\",\n    \"interval\",\n    \"invalidIteratorState\",\n    \"inverse\",\n    \"invertSelf\",\n    \"is\",\n    \"is2D\",\n    \"isAlternate\",\n    \"isArray\",\n    \"isBingCurrentSearchDefault\",\n    \"isBuffer\",\n    \"isCandidateWindowVisible\",\n    \"isChar\",\n    \"isCollapsed\",\n    \"isComposing\",\n    \"isContentEditable\",\n    \"isContentHandlerRegistered\",\n    \"isContextLost\",\n    \"isDefaultNamespace\",\n    \"isDisabled\",\n    \"isEnabled\",\n    \"isEqual\",\n    \"isEqualNode\",\n    \"isExtensible\",\n    \"isFinite\",\n    \"isFramebuffer\",\n    \"isFrozen\",\n    \"isGenerator\",\n    \"isId\",\n    \"isInjected\",\n    \"isInteger\",\n    \"isMap\",\n    \"isMultiLine\",\n    \"isNaN\",\n    \"isOpen\",\n    \"isPointInFill\",\n    \"isPointInPath\",\n    \"isPointInRange\",\n    \"isPointInStroke\",\n    \"isPrefAlternate\",\n    \"isPrimary\",\n    \"isProgram\",\n    \"isPropertyImplicit\",\n    \"isProtocolHandlerRegistered\",\n    \"isPrototypeOf\",\n    \"isRenderbuffer\",\n    \"isSafeInteger\",\n    \"isSameNode\",\n    \"isSealed\",\n    \"isShader\",\n    \"isSupported\",\n    \"isTextEdit\",\n    \"isTexture\",\n    \"isTrusted\",\n    \"isTypeSupported\",\n    \"isView\",\n    \"isolation\",\n    \"italics\",\n    \"item\",\n    \"itemId\",\n    \"itemProp\",\n    \"itemRef\",\n    \"itemScope\",\n    \"itemType\",\n    \"itemValue\",\n    \"iterateNext\",\n    \"iterator\",\n    \"javaEnabled\",\n    \"jobTitle\",\n    \"join\",\n    \"json\",\n    \"justify-content\",\n    \"justifyContent\",\n    \"k1\",\n    \"k2\",\n    \"k3\",\n    \"k4\",\n    \"kernelMatrix\",\n    \"kernelUnitLengthX\",\n    \"kernelUnitLengthY\",\n    \"kerning\",\n    \"key\",\n    \"keyCode\",\n    \"keyFor\",\n    \"keyIdentifier\",\n    \"keyLightEnabled\",\n    \"keyLocation\",\n    \"keyPath\",\n    \"keySystem\",\n    \"keyText\",\n    \"keyUsage\",\n    \"keys\",\n    \"keytype\",\n    \"kind\",\n    \"knee\",\n    \"label\",\n    \"labels\",\n    \"lang\",\n    \"language\",\n    \"languages\",\n    \"largeArcFlag\",\n    \"lastChild\",\n    \"lastElementChild\",\n    \"lastEventId\",\n    \"lastIndex\",\n    \"lastIndexOf\",\n    \"lastMatch\",\n    \"lastMessageSubject\",\n    \"lastMessageType\",\n    \"lastModified\",\n    \"lastModifiedDate\",\n    \"lastPage\",\n    \"lastParen\",\n    \"lastState\",\n    \"lastStyleSheetSet\",\n    \"latitude\",\n    \"layerX\",\n    \"layerY\",\n    \"layoutFlow\",\n    \"layoutGrid\",\n    \"layoutGridChar\",\n    \"layoutGridLine\",\n    \"layoutGridMode\",\n    \"layoutGridType\",\n    \"lbound\",\n    \"left\",\n    \"leftContext\",\n    \"leftMargin\",\n    \"length\",\n    \"lengthAdjust\",\n    \"lengthComputable\",\n    \"letter-spacing\",\n    \"letterSpacing\",\n    \"level\",\n    \"lighting-color\",\n    \"lightingColor\",\n    \"limitingConeAngle\",\n    \"line\",\n    \"line-height\",\n    \"lineAlign\",\n    \"lineBreak\",\n    \"lineCap\",\n    \"lineDashOffset\",\n    \"lineHeight\",\n    \"lineJoin\",\n    \"lineNumber\",\n    \"lineTo\",\n    \"lineWidth\",\n    \"linearRampToValueAtTime\",\n    \"lineno\",\n    \"link\",\n    \"linkColor\",\n    \"linkProgram\",\n    \"links\",\n    \"list\",\n    \"list-style\",\n    \"list-style-image\",\n    \"list-style-position\",\n    \"list-style-type\",\n    \"listStyle\",\n    \"listStyleImage\",\n    \"listStylePosition\",\n    \"listStyleType\",\n    \"listener\",\n    \"load\",\n    \"loadEventEnd\",\n    \"loadEventStart\",\n    \"loadTimes\",\n    \"loaded\",\n    \"localDescription\",\n    \"localName\",\n    \"localStorage\",\n    \"locale\",\n    \"localeCompare\",\n    \"location\",\n    \"locationbar\",\n    \"lock\",\n    \"lockedFile\",\n    \"log\",\n    \"log10\",\n    \"log1p\",\n    \"log2\",\n    \"logicalXDPI\",\n    \"logicalYDPI\",\n    \"longDesc\",\n    \"longitude\",\n    \"lookupNamespaceURI\",\n    \"lookupPrefix\",\n    \"loop\",\n    \"loopEnd\",\n    \"loopStart\",\n    \"looping\",\n    \"low\",\n    \"lower\",\n    \"lowerBound\",\n    \"lowerOpen\",\n    \"lowsrc\",\n    \"m11\",\n    \"m12\",\n    \"m13\",\n    \"m14\",\n    \"m21\",\n    \"m22\",\n    \"m23\",\n    \"m24\",\n    \"m31\",\n    \"m32\",\n    \"m33\",\n    \"m34\",\n    \"m41\",\n    \"m42\",\n    \"m43\",\n    \"m44\",\n    \"manifest\",\n    \"map\",\n    \"mapping\",\n    \"margin\",\n    \"margin-bottom\",\n    \"margin-left\",\n    \"margin-right\",\n    \"margin-top\",\n    \"marginBottom\",\n    \"marginHeight\",\n    \"marginLeft\",\n    \"marginRight\",\n    \"marginTop\",\n    \"marginWidth\",\n    \"mark\",\n    \"marker\",\n    \"marker-end\",\n    \"marker-mid\",\n    \"marker-offset\",\n    \"marker-start\",\n    \"markerEnd\",\n    \"markerHeight\",\n    \"markerMid\",\n    \"markerOffset\",\n    \"markerStart\",\n    \"markerUnits\",\n    \"markerWidth\",\n    \"marks\",\n    \"mask\",\n    \"mask-type\",\n    \"maskContentUnits\",\n    \"maskType\",\n    \"maskUnits\",\n    \"match\",\n    \"matchMedia\",\n    \"matchMedium\",\n    \"matches\",\n    \"matrix\",\n    \"matrixTransform\",\n    \"max\",\n    \"max-height\",\n    \"max-width\",\n    \"maxAlternatives\",\n    \"maxChannelCount\",\n    \"maxConnectionsPerServer\",\n    \"maxDecibels\",\n    \"maxDistance\",\n    \"maxHeight\",\n    \"maxLength\",\n    \"maxTouchPoints\",\n    \"maxValue\",\n    \"maxWidth\",\n    \"measure\",\n    \"measureText\",\n    \"media\",\n    \"mediaCapabilities\",\n    \"mediaDevices\",\n    \"mediaElement\",\n    \"mediaGroup\",\n    \"mediaKeys\",\n    \"mediaText\",\n    \"meetOrSlice\",\n    \"memory\",\n    \"menubar\",\n    \"mergeAttributes\",\n    \"message\",\n    \"messageClass\",\n    \"messageHandlers\",\n    \"metaKey\",\n    \"method\",\n    \"mimeType\",\n    \"mimeTypes\",\n    \"min\",\n    \"min-height\",\n    \"min-width\",\n    \"minDecibels\",\n    \"minHeight\",\n    \"minValue\",\n    \"minWidth\",\n    \"miterLimit\",\n    \"mix-blend-mode\",\n    \"mixBlendMode\",\n    \"mode\",\n    \"modify\",\n    \"mount\",\n    \"move\",\n    \"moveBy\",\n    \"moveEnd\",\n    \"moveFirst\",\n    \"moveFocusDown\",\n    \"moveFocusLeft\",\n    \"moveFocusRight\",\n    \"moveFocusUp\",\n    \"moveNext\",\n    \"moveRow\",\n    \"moveStart\",\n    \"moveTo\",\n    \"moveToBookmark\",\n    \"moveToElementText\",\n    \"moveToPoint\",\n    \"mozAdd\",\n    \"mozAnimationStartTime\",\n    \"mozAnon\",\n    \"mozApps\",\n    \"mozAudioCaptured\",\n    \"mozAudioChannelType\",\n    \"mozAutoplayEnabled\",\n    \"mozCancelAnimationFrame\",\n    \"mozCancelFullScreen\",\n    \"mozCancelRequestAnimationFrame\",\n    \"mozCaptureStream\",\n    \"mozCaptureStreamUntilEnded\",\n    \"mozClearDataAt\",\n    \"mozContact\",\n    \"mozContacts\",\n    \"mozCreateFileHandle\",\n    \"mozCurrentTransform\",\n    \"mozCurrentTransformInverse\",\n    \"mozCursor\",\n    \"mozDash\",\n    \"mozDashOffset\",\n    \"mozDecodedFrames\",\n    \"mozExitPointerLock\",\n    \"mozFillRule\",\n    \"mozFragmentEnd\",\n    \"mozFrameDelay\",\n    \"mozFullScreen\",\n    \"mozFullScreenElement\",\n    \"mozFullScreenEnabled\",\n    \"mozGetAll\",\n    \"mozGetAllKeys\",\n    \"mozGetAsFile\",\n    \"mozGetDataAt\",\n    \"mozGetMetadata\",\n    \"mozGetUserMedia\",\n    \"mozHasAudio\",\n    \"mozHasItem\",\n    \"mozHidden\",\n    \"mozImageSmoothingEnabled\",\n    \"mozIndexedDB\",\n    \"mozInnerScreenX\",\n    \"mozInnerScreenY\",\n    \"mozInputSource\",\n    \"mozIsTextField\",\n    \"mozItem\",\n    \"mozItemCount\",\n    \"mozItems\",\n    \"mozLength\",\n    \"mozLockOrientation\",\n    \"mozMatchesSelector\",\n    \"mozMovementX\",\n    \"mozMovementY\",\n    \"mozOpaque\",\n    \"mozOrientation\",\n    \"mozPaintCount\",\n    \"mozPaintedFrames\",\n    \"mozParsedFrames\",\n    \"mozPay\",\n    \"mozPointerLockElement\",\n    \"mozPresentedFrames\",\n    \"mozPreservesPitch\",\n    \"mozPressure\",\n    \"mozPrintCallback\",\n    \"mozRTCIceCandidate\",\n    \"mozRTCPeerConnection\",\n    \"mozRTCSessionDescription\",\n    \"mozRemove\",\n    \"mozRequestAnimationFrame\",\n    \"mozRequestFullScreen\",\n    \"mozRequestPointerLock\",\n    \"mozSetDataAt\",\n    \"mozSetImageElement\",\n    \"mozSourceNode\",\n    \"mozSrcObject\",\n    \"mozSystem\",\n    \"mozTCPSocket\",\n    \"mozTextStyle\",\n    \"mozTypesAt\",\n    \"mozUnlockOrientation\",\n    \"mozUserCancelled\",\n    \"mozVisibilityState\",\n    \"msAnimation\",\n    \"msAnimationDelay\",\n    \"msAnimationDirection\",\n    \"msAnimationDuration\",\n    \"msAnimationFillMode\",\n    \"msAnimationIterationCount\",\n    \"msAnimationName\",\n    \"msAnimationPlayState\",\n    \"msAnimationStartTime\",\n    \"msAnimationTimingFunction\",\n    \"msBackfaceVisibility\",\n    \"msBlockProgression\",\n    \"msCSSOMElementFloatMetrics\",\n    \"msCaching\",\n    \"msCachingEnabled\",\n    \"msCancelRequestAnimationFrame\",\n    \"msCapsLockWarningOff\",\n    \"msClearImmediate\",\n    \"msClose\",\n    \"msContentZoomChaining\",\n    \"msContentZoomFactor\",\n    \"msContentZoomLimit\",\n    \"msContentZoomLimitMax\",\n    \"msContentZoomLimitMin\",\n    \"msContentZoomSnap\",\n    \"msContentZoomSnapPoints\",\n    \"msContentZoomSnapType\",\n    \"msContentZooming\",\n    \"msConvertURL\",\n    \"msCrypto\",\n    \"msDoNotTrack\",\n    \"msElementsFromPoint\",\n    \"msElementsFromRect\",\n    \"msExitFullscreen\",\n    \"msExtendedCode\",\n    \"msFillRule\",\n    \"msFirstPaint\",\n    \"msFlex\",\n    \"msFlexAlign\",\n    \"msFlexDirection\",\n    \"msFlexFlow\",\n    \"msFlexItemAlign\",\n    \"msFlexLinePack\",\n    \"msFlexNegative\",\n    \"msFlexOrder\",\n    \"msFlexPack\",\n    \"msFlexPositive\",\n    \"msFlexPreferredSize\",\n    \"msFlexWrap\",\n    \"msFlowFrom\",\n    \"msFlowInto\",\n    \"msFontFeatureSettings\",\n    \"msFullscreenElement\",\n    \"msFullscreenEnabled\",\n    \"msGetInputContext\",\n    \"msGetRegionContent\",\n    \"msGetUntransformedBounds\",\n    \"msGraphicsTrustStatus\",\n    \"msGridColumn\",\n    \"msGridColumnAlign\",\n    \"msGridColumnSpan\",\n    \"msGridColumns\",\n    \"msGridRow\",\n    \"msGridRowAlign\",\n    \"msGridRowSpan\",\n    \"msGridRows\",\n    \"msHidden\",\n    \"msHighContrastAdjust\",\n    \"msHyphenateLimitChars\",\n    \"msHyphenateLimitLines\",\n    \"msHyphenateLimitZone\",\n    \"msHyphens\",\n    \"msImageSmoothingEnabled\",\n    \"msImeAlign\",\n    \"msIndexedDB\",\n    \"msInterpolationMode\",\n    \"msIsStaticHTML\",\n    \"msKeySystem\",\n    \"msKeys\",\n    \"msLaunchUri\",\n    \"msLockOrientation\",\n    \"msManipulationViewsEnabled\",\n    \"msMatchMedia\",\n    \"msMatchesSelector\",\n    \"msMaxTouchPoints\",\n    \"msOrientation\",\n    \"msOverflowStyle\",\n    \"msPerspective\",\n    \"msPerspectiveOrigin\",\n    \"msPlayToDisabled\",\n    \"msPlayToPreferredSourceUri\",\n    \"msPlayToPrimary\",\n    \"msPointerEnabled\",\n    \"msRegionOverflow\",\n    \"msReleasePointerCapture\",\n    \"msRequestAnimationFrame\",\n    \"msRequestFullscreen\",\n    \"msSaveBlob\",\n    \"msSaveOrOpenBlob\",\n    \"msScrollChaining\",\n    \"msScrollLimit\",\n    \"msScrollLimitXMax\",\n    \"msScrollLimitXMin\",\n    \"msScrollLimitYMax\",\n    \"msScrollLimitYMin\",\n    \"msScrollRails\",\n    \"msScrollSnapPointsX\",\n    \"msScrollSnapPointsY\",\n    \"msScrollSnapType\",\n    \"msScrollSnapX\",\n    \"msScrollSnapY\",\n    \"msScrollTranslation\",\n    \"msSetImmediate\",\n    \"msSetMediaKeys\",\n    \"msSetPointerCapture\",\n    \"msTextCombineHorizontal\",\n    \"msTextSizeAdjust\",\n    \"msToBlob\",\n    \"msTouchAction\",\n    \"msTouchSelect\",\n    \"msTraceAsyncCallbackCompleted\",\n    \"msTraceAsyncCallbackStarting\",\n    \"msTraceAsyncOperationCompleted\",\n    \"msTraceAsyncOperationStarting\",\n    \"msTransform\",\n    \"msTransformOrigin\",\n    \"msTransformStyle\",\n    \"msTransition\",\n    \"msTransitionDelay\",\n    \"msTransitionDuration\",\n    \"msTransitionProperty\",\n    \"msTransitionTimingFunction\",\n    \"msUnlockOrientation\",\n    \"msUpdateAsyncCallbackRelation\",\n    \"msUserSelect\",\n    \"msVisibilityState\",\n    \"msWrapFlow\",\n    \"msWrapMargin\",\n    \"msWrapThrough\",\n    \"msWriteProfilerMark\",\n    \"msZoom\",\n    \"msZoomTo\",\n    \"mt\",\n    \"multiEntry\",\n    \"multiSelectionObj\",\n    \"multiline\",\n    \"multiple\",\n    \"multiply\",\n    \"multiplySelf\",\n    \"mutableFile\",\n    \"muted\",\n    \"n\",\n    \"name\",\n    \"nameProp\",\n    \"namedItem\",\n    \"namedRecordset\",\n    \"names\",\n    \"namespaceURI\",\n    \"namespaces\",\n    \"naturalHeight\",\n    \"naturalWidth\",\n    \"navigate\",\n    \"navigation\",\n    \"navigationMode\",\n    \"navigationStart\",\n    \"navigator\",\n    \"near\",\n    \"nearestViewportElement\",\n    \"negative\",\n    \"netscape\",\n    \"networkState\",\n    \"newScale\",\n    \"newTranslate\",\n    \"newURL\",\n    \"newValue\",\n    \"newValueSpecifiedUnits\",\n    \"newVersion\",\n    \"newhome\",\n    \"next\",\n    \"nextElementSibling\",\n    \"nextNode\",\n    \"nextPage\",\n    \"nextSibling\",\n    \"nickname\",\n    \"noHref\",\n    \"noResize\",\n    \"noShade\",\n    \"noValidate\",\n    \"noWrap\",\n    \"nodeName\",\n    \"nodeType\",\n    \"nodeValue\",\n    \"normalize\",\n    \"normalizedPathSegList\",\n    \"notationName\",\n    \"notations\",\n    \"note\",\n    \"noteGrainOn\",\n    \"noteOff\",\n    \"noteOn\",\n    \"now\",\n    \"numOctaves\",\n    \"number\",\n    \"numberOfChannels\",\n    \"numberOfInputs\",\n    \"numberOfItems\",\n    \"numberOfOutputs\",\n    \"numberValue\",\n    \"oMatchesSelector\",\n    \"object\",\n    \"object-fit\",\n    \"object-position\",\n    \"objectFit\",\n    \"objectPosition\",\n    \"objectStore\",\n    \"objectStoreNames\",\n    \"observe\",\n    \"of\",\n    \"offscreenBuffering\",\n    \"offset\",\n    \"offsetHeight\",\n    \"offsetLeft\",\n    \"offsetNode\",\n    \"offsetParent\",\n    \"offsetTop\",\n    \"offsetWidth\",\n    \"offsetX\",\n    \"offsetY\",\n    \"ok\",\n    \"oldURL\",\n    \"oldValue\",\n    \"oldVersion\",\n    \"olderShadowRoot\",\n    \"onLine\",\n    \"onabort\",\n    \"onactivate\",\n    \"onactive\",\n    \"onaddstream\",\n    \"onaddtrack\",\n    \"onafterprint\",\n    \"onafterscriptexecute\",\n    \"onafterupdate\",\n    \"onaudioend\",\n    \"onaudioprocess\",\n    \"onaudiostart\",\n    \"onautocomplete\",\n    \"onautocompleteerror\",\n    \"onbeforeactivate\",\n    \"onbeforecopy\",\n    \"onbeforecut\",\n    \"onbeforedeactivate\",\n    \"onbeforeeditfocus\",\n    \"onbeforepaste\",\n    \"onbeforeprint\",\n    \"onbeforescriptexecute\",\n    \"onbeforeunload\",\n    \"onbeforeupdate\",\n    \"onblocked\",\n    \"onblur\",\n    \"onbounce\",\n    \"onboundary\",\n    \"oncached\",\n    \"oncancel\",\n    \"oncandidatewindowhide\",\n    \"oncandidatewindowshow\",\n    \"oncandidatewindowupdate\",\n    \"oncanplay\",\n    \"oncanplaythrough\",\n    \"oncellchange\",\n    \"onchange\",\n    \"onchargingchange\",\n    \"onchargingtimechange\",\n    \"onchecking\",\n    \"onclick\",\n    \"onclose\",\n    \"oncompassneedscalibration\",\n    \"oncomplete\",\n    \"oncontextmenu\",\n    \"oncontrolselect\",\n    \"oncopy\",\n    \"oncuechange\",\n    \"oncut\",\n    \"ondataavailable\",\n    \"ondatachannel\",\n    \"ondatasetchanged\",\n    \"ondatasetcomplete\",\n    \"ondblclick\",\n    \"ondeactivate\",\n    \"ondevicelight\",\n    \"ondevicemotion\",\n    \"ondeviceorientation\",\n    \"ondeviceproximity\",\n    \"ondischargingtimechange\",\n    \"ondisplay\",\n    \"ondownloading\",\n    \"ondrag\",\n    \"ondragend\",\n    \"ondragenter\",\n    \"ondragleave\",\n    \"ondragover\",\n    \"ondragstart\",\n    \"ondrop\",\n    \"ondurationchange\",\n    \"onemptied\",\n    \"onencrypted\",\n    \"onend\",\n    \"onended\",\n    \"onenter\",\n    \"onerror\",\n    \"onerrorupdate\",\n    \"onexit\",\n    \"onfilterchange\",\n    \"onfinish\",\n    \"onfocus\",\n    \"onfocusin\",\n    \"onfocusout\",\n    \"onfullscreenchange\",\n    \"onfullscreenerror\",\n    \"ongesturechange\",\n    \"ongestureend\",\n    \"ongesturestart\",\n    \"ongotpointercapture\",\n    \"onhashchange\",\n    \"onhelp\",\n    \"onicecandidate\",\n    \"oniceconnectionstatechange\",\n    \"oninactive\",\n    \"oninput\",\n    \"oninvalid\",\n    \"onkeydown\",\n    \"onkeypress\",\n    \"onkeyup\",\n    \"onlanguagechange\",\n    \"onlayoutcomplete\",\n    \"onlevelchange\",\n    \"onload\",\n    \"onloadeddata\",\n    \"onloadedmetadata\",\n    \"onloadend\",\n    \"onloadstart\",\n    \"onlosecapture\",\n    \"onlostpointercapture\",\n    \"only\",\n    \"onmark\",\n    \"onmessage\",\n    \"onmousedown\",\n    \"onmouseenter\",\n    \"onmouseleave\",\n    \"onmousemove\",\n    \"onmouseout\",\n    \"onmouseover\",\n    \"onmouseup\",\n    \"onmousewheel\",\n    \"onmove\",\n    \"onmoveend\",\n    \"onmovestart\",\n    \"onmozfullscreenchange\",\n    \"onmozfullscreenerror\",\n    \"onmozorientationchange\",\n    \"onmozpointerlockchange\",\n    \"onmozpointerlockerror\",\n    \"onmscontentzoom\",\n    \"onmsfullscreenchange\",\n    \"onmsfullscreenerror\",\n    \"onmsgesturechange\",\n    \"onmsgesturedoubletap\",\n    \"onmsgestureend\",\n    \"onmsgesturehold\",\n    \"onmsgesturestart\",\n    \"onmsgesturetap\",\n    \"onmsgotpointercapture\",\n    \"onmsinertiastart\",\n    \"onmslostpointercapture\",\n    \"onmsmanipulationstatechanged\",\n    \"onmsneedkey\",\n    \"onmsorientationchange\",\n    \"onmspointercancel\",\n    \"onmspointerdown\",\n    \"onmspointerenter\",\n    \"onmspointerhover\",\n    \"onmspointerleave\",\n    \"onmspointermove\",\n    \"onmspointerout\",\n    \"onmspointerover\",\n    \"onmspointerup\",\n    \"onmssitemodejumplistitemremoved\",\n    \"onmsthumbnailclick\",\n    \"onnegotiationneeded\",\n    \"onnomatch\",\n    \"onnoupdate\",\n    \"onobsolete\",\n    \"onoffline\",\n    \"ononline\",\n    \"onopen\",\n    \"onorientationchange\",\n    \"onpagechange\",\n    \"onpagehide\",\n    \"onpageshow\",\n    \"onpaste\",\n    \"onpause\",\n    \"onplay\",\n    \"onplaying\",\n    \"onpluginstreamstart\",\n    \"onpointercancel\",\n    \"onpointerdown\",\n    \"onpointerenter\",\n    \"onpointerleave\",\n    \"onpointerlockchange\",\n    \"onpointerlockerror\",\n    \"onpointermove\",\n    \"onpointerout\",\n    \"onpointerover\",\n    \"onpointerup\",\n    \"onpopstate\",\n    \"onprogress\",\n    \"onpropertychange\",\n    \"onratechange\",\n    \"onreadystatechange\",\n    \"onremovestream\",\n    \"onremovetrack\",\n    \"onreset\",\n    \"onresize\",\n    \"onresizeend\",\n    \"onresizestart\",\n    \"onresourcetimingbufferfull\",\n    \"onresult\",\n    \"onresume\",\n    \"onrowenter\",\n    \"onrowexit\",\n    \"onrowsdelete\",\n    \"onrowsinserted\",\n    \"onscroll\",\n    \"onsearch\",\n    \"onseeked\",\n    \"onseeking\",\n    \"onselect\",\n    \"onselectionchange\",\n    \"onselectstart\",\n    \"onshow\",\n    \"onsignalingstatechange\",\n    \"onsoundend\",\n    \"onsoundstart\",\n    \"onspeechend\",\n    \"onspeechstart\",\n    \"onstalled\",\n    \"onstart\",\n    \"onstatechange\",\n    \"onstop\",\n    \"onstorage\",\n    \"onstoragecommit\",\n    \"onsubmit\",\n    \"onsuccess\",\n    \"onsuspend\",\n    \"ontextinput\",\n    \"ontimeout\",\n    \"ontimeupdate\",\n    \"ontoggle\",\n    \"ontouchcancel\",\n    \"ontouchend\",\n    \"ontouchmove\",\n    \"ontouchstart\",\n    \"ontransitionend\",\n    \"onunload\",\n    \"onupdateready\",\n    \"onupgradeneeded\",\n    \"onuserproximity\",\n    \"onversionchange\",\n    \"onvoiceschanged\",\n    \"onvolumechange\",\n    \"onwaiting\",\n    \"onwarning\",\n    \"onwebkitanimationend\",\n    \"onwebkitanimationiteration\",\n    \"onwebkitanimationstart\",\n    \"onwebkitcurrentplaybacktargetiswirelesschanged\",\n    \"onwebkitfullscreenchange\",\n    \"onwebkitfullscreenerror\",\n    \"onwebkitkeyadded\",\n    \"onwebkitkeyerror\",\n    \"onwebkitkeymessage\",\n    \"onwebkitneedkey\",\n    \"onwebkitorientationchange\",\n    \"onwebkitplaybacktargetavailabilitychanged\",\n    \"onwebkitpointerlockchange\",\n    \"onwebkitpointerlockerror\",\n    \"onwebkitresourcetimingbufferfull\",\n    \"onwebkittransitionend\",\n    \"onwheel\",\n    \"onzoom\",\n    \"opacity\",\n    \"open\",\n    \"openCursor\",\n    \"openDatabase\",\n    \"openKeyCursor\",\n    \"opener\",\n    \"opera\",\n    \"operationType\",\n    \"operator\",\n    \"opr\",\n    \"optimum\",\n    \"options\",\n    \"order\",\n    \"orderX\",\n    \"orderY\",\n    \"ordered\",\n    \"org\",\n    \"orient\",\n    \"orientAngle\",\n    \"orientType\",\n    \"orientation\",\n    \"origin\",\n    \"originalTarget\",\n    \"orphans\",\n    \"oscpu\",\n    \"outerHTML\",\n    \"outerHeight\",\n    \"outerText\",\n    \"outerWidth\",\n    \"outline\",\n    \"outline-color\",\n    \"outline-offset\",\n    \"outline-style\",\n    \"outline-width\",\n    \"outlineColor\",\n    \"outlineOffset\",\n    \"outlineStyle\",\n    \"outlineWidth\",\n    \"outputBuffer\",\n    \"overflow\",\n    \"overflow-x\",\n    \"overflow-y\",\n    \"overflowX\",\n    \"overflowY\",\n    \"overrideMimeType\",\n    \"oversample\",\n    \"ownerDocument\",\n    \"ownerElement\",\n    \"ownerNode\",\n    \"ownerRule\",\n    \"ownerSVGElement\",\n    \"owningElement\",\n    \"p1\",\n    \"p2\",\n    \"p3\",\n    \"p4\",\n    \"pad\",\n    \"padding\",\n    \"padding-bottom\",\n    \"padding-left\",\n    \"padding-right\",\n    \"padding-top\",\n    \"paddingBottom\",\n    \"paddingLeft\",\n    \"paddingRight\",\n    \"paddingTop\",\n    \"page\",\n    \"page-break-after\",\n    \"page-break-before\",\n    \"page-break-inside\",\n    \"pageBreakAfter\",\n    \"pageBreakBefore\",\n    \"pageBreakInside\",\n    \"pageCount\",\n    \"pageX\",\n    \"pageXOffset\",\n    \"pageY\",\n    \"pageYOffset\",\n    \"pages\",\n    \"paint-order\",\n    \"paintOrder\",\n    \"paintRequests\",\n    \"paintType\",\n    \"palette\",\n    \"panningModel\",\n    \"parent\",\n    \"parentElement\",\n    \"parentNode\",\n    \"parentRule\",\n    \"parentStyleSheet\",\n    \"parentTextEdit\",\n    \"parentWindow\",\n    \"parse\",\n    \"parseFloat\",\n    \"parseFromString\",\n    \"parseInt\",\n    \"participants\",\n    \"password\",\n    \"pasteHTML\",\n    \"path\",\n    \"pathLength\",\n    \"pathSegList\",\n    \"pathSegType\",\n    \"pathSegTypeAsLetter\",\n    \"pathname\",\n    \"pattern\",\n    \"patternContentUnits\",\n    \"patternMismatch\",\n    \"patternTransform\",\n    \"patternUnits\",\n    \"pause\",\n    \"pauseAnimations\",\n    \"pauseOnExit\",\n    \"paused\",\n    \"pending\",\n    \"performance\",\n    \"permission\",\n    \"persisted\",\n    \"personalbar\",\n    \"perspective\",\n    \"perspective-origin\",\n    \"perspectiveOrigin\",\n    \"phoneticFamilyName\",\n    \"phoneticGivenName\",\n    \"photo\",\n    \"ping\",\n    \"pitch\",\n    \"pixelBottom\",\n    \"pixelDepth\",\n    \"pixelHeight\",\n    \"pixelLeft\",\n    \"pixelRight\",\n    \"pixelStorei\",\n    \"pixelTop\",\n    \"pixelUnitToMillimeterX\",\n    \"pixelUnitToMillimeterY\",\n    \"pixelWidth\",\n    \"placeholder\",\n    \"platform\",\n    \"play\",\n    \"playbackRate\",\n    \"playbackState\",\n    \"playbackTime\",\n    \"played\",\n    \"plugins\",\n    \"pluginspage\",\n    \"pname\",\n    \"pointer-events\",\n    \"pointerBeforeReferenceNode\",\n    \"pointerEnabled\",\n    \"pointerEvents\",\n    \"pointerId\",\n    \"pointerLockElement\",\n    \"pointerType\",\n    \"points\",\n    \"pointsAtX\",\n    \"pointsAtY\",\n    \"pointsAtZ\",\n    \"polygonOffset\",\n    \"pop\",\n    \"popupWindowFeatures\",\n    \"popupWindowName\",\n    \"popupWindowURI\",\n    \"port\",\n    \"port1\",\n    \"port2\",\n    \"ports\",\n    \"posBottom\",\n    \"posHeight\",\n    \"posLeft\",\n    \"posRight\",\n    \"posTop\",\n    \"posWidth\",\n    \"position\",\n    \"positionAlign\",\n    \"postError\",\n    \"postMessage\",\n    \"poster\",\n    \"pow\",\n    \"powerOff\",\n    \"preMultiplySelf\",\n    \"precision\",\n    \"preferredStyleSheetSet\",\n    \"preferredStylesheetSet\",\n    \"prefix\",\n    \"preload\",\n    \"preserveAlpha\",\n    \"preserveAspectRatio\",\n    \"preserveAspectRatioString\",\n    \"pressed\",\n    \"pressure\",\n    \"prevValue\",\n    \"preventDefault\",\n    \"preventExtensions\",\n    \"previousElementSibling\",\n    \"previousNode\",\n    \"previousPage\",\n    \"previousScale\",\n    \"previousSibling\",\n    \"previousTranslate\",\n    \"primaryKey\",\n    \"primitiveType\",\n    \"primitiveUnits\",\n    \"principals\",\n    \"print\",\n    \"privateKey\",\n    \"probablySupportsContext\",\n    \"process\",\n    \"processIceMessage\",\n    \"product\",\n    \"productSub\",\n    \"profile\",\n    \"profileEnd\",\n    \"profiles\",\n    \"prompt\",\n    \"properties\",\n    \"propertyIsEnumerable\",\n    \"propertyName\",\n    \"protocol\",\n    \"protocolLong\",\n    \"prototype\",\n    \"pseudoClass\",\n    \"pseudoElement\",\n    \"publicId\",\n    \"publicKey\",\n    \"published\",\n    \"push\",\n    \"pushNotification\",\n    \"pushState\",\n    \"put\",\n    \"putImageData\",\n    \"quadraticCurveTo\",\n    \"qualifier\",\n    \"queryCommandEnabled\",\n    \"queryCommandIndeterm\",\n    \"queryCommandState\",\n    \"queryCommandSupported\",\n    \"queryCommandText\",\n    \"queryCommandValue\",\n    \"querySelector\",\n    \"querySelectorAll\",\n    \"quote\",\n    \"quotes\",\n    \"r\",\n    \"r1\",\n    \"r2\",\n    \"race\",\n    \"radiogroup\",\n    \"radiusX\",\n    \"radiusY\",\n    \"random\",\n    \"range\",\n    \"rangeCount\",\n    \"rangeMax\",\n    \"rangeMin\",\n    \"rangeOffset\",\n    \"rangeOverflow\",\n    \"rangeParent\",\n    \"rangeUnderflow\",\n    \"rate\",\n    \"ratio\",\n    \"raw\",\n    \"read\",\n    \"readAsArrayBuffer\",\n    \"readAsBinaryString\",\n    \"readAsBlob\",\n    \"readAsDataURL\",\n    \"readAsText\",\n    \"readOnly\",\n    \"readPixels\",\n    \"readReportRequested\",\n    \"readyState\",\n    \"reason\",\n    \"reboot\",\n    \"receiver\",\n    \"receivers\",\n    \"recordNumber\",\n    \"recordset\",\n    \"rect\",\n    \"red\",\n    \"redirectCount\",\n    \"redirectEnd\",\n    \"redirectStart\",\n    \"reduce\",\n    \"reduceRight\",\n    \"reduction\",\n    \"refDistance\",\n    \"refX\",\n    \"refY\",\n    \"referenceNode\",\n    \"referrer\",\n    \"refresh\",\n    \"region\",\n    \"regionAnchorX\",\n    \"regionAnchorY\",\n    \"regionId\",\n    \"regions\",\n    \"register\",\n    \"registerContentHandler\",\n    \"registerElement\",\n    \"registerProtocolHandler\",\n    \"reject\",\n    \"rel\",\n    \"relList\",\n    \"relatedNode\",\n    \"relatedTarget\",\n    \"release\",\n    \"releaseCapture\",\n    \"releaseEvents\",\n    \"releasePointerCapture\",\n    \"releaseShaderCompiler\",\n    \"reliable\",\n    \"reload\",\n    \"remainingSpace\",\n    \"remoteDescription\",\n    \"remove\",\n    \"removeAllRanges\",\n    \"removeAttribute\",\n    \"removeAttributeNS\",\n    \"removeAttributeNode\",\n    \"removeBehavior\",\n    \"removeChild\",\n    \"removeCue\",\n    \"removeEventListener\",\n    \"removeFilter\",\n    \"removeImport\",\n    \"removeItem\",\n    \"removeListener\",\n    \"removeNamedItem\",\n    \"removeNamedItemNS\",\n    \"removeNode\",\n    \"removeParameter\",\n    \"removeProperty\",\n    \"removeRange\",\n    \"removeRegion\",\n    \"removeRule\",\n    \"removeSiteSpecificTrackingException\",\n    \"removeSourceBuffer\",\n    \"removeStream\",\n    \"removeTrack\",\n    \"removeVariable\",\n    \"removeWakeLockListener\",\n    \"removeWebWideTrackingException\",\n    \"removedNodes\",\n    \"renderbufferStorage\",\n    \"renderedBuffer\",\n    \"renderingMode\",\n    \"repeat\",\n    \"replace\",\n    \"replaceAdjacentText\",\n    \"replaceChild\",\n    \"replaceData\",\n    \"replaceId\",\n    \"replaceItem\",\n    \"replaceNode\",\n    \"replaceState\",\n    \"replaceTrack\",\n    \"replaceWholeText\",\n    \"reportValidity\",\n    \"requestAnimationFrame\",\n    \"requestAutocomplete\",\n    \"requestData\",\n    \"requestFullscreen\",\n    \"requestMediaKeySystemAccess\",\n    \"requestPermission\",\n    \"requestPointerLock\",\n    \"requestStart\",\n    \"requestingWindow\",\n    \"required\",\n    \"requiredExtensions\",\n    \"requiredFeatures\",\n    \"reset\",\n    \"resetTransform\",\n    \"resize\",\n    \"resizeBy\",\n    \"resizeTo\",\n    \"resolve\",\n    \"response\",\n    \"responseBody\",\n    \"responseEnd\",\n    \"responseStart\",\n    \"responseText\",\n    \"responseType\",\n    \"responseURL\",\n    \"responseXML\",\n    \"restore\",\n    \"result\",\n    \"resultType\",\n    \"resume\",\n    \"returnValue\",\n    \"rev\",\n    \"reverse\",\n    \"reversed\",\n    \"revocable\",\n    \"revokeObjectURL\",\n    \"rgbColor\",\n    \"right\",\n    \"rightContext\",\n    \"rightMargin\",\n    \"rolloffFactor\",\n    \"root\",\n    \"rootElement\",\n    \"rotate\",\n    \"rotateAxisAngle\",\n    \"rotateAxisAngleSelf\",\n    \"rotateFromVector\",\n    \"rotateFromVectorSelf\",\n    \"rotateSelf\",\n    \"rotation\",\n    \"rotationRate\",\n    \"round\",\n    \"rowIndex\",\n    \"rowSpan\",\n    \"rows\",\n    \"rubyAlign\",\n    \"rubyOverhang\",\n    \"rubyPosition\",\n    \"rules\",\n    \"runtime\",\n    \"runtimeStyle\",\n    \"rx\",\n    \"ry\",\n    \"safari\",\n    \"sampleCoverage\",\n    \"sampleRate\",\n    \"sandbox\",\n    \"save\",\n    \"scale\",\n    \"scale3d\",\n    \"scale3dSelf\",\n    \"scaleNonUniform\",\n    \"scaleNonUniformSelf\",\n    \"scaleSelf\",\n    \"scheme\",\n    \"scissor\",\n    \"scope\",\n    \"scopeName\",\n    \"scoped\",\n    \"screen\",\n    \"screenBrightness\",\n    \"screenEnabled\",\n    \"screenLeft\",\n    \"screenPixelToMillimeterX\",\n    \"screenPixelToMillimeterY\",\n    \"screenTop\",\n    \"screenX\",\n    \"screenY\",\n    \"scripts\",\n    \"scroll\",\n    \"scroll-behavior\",\n    \"scrollAmount\",\n    \"scrollBehavior\",\n    \"scrollBy\",\n    \"scrollByLines\",\n    \"scrollByPages\",\n    \"scrollDelay\",\n    \"scrollHeight\",\n    \"scrollIntoView\",\n    \"scrollIntoViewIfNeeded\",\n    \"scrollLeft\",\n    \"scrollLeftMax\",\n    \"scrollMaxX\",\n    \"scrollMaxY\",\n    \"scrollTo\",\n    \"scrollTop\",\n    \"scrollTopMax\",\n    \"scrollWidth\",\n    \"scrollX\",\n    \"scrollY\",\n    \"scrollbar3dLightColor\",\n    \"scrollbarArrowColor\",\n    \"scrollbarBaseColor\",\n    \"scrollbarDarkShadowColor\",\n    \"scrollbarFaceColor\",\n    \"scrollbarHighlightColor\",\n    \"scrollbarShadowColor\",\n    \"scrollbarTrackColor\",\n    \"scrollbars\",\n    \"scrolling\",\n    \"sdp\",\n    \"sdpMLineIndex\",\n    \"sdpMid\",\n    \"seal\",\n    \"search\",\n    \"searchBox\",\n    \"searchBoxJavaBridge_\",\n    \"searchParams\",\n    \"sectionRowIndex\",\n    \"secureConnectionStart\",\n    \"security\",\n    \"seed\",\n    \"seekable\",\n    \"seeking\",\n    \"select\",\n    \"selectAllChildren\",\n    \"selectNode\",\n    \"selectNodeContents\",\n    \"selectNodes\",\n    \"selectSingleNode\",\n    \"selectSubString\",\n    \"selected\",\n    \"selectedIndex\",\n    \"selectedOptions\",\n    \"selectedStyleSheetSet\",\n    \"selectedStylesheetSet\",\n    \"selection\",\n    \"selectionDirection\",\n    \"selectionEnd\",\n    \"selectionStart\",\n    \"selector\",\n    \"selectorText\",\n    \"self\",\n    \"send\",\n    \"sendAsBinary\",\n    \"sendBeacon\",\n    \"sender\",\n    \"sentTimestamp\",\n    \"separator\",\n    \"serializeToString\",\n    \"serviceWorker\",\n    \"sessionId\",\n    \"sessionStorage\",\n    \"set\",\n    \"setActive\",\n    \"setAlpha\",\n    \"setAttribute\",\n    \"setAttributeNS\",\n    \"setAttributeNode\",\n    \"setAttributeNodeNS\",\n    \"setBaseAndExtent\",\n    \"setBingCurrentSearchDefault\",\n    \"setCapture\",\n    \"setColor\",\n    \"setCompositeOperation\",\n    \"setCurrentTime\",\n    \"setCustomValidity\",\n    \"setData\",\n    \"setDate\",\n    \"setDragImage\",\n    \"setEnd\",\n    \"setEndAfter\",\n    \"setEndBefore\",\n    \"setEndPoint\",\n    \"setFillColor\",\n    \"setFilterRes\",\n    \"setFloat32\",\n    \"setFloat64\",\n    \"setFloatValue\",\n    \"setFullYear\",\n    \"setHours\",\n    \"setImmediate\",\n    \"setInt16\",\n    \"setInt32\",\n    \"setInt8\",\n    \"setInterval\",\n    \"setItem\",\n    \"setLineCap\",\n    \"setLineDash\",\n    \"setLineJoin\",\n    \"setLineWidth\",\n    \"setLocalDescription\",\n    \"setMatrix\",\n    \"setMatrixValue\",\n    \"setMediaKeys\",\n    \"setMilliseconds\",\n    \"setMinutes\",\n    \"setMiterLimit\",\n    \"setMonth\",\n    \"setNamedItem\",\n    \"setNamedItemNS\",\n    \"setNonUserCodeExceptions\",\n    \"setOrientToAngle\",\n    \"setOrientToAuto\",\n    \"setOrientation\",\n    \"setOverrideHistoryNavigationMode\",\n    \"setPaint\",\n    \"setParameter\",\n    \"setPeriodicWave\",\n    \"setPointerCapture\",\n    \"setPosition\",\n    \"setPreference\",\n    \"setProperty\",\n    \"setPrototypeOf\",\n    \"setRGBColor\",\n    \"setRGBColorICCColor\",\n    \"setRadius\",\n    \"setRangeText\",\n    \"setRemoteDescription\",\n    \"setRequestHeader\",\n    \"setResizable\",\n    \"setResourceTimingBufferSize\",\n    \"setRotate\",\n    \"setScale\",\n    \"setSeconds\",\n    \"setSelectionRange\",\n    \"setServerCertificate\",\n    \"setShadow\",\n    \"setSkewX\",\n    \"setSkewY\",\n    \"setStart\",\n    \"setStartAfter\",\n    \"setStartBefore\",\n    \"setStdDeviation\",\n    \"setStringValue\",\n    \"setStrokeColor\",\n    \"setSuggestResult\",\n    \"setTargetAtTime\",\n    \"setTargetValueAtTime\",\n    \"setTime\",\n    \"setTimeout\",\n    \"setTransform\",\n    \"setTranslate\",\n    \"setUTCDate\",\n    \"setUTCFullYear\",\n    \"setUTCHours\",\n    \"setUTCMilliseconds\",\n    \"setUTCMinutes\",\n    \"setUTCMonth\",\n    \"setUTCSeconds\",\n    \"setUint16\",\n    \"setUint32\",\n    \"setUint8\",\n    \"setUri\",\n    \"setValueAtTime\",\n    \"setValueCurveAtTime\",\n    \"setVariable\",\n    \"setVelocity\",\n    \"setVersion\",\n    \"setYear\",\n    \"settingName\",\n    \"settingValue\",\n    \"sex\",\n    \"shaderSource\",\n    \"shadowBlur\",\n    \"shadowColor\",\n    \"shadowOffsetX\",\n    \"shadowOffsetY\",\n    \"shadowRoot\",\n    \"shape\",\n    \"shape-rendering\",\n    \"shapeRendering\",\n    \"sheet\",\n    \"shift\",\n    \"shiftKey\",\n    \"shiftLeft\",\n    \"show\",\n    \"showHelp\",\n    \"showModal\",\n    \"showModalDialog\",\n    \"showModelessDialog\",\n    \"showNotification\",\n    \"sidebar\",\n    \"sign\",\n    \"signalingState\",\n    \"sin\",\n    \"singleNodeValue\",\n    \"sinh\",\n    \"size\",\n    \"sizeToContent\",\n    \"sizes\",\n    \"skewX\",\n    \"skewXSelf\",\n    \"skewY\",\n    \"skewYSelf\",\n    \"slice\",\n    \"slope\",\n    \"small\",\n    \"smooth\",\n    \"smil\",\n    \"smoothingTimeConstant\",\n    \"snapToLines\",\n    \"snapshotItem\",\n    \"snapshotLength\",\n    \"some\",\n    \"sort\",\n    \"source\",\n    \"sourceBuffer\",\n    \"sourceBuffers\",\n    \"sourceIndex\",\n    \"spacing\",\n    \"span\",\n    \"speakAs\",\n    \"speaking\",\n    \"specified\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"speechSynthesis\",\n    \"speed\",\n    \"speedOfSound\",\n    \"spellcheck\",\n    \"splice\",\n    \"split\",\n    \"splitText\",\n    \"spreadMethod\",\n    \"sqrt\",\n    \"src\",\n    \"srcElement\",\n    \"srcFilter\",\n    \"srcUrn\",\n    \"srcdoc\",\n    \"srclang\",\n    \"srcset\",\n    \"stack\",\n    \"stackTraceLimit\",\n    \"stacktrace\",\n    \"standalone\",\n    \"standby\",\n    \"start\",\n    \"startContainer\",\n    \"startIce\",\n    \"startOffset\",\n    \"startRendering\",\n    \"startTime\",\n    \"startsWith\",\n    \"state\",\n    \"status\",\n    \"statusMessage\",\n    \"statusText\",\n    \"statusbar\",\n    \"stdDeviationX\",\n    \"stdDeviationY\",\n    \"stencilFunc\",\n    \"stencilFuncSeparate\",\n    \"stencilMask\",\n    \"stencilMaskSeparate\",\n    \"stencilOp\",\n    \"stencilOpSeparate\",\n    \"step\",\n    \"stepDown\",\n    \"stepMismatch\",\n    \"stepUp\",\n    \"sticky\",\n    \"stitchTiles\",\n    \"stop\",\n    \"stop-color\",\n    \"stop-opacity\",\n    \"stopColor\",\n    \"stopImmediatePropagation\",\n    \"stopOpacity\",\n    \"stopPropagation\",\n    \"storageArea\",\n    \"storageName\",\n    \"storageStatus\",\n    \"storeSiteSpecificTrackingException\",\n    \"storeWebWideTrackingException\",\n    \"stpVersion\",\n    \"stream\",\n    \"strike\",\n    \"stringValue\",\n    \"stringify\",\n    \"stroke\",\n    \"stroke-dasharray\",\n    \"stroke-dashoffset\",\n    \"stroke-linecap\",\n    \"stroke-linejoin\",\n    \"stroke-miterlimit\",\n    \"stroke-opacity\",\n    \"stroke-width\",\n    \"strokeDasharray\",\n    \"strokeDashoffset\",\n    \"strokeLinecap\",\n    \"strokeLinejoin\",\n    \"strokeMiterlimit\",\n    \"strokeOpacity\",\n    \"strokeRect\",\n    \"strokeStyle\",\n    \"strokeText\",\n    \"strokeWidth\",\n    \"style\",\n    \"styleFloat\",\n    \"styleMedia\",\n    \"styleSheet\",\n    \"styleSheetSets\",\n    \"styleSheets\",\n    \"sub\",\n    \"subarray\",\n    \"subject\",\n    \"submit\",\n    \"subscribe\",\n    \"substr\",\n    \"substring\",\n    \"substringData\",\n    \"subtle\",\n    \"suffix\",\n    \"suffixes\",\n    \"summary\",\n    \"sup\",\n    \"supports\",\n    \"surfaceScale\",\n    \"surroundContents\",\n    \"suspend\",\n    \"suspendRedraw\",\n    \"swapCache\",\n    \"swapNode\",\n    \"sweepFlag\",\n    \"symbols\",\n    \"system\",\n    \"systemCode\",\n    \"systemId\",\n    \"systemLanguage\",\n    \"systemXDPI\",\n    \"systemYDPI\",\n    \"tBodies\",\n    \"tFoot\",\n    \"tHead\",\n    \"tabIndex\",\n    \"table\",\n    \"table-layout\",\n    \"tableLayout\",\n    \"tableValues\",\n    \"tag\",\n    \"tagName\",\n    \"tagUrn\",\n    \"tags\",\n    \"taintEnabled\",\n    \"takeRecords\",\n    \"tan\",\n    \"tanh\",\n    \"target\",\n    \"targetElement\",\n    \"targetTouches\",\n    \"targetX\",\n    \"targetY\",\n    \"tel\",\n    \"terminate\",\n    \"test\",\n    \"texImage2D\",\n    \"texParameterf\",\n    \"texParameteri\",\n    \"texSubImage2D\",\n    \"text\",\n    \"text-align\",\n    \"text-anchor\",\n    \"text-decoration\",\n    \"text-decoration-color\",\n    \"text-decoration-line\",\n    \"text-decoration-style\",\n    \"text-indent\",\n    \"text-overflow\",\n    \"text-rendering\",\n    \"text-shadow\",\n    \"text-transform\",\n    \"textAlign\",\n    \"textAlignLast\",\n    \"textAnchor\",\n    \"textAutospace\",\n    \"textBaseline\",\n    \"textContent\",\n    \"textDecoration\",\n    \"textDecorationBlink\",\n    \"textDecorationColor\",\n    \"textDecorationLine\",\n    \"textDecorationLineThrough\",\n    \"textDecorationNone\",\n    \"textDecorationOverline\",\n    \"textDecorationStyle\",\n    \"textDecorationUnderline\",\n    \"textIndent\",\n    \"textJustify\",\n    \"textJustifyTrim\",\n    \"textKashida\",\n    \"textKashidaSpace\",\n    \"textLength\",\n    \"textOverflow\",\n    \"textRendering\",\n    \"textShadow\",\n    \"textTracks\",\n    \"textTransform\",\n    \"textUnderlinePosition\",\n    \"then\",\n    \"threadId\",\n    \"threshold\",\n    \"tiltX\",\n    \"tiltY\",\n    \"time\",\n    \"timeEnd\",\n    \"timeStamp\",\n    \"timeout\",\n    \"timestamp\",\n    \"timestampOffset\",\n    \"timing\",\n    \"title\",\n    \"toArray\",\n    \"toBlob\",\n    \"toDataURL\",\n    \"toDateString\",\n    \"toElement\",\n    \"toExponential\",\n    \"toFixed\",\n    \"toFloat32Array\",\n    \"toFloat64Array\",\n    \"toGMTString\",\n    \"toISOString\",\n    \"toJSON\",\n    \"toLocaleDateString\",\n    \"toLocaleFormat\",\n    \"toLocaleLowerCase\",\n    \"toLocaleString\",\n    \"toLocaleTimeString\",\n    \"toLocaleUpperCase\",\n    \"toLowerCase\",\n    \"toMethod\",\n    \"toPrecision\",\n    \"toSdp\",\n    \"toSource\",\n    \"toStaticHTML\",\n    \"toString\",\n    \"toStringTag\",\n    \"toTimeString\",\n    \"toUTCString\",\n    \"toUpperCase\",\n    \"toggle\",\n    \"toggleLongPressEnabled\",\n    \"tooLong\",\n    \"toolbar\",\n    \"top\",\n    \"topMargin\",\n    \"total\",\n    \"totalFrameDelay\",\n    \"totalVideoFrames\",\n    \"touchAction\",\n    \"touches\",\n    \"trace\",\n    \"track\",\n    \"transaction\",\n    \"transactions\",\n    \"transform\",\n    \"transform-origin\",\n    \"transform-style\",\n    \"transformOrigin\",\n    \"transformPoint\",\n    \"transformString\",\n    \"transformStyle\",\n    \"transformToDocument\",\n    \"transformToFragment\",\n    \"transition\",\n    \"transition-delay\",\n    \"transition-duration\",\n    \"transition-property\",\n    \"transition-timing-function\",\n    \"transitionDelay\",\n    \"transitionDuration\",\n    \"transitionProperty\",\n    \"transitionTimingFunction\",\n    \"translate\",\n    \"translateSelf\",\n    \"translationX\",\n    \"translationY\",\n    \"trim\",\n    \"trimLeft\",\n    \"trimRight\",\n    \"trueSpeed\",\n    \"trunc\",\n    \"truncate\",\n    \"type\",\n    \"typeDetail\",\n    \"typeMismatch\",\n    \"typeMustMatch\",\n    \"types\",\n    \"ubound\",\n    \"undefined\",\n    \"unescape\",\n    \"uneval\",\n    \"unicode-bidi\",\n    \"unicodeBidi\",\n    \"uniform1f\",\n    \"uniform1fv\",\n    \"uniform1i\",\n    \"uniform1iv\",\n    \"uniform2f\",\n    \"uniform2fv\",\n    \"uniform2i\",\n    \"uniform2iv\",\n    \"uniform3f\",\n    \"uniform3fv\",\n    \"uniform3i\",\n    \"uniform3iv\",\n    \"uniform4f\",\n    \"uniform4fv\",\n    \"uniform4i\",\n    \"uniform4iv\",\n    \"uniformMatrix2fv\",\n    \"uniformMatrix3fv\",\n    \"uniformMatrix4fv\",\n    \"unique\",\n    \"uniqueID\",\n    \"uniqueNumber\",\n    \"unitType\",\n    \"units\",\n    \"unloadEventEnd\",\n    \"unloadEventStart\",\n    \"unlock\",\n    \"unmount\",\n    \"unobserve\",\n    \"unpause\",\n    \"unpauseAnimations\",\n    \"unreadCount\",\n    \"unregister\",\n    \"unregisterContentHandler\",\n    \"unregisterProtocolHandler\",\n    \"unscopables\",\n    \"unselectable\",\n    \"unshift\",\n    \"unsubscribe\",\n    \"unsuspendRedraw\",\n    \"unsuspendRedrawAll\",\n    \"unwatch\",\n    \"unwrapKey\",\n    \"update\",\n    \"updateCommands\",\n    \"updateIce\",\n    \"updateInterval\",\n    \"updateSettings\",\n    \"updated\",\n    \"updating\",\n    \"upload\",\n    \"upper\",\n    \"upperBound\",\n    \"upperOpen\",\n    \"uri\",\n    \"url\",\n    \"urn\",\n    \"urns\",\n    \"usages\",\n    \"useCurrentView\",\n    \"useMap\",\n    \"useProgram\",\n    \"usedSpace\",\n    \"userAgent\",\n    \"userLanguage\",\n    \"username\",\n    \"v8BreakIterator\",\n    \"vAlign\",\n    \"vLink\",\n    \"valid\",\n    \"validateProgram\",\n    \"validationMessage\",\n    \"validity\",\n    \"value\",\n    \"valueAsDate\",\n    \"valueAsNumber\",\n    \"valueAsString\",\n    \"valueInSpecifiedUnits\",\n    \"valueMissing\",\n    \"valueOf\",\n    \"valueText\",\n    \"valueType\",\n    \"values\",\n    \"vector-effect\",\n    \"vectorEffect\",\n    \"velocityAngular\",\n    \"velocityExpansion\",\n    \"velocityX\",\n    \"velocityY\",\n    \"vendor\",\n    \"vendorSub\",\n    \"verify\",\n    \"version\",\n    \"vertexAttrib1f\",\n    \"vertexAttrib1fv\",\n    \"vertexAttrib2f\",\n    \"vertexAttrib2fv\",\n    \"vertexAttrib3f\",\n    \"vertexAttrib3fv\",\n    \"vertexAttrib4f\",\n    \"vertexAttrib4fv\",\n    \"vertexAttribDivisorANGLE\",\n    \"vertexAttribPointer\",\n    \"vertical\",\n    \"vertical-align\",\n    \"verticalAlign\",\n    \"verticalOverflow\",\n    \"vibrate\",\n    \"videoHeight\",\n    \"videoTracks\",\n    \"videoWidth\",\n    \"view\",\n    \"viewBox\",\n    \"viewBoxString\",\n    \"viewTarget\",\n    \"viewTargetString\",\n    \"viewport\",\n    \"viewportAnchorX\",\n    \"viewportAnchorY\",\n    \"viewportElement\",\n    \"visibility\",\n    \"visibilityState\",\n    \"visible\",\n    \"vlinkColor\",\n    \"voice\",\n    \"volume\",\n    \"vrml\",\n    \"vspace\",\n    \"w\",\n    \"wand\",\n    \"warn\",\n    \"wasClean\",\n    \"watch\",\n    \"watchPosition\",\n    \"webdriver\",\n    \"webkitAddKey\",\n    \"webkitAnimation\",\n    \"webkitAnimationDelay\",\n    \"webkitAnimationDirection\",\n    \"webkitAnimationDuration\",\n    \"webkitAnimationFillMode\",\n    \"webkitAnimationIterationCount\",\n    \"webkitAnimationName\",\n    \"webkitAnimationPlayState\",\n    \"webkitAnimationTimingFunction\",\n    \"webkitAppearance\",\n    \"webkitAudioContext\",\n    \"webkitAudioDecodedByteCount\",\n    \"webkitAudioPannerNode\",\n    \"webkitBackfaceVisibility\",\n    \"webkitBackground\",\n    \"webkitBackgroundAttachment\",\n    \"webkitBackgroundClip\",\n    \"webkitBackgroundColor\",\n    \"webkitBackgroundImage\",\n    \"webkitBackgroundOrigin\",\n    \"webkitBackgroundPosition\",\n    \"webkitBackgroundPositionX\",\n    \"webkitBackgroundPositionY\",\n    \"webkitBackgroundRepeat\",\n    \"webkitBackgroundSize\",\n    \"webkitBackingStorePixelRatio\",\n    \"webkitBorderImage\",\n    \"webkitBorderImageOutset\",\n    \"webkitBorderImageRepeat\",\n    \"webkitBorderImageSlice\",\n    \"webkitBorderImageSource\",\n    \"webkitBorderImageWidth\",\n    \"webkitBoxAlign\",\n    \"webkitBoxDirection\",\n    \"webkitBoxFlex\",\n    \"webkitBoxOrdinalGroup\",\n    \"webkitBoxOrient\",\n    \"webkitBoxPack\",\n    \"webkitBoxSizing\",\n    \"webkitCancelAnimationFrame\",\n    \"webkitCancelFullScreen\",\n    \"webkitCancelKeyRequest\",\n    \"webkitCancelRequestAnimationFrame\",\n    \"webkitClearResourceTimings\",\n    \"webkitClosedCaptionsVisible\",\n    \"webkitConvertPointFromNodeToPage\",\n    \"webkitConvertPointFromPageToNode\",\n    \"webkitCreateShadowRoot\",\n    \"webkitCurrentFullScreenElement\",\n    \"webkitCurrentPlaybackTargetIsWireless\",\n    \"webkitDirectionInvertedFromDevice\",\n    \"webkitDisplayingFullscreen\",\n    \"webkitEnterFullScreen\",\n    \"webkitEnterFullscreen\",\n    \"webkitExitFullScreen\",\n    \"webkitExitFullscreen\",\n    \"webkitExitPointerLock\",\n    \"webkitFullScreenKeyboardInputAllowed\",\n    \"webkitFullscreenElement\",\n    \"webkitFullscreenEnabled\",\n    \"webkitGenerateKeyRequest\",\n    \"webkitGetAsEntry\",\n    \"webkitGetDatabaseNames\",\n    \"webkitGetEntries\",\n    \"webkitGetEntriesByName\",\n    \"webkitGetEntriesByType\",\n    \"webkitGetFlowByName\",\n    \"webkitGetGamepads\",\n    \"webkitGetImageDataHD\",\n    \"webkitGetNamedFlows\",\n    \"webkitGetRegionFlowRanges\",\n    \"webkitGetUserMedia\",\n    \"webkitHasClosedCaptions\",\n    \"webkitHidden\",\n    \"webkitIDBCursor\",\n    \"webkitIDBDatabase\",\n    \"webkitIDBDatabaseError\",\n    \"webkitIDBDatabaseException\",\n    \"webkitIDBFactory\",\n    \"webkitIDBIndex\",\n    \"webkitIDBKeyRange\",\n    \"webkitIDBObjectStore\",\n    \"webkitIDBRequest\",\n    \"webkitIDBTransaction\",\n    \"webkitImageSmoothingEnabled\",\n    \"webkitIndexedDB\",\n    \"webkitInitMessageEvent\",\n    \"webkitIsFullScreen\",\n    \"webkitKeys\",\n    \"webkitLineDashOffset\",\n    \"webkitLockOrientation\",\n    \"webkitMatchesSelector\",\n    \"webkitMediaStream\",\n    \"webkitNotifications\",\n    \"webkitOfflineAudioContext\",\n    \"webkitOrientation\",\n    \"webkitPeerConnection00\",\n    \"webkitPersistentStorage\",\n    \"webkitPointerLockElement\",\n    \"webkitPostMessage\",\n    \"webkitPreservesPitch\",\n    \"webkitPutImageDataHD\",\n    \"webkitRTCPeerConnection\",\n    \"webkitRegionOverset\",\n    \"webkitRequestAnimationFrame\",\n    \"webkitRequestFileSystem\",\n    \"webkitRequestFullScreen\",\n    \"webkitRequestFullscreen\",\n    \"webkitRequestPointerLock\",\n    \"webkitResolveLocalFileSystemURL\",\n    \"webkitSetMediaKeys\",\n    \"webkitSetResourceTimingBufferSize\",\n    \"webkitShadowRoot\",\n    \"webkitShowPlaybackTargetPicker\",\n    \"webkitSlice\",\n    \"webkitSpeechGrammar\",\n    \"webkitSpeechGrammarList\",\n    \"webkitSpeechRecognition\",\n    \"webkitSpeechRecognitionError\",\n    \"webkitSpeechRecognitionEvent\",\n    \"webkitStorageInfo\",\n    \"webkitSupportsFullscreen\",\n    \"webkitTemporaryStorage\",\n    \"webkitTextSizeAdjust\",\n    \"webkitTransform\",\n    \"webkitTransformOrigin\",\n    \"webkitTransition\",\n    \"webkitTransitionDelay\",\n    \"webkitTransitionDuration\",\n    \"webkitTransitionProperty\",\n    \"webkitTransitionTimingFunction\",\n    \"webkitURL\",\n    \"webkitUnlockOrientation\",\n    \"webkitUserSelect\",\n    \"webkitVideoDecodedByteCount\",\n    \"webkitVisibilityState\",\n    \"webkitWirelessVideoPlaybackDisabled\",\n    \"webkitdropzone\",\n    \"webstore\",\n    \"weight\",\n    \"whatToShow\",\n    \"wheelDelta\",\n    \"wheelDeltaX\",\n    \"wheelDeltaY\",\n    \"which\",\n    \"white-space\",\n    \"whiteSpace\",\n    \"wholeText\",\n    \"widows\",\n    \"width\",\n    \"will-change\",\n    \"willChange\",\n    \"willValidate\",\n    \"window\",\n    \"withCredentials\",\n    \"word-break\",\n    \"word-spacing\",\n    \"word-wrap\",\n    \"wordBreak\",\n    \"wordSpacing\",\n    \"wordWrap\",\n    \"wrap\",\n    \"wrapKey\",\n    \"write\",\n    \"writeln\",\n    \"writingMode\",\n    \"x\",\n    \"x1\",\n    \"x2\",\n    \"xChannelSelector\",\n    \"xmlEncoding\",\n    \"xmlStandalone\",\n    \"xmlVersion\",\n    \"xmlbase\",\n    \"xmllang\",\n    \"xmlspace\",\n    \"y\",\n    \"y1\",\n    \"y2\",\n    \"yChannelSelector\",\n    \"yandex\",\n    \"z\",\n    \"z-index\",\n    \"zIndex\",\n    \"zoom\",\n    \"zoomAndPan\",\n    \"zoomRectScreen\"\n]\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n/* global global, self */\n\nimport {\n    defaults,\n    Dictionary,\n    push_uniq,\n} from \"./utils\";\nimport { base54 } from \"./scope\";\nimport {\n    AST_Call,\n    AST_Conditional,\n    AST_Dot,\n    AST_ObjectKeyVal,\n    AST_ObjectProperty,\n    AST_Sequence,\n    AST_String,\n    AST_Sub,\n    TreeTransformer,\n    TreeWalker,\n} from \"./ast.js\";\nimport { domprops } from \"../tools/domprops.js\";\n\nfunction find_builtins(reserved) {\n    domprops.forEach(add);\n\n    // Compatibility fix for some standard defined globals not defined on every js environment\n    var new_globals = [\"Symbol\", \"Map\", \"Promise\", \"Proxy\", \"Reflect\", \"Set\", \"WeakMap\", \"WeakSet\"];\n    var objects = {};\n    var global_ref = typeof global === \"object\" ? global : self;\n\n    new_globals.forEach(function (new_global) {\n        objects[new_global] = global_ref[new_global] || new Function();\n    });\n\n    // NaN will be included due to Number.NaN\n    [\n        \"null\",\n        \"true\",\n        \"false\",\n        \"Infinity\",\n        \"-Infinity\",\n        \"undefined\",\n    ].forEach(add);\n    [ Object, Array, Function, Number,\n      String, Boolean, Error, Math,\n      Date, RegExp, objects.Symbol, ArrayBuffer,\n      DataView, decodeURI, decodeURIComponent,\n      encodeURI, encodeURIComponent, eval, EvalError,\n      Float32Array, Float64Array, Int8Array, Int16Array,\n      Int32Array, isFinite, isNaN, JSON, objects.Map, parseFloat,\n      parseInt, objects.Promise, objects.Proxy, RangeError, ReferenceError,\n      objects.Reflect, objects.Set, SyntaxError, TypeError, Uint8Array,\n      Uint8ClampedArray, Uint16Array, Uint32Array, URIError,\n      objects.WeakMap, objects.WeakSet\n    ].forEach(function(ctor) {\n        Object.getOwnPropertyNames(ctor).map(add);\n        if (ctor.prototype) {\n            Object.getOwnPropertyNames(ctor.prototype).map(add);\n        }\n    });\n    function add(name) {\n        reserved.add(name);\n    }\n}\n\nfunction reserve_quoted_keys(ast, reserved) {\n    function add(name) {\n        push_uniq(reserved, name);\n    }\n\n    ast.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_ObjectKeyVal && node.quote) {\n            add(node.key);\n        } else if (node instanceof AST_ObjectProperty && node.quote) {\n            add(node.key.name);\n        } else if (node instanceof AST_Sub) {\n            addStrings(node.property, add);\n        }\n    }));\n}\n\nfunction addStrings(node, add) {\n    node.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_Sequence) {\n            addStrings(node.tail_node(), add);\n        } else if (node instanceof AST_String) {\n            add(node.value);\n        } else if (node instanceof AST_Conditional) {\n            addStrings(node.consequent, add);\n            addStrings(node.alternative, add);\n        }\n        return true;\n    }));\n}\n\nfunction mangle_properties(ast, options) {\n    options = defaults(options, {\n        builtins: false,\n        cache: null,\n        debug: false,\n        keep_quoted: false,\n        only_cache: false,\n        regex: null,\n        reserved: null,\n    }, true);\n\n    var reserved_option = options.reserved;\n    if (!Array.isArray(reserved_option)) reserved_option = [reserved_option];\n    var reserved = new Set(reserved_option);\n    if (!options.builtins) find_builtins(reserved);\n\n    var cname = -1;\n    var cache;\n    if (options.cache) {\n        cache = options.cache.props;\n        cache.each(function(mangled_name) {\n            reserved.add(mangled_name);\n        });\n    } else {\n        cache = new Dictionary();\n    }\n\n    var regex = options.regex;\n\n    // note debug is either false (disabled), or a string of the debug suffix to use (enabled).\n    // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'\n    // the same as passing an empty string.\n    var debug = options.debug !== false;\n    var debug_name_suffix;\n    if (debug) {\n        debug_name_suffix = (options.debug === true ? \"\" : options.debug);\n    }\n\n    var names_to_mangle = new Set();\n    var unmangleable = new Set();\n\n    // step 1: find candidates to mangle\n    ast.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_ObjectKeyVal) {\n            if (typeof node.key == \"string\") {\n                add(node.key);\n            }\n        } else if (node instanceof AST_ObjectProperty) {\n            // setter or getter, since KeyVal is handled above\n            add(node.key.name);\n        } else if (node instanceof AST_Dot) {\n            var root = node;\n            while (root.expression) {\n                root = root.expression;\n            }\n            if (!(root.thedef && root.thedef.undeclared)) add(node.property);\n        } else if (node instanceof AST_Sub) {\n            addStrings(node.property, add);\n        } else if (node instanceof AST_Call\n            && node.expression.print_to_string() == \"Object.defineProperty\") {\n            addStrings(node.args[1], add);\n        }\n    }));\n\n    // step 2: transform the tree, renaming properties\n    return ast.transform(new TreeTransformer(function(node) {\n        if (node instanceof AST_ObjectKeyVal) {\n            if (typeof node.key == \"string\") {\n                node.key = mangle(node.key);\n            }\n        } else if (node instanceof AST_ObjectProperty) {\n            // setter or getter\n            node.key.name = mangle(node.key.name);\n        } else if (node instanceof AST_Dot) {\n            node.property = mangle(node.property);\n        } else if (!options.keep_quoted && node instanceof AST_Sub) {\n            node.property = mangleStrings(node.property);\n        } else if (node instanceof AST_Call\n            && node.expression.print_to_string() == \"Object.defineProperty\") {\n            node.args[1] = mangleStrings(node.args[1]);\n        }\n    }));\n\n    // only function declarations after this line\n\n    function can_mangle(name) {\n        if (unmangleable.has(name)) return false;\n        if (reserved.has(name)) return false;\n        if (options.only_cache) {\n            return cache.has(name);\n        }\n        if (/^-?[0-9]+(\\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;\n        return true;\n    }\n\n    function should_mangle(name) {\n        if (regex && !regex.test(name)) return false;\n        if (reserved.has(name)) return false;\n        return cache.has(name)\n            || names_to_mangle.has(name);\n    }\n\n    function add(name) {\n        if (can_mangle(name))\n            names_to_mangle.add(name);\n\n        if (!should_mangle(name)) {\n            unmangleable.add(name);\n        }\n    }\n\n    function mangle(name) {\n        if (!should_mangle(name)) {\n            return name;\n        }\n\n        var mangled = cache.get(name);\n        if (!mangled) {\n            if (debug) {\n                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.\n                var debug_mangled = \"_$\" + name + \"$\" + debug_name_suffix + \"_\";\n\n                if (can_mangle(debug_mangled)) {\n                    mangled = debug_mangled;\n                }\n            }\n\n            // either debug mode is off, or it is on and we could not use the mangled name\n            if (!mangled) {\n                do {\n                    mangled = base54(++cname);\n                } while (!can_mangle(mangled));\n            }\n\n            cache.set(name, mangled);\n        }\n        return mangled;\n    }\n\n    function mangleStrings(node) {\n        return node.transform(new TreeTransformer(function(node) {\n            if (node instanceof AST_Sequence) {\n                var last = node.expressions.length - 1;\n                node.expressions[last] = mangleStrings(node.expressions[last]);\n            } else if (node instanceof AST_String) {\n                node.value = mangle(node.value);\n            } else if (node instanceof AST_Conditional) {\n                node.consequent = mangleStrings(node.consequent);\n                node.alternative = mangleStrings(node.alternative);\n            }\n            return node;\n        }));\n    }\n}\n\nexport {\n    reserve_quoted_keys,\n    mangle_properties,\n};\n","\"use strict\";\n/* eslint-env browser, es6, node */\n\nimport {\n    defaults,\n    Dictionary,\n    HOP,\n} from \"./utils.js\";\nimport {\n    AST_Node,\n    AST_Toplevel,\n} from \"./ast.js\";\nimport { parse } from \"./parse.js\";\nimport { OutputStream } from \"./output.js\";\nimport { Compressor } from \"./compress/index.js\";\nimport { base54 } from \"./scope.js\";\nimport { SourceMap } from \"./sourcemap.js\";\nimport {\n    mangle_properties,\n    reserve_quoted_keys,\n} from \"./propmangle.js\";\n\nvar to_ascii = typeof atob == \"undefined\" ? function(b64) {\n    return Buffer.from(b64, \"base64\").toString();\n} : atob;\nvar to_base64 = typeof btoa == \"undefined\" ? function(str) {\n    return Buffer.from(str).toString(\"base64\");\n} : btoa;\n\nfunction read_source_map(code) {\n    var match = /(?:^|[^.])\\/\\/# sourceMappingURL=data:application\\/json(;[\\w=-]*)?;base64,([+/0-9A-Za-z]*=*)\\s*$/.exec(code);\n    if (!match) {\n        AST_Node.warn(\"inline source map not found\");\n        return null;\n    }\n    return to_ascii(match[2]);\n}\n\nfunction set_shorthand(name, options, keys) {\n    if (options[name]) {\n        keys.forEach(function(key) {\n            if (options[key]) {\n                if (typeof options[key] != \"object\") options[key] = {};\n                if (!(name in options[key])) options[key][name] = options[name];\n            }\n        });\n    }\n}\n\nfunction init_cache(cache) {\n    if (!cache) return;\n    if (!(\"props\" in cache)) {\n        cache.props = new Dictionary();\n    } else if (!(cache.props instanceof Dictionary)) {\n        cache.props = Dictionary.fromObject(cache.props);\n    }\n}\n\nfunction to_json(cache) {\n    return {\n        props: cache.props.toObject()\n    };\n}\n\nfunction minify(files, options) {\n    var warn_function = AST_Node.warn_function;\n    try {\n        options = defaults(options, {\n            compress: {},\n            ecma: undefined,\n            enclose: false,\n            ie8: false,\n            keep_classnames: undefined,\n            keep_fnames: false,\n            mangle: {},\n            module: false,\n            nameCache: null,\n            output: {},\n            parse: {},\n            rename: undefined,\n            safari10: false,\n            sourceMap: false,\n            timings: false,\n            toplevel: false,\n            warnings: false,\n            wrap: false,\n        }, true);\n        var timings = options.timings && {\n            start: Date.now()\n        };\n        if (options.keep_classnames === undefined) {\n            options.keep_classnames = options.keep_fnames;\n        }\n        if (options.rename === undefined) {\n            options.rename = options.compress && options.mangle;\n        }\n        set_shorthand(\"ecma\", options, [ \"parse\", \"compress\", \"output\" ]);\n        set_shorthand(\"ie8\", options, [ \"compress\", \"mangle\", \"output\" ]);\n        set_shorthand(\"keep_classnames\", options, [ \"compress\", \"mangle\" ]);\n        set_shorthand(\"keep_fnames\", options, [ \"compress\", \"mangle\" ]);\n        set_shorthand(\"module\", options, [ \"parse\", \"compress\", \"mangle\" ]);\n        set_shorthand(\"safari10\", options, [ \"mangle\", \"output\" ]);\n        set_shorthand(\"toplevel\", options, [ \"compress\", \"mangle\" ]);\n        set_shorthand(\"warnings\", options, [ \"compress\" ]);\n        var quoted_props;\n        if (options.mangle) {\n            options.mangle = defaults(options.mangle, {\n                cache: options.nameCache && (options.nameCache.vars || {}),\n                eval: false,\n                ie8: false,\n                keep_classnames: false,\n                keep_fnames: false,\n                module: false,\n                properties: false,\n                reserved: [],\n                safari10: false,\n                toplevel: false,\n            }, true);\n            if (options.mangle.properties) {\n                if (typeof options.mangle.properties != \"object\") {\n                    options.mangle.properties = {};\n                }\n                if (options.mangle.properties.keep_quoted) {\n                    quoted_props = options.mangle.properties.reserved;\n                    if (!Array.isArray(quoted_props)) quoted_props = [];\n                    options.mangle.properties.reserved = quoted_props;\n                }\n                if (options.nameCache && !(\"cache\" in options.mangle.properties)) {\n                    options.mangle.properties.cache = options.nameCache.props || {};\n                }\n            }\n            init_cache(options.mangle.cache);\n            init_cache(options.mangle.properties.cache);\n        }\n        if (options.sourceMap) {\n            options.sourceMap = defaults(options.sourceMap, {\n                content: null,\n                filename: null,\n                includeSources: false,\n                root: null,\n                url: null,\n            }, true);\n        }\n        var warnings = [];\n        if (options.warnings && !AST_Node.warn_function) {\n            AST_Node.warn_function = function(warning) {\n                warnings.push(warning);\n            };\n        }\n        if (timings) timings.parse = Date.now();\n        var toplevel;\n        if (files instanceof AST_Toplevel) {\n            toplevel = files;\n        } else {\n            if (typeof files == \"string\") {\n                files = [ files ];\n            }\n            options.parse = options.parse || {};\n            options.parse.toplevel = null;\n            for (var name in files) if (HOP(files, name)) {\n                options.parse.filename = name;\n                options.parse.toplevel = parse(files[name], options.parse);\n                if (options.sourceMap && options.sourceMap.content == \"inline\") {\n                    if (Object.keys(files).length > 1)\n                        throw new Error(\"inline source map only works with singular input\");\n                    options.sourceMap.content = read_source_map(files[name]);\n                }\n            }\n            toplevel = options.parse.toplevel;\n        }\n        if (quoted_props) {\n            reserve_quoted_keys(toplevel, quoted_props);\n        }\n        if (options.wrap) {\n            toplevel = toplevel.wrap_commonjs(options.wrap);\n        }\n        if (options.enclose) {\n            toplevel = toplevel.wrap_enclose(options.enclose);\n        }\n        if (timings) timings.rename = Date.now();\n        // disable rename on harmony due to expand_names bug in for-of loops\n        // https://github.com/mishoo/UglifyJS2/issues/2794\n        if (0 && options.rename) {\n            toplevel.figure_out_scope(options.mangle);\n            toplevel.expand_names(options.mangle);\n        }\n        if (timings) timings.compress = Date.now();\n        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);\n        if (timings) timings.scope = Date.now();\n        if (options.mangle) toplevel.figure_out_scope(options.mangle);\n        if (timings) timings.mangle = Date.now();\n        if (options.mangle) {\n            base54.reset();\n            toplevel.compute_char_frequency(options.mangle);\n            toplevel.mangle_names(options.mangle);\n        }\n        if (timings) timings.properties = Date.now();\n        if (options.mangle && options.mangle.properties) {\n            toplevel = mangle_properties(toplevel, options.mangle.properties);\n        }\n        if (timings) timings.output = Date.now();\n        var result = {};\n        if (options.output.ast) {\n            result.ast = toplevel;\n        }\n        if (!HOP(options.output, \"code\") || options.output.code) {\n            if (options.sourceMap) {\n                if (typeof options.sourceMap.content == \"string\") {\n                    options.sourceMap.content = JSON.parse(options.sourceMap.content);\n                }\n                options.output.source_map = SourceMap({\n                    file: options.sourceMap.filename,\n                    orig: options.sourceMap.content,\n                    root: options.sourceMap.root\n                });\n                if (options.sourceMap.includeSources) {\n                    if (files instanceof AST_Toplevel) {\n                        throw new Error(\"original source content unavailable\");\n                    } else for (var name in files) if (HOP(files, name)) {\n                        options.output.source_map.get().setSourceContent(name, files[name]);\n                    }\n                }\n            }\n            delete options.output.ast;\n            delete options.output.code;\n            var stream = OutputStream(options.output);\n            toplevel.print(stream);\n            result.code = stream.get();\n            if (options.sourceMap) {\n                result.map = options.output.source_map.toString();\n                if (options.sourceMap.url == \"inline\") {\n                    result.code += \"\\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,\" + to_base64(result.map);\n                } else if (options.sourceMap.url) {\n                    result.code += \"\\n//# sourceMappingURL=\" + options.sourceMap.url;\n                }\n            }\n        }\n        if (options.nameCache && options.mangle) {\n            if (options.mangle.cache) options.nameCache.vars = to_json(options.mangle.cache);\n            if (options.mangle.properties && options.mangle.properties.cache) {\n                options.nameCache.props = to_json(options.mangle.properties.cache);\n            }\n        }\n        if (timings) {\n            timings.end = Date.now();\n            result.timings = {\n                parse: 1e-3 * (timings.rename - timings.parse),\n                rename: 1e-3 * (timings.compress - timings.rename),\n                compress: 1e-3 * (timings.scope - timings.compress),\n                scope: 1e-3 * (timings.mangle - timings.scope),\n                mangle: 1e-3 * (timings.properties - timings.mangle),\n                properties: 1e-3 * (timings.output - timings.properties),\n                output: 1e-3 * (timings.end - timings.output),\n                total: 1e-3 * (timings.end - timings.start)\n            };\n        }\n        if (warnings.length) {\n            result.warnings = warnings;\n        }\n        return result;\n    } catch (ex) {\n        return { error: ex };\n    } finally {\n        AST_Node.warn_function = warn_function;\n    }\n}\n\nexport {\n  minify,\n  to_ascii,\n};\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport * as ast from \"./ast.js\";\nimport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Atom,\n    AST_Await,\n    AST_Binary,\n    AST_Block,\n    AST_BlockStatement,\n    AST_Boolean,\n    AST_Break,\n    AST_Call,\n    AST_Case,\n    AST_Catch,\n    AST_Class,\n    AST_ClassExpression,\n    AST_ConciseMethod,\n    AST_Conditional,\n    AST_Const,\n    AST_Constant,\n    AST_Continue,\n    AST_Debugger,\n    AST_Default,\n    AST_DefClass,\n    AST_Definitions,\n    AST_Defun,\n    AST_Destructuring,\n    AST_Directive,\n    AST_Do,\n    AST_Dot,\n    AST_EmptyStatement,\n    AST_Expansion,\n    AST_Export,\n    AST_False,\n    AST_Finally,\n    AST_For,\n    AST_ForIn,\n    AST_ForOf,\n    AST_Function,\n    AST_Hole,\n    AST_If,\n    AST_Import,\n    AST_Label,\n    AST_LabeledStatement,\n    AST_LabelRef,\n    AST_Lambda,\n    AST_Let,\n    AST_NameMapping,\n    AST_New,\n    AST_NewTarget,\n    AST_Node,\n    AST_Null,\n    AST_Number,\n    AST_Object,\n    AST_ObjectGetter,\n    AST_ObjectKeyVal,\n    AST_ObjectProperty,\n    AST_ObjectSetter,\n    AST_PrefixedTemplateString,\n    AST_PropAccess,\n    AST_RegExp,\n    AST_Return,\n    AST_Sequence,\n    AST_SimpleStatement,\n    AST_Statement,\n    AST_String,\n    AST_Sub,\n    AST_Super,\n    AST_Switch,\n    AST_SwitchBranch,\n    AST_Symbol,\n    AST_SymbolCatch,\n    AST_SymbolClass,\n    AST_SymbolConst,\n    AST_SymbolDefClass,\n    AST_SymbolDefun,\n    AST_SymbolExport,\n    AST_SymbolExportForeign,\n    AST_SymbolFunarg,\n    AST_SymbolImport,\n    AST_SymbolImportForeign,\n    AST_SymbolLambda,\n    AST_SymbolLet,\n    AST_SymbolMethod,\n    AST_SymbolRef,\n    AST_SymbolVar,\n    AST_TemplateSegment,\n    AST_TemplateString,\n    AST_This,\n    AST_Throw,\n    AST_Token,\n    AST_Toplevel,\n    AST_True,\n    AST_Try,\n    AST_Unary,\n    AST_UnaryPostfix,\n    AST_UnaryPrefix,\n    AST_Var,\n    AST_VarDef,\n    AST_While,\n    AST_With,\n    AST_Yield,\n} from \"./ast.js\";\n\n(function() {\n\n    var normalize_directives = function(body) {\n        var in_directive = true;\n\n        for (var i = 0; i < body.length; i++) {\n            if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) {\n                body[i] = new AST_Directive({\n                    start: body[i].start,\n                    end: body[i].end,\n                    value: body[i].body.value\n                });\n            } else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) {\n                in_directive = false;\n            }\n        }\n\n        return body;\n    };\n\n    var MOZ_TO_ME = {\n        Program: function(M) {\n            return new AST_Toplevel({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                body: normalize_directives(M.body.map(from_moz))\n            });\n        },\n        ArrayPattern: function(M) {\n            return new AST_Destructuring({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                names: M.elements.map(function(elm) {\n                    if (elm === null) {\n                        return new AST_Hole();\n                    }\n                    return from_moz(elm);\n                }),\n                is_array: true\n            });\n        },\n        ObjectPattern: function(M) {\n            return new AST_Destructuring({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                names: M.properties.map(from_moz),\n                is_array: false\n            });\n        },\n        AssignmentPattern: function(M) {\n            return new AST_Binary({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                left: from_moz(M.left),\n                operator: \"=\",\n                right: from_moz(M.right)\n            });\n        },\n        SpreadElement: function(M) {\n            return new AST_Expansion({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                expression: from_moz(M.argument)\n            });\n        },\n        RestElement: function(M) {\n            return new AST_Expansion({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                expression: from_moz(M.argument)\n            });\n        },\n        TemplateElement: function(M) {\n            return new AST_TemplateSegment({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                value: M.value.cooked,\n                raw: M.value.raw\n            });\n        },\n        TemplateLiteral: function(M) {\n            var segments = [];\n            for (var i = 0; i < M.quasis.length; i++) {\n                segments.push(from_moz(M.quasis[i]));\n                if (M.expressions[i]) {\n                    segments.push(from_moz(M.expressions[i]));\n                }\n            }\n            return new AST_TemplateString({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                segments: segments\n            });\n        },\n        TaggedTemplateExpression: function(M) {\n            return new AST_PrefixedTemplateString({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                template_string: from_moz(M.quasi),\n                prefix: from_moz(M.tag)\n            });\n        },\n        FunctionDeclaration: function(M) {\n            return new AST_Defun({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                name: from_moz(M.id),\n                argnames: M.params.map(from_moz),\n                is_generator: M.generator,\n                async: M.async,\n                body: normalize_directives(from_moz(M.body).body)\n            });\n        },\n        FunctionExpression: function(M) {\n            return new AST_Function({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                name: from_moz(M.id),\n                argnames: M.params.map(from_moz),\n                is_generator: M.generator,\n                async: M.async,\n                body: normalize_directives(from_moz(M.body).body)\n            });\n        },\n        ArrowFunctionExpression: function(M) {\n            return new AST_Arrow({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                argnames: M.params.map(from_moz),\n                body: from_moz(M.body),\n                async: M.async,\n            });\n        },\n        ExpressionStatement: function(M) {\n            return new AST_SimpleStatement({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                body: from_moz(M.expression)\n            });\n        },\n        TryStatement: function(M) {\n            var handlers = M.handlers || [M.handler];\n            if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {\n                throw new Error(\"Multiple catch clauses are not supported.\");\n            }\n            return new AST_Try({\n                start    : my_start_token(M),\n                end      : my_end_token(M),\n                body     : from_moz(M.block).body,\n                bcatch   : from_moz(handlers[0]),\n                bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null\n            });\n        },\n        Property: function(M) {\n            var key = M.key;\n            var args = {\n                start    : my_start_token(key || M.value),\n                end      : my_end_token(M.value),\n                key      : key.type == \"Identifier\" ? key.name : key.value,\n                value    : from_moz(M.value)\n            };\n            if (M.computed) {\n                args.key = from_moz(M.key);\n            }\n            if (M.method) {\n                args.is_generator = M.value.generator;\n                args.async = M.value.async;\n                if (!M.computed) {\n                    args.key = new AST_SymbolMethod({ name: args.key });\n                } else {\n                    args.key = from_moz(M.key);\n                }\n                return new AST_ConciseMethod(args);\n            }\n            if (M.kind == \"init\") {\n                if (key.type != \"Identifier\" && key.type != \"Literal\") {\n                    args.key = from_moz(key);\n                }\n                return new AST_ObjectKeyVal(args);\n            }\n            if (typeof args.key === \"string\" || typeof args.key === \"number\") {\n                args.key = new AST_SymbolMethod({\n                    name: args.key\n                });\n            }\n            args.value = new AST_Accessor(args.value);\n            if (M.kind == \"get\") return new AST_ObjectGetter(args);\n            if (M.kind == \"set\") return new AST_ObjectSetter(args);\n            if (M.kind == \"method\") {\n                args.async = M.value.async;\n                args.is_generator = M.value.generator;\n                args.quote = M.computed ? \"\\\"\" : null;\n                return new AST_ConciseMethod(args);\n            }\n        },\n        MethodDefinition: function(M) {\n            var args = {\n                start    : my_start_token(M),\n                end      : my_end_token(M),\n                key      : M.computed ? from_moz(M.key) : new AST_SymbolMethod({ name: M.key.name || M.key.value }),\n                value    : from_moz(M.value),\n                static   : M.static,\n            };\n            if (M.kind == \"get\") {\n                return new AST_ObjectGetter(args);\n            }\n            if (M.kind == \"set\") {\n                return new AST_ObjectSetter(args);\n            }\n            args.is_generator = M.value.generator;\n            args.async = M.value.async;\n            return new AST_ConciseMethod(args);\n        },\n        ArrayExpression: function(M) {\n            return new AST_Array({\n                start    : my_start_token(M),\n                end      : my_end_token(M),\n                elements : M.elements.map(function(elem) {\n                    return elem === null ? new AST_Hole() : from_moz(elem);\n                })\n            });\n        },\n        ObjectExpression: function(M) {\n            return new AST_Object({\n                start      : my_start_token(M),\n                end        : my_end_token(M),\n                properties : M.properties.map(function(prop) {\n                    if (prop.type === \"SpreadElement\") {\n                        return from_moz(prop);\n                    }\n                    prop.type = \"Property\";\n                    return from_moz(prop);\n                })\n            });\n        },\n        SequenceExpression: function(M) {\n            return new AST_Sequence({\n                start      : my_start_token(M),\n                end        : my_end_token(M),\n                expressions: M.expressions.map(from_moz)\n            });\n        },\n        MemberExpression: function(M) {\n            return new (M.computed ? AST_Sub : AST_Dot)({\n                start      : my_start_token(M),\n                end        : my_end_token(M),\n                property   : M.computed ? from_moz(M.property) : M.property.name,\n                expression : from_moz(M.object)\n            });\n        },\n        SwitchCase: function(M) {\n            return new (M.test ? AST_Case : AST_Default)({\n                start      : my_start_token(M),\n                end        : my_end_token(M),\n                expression : from_moz(M.test),\n                body       : M.consequent.map(from_moz)\n            });\n        },\n        VariableDeclaration: function(M) {\n            return new (M.kind === \"const\" ? AST_Const :\n                        M.kind === \"let\" ? AST_Let : AST_Var)({\n                start       : my_start_token(M),\n                end         : my_end_token(M),\n                definitions : M.declarations.map(from_moz)\n            });\n        },\n\n        ImportDeclaration: function(M) {\n            var imported_name = null;\n            var imported_names = null;\n            M.specifiers.forEach(function (specifier) {\n                if (specifier.type === \"ImportSpecifier\") {\n                    if (!imported_names) { imported_names = []; }\n                    imported_names.push(new AST_NameMapping({\n                        start: my_start_token(specifier),\n                        end: my_end_token(specifier),\n                        foreign_name: from_moz(specifier.imported),\n                        name: from_moz(specifier.local)\n                    }));\n                } else if (specifier.type === \"ImportDefaultSpecifier\") {\n                    imported_name = from_moz(specifier.local);\n                } else if (specifier.type === \"ImportNamespaceSpecifier\") {\n                    if (!imported_names) { imported_names = []; }\n                    imported_names.push(new AST_NameMapping({\n                        start: my_start_token(specifier),\n                        end: my_end_token(specifier),\n                        foreign_name: new AST_SymbolImportForeign({ name: \"*\" }),\n                        name: from_moz(specifier.local)\n                    }));\n                }\n            });\n            return new AST_Import({\n                start       : my_start_token(M),\n                end         : my_end_token(M),\n                imported_name: imported_name,\n                imported_names : imported_names,\n                module_name : from_moz(M.source)\n            });\n        },\n        ExportAllDeclaration: function(M) {\n            return new AST_Export({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                exported_names: [\n                    new AST_NameMapping({\n                        name: new AST_SymbolExportForeign({ name: \"*\" }),\n                        foreign_name: new AST_SymbolExportForeign({ name: \"*\" })\n                    })\n                ],\n                module_name: from_moz(M.source)\n            });\n        },\n        ExportNamedDeclaration: function(M) {\n            return new AST_Export({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                exported_definition: from_moz(M.declaration),\n                exported_names: M.specifiers && M.specifiers.length ? M.specifiers.map(function (specifier) {\n                    return new AST_NameMapping({\n                        foreign_name: from_moz(specifier.exported),\n                        name: from_moz(specifier.local)\n                    });\n                }) : null,\n                module_name: from_moz(M.source)\n            });\n        },\n        ExportDefaultDeclaration: function(M) {\n            return new AST_Export({\n                start: my_start_token(M),\n                end: my_end_token(M),\n                exported_value: from_moz(M.declaration),\n                is_default: true\n            });\n        },\n        Literal: function(M) {\n            var val = M.value, args = {\n                start  : my_start_token(M),\n                end    : my_end_token(M)\n            };\n            if (val === null) return new AST_Null(args);\n            var rx = M.regex;\n            if (rx && rx.pattern) {\n                // RegExpLiteral as per ESTree AST spec\n                args.value = new RegExp(rx.pattern, rx.flags);\n                var raw = args.value.toString();\n                args.value.raw_source = rx.flags\n                    ? raw.substring(0, raw.length - rx.flags.length) + rx.flags\n                    : raw;\n                return new AST_RegExp(args);\n            } else if (rx) {\n                // support legacy RegExp\n                args.value = M.regex && M.raw ? M.raw : val;\n                return new AST_RegExp(args);\n            }\n            switch (typeof val) {\n              case \"string\":\n                args.value = val;\n                return new AST_String(args);\n              case \"number\":\n                args.value = val;\n                return new AST_Number(args);\n              case \"boolean\":\n                return new (val ? AST_True : AST_False)(args);\n            }\n        },\n        MetaProperty: function(M) {\n            if (M.meta.name === \"new\" && M.property.name === \"target\") {\n                return new AST_NewTarget({\n                    start: my_start_token(M),\n                    end: my_end_token(M)\n                });\n            }\n        },\n        Identifier: function(M) {\n            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];\n            return new (  p.type == \"LabeledStatement\" ? AST_Label\n                        : p.type == \"VariableDeclarator\" && p.id === M ? (p.kind == \"const\" ? AST_SymbolConst : p.kind == \"let\" ? AST_SymbolLet : AST_SymbolVar)\n                        : /Import.*Specifier/.test(p.type) ? (p.local === M ? AST_SymbolImport : AST_SymbolImportForeign)\n                        : p.type == \"ExportSpecifier\" ? (p.local === M ? AST_SymbolExport : AST_SymbolExportForeign)\n                        : p.type == \"FunctionExpression\" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)\n                        : p.type == \"FunctionDeclaration\" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)\n                        : p.type == \"ArrowFunctionExpression\" ? (p.params.includes(M)) ? AST_SymbolFunarg : AST_SymbolRef\n                        : p.type == \"ClassExpression\" ? (p.id === M ? AST_SymbolClass : AST_SymbolRef)\n                        : p.type == \"Property\" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolMethod)\n                        : p.type == \"ClassDeclaration\" ? (p.id === M ? AST_SymbolDefClass : AST_SymbolRef)\n                        : p.type == \"MethodDefinition\" ? (p.computed ? AST_SymbolRef : AST_SymbolMethod)\n                        : p.type == \"CatchClause\" ? AST_SymbolCatch\n                        : p.type == \"BreakStatement\" || p.type == \"ContinueStatement\" ? AST_LabelRef\n                        : AST_SymbolRef)({\n                            start : my_start_token(M),\n                            end   : my_end_token(M),\n                            name  : M.name\n                        });\n        }\n    };\n\n    MOZ_TO_ME.UpdateExpression =\n    MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) {\n        var prefix = \"prefix\" in M ? M.prefix\n            : M.type == \"UnaryExpression\" ? true : false;\n        return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({\n            start      : my_start_token(M),\n            end        : my_end_token(M),\n            operator   : M.operator,\n            expression : from_moz(M.argument)\n        });\n    };\n\n    MOZ_TO_ME.ClassDeclaration =\n    MOZ_TO_ME.ClassExpression = function From_Moz_Class(M) {\n        return new (M.type === \"ClassDeclaration\" ? AST_DefClass : AST_ClassExpression)({\n            start    : my_start_token(M),\n            end      : my_end_token(M),\n            name     : from_moz(M.id),\n            extends  : from_moz(M.superClass),\n            properties: M.body.body.map(from_moz)\n        });\n    };\n\n    map(\"EmptyStatement\", AST_EmptyStatement);\n    map(\"BlockStatement\", AST_BlockStatement, \"body@body\");\n    map(\"IfStatement\", AST_If, \"test>condition, consequent>body, alternate>alternative\");\n    map(\"LabeledStatement\", AST_LabeledStatement, \"label>label, body>body\");\n    map(\"BreakStatement\", AST_Break, \"label>label\");\n    map(\"ContinueStatement\", AST_Continue, \"label>label\");\n    map(\"WithStatement\", AST_With, \"object>expression, body>body\");\n    map(\"SwitchStatement\", AST_Switch, \"discriminant>expression, cases@body\");\n    map(\"ReturnStatement\", AST_Return, \"argument>value\");\n    map(\"ThrowStatement\", AST_Throw, \"argument>value\");\n    map(\"WhileStatement\", AST_While, \"test>condition, body>body\");\n    map(\"DoWhileStatement\", AST_Do, \"test>condition, body>body\");\n    map(\"ForStatement\", AST_For, \"init>init, test>condition, update>step, body>body\");\n    map(\"ForInStatement\", AST_ForIn, \"left>init, right>object, body>body\");\n    map(\"ForOfStatement\", AST_ForOf, \"left>init, right>object, body>body, await=await\");\n    map(\"AwaitExpression\", AST_Await, \"argument>expression\");\n    map(\"YieldExpression\", AST_Yield, \"argument>expression, delegate=is_star\");\n    map(\"DebuggerStatement\", AST_Debugger);\n    map(\"VariableDeclarator\", AST_VarDef, \"id>name, init>value\");\n    map(\"CatchClause\", AST_Catch, \"param>argname, body%body\");\n\n    map(\"ThisExpression\", AST_This);\n    map(\"Super\", AST_Super);\n    map(\"BinaryExpression\", AST_Binary, \"operator=operator, left>left, right>right\");\n    map(\"LogicalExpression\", AST_Binary, \"operator=operator, left>left, right>right\");\n    map(\"AssignmentExpression\", AST_Assign, \"operator=operator, left>left, right>right\");\n    map(\"ConditionalExpression\", AST_Conditional, \"test>condition, consequent>consequent, alternate>alternative\");\n    map(\"NewExpression\", AST_New, \"callee>expression, arguments@args\");\n    map(\"CallExpression\", AST_Call, \"callee>expression, arguments@args\");\n\n    def_to_moz(AST_Toplevel, function To_Moz_Program(M) {\n        return to_moz_scope(\"Program\", M);\n    });\n\n    def_to_moz(AST_Expansion, function To_Moz_Spread(M, parent) {\n        return {\n            type: to_moz_in_destructuring() ? \"RestElement\" : \"SpreadElement\",\n            argument: to_moz(M.expression)\n        };\n    });\n\n    def_to_moz(AST_PrefixedTemplateString, function To_Moz_TaggedTemplateExpression(M) {\n        return {\n            type: \"TaggedTemplateExpression\",\n            tag: to_moz(M.prefix),\n            quasi: to_moz(M.template_string)\n        };\n    });\n\n    def_to_moz(AST_TemplateString, function To_Moz_TemplateLiteral(M) {\n        var quasis = [];\n        var expressions = [];\n        for (var i = 0; i < M.segments.length; i++) {\n            if (i % 2 !== 0) {\n                expressions.push(to_moz(M.segments[i]));\n            } else {\n                quasis.push({\n                    type: \"TemplateElement\",\n                    value: {\n                        raw: M.segments[i].raw,\n                        cooked: M.segments[i].value\n                    },\n                    tail: i === M.segments.length - 1\n                });\n            }\n        }\n        return {\n            type: \"TemplateLiteral\",\n            quasis: quasis,\n            expressions: expressions\n        };\n    });\n\n    def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {\n        return {\n            type: \"FunctionDeclaration\",\n            id: to_moz(M.name),\n            params: M.argnames.map(to_moz),\n            generator: M.is_generator,\n            async: M.async,\n            body: to_moz_scope(\"BlockStatement\", M)\n        };\n    });\n\n    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M, parent) {\n        var is_generator = parent.is_generator !== undefined ?\n            parent.is_generator : M.is_generator;\n        return {\n            type: \"FunctionExpression\",\n            id: to_moz(M.name),\n            params: M.argnames.map(to_moz),\n            generator: is_generator,\n            async: M.async,\n            body: to_moz_scope(\"BlockStatement\", M)\n        };\n    });\n\n    def_to_moz(AST_Arrow, function To_Moz_ArrowFunctionExpression(M) {\n        var body = M.body instanceof Array ? {\n            type: \"BlockStatement\",\n            body: M.body.map(to_moz)\n        } : to_moz(M.body);\n        return {\n            type: \"ArrowFunctionExpression\",\n            params: M.argnames.map(to_moz),\n            async: M.async,\n            body: body\n        };\n    });\n\n    def_to_moz(AST_Destructuring, function To_Moz_ObjectPattern(M) {\n        if (M.is_array) {\n            return {\n                type: \"ArrayPattern\",\n                elements: M.names.map(to_moz)\n            };\n        }\n        return {\n            type: \"ObjectPattern\",\n            properties: M.names.map(to_moz)\n        };\n    });\n\n    def_to_moz(AST_Directive, function To_Moz_Directive(M) {\n        return {\n            type: \"ExpressionStatement\",\n            expression: {\n                type: \"Literal\",\n                value: M.value\n            }\n        };\n    });\n\n    def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) {\n        return {\n            type: \"ExpressionStatement\",\n            expression: to_moz(M.body)\n        };\n    });\n\n    def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {\n        return {\n            type: \"SwitchCase\",\n            test: to_moz(M.expression),\n            consequent: M.body.map(to_moz)\n        };\n    });\n\n    def_to_moz(AST_Try, function To_Moz_TryStatement(M) {\n        return {\n            type: \"TryStatement\",\n            block: to_moz_block(M),\n            handler: to_moz(M.bcatch),\n            guardedHandlers: [],\n            finalizer: to_moz(M.bfinally)\n        };\n    });\n\n    def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {\n        return {\n            type: \"CatchClause\",\n            param: to_moz(M.argname),\n            guard: null,\n            body: to_moz_block(M)\n        };\n    });\n\n    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {\n        return {\n            type: \"VariableDeclaration\",\n            kind:\n                M instanceof AST_Const ? \"const\" :\n                M instanceof AST_Let ? \"let\" : \"var\",\n            declarations: M.definitions.map(to_moz)\n        };\n    });\n\n    def_to_moz(AST_Export, function To_Moz_ExportDeclaration(M) {\n        if (M.exported_names) {\n            if (M.exported_names[0].name.name === \"*\") {\n                return {\n                    type: \"ExportAllDeclaration\",\n                    source: to_moz(M.module_name)\n                };\n            }\n            return {\n                type: \"ExportNamedDeclaration\",\n                specifiers: M.exported_names.map(function (name_mapping) {\n                    return {\n                        type: \"ExportSpecifier\",\n                        exported: to_moz(name_mapping.foreign_name),\n                        local: to_moz(name_mapping.name)\n                    };\n                }),\n                declaration: to_moz(M.exported_definition),\n                source: to_moz(M.module_name)\n            };\n        }\n        return {\n            type: M.is_default ? \"ExportDefaultDeclaration\" : \"ExportNamedDeclaration\",\n            declaration: to_moz(M.exported_value || M.exported_definition)\n        };\n    });\n\n    def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) {\n        var specifiers = [];\n        if (M.imported_name) {\n            specifiers.push({\n                type: \"ImportDefaultSpecifier\",\n                local: to_moz(M.imported_name)\n            });\n        }\n        if (M.imported_names && M.imported_names[0].foreign_name.name === \"*\") {\n            specifiers.push({\n                type: \"ImportNamespaceSpecifier\",\n                local: to_moz(M.imported_names[0].name)\n            });\n        } else if (M.imported_names) {\n            M.imported_names.forEach(function(name_mapping) {\n                specifiers.push({\n                    type: \"ImportSpecifier\",\n                    local: to_moz(name_mapping.name),\n                    imported: to_moz(name_mapping.foreign_name)\n                });\n            });\n        }\n        return {\n            type: \"ImportDeclaration\",\n            specifiers: specifiers,\n            source: to_moz(M.module_name)\n        };\n    });\n\n    def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {\n        return {\n            type: \"SequenceExpression\",\n            expressions: M.expressions.map(to_moz)\n        };\n    });\n\n    def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {\n        var isComputed = M instanceof AST_Sub;\n        return {\n            type: \"MemberExpression\",\n            object: to_moz(M.expression),\n            computed: isComputed,\n            property: isComputed ? to_moz(M.property) : {type: \"Identifier\", name: M.property}\n        };\n    });\n\n    def_to_moz(AST_Unary, function To_Moz_Unary(M) {\n        return {\n            type: M.operator == \"++\" || M.operator == \"--\" ? \"UpdateExpression\" : \"UnaryExpression\",\n            operator: M.operator,\n            prefix: M instanceof AST_UnaryPrefix,\n            argument: to_moz(M.expression)\n        };\n    });\n\n    def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {\n        if (M.operator == \"=\" && to_moz_in_destructuring()) {\n            return {\n                type: \"AssignmentPattern\",\n                left: to_moz(M.left),\n                right: to_moz(M.right)\n            };\n        }\n        return {\n            type: M.operator == \"&&\" || M.operator == \"||\" ? \"LogicalExpression\" : \"BinaryExpression\",\n            left: to_moz(M.left),\n            operator: M.operator,\n            right: to_moz(M.right)\n        };\n    });\n\n    def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) {\n        return {\n            type: \"ArrayExpression\",\n            elements: M.elements.map(to_moz)\n        };\n    });\n\n    def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) {\n        return {\n            type: \"ObjectExpression\",\n            properties: M.properties.map(to_moz)\n        };\n    });\n\n    def_to_moz(AST_ObjectProperty, function To_Moz_Property(M, parent) {\n        var key = M.key instanceof AST_Node ? to_moz(M.key) : {\n            type: \"Identifier\",\n            value: M.key\n        };\n        if (typeof M.key === \"number\") {\n            key = {\n                type: \"Literal\",\n                value: Number(M.key)\n            };\n        }\n        if (typeof M.key === \"string\") {\n            key = {\n                type: \"Identifier\",\n                name: M.key\n            };\n        }\n        var kind;\n        var string_or_num = typeof M.key === \"string\" || typeof M.key === \"number\";\n        var computed = string_or_num ? false : !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef;\n        if (M instanceof AST_ObjectKeyVal) {\n            kind = \"init\";\n            computed = !string_or_num;\n        } else\n        if (M instanceof AST_ObjectGetter) {\n            kind = \"get\";\n        } else\n        if (M instanceof AST_ObjectSetter) {\n            kind = \"set\";\n        }\n        if (parent instanceof AST_Class) {\n            return {\n                type: \"MethodDefinition\",\n                computed: computed,\n                kind: kind,\n                static: M.static,\n                key: to_moz(M.key),\n                value: to_moz(M.value)\n            };\n        }\n        return {\n            type: \"Property\",\n            computed: computed,\n            kind: kind,\n            key: key,\n            value: to_moz(M.value)\n        };\n    });\n\n    def_to_moz(AST_ConciseMethod, function To_Moz_MethodDefinition(M, parent) {\n        if (parent instanceof AST_Object) {\n            return {\n                type: \"Property\",\n                computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,\n                kind: \"init\",\n                method: true,\n                shorthand: false,\n                key: to_moz(M.key),\n                value: to_moz(M.value)\n            };\n        }\n        return {\n            type: \"MethodDefinition\",\n            computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,\n            kind: M.key === \"constructor\" ? \"constructor\" : \"method\",\n            static: M.static,\n            key: to_moz(M.key),\n            value: to_moz(M.value)\n        };\n    });\n\n    def_to_moz(AST_Class, function To_Moz_Class(M) {\n        var type = M instanceof AST_ClassExpression ? \"ClassExpression\" : \"ClassDeclaration\";\n        return {\n            type: type,\n            superClass: to_moz(M.extends),\n            id: M.name ? to_moz(M.name) : null,\n            body: {\n                type: \"ClassBody\",\n                body: M.properties.map(to_moz)\n            }\n        };\n    });\n\n    def_to_moz(AST_NewTarget, function To_Moz_MetaProperty(M) {\n        return {\n            type: \"MetaProperty\",\n            meta: {\n                type: \"Identifier\",\n                name: \"new\"\n            },\n            property: {\n                type: \"Identifier\",\n                name: \"target\"\n            }\n        };\n    });\n\n    def_to_moz(AST_Symbol, function To_Moz_Identifier(M, parent) {\n        if (M instanceof AST_SymbolMethod && parent.quote) {\n            return {\n                type: \"Literal\",\n                value: M.name\n            };\n        }\n        var def = M.definition();\n        return {\n            type: \"Identifier\",\n            name: def ? def.mangled_name || def.name : M.name\n        };\n    });\n\n    def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {\n        var pattern = M.value.source;\n        var flags = M.value.toString().match(/[gimuys]*$/)[0];\n        return {\n            type: \"Literal\",\n            value: new RegExp(pattern, flags),\n            raw: M.value.raw_source,\n            regex: {\n                pattern: pattern,\n                flags: flags,\n            }\n        };\n    });\n\n    def_to_moz(AST_Constant, function To_Moz_Literal(M) {\n        var value = M.value;\n        if (typeof value === \"number\" && (value < 0 || (value === 0 && 1 / value < 0))) {\n            return {\n                type: \"UnaryExpression\",\n                operator: \"-\",\n                prefix: true,\n                argument: {\n                    type: \"Literal\",\n                    value: -value,\n                    raw: M.start.raw\n                }\n            };\n        }\n        return {\n            type: \"Literal\",\n            value: value,\n            raw: M.start.raw\n        };\n    });\n\n    def_to_moz(AST_Atom, function To_Moz_Atom(M) {\n        return {\n            type: \"Identifier\",\n            name: String(M.value)\n        };\n    });\n\n    AST_Boolean.DEFMETHOD(\"to_mozilla_ast\", AST_Constant.prototype.to_mozilla_ast);\n    AST_Null.DEFMETHOD(\"to_mozilla_ast\", AST_Constant.prototype.to_mozilla_ast);\n    AST_Hole.DEFMETHOD(\"to_mozilla_ast\", function To_Moz_ArrayHole() { return null; });\n\n    AST_Block.DEFMETHOD(\"to_mozilla_ast\", AST_BlockStatement.prototype.to_mozilla_ast);\n    AST_Lambda.DEFMETHOD(\"to_mozilla_ast\", AST_Function.prototype.to_mozilla_ast);\n\n    /* -----[ tools ]----- */\n\n    function raw_token(moznode) {\n        if (moznode.type == \"Literal\") {\n            return moznode.raw != null ? moznode.raw : moznode.value + \"\";\n        }\n    }\n\n    function my_start_token(moznode) {\n        var loc = moznode.loc, start = loc && loc.start;\n        var range = moznode.range;\n        return new AST_Token({\n            file    : loc && loc.source,\n            line    : start && start.line,\n            col     : start && start.column,\n            pos     : range ? range[0] : moznode.start,\n            endline : start && start.line,\n            endcol  : start && start.column,\n            endpos  : range ? range[0] : moznode.start,\n            raw     : raw_token(moznode),\n        });\n    }\n\n    function my_end_token(moznode) {\n        var loc = moznode.loc, end = loc && loc.end;\n        var range = moznode.range;\n        return new AST_Token({\n            file    : loc && loc.source,\n            line    : end && end.line,\n            col     : end && end.column,\n            pos     : range ? range[1] : moznode.end,\n            endline : end && end.line,\n            endcol  : end && end.column,\n            endpos  : range ? range[1] : moznode.end,\n            raw     : raw_token(moznode),\n        });\n    }\n\n    function map(moztype, mytype, propmap) {\n        var moz_to_me = \"function From_Moz_\" + moztype + \"(M){\\n\";\n        moz_to_me += \"return new U2.\" + mytype.name + \"({\\n\" +\n            \"start: my_start_token(M),\\n\" +\n            \"end: my_end_token(M)\";\n\n        var me_to_moz = \"function To_Moz_\" + moztype + \"(M){\\n\";\n        me_to_moz += \"return {\\n\" +\n            \"type: \" + JSON.stringify(moztype);\n\n        if (propmap) propmap.split(/\\s*,\\s*/).forEach(function(prop) {\n            var m = /([a-z0-9$_]+)([=@>%])([a-z0-9$_]+)/i.exec(prop);\n            if (!m) throw new Error(\"Can't understand property map: \" + prop);\n            var moz = m[1], how = m[2], my = m[3];\n            moz_to_me += \",\\n\" + my + \": \";\n            me_to_moz += \",\\n\" + moz + \": \";\n            switch (how) {\n                case \"@\":\n                    moz_to_me += \"M.\" + moz + \".map(from_moz)\";\n                    me_to_moz += \"M.\" +  my + \".map(to_moz)\";\n                    break;\n                case \">\":\n                    moz_to_me += \"from_moz(M.\" + moz + \")\";\n                    me_to_moz += \"to_moz(M.\" + my + \")\";\n                    break;\n                case \"=\":\n                    moz_to_me += \"M.\" + moz;\n                    me_to_moz += \"M.\" + my;\n                    break;\n                case \"%\":\n                    moz_to_me += \"from_moz(M.\" + moz + \").body\";\n                    me_to_moz += \"to_moz_block(M)\";\n                    break;\n                default:\n                    throw new Error(\"Can't understand operator in propmap: \" + prop);\n            }\n        });\n\n        moz_to_me += \"\\n})\\n}\";\n        me_to_moz += \"\\n}\\n}\";\n\n        //moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });\n        //me_to_moz = parse(me_to_moz).print_to_string({ beautify: true });\n        //console.log(moz_to_me);\n\n        moz_to_me = new Function(\"U2\", \"my_start_token\", \"my_end_token\", \"from_moz\", \"return(\" + moz_to_me + \")\")(\n            ast, my_start_token, my_end_token, from_moz\n        );\n        me_to_moz = new Function(\"to_moz\", \"to_moz_block\", \"to_moz_scope\", \"return(\" + me_to_moz + \")\")(\n            to_moz, to_moz_block, to_moz_scope\n        );\n        MOZ_TO_ME[moztype] = moz_to_me;\n        def_to_moz(mytype, me_to_moz);\n    }\n\n    var FROM_MOZ_STACK = null;\n\n    function from_moz(node) {\n        FROM_MOZ_STACK.push(node);\n        var ret = node != null ? MOZ_TO_ME[node.type](node) : null;\n        FROM_MOZ_STACK.pop();\n        return ret;\n    }\n\n    AST_Node.from_mozilla_ast = function(node) {\n        var save_stack = FROM_MOZ_STACK;\n        FROM_MOZ_STACK = [];\n        var ast = from_moz(node);\n        FROM_MOZ_STACK = save_stack;\n        return ast;\n    };\n\n    function set_moz_loc(mynode, moznode, myparent) {\n        var start = mynode.start;\n        var end = mynode.end;\n        if (start.pos != null && end.endpos != null) {\n            moznode.range = [start.pos, end.endpos];\n        }\n        if (start.line) {\n            moznode.loc = {\n                start: {line: start.line, column: start.col},\n                end: end.endline ? {line: end.endline, column: end.endcol} : null\n            };\n            if (start.file) {\n                moznode.loc.source = start.file;\n            }\n        }\n        return moznode;\n    }\n\n    function def_to_moz(mytype, handler) {\n        mytype.DEFMETHOD(\"to_mozilla_ast\", function(parent) {\n            return set_moz_loc(this, handler(this, parent));\n        });\n    }\n\n    var TO_MOZ_STACK = null;\n\n    function to_moz(node) {\n        if (TO_MOZ_STACK === null) { TO_MOZ_STACK = []; }\n        TO_MOZ_STACK.push(node);\n        var ast = node != null ? node.to_mozilla_ast(TO_MOZ_STACK[TO_MOZ_STACK.length - 2]) : null;\n        TO_MOZ_STACK.pop();\n        if (TO_MOZ_STACK.length === 0) { TO_MOZ_STACK = null; }\n        return ast;\n    }\n\n    function to_moz_in_destructuring() {\n        var i = TO_MOZ_STACK.length;\n        while (i--) {\n            if (TO_MOZ_STACK[i] instanceof AST_Destructuring) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    function to_moz_block(node) {\n        return {\n            type: \"BlockStatement\",\n            body: node.body.map(to_moz)\n        };\n    }\n\n    function to_moz_scope(type, node) {\n        var body = node.body.map(to_moz);\n        if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {\n            body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));\n        }\n        return {\n            type: type,\n            body: body\n        };\n    }\n})();\n","/***********************************************************************\n\n  A JavaScript tokenizer / parser / beautifier / compressor.\n  https://github.com/mishoo/UglifyJS2\n\n  -------------------------------- (C) ---------------------------------\n\n                           Author: Mihai Bazon\n                         <mihai.bazon@gmail.com>\n                       http://mihai.bazon.net/blog\n\n  Distributed under the BSD license:\n\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions\n    are met:\n\n        * Redistributions of source code must retain the above\n          copyright notice, this list of conditions and the following\n          disclaimer.\n\n        * Redistributions in binary form must reproduce the above\n          copyright notice, this list of conditions and the following\n          disclaimer in the documentation and/or other materials\n          provided with the distribution.\n\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n    SUCH DAMAGE.\n\n ***********************************************************************/\n\n\"use strict\";\n\nimport MOZ_SourceMap from \"source-map\";\nimport {\n    defaults,\n} from \"./utils.js\";\n\n// a small wrapper around fitzgen's source-map library\nfunction SourceMap(options) {\n    options = defaults(options, {\n        file : null,\n        root : null,\n        orig : null,\n\n        orig_line_diff : 0,\n        dest_line_diff : 0,\n    });\n    var generator = new MOZ_SourceMap.SourceMapGenerator({\n        file       : options.file,\n        sourceRoot : options.root\n    });\n    var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);\n\n    if (orig_map) {\n        orig_map.sources.forEach(function(source) {\n            var sourceContent = orig_map.sourceContentFor(source, true);\n            if (sourceContent) {\n                generator.setSourceContent(source, sourceContent);\n            }\n        });\n    }\n\n    function add(source, gen_line, gen_col, orig_line, orig_col, name) {\n        if (orig_map) {\n            var info = orig_map.originalPositionFor({\n                line: orig_line,\n                column: orig_col\n            });\n            if (info.source === null) {\n                return;\n            }\n            source = info.source;\n            orig_line = info.line;\n            orig_col = info.column;\n            name = info.name || name;\n        }\n        generator.addMapping({\n            generated : { line: gen_line + options.dest_line_diff, column: gen_col },\n            original  : { line: orig_line + options.orig_line_diff, column: orig_col },\n            source    : source,\n            name      : name\n        });\n    }\n    return {\n        add        : add,\n        get        : function() { return generator; },\n        toString   : function() { return JSON.stringify(generator.toJSON()); }\n    };\n}\n\nexport {\n    SourceMap,\n};\n"]}