{"version":3,"sources":["../lib/utils/index.js","../lib/parse.js","../lib/ast.js","../lib/utils/first_in_statement.js","../lib/transform.js","../lib/output.js","../lib/scope.js","../lib/compress/index.js","../tools/domprops.js","../lib/propmangle.js","../lib/minify.js","../lib/sourcemap.js","../tools/node.js","../lib/mozilla-ast.js"],"names":["characters","str","split","member","name","array","includes","DefaultsError","Error","[object Object]","msg","defs","super","this","message","defaults","args","croak","ret","i","HOP","noop","return_false","return_true","return_this","return_null","MAP","a","f","backwards","top","doit","val","is_last","Last","v","AtTop","Splice","push","apply","slice","reverse","skip","Array","isArray","length","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","merge","makePredicate","words","Set","map_add","map","key","value","has","get","set","obj","prop","Object","prototype","hasOwnProperty","call","keep_name","keep_setting","RegExp","test","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","RE_BIG_INT","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_start","ch","is_identifier_char","is_identifier_string","JS_Parse_Error","filename","line","col","js_error","is_token","token","type","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","substr","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","err","read_num","prefix","has_e","after_e","has_x","has_dot","is_big_int","num","pred","read_while","next_token","has_directive","endsWith","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","n","digit","read_string","with_eof_error","quote","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","e","read_operator","grow","op","bigger","handle_slash","eof_error","cont","x","ex","force_regexp","word","context","nc","add_directive","directive","undefined","push_directives_stack","pop_directives_stack","UNARY_PREFIX","ASSIGNMENT","PRECEDENCE","j","ATOMIC_START_TOKEN","parse","options","bare_returns","ecma","expression","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","every","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","body","AST_String","AST_Directive","function_","AST_Defun","node","imported_name","imported_names","as_symbol","AST_SymbolImport","map_names","mod_str","AST_Import","module_name","import_","label","AST_Label","some","l","AST_IterationStatement","references","forEach","ref","AST_Continue","AST_LabeledStatement","labeled_statement","AST_BlockStatement","block_","AST_EmptyStatement","break_cont","AST_Break","AST_Debugger","condition","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","TYPE","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","add","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_BigInt","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","AST_Sequence","expressions","len","unshift","comments_before_length","array_","object_or_destructuring_","func","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","AST_Dot","AST_Sub","call_args","AST_PrefixedTemplateString","maybe_unary","AST_Await","make_unary","AST_UnaryPrefix","AST_UnaryPostfix","expr_op","min_prec","prec","AST_Binary","maybe_conditional","expr_ops","yes","AST_Conditional","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","Function","BASE","SUBCLASSES","CTOR","SELF_PROPS","DEFMETHOD","_clone","deep","self","clone","transform","TreeTransformer","$documentation","$propdoc","_walk","visitor","_visit","walk","warn_function","warn","txt","AST_Statement","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","Map","pinned","globals","wrap_commonjs","wrapped_tl","wrap_enclose","args_values","index","join","uses_arguments","args_as_names","out","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","stack","create","descend","parent","getPrototypeOf","find_parent","st","loopcontrol_target","before","after","first_in_statement","tw","in_list","y","do_list","list","EXPECT_DIRECTIVE","CODE_LINE_BREAK","CODE_SPACE","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","get_full_char_code","toString","s","encode_string","dq","sq","quote_single","quote_double","make_string","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","back","repeat","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","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","match","digits","candidates","toLowerCase","exec","best","best_of","DEFMAP","stream","force_parens","_codegen","add_source_map","needs_parens","po","pp","so","sp","p1","startsWith","_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","ext","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","delete","def_function","mark_export","def_variable","destructuring","mark_enclosed","find_variable","reference","level","exported","def_global","refs","g","d","symbol","mangled_names","tricky_def","tricky_name","_default_mangler_options","lname","to_mangle","collect","save_nesting","avoid","to_avoid","add_def","reset","sort","find_colliding_names","rename","next_name","_print","consider","skip_string","tail_node","print_to_string","chars","frequency","leading","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","resolve_defines","process_expression","min_count","stopping","pass","figure_out_scope","reset_opt_flags","count","info","_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","exposed","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_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","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","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","is_return_void","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_may_throw_on_access","_dot_throw","def_is_boolean","unary_bool","binary_bool","is_boolean","def_is_number","unary","binary","is_number","is_string","unary_side_effects","best_of_expression","ast1","ast2","convert_to_predicate","keys","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","static_value","static_fn","native_fn","constructor","def_negate","basic_negation","negated","global_pure_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_ids","fixed_ids","var_defs_by_id","initializations","destructuring_value","node_def","in_export","destructuring_cache","scan_ref_scoped","in_use","trim","__unused","unreferenced","template","drop_block","head","is_destructure","var_defs","assign","dirs","hoisted","vars_found","var_decl","to_assignments","is_lambda","varNames","var_names","_var_names","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","arg_vals_outer_refs","value_walker","scope_outer_refs","size","can_inject_args_values","is_reachable","can_inject_symbols","append_var","flatten_args","lines","flatten_vars","flatten_fn","ev","trim_right_for_undefined","lift_sequences","in_boolean_context","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","JSON","Promise","Proxy","RangeError","ReferenceError","Reflect","SyntaxError","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","URIError","WeakMap","WeakSet","getOwnPropertyNames","find_builtins","debug_name_suffix","names_to_mangle","keep_quoted_strict","root","mangleStrings","can_mangle","should_mangle","mangled","debug_mangled","to_ascii","atob","b64","Buffer","from","to_base64","btoa","set_shorthand","init_cache","map_from_object","to_json","minify","files","quoted_props","timings","compress","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","column","addMapping","generated","original","stringify","toJSON","SourceMap","total","error","infer_options","normalize_directives","MOZ_TO_ME","Program","M","my_start_token","my_end_token","from_moz","ArrayPattern","elm","ObjectPattern","AssignmentPattern","Type","FROM_MOZ_STACK","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","BigIntLiteral","raw_token","moznode","loc","range","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","to_mozilla_ast","mynode","from_mozilla_ast","save_stack","TO_MOZ_STACK","0","component"],"mappings":"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AAS6S,EAAW7S,OAAOpmB,GAC/B,IAAKomB,EAAQ,OAAO,EACpB,GAAU,IAANjoB,GAA0B,iBAAfioB,EAAOnR,KAAtB,CACA,IAAK85B,EAAU5wC,GAAG+D,KAAKkkB,EAAOnR,MAC1B,OAAO,EAEX9W,KAEJ,OAAO,EA5BH6wC,CAA6B/V,GAAa,CAE9C,IADA,IAAIgW,EAAO,GACFtxC,EAAI,EAAGA,EAAIokB,EAAKhK,MAAM1Y,OAAQ1B,IAAK,CACxC,IAAIuxC,EAAOntB,EAAKhK,MAAMpa,GAChBuxC,aAAgBj3B,IACI,iBAAZi3B,EAAK9tC,KACZ8tC,EAAK7tC,iBAAiB2U,KACrBm5B,EAAclW,EAAYiW,EAAK7tC,MAAM0vB,eACzCke,EAAKnwC,KAAKowC,GAGdD,EAAK5vC,QAAU0iB,EAAKhK,MAAM1Y,SAC1B0iB,EAAKhK,MAAQk3B,GAGrB,OAAOltB,EAgBP,SAASotB,EAAclW,EAAY9f,GAC/B,QAAIA,EAAI1I,WAAWpR,UACd8Z,EAAIsU,UACLwL,EAAWnsB,SAAS+qB,QACfoB,EAAWlC,YACJkC,EAAWlC,WAAW5d,OAx+MlD,GC3ZO,IAAIi2B,GAAW,CAClB,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,SACA,aACA,YACA,SACA,oBACA,iBACA,kBACA,WACA,2BACA,2BACA,uBACA,UACA,QACA,aACA,WACA,SACA,WACA,0BACA,eACA,uBACA,mBACA,iBACA,YACA,oBACA,eACA,iBACA,qBACA,mBACA,6BACA,QACA,cACA,OACA,QACA,cACA,wBACA,eACA,uBACA,gBACA,YACA,aACA,uBACA,mBACA,yBACA,OACA,yBACA,WACA,QACA,cACA,kBACA,gBACA,iBACA,uBACA,qBACA,kBACA,gBACA,YACA,OACA,OACA,eACA,YACA,YACA,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,kBACA,gBACA,qBACA,oBACA,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,gBACA,wBACA,WACA,eACA,UACA,iBACA,yBACA,oBACA,gBACA,UACA,oBACA,YACA,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,UACA,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,0BACA,+BACA,+BACA,oBACA,2BACA,yBACA,uBACA,kBACA,wBACA,mBACA,wBACA,2BACA,2BACA,iCACA,YACA,0BACA,mBA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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\nfunction characters(str) {\n    return str.split(\"\");\n}\n\nfunction member(name, array) {\n    return array.includes(name);\n}\n\nclass DefaultsError extends Error {\n    constructor(msg, defs) {\n        super();\n\n        this.name = \"DefaultsError\";\n        this.message = msg;\n        this.defs = defs;\n    }\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        throw new DefaultsError(\"`\" + 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 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 (Array.isArray(a)) {\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\nfunction makePredicate(words) {\n    if (!Array.isArray(words)) words = words.split(\" \");\n\n    return new Set(words);\n}\n\nfunction map_add(map, key, value) {\n    if (map.has(key)) {\n        map.get(key).push(value);\n    } else {\n        map.set(key, [ value ]);\n    }\n}\n\nfunction map_from_object(obj) {\n    var map = new Map();\n    for (var key in obj) {\n        if (HOP(obj, key) && key.charAt(0) === \"$\") {\n            map.set(key.substr(1), obj[key]);\n        }\n    }\n    return map;\n}\n\nfunction map_to_object(map) {\n    var obj = Object.create(null);\n    map.forEach(function (value, key) {\n        obj[\"$\" + key] = value;\n    });\n    return obj;\n}\n\nfunction HOP(obj, prop) {\n    return Object.prototype.hasOwnProperty.call(obj, prop);\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    characters,\n    defaults,\n    HOP,\n    keep_name,\n    makePredicate,\n    map_add,\n    map_from_object,\n    map_to_object,\n    MAP,\n    member,\n    mergeSort,\n    noop,\n    push_uniq,\n    remove,\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    characters,\n    defaults,\n    HOP,\n    makePredicate,\n} from \"./utils/index.js\";\nimport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Await,\n    AST_BigInt,\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;\nvar RE_BIG_INT = /^(0[xob])?[0-9]+n$/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_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\nclass JS_Parse_Error extends Error {\n    constructor(message, filename, line, col, pos) {\n        super();\n\n        this.name = \"SyntaxError\";\n        this.message = message;\n        this.filename = filename;\n        this.line = line;\n        this.col = col;\n        this.pos = pos;\n    }\n}\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.has(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.has(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.has(value)) ||\n                           (type == \"keyword\" && KEYWORDS_BEFORE_EXPRESSION.has(value)) ||\n                           (type == \"punc\" && PUNC_BEFORE_EXPRESSION.has(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.has(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 == \".\", is_big_int = false;\n        var num = read_while(function(ch, i) {\n            if (is_big_int) return false;\n\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\n            if (ch === \"n\") {\n                is_big_int = true;\n\n                return true;\n            }\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        if (num.endsWith(\"n\")) {\n            if (!has_dot && RE_BIG_INT.test(num))\n                return token(\"big_int\", num.replace(\"n\", \"\"));\n            parse_error(\"Invalid or unexpected token\");\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() {\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 (ch == \"\\r\" || ch == \"\\n\") 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;\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;\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.has(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.has(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.has(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.has(word) ? token(\"atom\", word)\n            : !KEYWORDS.has(word) ? token(\"name\", word)\n            : OPERATORS.has(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();\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.has(ch)) return token(\"punc\", next());\n            if (OPERATOR_CHARS.has(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\", \"big_int\", \"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 || !token.comments_before.every((comment) => !comment.nlb);\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 \"big_int\":\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 (S.labels.some((l) => l.name === label.name)) {\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 = S.labels.find((l) => l.name === label.name);\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 = new Set();\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.has(token.value)) {\n                    if (duplicate === false) {\n                        duplicate = token;\n                    }\n                    tracker.check_strict();\n                } else {\n                    parameters.add(token.value);\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.has(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.has(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 \"big_int\":\n            ret = new AST_BigInt({ 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.has(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 \"big_int\":\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.has(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.has(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.has(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_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/index.js\";\nimport { parse } from \"./parse.js\";\n\nfunction DEFNODE(type, props, methods, 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 (i[0] === \"$\") {\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: \"[Map/S] a map of name -> SymbolDef for all variables/functions defined in this scope\",\n        functions: \"[Map/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 = new Map(this.variables);\n        if (this.functions) node.functions = new Map(this.functions);\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: \"[Map/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\", \"quote\", {\n    $documentation: \"A dotted property access expression\",\n    $propdoc: {\n        quote: \"[string] the original quote character when transformed from AST_Sub\",\n    },\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_BigInt = DEFNODE(\"BigInt\", \"value\", {\n    $documentation: \"A big int literal\",\n    $propdoc: {\n        value: \"[string] big int value\"\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.\nclass TreeTransformer extends TreeWalker {\n    constructor(before, after) {\n        super();\n        this.before = before;\n        this.after = after;\n    }\n}\n\nexport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Atom,\n    AST_Await,\n    AST_BigInt,\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","import { AST_Binary, AST_Conditional, AST_Dot, AST_Sequence, AST_Statement, AST_Sub, AST_UnaryPostfix } from \"../ast.js\";\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    let node = stack.parent(-1);\n    for (let 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\nexport { first_in_statement };\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/index.js\";\n\n(function() {\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    defaults,\n    makePredicate,\n    noop,\n    return_false,\n    return_true,\n} from \"./utils/index.js\";\nimport { first_in_statement } from \"./utils/first_in_statement.js\";\nimport {\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Await,\n    AST_BigInt,\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_surrogate_pair_head,\n    is_surrogate_pair_tail,\n    PRECEDENCE,\n    RESERVED_WORDS,\n} from \"./parse.js\";\n\nvar EXPECT_DIRECTIVE = /^$|[;{][\\s\\n]*$/;\nconst CODE_LINE_BREAK = 10;\nconst CODE_SPACE = 32;\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(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.has(ch)) {\n                    OUTPUT += \";\";\n                    current_col++;\n                    current_pos++;\n                } else {\n                    ensure_line_len();\n                    if (current_col > 0) {\n                        OUTPUT += \"\\n\";\n                        current_pos++;\n                        current_line++;\n                        current_col = 0;\n                    }\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        let n = OUTPUT.length - 1;\n        while (n >= 0) {\n            const code = OUTPUT.charCodeAt(n);\n            if (code === CODE_LINE_BREAK) {\n                return true;\n            }\n\n            if (code !== CODE_SPACE) {\n                return false;\n            }\n            n--;\n        }\n        return true;\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 || comments.every((c) =>\n            !/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_BigInt, function(output) {\n        var p = output.parent();\n        if (p instanceof AST_PropAccess && p.expression === this) {\n            var value = this.getValue();\n            if (value.startsWith(\"-\")) {\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 && !(parent instanceof AST_Assign)) ||\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.has(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.has(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            !RESERVED_WORDS.has(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    DEFPRINT(AST_BigInt, function(self, output) {\n        output.print(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).replace(/^0\\./, \".\").replace(\"e+\", \"e\");\n        var candidates = [ str ];\n        if (Math.floor(num) === num) {\n            if (num < 0) {\n                candidates.push(\"-0x\" + (-num).toString(16).toLowerCase());\n            } else {\n                candidates.push(\"0x\" + num.toString(16).toLowerCase());\n            }\n        }\n        var match, len, digits;\n        if (match = /^\\.0+/.exec(str)) {\n            len = match[0].length;\n            digits = str.slice(len);\n            candidates.push(digits + \"e-\" + (digits.length + len - 1));\n        } else if (match = /0+$/.exec(str)) {\n            len = match[0].length;\n            candidates.push(str.slice(0, -len) + \"e\" + len);\n        } else if (match = /^(\\d)\\.(\\d+)e(-?\\d+)$/.exec(str)) {\n            candidates.push(match[1] + match[2] + \"e\" + (match[3] - match[2].length));\n        }\n        return best_of(candidates);\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    defaults,\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/index.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    RESERVED_WORDS,\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 Map();\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 Map();\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.delete(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 (!def.orig.every((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 Map();\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.forEach(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 Map();         // map name to AST_SymbolVar (variables defined in this scope; includes functions)\n    this.functions = new Map();         // 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.forEach(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 (RESERVED_WORDS.has(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.forEach(collect);\n        if (options.cache.props) {\n            options.cache.props.forEach(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.forEach(collect);\n            return;\n        }\n        if (node.is_block_scope()) {\n            node.block_scope.variables.forEach(collect);\n            return;\n        }\n        if (node instanceof AST_Label) {\n            var name;\n            do name = base54(++lname); while (RESERVED_WORDS.has(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 = new Set();\n    options.reserved.forEach(to_avoid);\n    this.globals.forEach(add_def);\n    this.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_Scope) node.variables.forEach(add_def);\n        if (node instanceof AST_SymbolCatch) add_def(node.definition());\n    }));\n    return avoid;\n\n    function to_avoid(name) {\n        avoid.add(name);\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.forEach(rename);\n    this.walk(new TreeWalker(function(node) {\n        if (node instanceof AST_Scope) node.variables.forEach(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.has(name) || RESERVED_WORDS.has(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 = new Map();\n        leading.forEach(function(ch) {\n            frequency.set(ch, 0);\n        });\n        digits.forEach(function(ch) {\n            frequency.set(ch, 0);\n        });\n    }\n    base54.consider = function(str, delta) {\n        for (var i = str.length; --i >= 0;) {\n            frequency.set(str[i], frequency.get(str[i]) + delta);\n        }\n    };\n    function compare(a, b) {\n        return frequency.get(b) - frequency.get(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    defaults,\n    HOP,\n    keep_name,\n    makePredicate,\n    map_add,\n    MAP,\n    member,\n    noop,\n    remove,\n    return_false,\n    return_null,\n    return_this,\n    return_true,\n    string_template,\n} from \"../utils/index.js\";\nimport { first_in_statement, } from \"../utils/first_in_statement.js\";\nimport {\n    AST_Accessor,\n    AST_Array,\n    AST_Arrow,\n    AST_Assign,\n    AST_Await,\n    AST_BigInt,\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\nclass Compressor extends TreeWalker {\n    constructor(options, false_by_default) {\n        super();\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 (key[0] === \"@\" && 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\n    option(key) {\n        return this.options[key];\n    }\n\n    exposed(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\n    in_boolean_context() {\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\n    compress(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\n    info() {\n        if (this.options.warnings == \"verbose\") {\n            AST_Node.warn.apply(AST_Node, arguments);\n        }\n    }\n\n    warn(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\n    clear_warnings() {\n        this.warnings_produced = {};\n    }\n    before(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.forEach(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.forEach(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 def.orig.every((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.has(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.has(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            if (node.uses_arguments) {\n                descend();\n                pop(tw);\n                return;\n            }\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                    // Avoid setting fixed when there's more than one origin for a variable value\n                    if (d.orig.length > 1) return;\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.forEach(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.has(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                    || node instanceof AST_Export\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.has(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.get(node.name) || side_effects && may_modify(node))\n                    || node instanceof AST_VarDef && node.value\n                        && (lvalues.has(node.name.name) || side_effects && may_modify(node.name))\n                    || (sym = is_lhs(node.left, node))\n                        && (sym instanceof AST_PropAccess || lvalues.has(sym.name))\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.set(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                    && iife.args.every((arg) =>\n                        !(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 = new Set();\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 (names.has(sym.name)) continue;\n                        names.add(sym.name);\n                        if (sym instanceof AST_Expansion) {\n                            var elements = iife.args.slice(i);\n                            if (elements.every((arg) =>\n                                !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                            || lvalues.has(parent.left.name))) {\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.has(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 = new Map();\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.set(sym.name, lvalues.get(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                        && (lvalues.has(lhs.name)\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 !def.references.every((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 && stat.body.every(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[i] = 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[i] = 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[i] = 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 node.definitions.every((var_def) =>\n                !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 (!def.value.properties.every(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_may_throw_on_access) {\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_may_throw_on_access(AST_Node, is_strict);\n        def_may_throw_on_access(AST_Null, return_true);\n        def_may_throw_on_access(AST_Undefined, return_true);\n        def_may_throw_on_access(AST_Constant, return_false);\n        def_may_throw_on_access(AST_Array, return_false);\n        def_may_throw_on_access(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_may_throw_on_access(AST_ObjectProperty, return_false);\n        def_may_throw_on_access(AST_ObjectGetter, return_true);\n        def_may_throw_on_access(AST_Expansion, function(compressor) {\n            return this.expression._dot_throw(compressor);\n        });\n        def_may_throw_on_access(AST_Function, return_false);\n        def_may_throw_on_access(AST_Arrow, return_false);\n        def_may_throw_on_access(AST_UnaryPostfix, return_false);\n        def_may_throw_on_access(AST_UnaryPrefix, function() {\n            return this.operator == \"void\";\n        });\n        def_may_throw_on_access(AST_Binary, function(compressor) {\n            return (this.operator == \"&&\" || this.operator == \"||\")\n                && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor));\n        });\n        def_may_throw_on_access(AST_Assign, function(compressor) {\n            return this.operator == \"=\"\n                && this.right._dot_throw(compressor);\n        });\n        def_may_throw_on_access(AST_Conditional, function(compressor) {\n            return this.consequent._dot_throw(compressor)\n                || this.alternative._dot_throw(compressor);\n        });\n        def_may_throw_on_access(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_may_throw_on_access(AST_Sequence, function(compressor) {\n            return this.tail_node()._dot_throw(compressor);\n        });\n        def_may_throw_on_access(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        const unary_bool = makePredicate(\"! delete\");\n        const binary_bool = makePredicate(\"in instanceof == != === !== < <= >= >\");\n        def_is_boolean(AST_Node, return_false);\n        def_is_boolean(AST_UnaryPrefix, function() {\n            return unary_bool.has(this.operator);\n        });\n        def_is_boolean(AST_Binary, function() {\n            return binary_bool.has(this.operator)\n                || lazy_op.has(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.has(this.operator);\n        });\n        var binary = makePredicate(\"- * / % & | ^ << >> >>>\");\n        def_is_number(AST_Binary, function(compressor) {\n            return binary.has(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.has(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.has(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 of Object.keys(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.has(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.has(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.has(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                    var static_value = static_values[exp.name];\n                    if (!static_value || !static_value.has(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                    var static_fn = static_fns[e.name];\n                    if (!static_fn || !static_fn.has(key)) return this;\n                    val = global_objs[e.name];\n                } else {\n                    val = e._eval(compressor, depth + 1);\n                    if (val === e || !val) return this;\n                    var native_fn = native_fns[val.constructor.name];\n                    if (!native_fn || !native_fn.has(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.has(expr.name)) return true;\n            if (expr instanceof AST_Dot\n                && is_undeclared_ref(expr.expression)\n                && static_fns.hasOwnProperty(expr.expression.name)\n                && static_fns[expr.expression.name].has(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        const expr = this.expression;\n        let map;\n        if (expr instanceof AST_Array) {\n            map = native_fns.Array;\n        } else if (expr.is_boolean()) {\n            map = native_fns.Boolean;\n        } else if (expr.is_number(compressor)) {\n            map = native_fns.Number;\n        } else if (expr instanceof AST_RegExp) {\n            map = native_fns.RegExp;\n        } else if (expr.is_string(compressor)) {\n            map = native_fns.String;\n        } else if (!this.may_throw_on_access(compressor)) {\n            map = native_fns.Object;\n        }\n        return map && map.has(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.has(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_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 this.elements.every((l) => l.is_constant_expression());\n        });\n        def_is_constant_expression(AST_Object, function() {\n            return this.properties.every((l) => l.is_constant_expression());\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_ids = new Map();\n        var fixed_ids = new Map();\n        if (self instanceof AST_Toplevel && compressor.top_retain) {\n            self.variables.forEach(function(def) {\n                if (compressor.top_retain(def) && !in_use_ids.has(def.id)) {\n                    in_use_ids.set(def.id, def);\n                }\n            });\n        }\n        var var_defs_by_id = new Map();\n        var initializations = new Map();\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 (!in_use_ids.has(def.id)) {\n                        in_use_ids.set(def.id, 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 && !in_use_ids.has(node_def.id)) {\n                        in_use_ids.set(node_def.id, node_def);\n                    }\n                }\n                map_add(initializations, node_def.id, node);\n                return true; // don't go in nested scopes\n            }\n            if (node instanceof AST_SymbolFunarg && scope === self) {\n                map_add(var_defs_by_id, 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                        map_add(var_defs_by_id, 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) && !in_use_ids.has(def.id)) {\n                                    in_use_ids.set(def.id, 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                            map_add(initializations, node_def.id, def.value);\n                            if (!node_def.chained && def.name.fixed_value() === def.value) {\n                                fixed_ids.set(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                map_add(initializations, 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        in_use_ids.forEach(function (def) {\n            var init = initializations.get(def.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 = in_use_ids.has(def.id);\n                        if (node instanceof AST_Assign) {\n                            if (!in_use || fixed_ids.has(def.id) && fixed_ids.get(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 (!in_use_ids.has(def.id) || 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) && !in_use_ids.has(sym.definition().id)) {\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 = in_use_ids.has(def.id) || !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                            || in_use_ids.has(sym.id)) {\n                            if (def.value && fixed_ids.has(sym.id) && fixed_ids.get(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.get(sym.id) === def) {\n                                            fixed_ids.set(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 && node.body.every(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.set(node_def.id, node);\n                    }\n                }\n                return true;\n            }\n            if (node instanceof AST_SymbolRef) {\n                node_def = node.definition();\n                if (!in_use_ids.has(node_def.id)) {\n                    in_use_ids.set(node_def.id, node_def);\n                    if (node_def = node_def.redefined()) {\n                        in_use_ids.set(node_def.id, 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 Map(), 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                const is_lambda = self instanceof AST_Lambda;\n                const args_as_names = is_lambda ? self.args_as_names() : null;\n                vars.forEach((def, name) => {\n                    if (is_lambda && args_as_names.some((x) => x.name === def.name.name)) {\n                        vars.delete(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            this._var_names = var_names = new Set(this.parent_scope ? varNames.call(this.parent_scope) : null);\n            this.enclosed.forEach(function(def) {\n                var_names.add(def.name);\n            });\n            this.variables.forEach(function(def, name) {\n                var_names.add(name);\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.has(name); i++) name = prefix + \"$\" + i;\n        var_names.add(name);\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 = new Map();\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 Map();\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.set(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.get(node.expression.definition().id);\n                if (defs) {\n                    var def = defs.get(String(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(String(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.has(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.has(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 && self.bfinally.body.every(is_empty)) self.bfinally = null;\n        if (compressor.option(\"dead_code\") && self.body.every(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 = self.args.every((arg) =>\n            !(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                } else if (self.args[0] instanceof AST_Number && self.args[0].value <= 11) {\n                    const elements = [];\n                    for (let i = 0; i < self.args[0].value; i++) elements.push(new AST_Hole);\n                    return new AST_Array({ elements });\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 (self.args.every((arg) => {\n                    var value = arg.evaluate(compressor);\n                    params.push(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 (self.args.every((x) =>\n                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) && fn.body.every(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 && !line.definitions.every((var_def) =>\n                        !var_def.value\n                    )) {\n                        return false;\n                    }\n                } else if (stat) {\n                    return false;\n                } else if (!(line instanceof AST_EmptyStatement)) {\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.has(arg.name)\n                    || identifier_atom.has(arg.name)\n                    || scope.var_names().has(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_args_values() {\n            var arg_vals_outer_refs = new Set();\n            var value_walker = new TreeWalker(function(node) {\n                if (node instanceof AST_Scope) {\n                    var scope_outer_refs = new Set();\n                    node.enclosed.forEach(function(def) {\n                        scope_outer_refs.add(def.name);\n                    });\n                    node.variables.forEach(function(name) {\n                        scope_outer_refs.delete(name);\n                    });\n                    scope_outer_refs.forEach(function(name) {\n                        arg_vals_outer_refs.add(name);\n                    });\n                    return true;\n                }\n                return false;\n            });\n            self.args.forEach(function(value) {\n                value.walk(value_walker);\n            });\n            if (arg_vals_outer_refs.size == 0) return true;\n            for (var i = 0, len = fn.argnames.length; i < len; i++) {\n                var arg = fn.argnames[i];\n                if (arg instanceof AST_DefaultAssign && arg.left.__unused) continue;\n                if (arg instanceof AST_Expansion && arg.expression.__unused) continue;\n                if (arg.__unused) continue;\n                if (arg_vals_outer_refs.has(arg.name)) return false;\n            }\n            for (var i = 0, len = fn.body.length; i < len; i++) {\n                var stat = fn.body[i];\n                if (!(stat instanceof AST_Var)) continue;\n                for (var j = stat.definitions.length; --j >= 0;) {\n                    var name = stat.definitions[j].name;\n                    if (name instanceof AST_Destructuring\n                        || arg_vals_outer_refs.has(name.name)) {\n                        return false;\n                    }\n                }\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.has(name.name)\n                        || identifier_atom.has(name.name)\n                        || scope.var_names().has(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 = new Set();\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.forEach(function (variable) {\n                            block_scoped.add(variable.name);\n                        });\n                    }\n                }\n                if (scope instanceof AST_Catch) {\n                    if (scope.argname) {\n                        block_scoped.add(scope.argname.name);\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            if (!can_inject_args_values()) 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().has(name.name)) {\n                scope.var_names().add(name.name);\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().has(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 && fn.argnames.every((argname) =>\n                        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        if (\n            compressor.option(\"unsafe\") &&\n            is_undeclared_ref(self.expression) &&\n            [\"Object\", \"RegExp\", \"Function\", \"Error\", \"Array\"].includes(self.expression.name)\n        ) return make_node(AST_Call, self, self).transform(compressor);\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 || e instanceof AST_BigInt)) {\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.has(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.has(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                        && d.references.every((ref) =>\n                            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    const ASSIGN_OPS = makePredicate(\"+ - / * % >> << >>> | ^ &\");\n    const ASSIGN_OPS_COMMUTATIVE = makePredicate(\"* | ^ &\");\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                && ASSIGN_OPS.has(self.right.operator)) {\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                && ASSIGN_OPS_COMMUTATIVE.has(self.right.operator)\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                        quote: prop.quote,\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 = new Set();\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 (params.has(param)) {\n                    break OPT_ARGUMENTS; // duplicate parameter - bail\n                }\n                params.add(param);\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 (!props.every((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    \"attributeFilter\",\n    \"attributeName\",\n    \"attributeNamespace\",\n    \"attributeOldValue\",\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    \"characterData\",\n    \"characterDataOldValue\",\n    \"charging\",\n    \"chargingTime\",\n    \"charset\",\n    \"checkEnclosure\",\n    \"checkFramebufferStatus\",\n    \"checkIntersection\",\n    \"checkValidity\",\n    \"checked\",\n    \"childElementCount\",\n    \"childList\",\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    \"subtree\",\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    push_uniq,\n} from \"./utils/index.js\";\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.forEach(function(mangled_name) {\n            reserved.add(mangled_name);\n        });\n    } else {\n        cache = new Map();\n    }\n\n    var regex = options.regex && new RegExp(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    var keep_quoted_strict = options.keep_quoted === \"strict\";\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                (!keep_quoted_strict || !node.quote)) {\n                add(node.key);\n            }\n        } else if (node instanceof AST_ObjectProperty) {\n            // setter or getter, since KeyVal is handled above\n            if (!keep_quoted_strict || !node.key.end.quote) {\n                add(node.key.name);\n            }\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) &&\n                (!keep_quoted_strict || !node.quote)) {\n                add(node.property);\n            }\n        } else if (node instanceof AST_Sub) {\n            if (!keep_quoted_strict) {\n                addStrings(node.property, add);\n            }\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                (!keep_quoted_strict || !node.quote)) {\n                node.key = mangle(node.key);\n            }\n        } else if (node instanceof AST_ObjectProperty) {\n            // setter or getter\n            if (!keep_quoted_strict || !node.key.end.quote) {\n                node.key.name = mangle(node.key.name);\n            }\n        } else if (node instanceof AST_Dot) {\n            if (!keep_quoted_strict || !node.quote) {\n                node.property = mangle(node.property);\n            }\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    map_from_object,\n    map_to_object,\n    HOP,\n} from \"./utils/index.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 Map();\n    } else if (!(cache.props instanceof Map)) {\n        cache.props = map_from_object(cache.props);\n    }\n}\n\nfunction to_json(cache) {\n    return {\n        props: map_to_object(cache.props)\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 && options.mangle.properties.keep_quoted !== \"strict\") {\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 MOZ_SourceMap from \"source-map\";\nimport {\n    defaults,\n} from \"./utils/index.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","import { minify } from \"../lib/minify\";\n\nexport function default_options() {\n    const defs = {};\n\n    Object.keys(infer_options({ 0: 0 })).forEach((component) => {\n        const options = infer_options({\n            [component]: {0: 0}\n        });\n\n        if (options) defs[component] = options;\n    });\n    return defs;\n}\n\nfunction infer_options(options) {\n    var result = minify(\"\", options);\n    return result.error && result.error.defs;\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_BigInt,\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_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            var Type = AST_Binary;\n            if(FROM_MOZ_STACK.length > 2) {\n                var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];\n                if(p.type === \"FunctionDeclaration\"\n                   || p.type === \"FunctionExpression\"\n                   || p.type === \"ArrowFunctionExpression\") {\n                    Type = AST_DefaultAssign;\n                }\n            }\n            return new Type({\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        BigIntLiteral(M) {\n            return new AST_BigInt({\n                start : my_start_token(M),\n                end   : my_end_token(M),\n                value : M.value\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    def_to_moz(AST_BigInt, M => ({\n        type: \"BigIntLiteral\",\n        value: M.value\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"]}