New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

p-promise

Package Overview
Dependencies
Maintainers
1
Versions
41
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

p-promise - npm Package Compare versions

Comparing version 0.3.8 to 0.4.0

all.js
hydrogen.cfg
p-alt.js
test/opt-stats.txt
test/p.js
test/test-and-trace.js
test/trace-opt.js

1143

out.txt

@@ -1,416 +0,727 @@

Usage:
shell [options] -e string
execute string in V8
shell [options] file1 file2 ... filek
run JavaScript scripts in file1, file2, ..., filek
shell [options]
shell [options] --shell [file1 file2 ... filek]
run an interactive JavaScript shell
d8 [options] file1 file2 ... filek
d8 [options]
d8 [options] --shell [file1 file2 ... filek]
run the new debugging shell
Options:
--use_strict (enforce strict mode)
type: bool default: false
--es5_readonly (activate correct semantics for inheriting readonliness)
type: bool default: true
--es52_globals (activate new semantics for global var declarations)
type: bool default: true
--harmony_typeof (enable harmony semantics for typeof)
type: bool default: false
--harmony_scoping (enable harmony block scoping)
type: bool default: false
--harmony_modules (enable harmony modules (implies block scoping))
type: bool default: false
--harmony_proxies (enable harmony proxies)
type: bool default: false
--harmony_collections (enable harmony collections (sets, maps, and weak maps))
type: bool default: false
--harmony (enable all harmony features (except typeof))
type: bool default: false
--packed_arrays (optimizes arrays that have no holes)
type: bool default: true
--smi_only_arrays (tracks arrays with only smi values)
type: bool default: true
--clever_optimizations (Optimize object size, Array shift, DOM strings and string +)
type: bool default: true
--unbox_double_arrays (automatically unbox arrays of doubles)
type: bool default: true
--string_slices (use string slices)
type: bool default: true
--crankshaft (use crankshaft)
type: bool default: true
--hydrogen_filter (optimization filter)
type: string default:
--use_range (use hydrogen range analysis)
type: bool default: true
--eliminate_dead_phis (eliminate dead phis)
type: bool default: true
--use_gvn (use hydrogen global value numbering)
type: bool default: true
--use_canonicalizing (use hydrogen instruction canonicalizing)
type: bool default: true
--use_inlining (use function inlining)
type: bool default: true
--max_inlined_source_size (maximum source size in bytes considered for a single inlining)
type: int default: 600
--max_inlined_nodes (maximum number of AST nodes considered for a single inlining)
type: int default: 196
--max_inlined_nodes_cumulative (maximum cumulative number of AST nodes considered for inlining)
type: int default: 196
--loop_invariant_code_motion (loop invariant code motion)
type: bool default: true
--collect_megamorphic_maps_from_stub_cache (crankshaft harvests type feedback from stub cache)
type: bool default: true
--hydrogen_stats (print statistics for hydrogen)
type: bool default: false
--trace_hydrogen (trace generated hydrogen to file)
type: bool default: false
--trace_phase (trace generated IR for specified phases)
type: string default: Z
--trace_inlining (trace inlining decisions)
type: bool default: false
--trace_alloc (trace register allocator)
type: bool default: false
--trace_all_uses (trace all use positions)
type: bool default: false
--trace_range (trace range analysis)
type: bool default: false
--trace_gvn (trace global value numbering)
type: bool default: false
--trace_representation (trace representation types)
type: bool default: false
--stress_pointer_maps (pointer map for every instruction)
type: bool default: false
--stress_environments (environment for every instruction)
type: bool default: false
--deopt_every_n_times (deoptimize every n times a deopt point is passed)
type: int default: 0
--trap_on_deopt (put a break point before deoptimizing)
type: bool default: false
--deoptimize_uncommon_cases (deoptimize uncommon cases)
type: bool default: true
--polymorphic_inlining (polymorphic inlining)
type: bool default: true
--use_osr (use on-stack replacement)
type: bool default: true
--array_bounds_checks_elimination (perform array bounds checks elimination)
type: bool default: true
--array_index_dehoisting (perform array index dehoisting)
type: bool default: true
--dead_code_elimination (use dead code elimination)
type: bool default: true
--trace_dead_code_elimination (trace dead code elimination)
type: bool default: false
--trace_osr (trace on-stack replacement)
type: bool default: false
--stress_runs (number of stress runs)
type: int default: 0
--optimize_closures (optimize closures)
type: bool default: true
--lookup_sample_by_shared (when picking a function to optimize, watch for shared function info, not JSFunction itself)
type: bool default: true
--cache_optimized_code (cache optimized code for closures)
type: bool default: true
--inline_construct (inline constructor calls)
type: bool default: true
--inline_arguments (inline functions with arguments object)
type: bool default: true
--inline_accessors (inline JavaScript accessors)
type: bool default: true
--loop_weight (loop weight for representation inference)
type: int default: 1
--optimize_for_in (optimize functions containing for-in loops)
type: bool default: true
--opt_safe_uint32_operations (allow uint32 values on optimize frames if they are used only insafe operations)
type: bool default: true
--parallel_recompilation (optimizing hot functions asynchronously on a separate thread)
type: bool default: false
--trace_parallel_recompilation (track parallel recompilation)
type: bool default: false
--parallel_recompilation_queue_length (the length of the parallel compilation queue)
type: int default: 2
--experimental_profiler (enable all profiler experiments)
type: bool default: true
--watch_ic_patching (profiler considers IC stability)
type: bool default: false
--frame_count (number of stack frames inspected by the profiler)
type: int default: 1
--self_optimization (primitive functions trigger their own optimization)
type: bool default: false
--direct_self_opt (call recompile stub directly when self-optimizing)
type: bool default: false
--retry_self_opt (re-try self-optimization if it failed)
type: bool default: false
--count_based_interrupts (trigger profiler ticks based on counting instead of timing)
type: bool default: false
--interrupt_at_exit (insert an interrupt check at function exit)
type: bool default: false
--weighted_back_edges (weight back edges by jump distance for interrupt triggering)
type: bool default: false
--interrupt_budget (execution budget before interrupt is triggered)
type: int default: 5888
--type_info_threshold (percentage of ICs that must have type info to allow optimization)
type: int default: 15
--self_opt_count (call count before self-optimization)
type: int default: 130
--trace_opt_verbose (extra verbose compilation tracing)
type: bool default: false
--debug_code (generate extra code (assertions) for debugging)
type: bool default: false
--code_comments (emit comments in code disassembly)
type: bool default: false
--enable_sse2 (enable use of SSE2 instructions if available)
type: bool default: true
--enable_sse3 (enable use of SSE3 instructions if available)
type: bool default: true
--enable_sse4_1 (enable use of SSE4.1 instructions if available)
type: bool default: true
--enable_cmov (enable use of CMOV instruction if available)
type: bool default: true
--enable_rdtsc (enable use of RDTSC instruction if available)
type: bool default: true
--enable_sahf (enable use of SAHF instruction if available (X64 only))
type: bool default: true
--enable_vfp3 (enable use of VFP3 instructions if available - this implies enabling ARMv7 and VFP2 instructions (ARM only))
type: bool default: true
--enable_vfp2 (enable use of VFP2 instructions if available)
type: bool default: true
--enable_armv7 (enable use of ARMv7 instructions if available (ARM only))
type: bool default: true
--enable_sudiv (enable use of SDIV and UDIV instructions if available (ARM only))
type: bool default: true
--enable_movw_movt (enable loading 32-bit constant by means of movw/movt instruction pairs (ARM only))
type: bool default: false
--enable_unaligned_accesses (enable unaligned accesses for ARMv7 (ARM only))
type: bool default: true
--enable_fpu (enable use of MIPS FPU instructions if available (MIPS only))
type: bool default: true
--expose_natives_as (expose natives in global object)
type: string default: NULL
--expose_debug_as (expose debug in global object)
type: string default: NULL
--expose_gc (expose gc extension)
type: bool default: false
--expose_externalize_string (expose externalize string extension)
type: bool default: false
--stack_trace_limit (number of stack frames to capture)
type: int default: 10
--builtins_in_stack_traces (show built-in functions in stack traces)
type: bool default: false
--disable_native_files (disable builtin natives files)
type: bool default: false
--inline_new (use fast inline allocation)
type: bool default: true
--stack_trace_on_abort (print a stack trace if an assertion failure occurs)
type: bool default: true
--trace (trace function calls)
type: bool default: false
--mask_constants_with_cookie (use random jit cookie to mask large constants)
type: bool default: true
--lazy (use lazy compilation)
type: bool default: true
--trace_opt (trace lazy optimization)
type: bool default: false
--trace_opt_stats (trace lazy optimization statistics)
type: bool default: false
--opt (use adaptive optimizations)
type: bool default: true
--always_opt (always try to optimize functions)
type: bool default: false
--prepare_always_opt (prepare for turning on always opt)
type: bool default: false
--trace_deopt (trace deoptimization)
type: bool default: false
--min_preparse_length (minimum length for automatic enable preparsing)
type: int default: 1024
--always_full_compiler (try to use the dedicated run-once backend for all code)
type: bool default: false
--max_opt_count (maximum number of optimization attempts before giving up.)
type: int default: 10
--compilation_cache (enable compilation cache)
type: bool default: true
--cache_prototype_transitions (cache prototype transitions)
type: bool default: true
--trace_debug_json (trace debugging JSON request/response)
type: bool default: false
--debugger_auto_break (automatically set the debug break flag when debugger commands are in the queue)
type: bool default: true
--enable_liveedit (enable liveedit experimental feature)
type: bool default: true
--break_on_abort (always cause a debug break before aborting)
type: bool default: true
--stack_size (default size of stack region v8 is allowed to use (in kBytes))
type: int default: 984
--max_stack_trace_source_length (maximum length of function source code printed in a stack trace.)
type: int default: 300
--always_inline_smi_code (always inline smi code in non-opt code)
type: bool default: false
--max_new_space_size (max size of the new generation (in kBytes))
type: int default: 0
--max_old_space_size (max size of the old generation (in Mbytes))
type: int default: 0
--max_executable_size (max size of executable memory (in Mbytes))
type: int default: 0
--gc_global (always perform global GCs)
type: bool default: false
--gc_interval (garbage collect after <n> allocations)
type: int default: -1
--trace_gc (print one trace line following each garbage collection)
type: bool default: false
--trace_gc_nvp (print one detailed trace line in name=value format after each garbage collection)
type: bool default: false
--trace_gc_ignore_scavenger (do not print trace line after scavenger collection)
type: bool default: false
--print_cumulative_gc_stat (print cumulative GC statistics in name=value format on exit)
type: bool default: false
--trace_gc_verbose (print more details following each garbage collection)
type: bool default: false
--trace_fragmentation (report fragmentation for old pointer and data pages)
type: bool default: false
--trace_external_memory (print amount of external allocated memory after each time it is adjusted.)
type: bool default: false
--collect_maps (garbage collect maps from which no objects can be reached)
type: bool default: true
--flush_code (flush code that we expect not to use again before full gc)
type: bool default: true
--incremental_marking (use incremental marking)
type: bool default: true
--incremental_marking_steps (do incremental marking steps)
type: bool default: true
--trace_incremental_marking (trace progress of the incremental marking)
type: bool default: false
--track_gc_object_stats (track object counts and memory usage)
type: bool default: false
--use_idle_notification (Use idle notification to reduce memory footprint.)
type: bool default: true
--use_ic (use inline caching)
type: bool default: true
--native_code_counters (generate extra code for manipulating stats counters)
type: bool default: false
--always_compact (Perform compaction on every full GC)
type: bool default: false
--lazy_sweeping (Use lazy sweeping for old pointer and data spaces)
type: bool default: true
--never_compact (Never perform compaction on full GC - testing only)
type: bool default: false
--compact_code_space (Compact code space on full non-incremental collections)
type: bool default: true
--incremental_code_compaction (Compact code space on full incremental collections)
type: bool default: true
--cleanup_code_caches_at_gc (Flush inline caches prior to mark compact collection and flush code caches in maps during mark compact cycle.)
type: bool default: true
--random_seed (Default seed for initializing random generator (0, the default, means to use system random).)
type: int default: 0
--use_verbose_printer (allows verbose printing)
type: bool default: true
--allow_natives_syntax (allow natives syntax)
type: bool default: false
--trace_parse (trace parsing and preparsing)
type: bool default: false
--trace_sim (Trace simulator execution)
type: bool default: false
--check_icache (Check icache flushes in ARM and MIPS simulator)
type: bool default: false
--stop_sim_at (Simulator stop after x number of instructions)
type: int default: 0
--sim_stack_alignment (Stack alingment in bytes in simulator (4 or 8, 8 is default))
type: int default: 8
--abort_on_uncaught_exception (abort program (dump core) when an uncaught exception is thrown)
type: bool default: false
--trace_exception (print stack trace when throwing exceptions)
type: bool default: false
--preallocate_message_memory (preallocate some memory to build stack traces.)
type: bool default: false
--randomize_hashes (randomize hashes to avoid predictable hash collisions (with snapshots this option cannot override the baked-in seed))
type: bool default: true
--hash_seed (Fixed seed to use to hash property keys (0 means random)(with snapshots this option cannot override the baked-in seed))
type: int default: 0
--preemption (activate a 100ms timer that switches between V8 threads)
type: bool default: false
--regexp_optimization (generate optimized regexp code)
type: bool default: true
--testing_bool_flag (testing_bool_flag)
type: bool default: true
--testing_int_flag (testing_int_flag)
type: int default: 13
--testing_float_flag (float-flag)
type: float default: 2.500000
--testing_string_flag (string-flag)
type: string default: Hello, world!
--testing_prng_seed (Seed used for threading test randomness)
type: int default: 42
--testing_serialization_file (file in which to testing_serialize heap)
type: string default: C:\Windows\Temp\serdes
--extra_code (A filename with extra code to be included in the snapshot (mksnapshot only))
type: string default: NULL
--help (Print usage message, including flags, on console)
type: bool default: true
--dump_counters (Dump counters on exit)
type: bool default: false
--debugger (Enable JavaScript debugger)
type: bool default: false
--remote_debugger (Connect JavaScript debugger to the debugger agent in another process)
type: bool default: false
--debugger_agent (Enable debugger agent)
type: bool default: false
--debugger_port (Port to use for remote debugging)
type: int default: 5858
--map_counters (Map counters to a file)
type: string default:
--js_arguments (Pass all remaining arguments to the script. Alias for "--".)
type: arguments default:
--debug_compile_events (Enable debugger compile events)
type: bool default: true
--debug_script_collected_events (Enable debugger script collected events)
type: bool default: true
--gdbjit (enable GDBJIT interface (disables compacting GC))
type: bool default: false
--gdbjit_full (enable GDBJIT interface for all code objects)
type: bool default: false
--gdbjit_dump (dump elf objects with debug info to disk)
type: bool default: false
--gdbjit_dump_filter (dump only objects containing this substring)
type: string default:
--force_marking_deque_overflows (force overflows of marking deque by reducing it's size to 64 words)
type: bool default: false
--stress_compaction (stress the GC compactor to flush out bugs (implies --force_marking_deque_overflows))
type: bool default: false
--log (Minimal logging (no API, code, GC, suspect, or handles samples).)
type: bool default: false
--log_all (Log all events to the log file.)
type: bool default: false
--log_runtime (Activate runtime system %Log call.)
type: bool default: false
--log_api (Log API events to the log file.)
type: bool default: false
--log_code (Log code events to the log file without profiling.)
type: bool default: false
--log_gc (Log heap samples on garbage collection for the hp2ps tool.)
type: bool default: false
--log_handles (Log global handle events.)
type: bool default: false
--log_snapshot_positions (log positions of (de)serialized objects in the snapshot.)
type: bool default: false
--log_suspect (Log suspect operations.)
type: bool default: false
--prof (Log statistical profiling information (implies --log-code).)
type: bool default: false
--prof_auto (Used with --prof, starts profiling automatically)
type: bool default: true
--prof_lazy (Used with --prof, only does sampling and logging when profiler is active (implies --noprof_auto).)
type: bool default: false
--prof_browser_mode (Used with --prof, turns on browser-compatible mode for profiling.)
type: bool default: true
--log_regexp (Log regular expression execution.)
type: bool default: false
--sliding_state_window (Update sliding state window counters.)
type: bool default: false
--logfile (Specify the name of the log file.)
type: string default: v8.log
--ll_prof (Enable low-level linux profiler.)
type: bool default: false
--gc_fake_mmap (Specify the name of the file for fake gc mmap used in ll_prof)
type: string default: /tmp/__v8_gc__
[deoptimize context: 9aa414b1]
[marking f 0xf2fcdc38 for recompilation, reason: hot and stable, ICs with typeinfo: 0/0 (100%)]
[marking DoRegExpExec 0x9aa54a70 for recompilation, reason: hot and stable, ICs with typeinfo: 2/2 (100%)]
-----------------------------------------------------------
Compiling method DoRegExpExec using hydrogen
[optimizing: DoRegExpExec / 9aa54a71 - took 2.000, 0.000, 0.000 ms]
[marking f 0xf2fe3f68 for recompilation, reason: hot and stable, ICs with typeinfo: 0/0 (100%)]
-----------------------------------------------------------
Compiling method f using hydrogen
[optimizing: f / f2fe3f69 - took 1.000, 0.000, 0.000 ms]
[marking UseSparseVariant 0x9aa4c508 for recompilation, reason: small function, ICs with typeinfo: 0/3 (0%)]
-----------------------------------------------------------
Compiling method UseSparseVariant using hydrogen
[optimizing: UseSparseVariant / 9aa4c509 - took 1.000, 0.000, 0.000 ms]
[marking NativeModule.getCached 0x9aa605b8 for recompilation, reason: small function, ICs with typeinfo: 2/2 (100%)]
-----------------------------------------------------------
Compiling method NativeModule.getCached using hydrogen
[optimizing: NativeModule.getCached / 9aa605b9 - took 0.000, 0.000, 0.000 ms]
[marking setTime 0x9aa486b8 for recompilation, reason: small function, ICs with typeinfo: 1/3 (33%)]
[marking CreateDate 0x9aa54608 for recompilation, reason: small function, ICs with typeinfo: 2/2 (100%)]
-----------------------------------------------------------
Compiling method CreateDate using hydrogen
[optimizing: CreateDate / 9aa54609 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method setTime using hydrogen
[optimizing: setTime / 9aa486b9 - took 0.000, 0.000, 0.000 ms]
[marking SubString 0x9aa52858 for recompilation, reason: small function, ICs with typeinfo: 1/2 (50%)]
[marking ToObject 0x9aa4a790 for recompilation, reason: small function, ICs with typeinfo: 0/4 (0%)]
-----------------------------------------------------------
Compiling method SubString using hydrogen
[optimizing: SubString / 9aa52859 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method ToObject using hydrogen
[disabled optimization for ToObject, reason: call to a JavaScript runtime function]
[marking ToUint32 0x9aa49148 for recompilation, reason: small function, ICs with typeinfo: 0/2 (0%)]
-----------------------------------------------------------
Compiling method ToUint32 using hydrogen
[optimizing: ToUint32 / 9aa49149 - took 0.000, 0.000, 0.000 ms]
[marking exec 0x9aa48648 for recompilation, reason: hot and stable, ICs with typeinfo: 9/16 (56%)]
-----------------------------------------------------------
Compiling method exec using hydrogen
[optimizing: exec / 9aa48649 - took 1.000, 0.000, 0.000 ms]
[marking StringSplitOnRegExp 0x9aa48c10 for recompilation, reason: hot and stable, ICs with typeinfo: 13/35 (37%)]
-----------------------------------------------------------
Compiling method StringSplitOnRegExp using hydrogen
[optimizing: StringSplitOnRegExp / 9aa48c11 - took 1.000, 1.000, 0.000 ms]
[marking nullCheck 0xd1930060 for recompilation, reason: small function, ICs with typeinfo: 2/6 (33%)]
-----------------------------------------------------------
Compiling method nullCheck using hydrogen
[optimizing: nullCheck / d1930061 - took 1.000, 0.000, 0.000 ms]
[marking join 0x9aa488b8 for recompilation, reason: hot and stable, ICs with typeinfo: 4/6 (66%)]
-----------------------------------------------------------
Compiling method join using hydrogen
[disabled optimization for join, reason: inlined runtime function: FastAsciiArrayJoin]
[marking BuildResultFromMatchInfo 0x9aa54698 for recompilation, reason: hot and stable, ICs with typeinfo: 14/19 (73%)]
-----------------------------------------------------------
Compiling method BuildResultFromMatchInfo using hydrogen
[optimizing: BuildResultFromMatchInfo / 9aa54699 - took 1.000, 0.000, 0.000 ms]
[marking splitPath 0xd19300f0 for recompilation, reason: small function, ICs with typeinfo: 9/9 (100%)]
-----------------------------------------------------------
Compiling method splitPath using hydrogen
[optimizing: splitPath / d19300f1 - took 1.000, 0.000, 0.000 ms]
[marking Module._debug 0x9aa71ca8 for recompilation, reason: small function, ICs with typeinfo: 0/0 (100%)]
[marking NativeModule.require 0x9aa60570 for recompilation, reason: small function, ICs with typeinfo: 9/12 (75%)]
-----------------------------------------------------------
Compiling method NativeModule.require using hydrogen
[optimizing: NativeModule.require / 9aa60571 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method Module._debug using hydrogen
[optimizing: Module._debug / 9aa71ca9 - took 1.000, 0.000, 0.000 ms]
[marking split 0x9aa4b358 for recompilation, reason: hot and stable, ICs with typeinfo: 2/10 (20%)]
-----------------------------------------------------------
Compiling method split using hydrogen
[optimizing: split / 9aa4b359 - took 1.000, 0.000, 0.000 ms]
[marking exports.dirname 0x9aa6fd90 for recompilation, reason: small function, ICs with typeinfo: 6/6 (100%)]
-----------------------------------------------------------
Compiling method exports.dirname using hydrogen
[optimizing: exports.dirname / 9aa6fd91 - took 1.000, 0.000, 0.000 ms]
[marking $Array.set_ 0x9aa4cf58 for recompilation, reason: small function, ICs with typeinfo: 1/1 (100%)]
-----------------------------------------------------------
Compiling method $Array.set_ using hydrogen
[optimizing: $Array.set_ / 9aa4cf59 - took 1.000, 0.000, 0.000 ms]
[marking keys 0x9aa41960 for recompilation, reason: small function, ICs with typeinfo: 0/4 (0%)]
[marking BasicJSONSerialize 0x9aa55170 for recompilation, reason: hot and stable, ICs with typeinfo: 4/22 (18%)]
-----------------------------------------------------------
Compiling method keys using hydrogen
[optimizing: keys / 9aa41961 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method BasicJSONSerialize using hydrogen
[optimizing: BasicJSONSerialize / 9aa55171 - took 1.000, 1.000, 0.000 ms]
[marking $Array.enumerable_ 0x9aa4ce38 for recompilation, reason: small function, ICs with typeinfo: 1/1 (100%)]
-----------------------------------------------------------
Compiling method $Array.enumerable_ using hydrogen
[optimizing: $Array.enumerable_ / 9aa4ce39 - took 1.000, 0.000, 0.000 ms]
**** DEOPT: NativeModule.require at bailout #10, address 0x0, frame size 120
;;; Deferred code @140: allocate-object.
[deoptimizing: begin 0x9aa60571 NativeModule.require @10]
translating NativeModule.require => node=63, height=16
0x0025ee40: [top + 56] <- 0xd195f309 ; [sp + 160] 00000000D195F309 <JS Function NativeModule>
0x0025ee38: [top + 48] <- 0xf8f16271 ; [sp + 152] 00000000F8F16271 <String[6]: domain>
0x0025ee30: [top + 40] <- 0x0284d051 ; caller's pc
0x0025ee28: [top + 32] <- 0x0025ee80 ; caller's fp
0x0025ee20: [top + 24] <- 0xd1956f21; context
0x0025ee18: [top + 16] <- 0x9aa60571; function
0x0025ee10: [top + 8] <- 0x9aa04121 ; rax 000000009AA04121 <undefined>
0x0025ee08: [top + 0] <- 000000009AA04121 <undefined> ; literal
translating NativeModule.exists => node=2, height=0
0x0025ee00: [top + 40] <- 0xd195f309 ; rdx 00000000D195F309 <JS Function NativeModule>
0x0025edf8: [top + 32] <- 0xf8f16271 ; [sp + 152] 00000000F8F16271 <String[6]: domain>
0x0025edf0: [top + 24] <- 0x0282d72b ; caller's pc
0x0025ede8: [top + 16] <- 0x0025ee28 ; caller's fp
0x0025ede0: [top + 8] <- 0xd1956f21; context
0x0025edd8: [top + 0] <- 0x9aa60601; function
[deoptimizing: end 0x9aa60601 NativeModule.exists => node=2, pc=0x0282d9a6, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: NativeModule.require]
-----------------------------------------------------------
Compiling method P using hydrogen
[optimizing: P / f2f9a441 - took 1.000, 1.000, 0.000 ms]
[marking bind 0xf2fdebe8 for recompilation, reason: small function, ICs with typeinfo: 0/0 (100%)]
-----------------------------------------------------------
Compiling method bind using hydrogen
[optimizing: bind / f2fdebe9 - took 1.000, 0.000, 0.000 ms]
[marking Assertion 0xf2fdeb80 for recompilation, reason: hot and stable, ICs with typeinfo: 29/32 (90%)]
-----------------------------------------------------------
Compiling method Assertion using hydrogen
[optimizing: Assertion / f2fdeb81 - took 1.000, 1.000, 0.000 ms]
**** DEOPT: Assertion at bailout #60, address 0x0, frame size 224
;;; Deferred code @314: stack-check.
[deoptimizing: begin 0xf2fdeb81 Assertion @60]
translating Assertion => node=324, height=56
0x0025f1e0: [top + 112] <- 0xf2ef1269 ; [sp + 280] 00000000F2EF1269 <an Assertion>
0x0025f1d8: [top + 104] <- 0xf0388b59 ; [sp + 272] 00000000F0388B59 <String[7]: Promise>
0x0025f1d0: [top + 96] <- 0xf0388891 ; [sp + 264] 00000000F0388891 <String[2]: be>
0x0025f1c8: [top + 88] <- 0xf2ee41f9 ; [sp + 256] 00000000F2EE41F9 <an Assertion>
0x0025f1c0: [top + 80] <- 0x0281580e ; caller's pc
0x0025f1b8: [top + 72] <- 0x0025f210 ; caller's fp
0x0025f1b0: [top + 64] <- 0xf2ef12a1; context
0x0025f1a8: [top + 56] <- 0xf2fdeb81; function
0x0025f1a0: [top + 48] <- 0 ; [sp + 112] (smi)
0x0025f198: [top + 40] <- 0xf2fdf859 ; [sp + 152] 00000000F2FDF859 <JS Array[1]>
0x0025f190: [top + 32] <- 0x100000000 ; [sp + 144] 1
0x0025f188: [top + 24] <- 0xf038d291 ; [sp + 104] 00000000F038D291 <String[2]: an>
0x0025f180: [top + 16] <- 0xf2ef1321 ; [sp + 88] 00000000F2EF1321 <an Assertion>
0x0025f178: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025f170: [top + 0] <- 0xf2fdf8a9 ; [sp + 64] 00000000F2FDF8A9 <an Object>
[deoptimizing: end 0xf2fdeb81 Assertion => node=324, pc=0x028d2da8, state=TOS_REG, alignment=no padding, took 0.000 ms]
[removing optimized code for: Assertion]
-----------------------------------------------------------
Compiling method HandleSettled using hydrogen
[optimizing: HandleSettled / f3f398e1 - took 1.000, 0.000, 0.000 ms]
[marking Assertion 0xf3f0a218 for recompilation, reason: hot and stable, ICs with typeinfo: 29/32 (90%)]
-----------------------------------------------------------
Compiling method Assertion using hydrogen
[optimizing: Assertion / f3f0a219 - took 1.000, 1.000, 0.000 ms]
**** DEOPT: Assertion at bailout #60, address 0x0, frame size 224
;;; Deferred code @308: stack-check.
[deoptimizing: begin 0xf3f0a219 Assertion @60]
translating Assertion => node=324, height=56
0x0025ee38: [top + 112] <- 0xf3e547d1 ; [sp + 280] 00000000F3E547D1 <an Assertion>
0x0025ee30: [top + 104] <- 0xf0388b59 ; [sp + 272] 00000000F0388B59 <String[7]: Promise>
0x0025ee28: [top + 96] <- 0xf0388891 ; [sp + 264] 00000000F0388891 <String[2]: be>
0x0025ee20: [top + 88] <- 0xf3e53a49 ; [sp + 256] 00000000F3E53A49 <an Assertion>
0x0025ee18: [top + 80] <- 0x0281580e ; caller's pc
0x0025ee10: [top + 72] <- 0x0025ee68 ; caller's fp
0x0025ee08: [top + 64] <- 0xf3e54809; context
0x0025ee00: [top + 56] <- 0xf3f0a219; function
0x0025edf8: [top + 48] <- 0 ; [sp + 128] (smi)
0x0025edf0: [top + 40] <- 0x96e0ec09 ; [sp + 152] 0000000096E0EC09 <JS Array[1]>
0x0025ede8: [top + 32] <- 0x100000000 ; [sp + 144] 1
0x0025ede0: [top + 24] <- 0xf038d291 ; [sp + 120] 00000000F038D291 <String[2]: an>
0x0025edd8: [top + 16] <- 0xf3e54979 ; [sp + 96] 00000000F3E54979 <an Assertion>
0x0025edd0: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025edc8: [top + 0] <- 0xf3f399c1 ; [sp + 72] 00000000F3F399C1 <an Object>
[deoptimizing: end 0xf3f0a219 Assertion => node=324, pc=0x028d2da8, state=TOS_REG, alignment=no padding, took 0.000 ms]
[forced deoptimization: Assertion / f3f0a219]
**** DEOPT: Assertion at bailout #48, address 0x28dd13c, frame size 224
[deoptimizing (lazy): begin 0xf3f0a219 Assertion @48]
translating Assertion => node=258, height=56
0x0025efb0: [top + 112] <- 0xf3e53a49 ; [sp + 280] 00000000F3E53A49 <an Assertion>
0x0025efa8: [top + 104] <- 0xf0388b59 ; [sp + 272] 00000000F0388B59 <String[7]: Promise>
0x0025efa0: [top + 96] <- 0xf0389669 ; [sp + 264] 00000000F0389669 <String[3]: not>
0x0025ef98: [top + 88] <- 0xf3e50b19 ; [sp + 256] 00000000F3E50B19 <an Assertion>
0x0025ef90: [top + 80] <- 0x0281580e ; caller's pc
0x0025ef88: [top + 72] <- 0x0025efe0 ; caller's fp
0x0025ef80: [top + 64] <- 0xf3e54721; context
0x0025ef78: [top + 56] <- 0xf3f0a219; function
0x0025ef70: [top + 48] <- 1 ; [sp + 128] (smi)
0x0025ef68: [top + 40] <- 0x96e0eb89 ; [sp + 152] 0000000096E0EB89 <JS Array[5]>
0x0025ef60: [top + 32] <- 0x500000000 ; [sp + 144] 5
0x0025ef58: [top + 24] <- 0xf0388891 ; [sp + 120] 00000000F0388891 <String[2]: be>
0x0025ef50: [top + 16] <- 000000009AA04121 <undefined> ; literal
0x0025ef48: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025ef40: [top + 0] <- 0xf3e547d1 ; rbx 00000000F3E547D1 <an Assertion>
[deoptimizing: end 0xf3f0a219 Assertion => node=258, pc=0x028d2ca3, state=TOS_REG, alignment=no padding, took 1.000 ms]
[marking Assertion 0x96e76ae8 for recompilation, reason: hot and stable, ICs with typeinfo: 29/32 (90%)]
-----------------------------------------------------------
Compiling method Assertion using hydrogen
[optimizing: Assertion / 96e76ae9 - took 1.000, 1.000, 0.000 ms]
**** DEOPT: Assertion at bailout #60, address 0x0, frame size 224
;;; Deferred code @308: stack-check.
[deoptimizing: begin 0x96e76ae9 Assertion @60]
translating Assertion => node=324, height=56
0x0025f068: [top + 112] <- 0xf2fb3791 ; [sp + 280] 00000000F2FB3791 <an Assertion>
0x0025f060: [top + 104] <- 0xf0388b59 ; [sp + 272] 00000000F0388B59 <String[7]: Promise>
0x0025f058: [top + 96] <- 0xf0388891 ; [sp + 264] 00000000F0388891 <String[2]: be>
0x0025f050: [top + 88] <- 0xf2fb36d9 ; [sp + 256] 00000000F2FB36D9 <an Assertion>
0x0025f048: [top + 80] <- 0x0281580e ; caller's pc
0x0025f040: [top + 72] <- 0x0025f098 ; caller's fp
0x0025f038: [top + 64] <- 0xf2fb37c9; context
0x0025f030: [top + 56] <- 0x96e76ae9; function
0x0025f028: [top + 48] <- 0 ; [sp + 128] (smi)
0x0025f020: [top + 40] <- 0x96e0ec09 ; [sp + 152] 0000000096E0EC09 <JS Array[1]>
0x0025f018: [top + 32] <- 0x100000000 ; [sp + 144] 1
0x0025f010: [top + 24] <- 0xf038d291 ; [sp + 120] 00000000F038D291 <String[2]: an>
0x0025f008: [top + 16] <- 0xf2fb3849 ; [sp + 96] 00000000F2FB3849 <an Assertion>
0x0025f000: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025eff8: [top + 0] <- 0x96e76ad1 ; [sp + 72] 0000000096E76AD1 <an Object>
[deoptimizing: end 0x96e76ae9 Assertion => node=324, pc=0x028d2da8, state=TOS_REG, alignment=no padding, took 0.000 ms]
[forced deoptimization: Assertion / 96e76ae9]
**** DEOPT: Assertion at bailout #48, address 0x28dea93, frame size 224
[deoptimizing (lazy): begin 0x96e76ae9 Assertion @48]
translating Assertion => node=258, height=56
0x0025f1e0: [top + 112] <- 0xf2fb36d9 ; [sp + 280] 00000000F2FB36D9 <an Assertion>
0x0025f1d8: [top + 104] <- 0xf0388b59 ; [sp + 272] 00000000F0388B59 <String[7]: Promise>
0x0025f1d0: [top + 96] <- 0xf8f20161 ; [sp + 264] 00000000F8F20161 <String[2]: to>
0x0025f1c8: [top + 88] <- 0xf2fac9c9 ; [sp + 256] 00000000F2FAC9C9 <an Assertion>
0x0025f1c0: [top + 80] <- 0x0281580e ; caller's pc
0x0025f1b8: [top + 72] <- 0x0025f210 ; caller's fp
0x0025f1b0: [top + 64] <- 0xf2fb3711; context
0x0025f1a8: [top + 56] <- 0x96e76ae9; function
0x0025f1a0: [top + 48] <- 0 ; [sp + 128] (smi)
0x0025f198: [top + 40] <- 0x96e0eba9 ; [sp + 152] 0000000096E0EBA9 <JS Array[5]>
0x0025f190: [top + 32] <- 0x500000000 ; [sp + 144] 5
0x0025f188: [top + 24] <- 0xf0388891 ; [sp + 120] 00000000F0388891 <String[2]: be>
0x0025f180: [top + 16] <- 000000009AA04121 <undefined> ; literal
0x0025f178: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025f170: [top + 0] <- 0xf2fb3791 ; rbx 00000000F2FB3791 <an Assertion>
[deoptimizing: end 0x96e76ae9 Assertion => node=258, pc=0x028d2ca3, state=TOS_REG, alignment=no padding, took 0.000 ms]
[marking Assertion 0x96e76ae8 for recompilation, reason: hot and stable, ICs with typeinfo: 29/32 (90%)]
-----------------------------------------------------------
Compiling method Assertion using hydrogen
[optimizing: Assertion / 96e76ae9 - took 0.000, 1.000, 0.000 ms]
**** DEOPT: Assertion at bailout #60, address 0x0, frame size 224
;;; Deferred code @308: stack-check.
[deoptimizing: begin 0x96e76ae9 Assertion @60]
translating Assertion => node=324, height=56
0x0025efb0: [top + 112] <- 0xf2e94a81 ; [sp + 280] 00000000F2E94A81 <an Assertion>
0x0025efa8: [top + 104] <- 0xf0388b59 ; [sp + 272] 00000000F0388B59 <String[7]: Promise>
0x0025efa0: [top + 96] <- 0xf0388891 ; [sp + 264] 00000000F0388891 <String[2]: be>
0x0025ef98: [top + 88] <- 0xf2e90cb9 ; [sp + 256] 00000000F2E90CB9 <an Assertion>
0x0025ef90: [top + 80] <- 0x0281580e ; caller's pc
0x0025ef88: [top + 72] <- 0x0025efe0 ; caller's fp
0x0025ef80: [top + 64] <- 0xf2e94ab9; context
0x0025ef78: [top + 56] <- 0x96e76ae9; function
0x0025ef70: [top + 48] <- 0 ; [sp + 128] (smi)
0x0025ef68: [top + 40] <- 0x96e0ec09 ; [sp + 152] 0000000096E0EC09 <JS Array[1]>
0x0025ef60: [top + 32] <- 0x100000000 ; [sp + 144] 1
0x0025ef58: [top + 24] <- 0xf038d291 ; [sp + 120] 00000000F038D291 <String[2]: an>
0x0025ef50: [top + 16] <- 0xf2e94b39 ; [sp + 96] 00000000F2E94B39 <an Assertion>
0x0025ef48: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025ef40: [top + 0] <- 0x96e76ad1 ; [sp + 72] 0000000096E76AD1 <an Object>
[deoptimizing: end 0x96e76ae9 Assertion => node=324, pc=0x028d2da8, state=TOS_REG, alignment=no padding, took 0.000 ms]
[removing optimized code for: Assertion]
[marking Assertion 0x96e76ae8 for recompilation, reason: hot and stable, ICs with typeinfo: 29/32 (90%)]
-----------------------------------------------------------
Compiling method Assertion using hydrogen
[disabled optimization for Assertion, reason: ForInStatement is not fast case]
-----------------------------------------------------------
Compiling method Resolve using hydrogen
[optimizing: Resolve / 96e8a6c9 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method Fulfill using hydrogen
[optimizing: Fulfill / 96e8a711 - took 0.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method ResolveWithObject using hydrogen
[optimizing: ResolveWithObject / 96e8a759 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method Reject using hydrogen
[optimizing: Reject / 96ecb591 - took 1.000, 0.000, 0.000 ms]
**** DEOPT: Reject at bailout #10, address 0x0, frame size 8
;;; @133: gap.
[deoptimizing: begin 0x96ecb591 Reject @10]
translating Reject => node=78, height=0
0x0025f1e8: [top + 48] <- 0x9aa04121 ; [sp + 56] 000000009AA04121 <undefined>
0x0025f1e0: [top + 40] <- 0xf3e7c7b1 ; rdx 00000000F3E7C7B1 <a Promise>
0x0025f1d8: [top + 32] <- 0xf8f09a09 ; [sp + 40] 00000000F8F09A09 <String[0]: >
0x0025f1d0: [top + 24] <- 0x028e4e26 ; caller's pc
0x0025f1c8: [top + 16] <- 0x0025f208 ; caller's fp
0x0025f1c0: [top + 8] <- 0x96e80d01; context
0x0025f1b8: [top + 0] <- 0x96ecb591; function
[deoptimizing: end 0x96ecb591 Reject => node=78, pc=0x028b35f3, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: Reject]
-----------------------------------------------------------
Compiling method Promise using hydrogen
[optimizing: Promise / 96e70a19 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TaskNode using hydrogen
[optimizing: TaskNode / 96e80929 - took 0.000, 0.000, 0.000 ms]
**** DEOPT: HandleSettled at bailout #3, address 0x0, frame size 8
;;; @21: branch.
[deoptimizing: begin 0x96e77201 HandleSettled @3]
translating HandleSettled => node=3, height=0
0x0025f570: [top + 40] <- 0x9aa04121 ; [sp + 48] 000000009AA04121 <undefined>
0x0025f568: [top + 32] <- 0xf2f7c6d9 ; rbx 00000000F2F7C6D9 <a Promise>
0x0025f560: [top + 24] <- 0x028e4398 ; caller's pc
0x0025f558: [top + 16] <- 0x0025f590 ; caller's fp
0x0025f550: [top + 8] <- 0x96e80d01; context
0x0025f548: [top + 0] <- 0x96e77201; function
[deoptimizing: end 0x96e77201 HandleSettled => node=3, pc=0x028b19d4, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: HandleSettled]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.then using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.then / d19b2739 - took 1.000, 1.000, 0.000 ms]
-----------------------------------------------------------
Compiling method HandleSettled using hydrogen
[optimizing: HandleSettled / 96e77201 - took 0.000, 1.000, 0.000 ms]
-----------------------------------------------------------
Compiling method all using hydrogen
[optimizing: all / 9a534859 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method OnSettled using hydrogen
[optimizing: OnSettled / 9a534e61 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method flush using hydrogen
[optimizing: flush / 9a534c69 - took 1.000, 1.000, 0.000 ms]
**** DEOPT: HandleSettled at bailout #5, address 0x0, frame size 104
;;; Deferred code @238: allocate-object.
[deoptimizing: begin 0x96e77201 HandleSettled @5]
translating HandleSettled => node=33, height=8
0x0025f588: [top + 48] <- 0x9aa04121 ; [sp + 144] 000000009AA04121 <undefined>
0x0025f580: [top + 40] <- 0xf2d696c9 ; rax 00000000F2D696C9 <a Promise>
0x0025f578: [top + 32] <- 0x028e4398 ; caller's pc
0x0025f570: [top + 24] <- 0x0025f5a8 ; caller's fp
0x0025f568: [top + 16] <- 0x96e80d01; context
0x0025f560: [top + 8] <- 0x96e77201; function
0x0025f558: [top + 0] <- 0x9a534e19 ; rcx 000000009A534E19 <JS Function HandlePending>
translating HandlePending => node=131, height=16
0x0025f550: [top + 72] <- 000000009AA04121 <undefined> ; literal
0x0025f548: [top + 64] <- 0xf2d696c9 ; rax 00000000F2D696C9 <a Promise>
0x0025f540: [top + 56] <- 0x00000000 ; r8 0
0x0025f538: [top + 48] <- 0xf2d6c7b9 ; rbx 00000000F2D6C7B9 <JS Function onSettled>
0x0025f530: [top + 40] <- 0x028b1a50 ; caller's pc
0x0025f528: [top + 32] <- 0x0025f570 ; caller's fp
0x0025f520: [top + 24] <- 0x96e80d01; context
0x0025f518: [top + 16] <- 0x9a534e19; function
0x0025f510: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025f508: [top + 0] <- 000000009AA04121 <undefined> ; literal
[deoptimizing: end 0x9a534e19 HandlePending => node=131, pc=0x028e512c, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: HandleSettled]
[marking expect 0x96ecb500 for recompilation, reason: small function, ICs with typeinfo: 0/0 (100%)]
-----------------------------------------------------------
Compiling method HandlePending using hydrogen
[optimizing: HandlePending / 9a534e19 - took 1.000, 1.000, 0.000 ms]
-----------------------------------------------------------
Compiling method expect using hydrogen
[optimizing: expect / 96ecb501 - took 0.000, 0.000, 0.000 ms]
[marking 0xf2b5c980 for recompilation, reason: hot and stable, ICs with typeinfo: 1/1 (100%)]
-----------------------------------------------------------
Compiling method using hydrogen
[optimizing: / f2b5c981 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method resolverFor using hydrogen
[optimizing: resolverFor / 9a534f39 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.inspect using hydrogen
[disabled optimization for TRACE_FUNCTIONS.fn.Promise.inspect, reason: SwitchStatement: non-literal switch label]
-----------------------------------------------------------
Compiling method Reject using hydrogen
[optimizing: Reject / 96ecb591 - took 1.000, 1.000, 0.000 ms]
**** DEOPT: flush at bailout #21, address 0x0, frame size 88
;;; @162: deoptimize.
[deoptimizing: begin 0x9a534c69 flush @21]
translating flush => node=146, height=32
0x0025f6e0: [top + 64] <- 0xf2b7d5a9 ; [sp + 120] 00000000F2B7D5A9 <an Object>
0x0025f6d8: [top + 56] <- 0x028c7d37 ; caller's pc
0x0025f6d0: [top + 48] <- 0x0025f700 ; caller's fp
0x0025f6c8: [top + 40] <- 0x96e80d01; context
0x0025f6c0: [top + 32] <- 0x9a534c69; function
0x0025f6b8: [top + 24] <- 0xf2f7d369 ; rbx 00000000F2F7D369 <a TaskNode>
0x0025f6b0: [top + 16] <- 0xf2b5d879 ; rdx 00000000F2B5D879 <a Promise>
0x0025f6a8: [top + 8] <- 0xf2b7d461 ; rcx 00000000F2B7D461 <a Promise>
0x0025f6a0: [top + 0] <- 0x9a534ea9 ; r8 000000009A534EA9 <JS Function Then>
translating Then => node=74, height=16
0x0025f698: [top + 64] <- 000000009AA04121 <undefined> ; literal
0x0025f690: [top + 56] <- 0xf2b5d879 ; rdx 00000000F2B5D879 <a Promise>
0x0025f688: [top + 48] <- 0xf2b7d461 ; rcx 00000000F2B7D461 <a Promise>
0x0025f680: [top + 40] <- 0x0286b4f5 ; caller's pc
0x0025f678: [top + 32] <- 0x0025f6d0 ; caller's fp
0x0025f670: [top + 24] <- 0x96e80d01; context
0x0025f668: [top + 16] <- 0x9a534ea9; function
0x0025f660: [top + 8] <- 0x9aa04101 ; r9 000000009AA04101 <null>
0x0025f658: [top + 0] <- 000000009AA04121 <undefined> ; literal
[deoptimizing: end 0x9a534ea9 Then => node=74, pc=0x0286b7cc, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: flush]
-----------------------------------------------------------
Compiling method HandleSettled using hydrogen
[optimizing: HandleSettled / 96e77201 - took 1.000, 1.000, 0.000 ms]
-----------------------------------------------------------
Compiling method Then using hydrogen
[optimizing: Then / 9a534ea9 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method reject using hydrogen
[optimizing: reject / 9a5347c9 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method flush using hydrogen
[optimizing: flush / 9a534c69 - took 1.000, 0.000, 0.000 ms]
[marking Assertion.be.Assertion.equal 0xd19b54f8 for recompilation, reason: small function, ICs with typeinfo: 2/3 (66%)]
[marking Assertion.(anonymous function) 0x96ea9f00 for recompilation, reason: small function, ICs with typeinfo: 1/1 (100%)]
-----------------------------------------------------------
Compiling method Assertion.be.Assertion.equal using hydrogen
[optimizing: Assertion.be.Assertion.equal / d19b54f9 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method defer using hydrogen
[optimizing: defer / 9a534781 - took 1.000, 0.000, 0.000 ms]
**** DEOPT: all at bailout #25, address 0x0, frame size 96
;;; @244: deoptimize.
[deoptimizing: begin 0x9a534859 all @25]
translating all => node=246, height=32
0x0025f428: [top + 72] <- 0x96ecb429 ; [sp + 136] 0000000096ECB429 <JS Function P>
0x0025f420: [top + 64] <- 0xf2f0c409 ; [sp + 128] 00000000F2F0C409 <JS Array[19]>
0x0025f418: [top + 56] <- 0x028bb23b ; caller's pc
0x0025f410: [top + 48] <- 0x0025f458 ; caller's fp
0x0025f408: [top + 40] <- 0xf2f0cd39; context
0x0025f400: [top + 32] <- 0x9a534859; function
0x0025f3f8: [top + 24] <- 0x1300000000 ; [sp + 64] 19
0x0025f3f0: [top + 16] <- 0xf2f0cd81 ; [sp + 80] 00000000F2F0CD81 <JS Function onSettled>
0x0025f3e8: [top + 8] <- 0 ; [sp + 24] (smi)
0x0025f3e0: [top + 0] <- 0xf2f0cee9 ; [sp + 16] 00000000F2F0CEE9 <a Promise>
[deoptimizing: end 0x9a534859 all => node=246, pc=0x02885f07, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: all]
[marking a 0xf2f21f30 for recompilation, reason: small function, ICs with typeinfo: 2/5 (40%)]
-----------------------------------------------------------
Compiling method a using hydrogen
[optimizing: a / f2f21f31 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method all using hydrogen
[optimizing: all / 9a534859 - took 0.000, 1.000, 0.000 ms]
**** DEOPT: all at bailout #26, address 0x0, frame size 80
;;; Deferred code @308: tagged-to-i.
[deoptimizing: begin 0x9a534859 all @26]
translating all => node=246, height=32
0x0025f430: [top + 72] <- 0x96ecb429 ; [sp + 120] 0000000096ECB429 <JS Function P>
0x0025f428: [top + 64] <- 0xf2f35819 ; [sp + 112] 00000000F2F35819 <JS Array[19]>
0x0025f420: [top + 56] <- 0x028bb470 ; caller's pc
0x0025f418: [top + 48] <- 0x0025f458 ; caller's fp
0x0025f410: [top + 40] <- 0xf2f35e89; context
0x0025f408: [top + 32] <- 0x9a534859; function
0x0025f400: [top + 24] <- 0x1300000000 ; [sp + 48] 19
0x0025f3f8: [top + 16] <- 0xf2f35ed1 ; [sp + 64] 00000000F2F35ED1 <JS Function onSettled>
0x0025f3f0: [top + 8] <- 0 ; [sp + 16] (smi)
0x0025f3e8: [top + 0] <- 0xf2f36039 ; rdx 00000000F2F36039 <a Promise>
[deoptimizing: end 0x9a534859 all => node=246, pc=0x02885f07, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: all]
-----------------------------------------------------------
Compiling method all using hydrogen
[optimizing: all / 9a534859 - took 1.000, 0.000, 0.000 ms]
**** DEOPT: all at bailout #15, address 0x0, frame size 80
;;; Deferred code @312: tagged-to-i.
[deoptimizing: begin 0x9a534859 all @15]
translating all => node=249, height=32
0x0025f5e8: [top + 72] <- 0x9aa04121 ; [sp + 120] 000000009AA04121 <undefined>
0x0025f5e0: [top + 64] <- 0xf2f772d9 ; rbx 00000000F2F772D9 <JS Array[3]>
0x0025f5d8: [top + 56] <- 0x0286bc9f ; caller's pc
0x0025f5d0: [top + 48] <- 0x0025f638 ; caller's fp
0x0025f5c8: [top + 40] <- 0xf2f78071; context
0x0025f5c0: [top + 32] <- 0x9a534859; function
0x0025f5b8: [top + 24] <- 0x300000000 ; [sp + 48] 3
0x0025f5b0: [top + 16] <- 0xf2f780b9 ; [sp + 64] 00000000F2F780B9 <JS Function onSettled>
0x0025f5a8: [top + 8] <- 0 ; [sp + 16] (smi)
0x0025f5a0: [top + 0] <- 000000009AA04121 <undefined> ; literal
[deoptimizing: end 0x9a534859 all => node=249, pc=0x02885e6e, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: all]
-----------------------------------------------------------
Compiling method ResolveWithPromise using hydrogen
[optimizing: ResolveWithPromise / 9a534d89 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.spread using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.spread / d19b2811 - took 0.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method all using hydrogen
[optimizing: all / 9a534859 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method Propagate using hydrogen
[optimizing: Propagate / 9a534d41 - took 0.000, 1.000, 0.000 ms]
[marking isEmpty 0xd1985810 for recompilation, reason: small function, ICs with typeinfo: 1/2 (50%)]
-----------------------------------------------------------
Compiling method isEmpty using hydrogen
[optimizing: isEmpty / d1985811 - took 1.000, 0.000, 0.000 ms]
[marking remove 0xd1985780 for recompilation, reason: small function, ICs with typeinfo: 10/10 (100%)]
-----------------------------------------------------------
Compiling method remove using hydrogen
[optimizing: remove / d1985781 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.delay using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.delay / d19b28a1 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.timeout using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.timeout / d19b2859 - took 0.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method requestFlushForNodeJS using hydrogen
[optimizing: requestFlushForNodeJS / 9a534b71 - took 0.000, 1.000, 0.000 ms]
[marking init 0xd19856a8 for recompilation, reason: small function, ICs with typeinfo: 2/2 (100%)]
-----------------------------------------------------------
Compiling method init using hydrogen
[optimizing: init / d19856a9 - took 1.000, 0.000, 0.000 ms]
**** DEOPT: remove at bailout #3, address 0x0, frame size 8
;;; @21: branch.
[deoptimizing: begin 0xd1985781 remove @3]
translating remove => node=8, height=8
0x0025f360: [top + 48] <- 0xd19858b9 ; [sp + 48] 00000000D19858B9 <an Object>
0x0025f358: [top + 40] <- 0xf2e833d1 ; [sp + 40] 00000000F2E833D1 <JS Object>
0x0025f350: [top + 32] <- 0x028e61ad ; caller's pc
0x0025f348: [top + 24] <- 0x0025f380 ; caller's fp
0x0025f340: [top + 16] <- 0xd1987cc9; context
0x0025f338: [top + 8] <- 0xd1985781; function
0x0025f330: [top + 0] <- 0x9aa04101 ; rax 000000009AA04101 <null>
[deoptimizing: end 0xd1985781 remove => node=8, pc=0x028c6444, state=TOS_REG, alignment=no padding, took 0.000 ms]
[removing optimized code for: remove]
[marking Suite.fullTitle 0xd1956328 for recompilation, reason: small function, ICs with typeinfo: 7/7 (100%)]
-----------------------------------------------------------
Compiling method Suite.fullTitle using hydrogen
[optimizing: Suite.fullTitle / d1956329 - took 1.000, 0.000, 0.000 ms]
[marking global.setImmediate 0x9aa6ce58 for recompilation, reason: small function, ICs with typeinfo: 3/3 (100%)]
-----------------------------------------------------------
Compiling method global.setImmediate using hydrogen
[optimizing: global.setImmediate / 9aa6ce59 - took 1.000, 1.000, 0.000 ms]
[marking shift 0xd1985738 for recompilation, reason: small function, ICs with typeinfo: 1/1 (100%)]
-----------------------------------------------------------
Compiling method shift using hydrogen
[optimizing: shift / d1985739 - took 1.000, 0.000, 0.000 ms]
[marking NonNumberToNumber 0x9aa49a28 for recompilation, reason: small function, ICs with typeinfo: 2/3 (66%)]
-----------------------------------------------------------
Compiling method NonNumberToNumber using hydrogen
[disabled optimization for NonNumberToNumber, reason: call to a JavaScript runtime function]
[marking next 0xf2de1f88 for recompilation, reason: small function, ICs with typeinfo: 3/3 (100%)]
[marking valueOf 0x9aa4ddf8 for recompilation, reason: small function, ICs with typeinfo: 0/0 (100%)]
-----------------------------------------------------------
Compiling method valueOf using hydrogen
[optimizing: valueOf / 9aa4ddf9 - took 0.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method next using hydrogen
[optimizing: next / f2de1f89 - took 0.000, 1.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.done using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.done / d19b2781 - took 0.000, 0.000, 0.000 ms]
**** DEOPT: TRACE_FUNCTIONS.fn.Promise.done at bailout #1, address 0x0, frame size 16
;;; @17: branch.
[deoptimizing: begin 0xd19b2781 TRACE_FUNCTIONS.fn.Promise.done @1]
translating TRACE_FUNCTIONS.fn.Promise.done => node=3, height=8
0x0025f440: [top + 56] <- 0xf2de52f9 ; [sp + 64] 00000000F2DE52F9 <a Promise>
0x0025f438: [top + 48] <- 0xf2de53d1 ; rax 00000000F2DE53D1 <JS Function>
0x0025f430: [top + 40] <- 0xf2de5351 ; [sp + 48] 00000000F2DE5351 <JS Function>
0x0025f428: [top + 32] <- 0x02b219de ; caller's pc
0x0025f420: [top + 24] <- 0x0025f458 ; caller's fp
0x0025f418: [top + 16] <- 0x96e80d01; context
0x0025f410: [top + 8] <- 0xd19b2781; function
0x0025f408: [top + 0] <- 000000009AA04121 <undefined> ; literal
[deoptimizing: end 0xd19b2781 TRACE_FUNCTIONS.fn.Promise.done => node=3, pc=0x02b0d698, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: TRACE_FUNCTIONS.fn.Promise.done]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.nodeify using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.nodeify / d19b29f1 - took 1.000, 0.000, 0.000 ms]
**** DEOPT: TRACE_FUNCTIONS.fn.Promise.nodeify at bailout #1, address 0x0, frame size 8
;;; @17: branch.
[deoptimizing: begin 0xd19b29f1 TRACE_FUNCTIONS.fn.Promise.nodeify @1]
translating TRACE_FUNCTIONS.fn.Promise.nodeify => node=3, height=0
0x0025f438: [top + 40] <- 0xf2c660e1 ; [sp + 48] 00000000F2C660E1 <a Promise>
0x0025f430: [top + 32] <- 0x9aa04121 ; [sp + 40] 000000009AA04121 <undefined>
0x0025f428: [top + 24] <- 0x028bf08f ; caller's pc
0x0025f420: [top + 16] <- 0x0025f450 ; caller's fp
0x0025f418: [top + 8] <- 0xf2c664a9; context
0x0025f410: [top + 0] <- 0xd19b29f1; function
[deoptimizing: end 0xd19b29f1 TRACE_FUNCTIONS.fn.Promise.nodeify => node=3, pc=0x02b21993, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: TRACE_FUNCTIONS.fn.Promise.nodeify]
[marking Runnable.timeout 0xd1955d88 for recompilation, reason: small function, ICs with typeinfo: 2/6 (33%)]
-----------------------------------------------------------
Compiling method Runnable.timeout using hydrogen
[disabled optimization for Runnable.timeout, reason: assignment to parameter in arguments object]
[marking Runner.hook 0xd19ab230 for recompilation, reason: small function, ICs with typeinfo: 4/4 (100%)]
-----------------------------------------------------------
Compiling method Runner.hook using hydrogen
[optimizing: Runner.hook / d19ab231 - took 0.000, 1.000, 0.000 ms]
[marking 0xf2ca59d8 for recompilation, reason: small function, ICs with typeinfo: 0/0 (100%)]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.nodeify using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.nodeify / d19b29f1 - took 0.000, 0.000, 0.000 ms]
[marking IsPrimitive 0x9aa54650 for recompilation, reason: small function, ICs with typeinfo: 0/0 (100%)]
-----------------------------------------------------------
Compiling method IsPrimitive using hydrogen
[optimizing: IsPrimitive / 9aa54651 - took 0.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method TRACE_FUNCTIONS.fn.Promise.done using hydrogen
[optimizing: TRACE_FUNCTIONS.fn.Promise.done / d19b2781 - took 1.000, 0.000, 0.000 ms]
-----------------------------------------------------------
Compiling method queueTask using hydrogen
[optimizing: queueTask / 9a534cb1 - took 0.000, 0.000, 0.000 ms]
**** DEOPT: flush at bailout #23, address 0x0, frame size 88
;;; @207: branch.
[deoptimizing: begin 0x9a534c69 flush @23]
translating flush => node=146, height=32
0x0025f6e0: [top + 64] <- 0xf2cf0931 ; [sp + 120] 00000000F2CF0931 <an Object>
0x0025f6d8: [top + 56] <- 0x028c7d37 ; caller's pc
0x0025f6d0: [top + 48] <- 0x0025f700 ; caller's fp
0x0025f6c8: [top + 40] <- 0x96e80d01; context
0x0025f6c0: [top + 32] <- 0x9a534c69; function
0x0025f6b8: [top + 24] <- 0x9a51b7b1 ; [sp + 56] 000000009A51B7B1 <a TaskNode>
0x0025f6b0: [top + 16] <- 0xf2cf11a9 ; [sp + 40] 00000000F2CF11A9 <a Promise>
0x0025f6a8: [top + 8] <- 0xf2cf1261 ; rbx 00000000F2CF1261 <a Promise>
0x0025f6a0: [top + 0] <- 0x9a534ea9 ; [sp + 24] 000000009A534EA9 <JS Function Then>
translating Then => node=224, height=16
0x0025f698: [top + 64] <- 000000009AA04121 <undefined> ; literal
0x0025f690: [top + 56] <- 0xf2cf11a9 ; [sp + 40] 00000000F2CF11A9 <a Promise>
0x0025f688: [top + 48] <- 0xf2cf1261 ; rbx 00000000F2CF1261 <a Promise>
0x0025f680: [top + 40] <- 0x0286b4f5 ; caller's pc
0x0025f678: [top + 32] <- 0x0025f6d0 ; caller's fp
0x0025f670: [top + 24] <- 0x96e80d01; context
0x0025f668: [top + 16] <- 0x9a534ea9; function
0x0025f660: [top + 8] <- 0xf2cf0971 ; rax 00000000F2CF0971 <a Domain>
0x0025f658: [top + 0] <- 0xf2cf1219 ; rdx 00000000F2CF1219 <JS Function>
[deoptimizing: end 0x9a534ea9 Then => node=224, pc=0x0286b8ad, state=NO_REGISTERS, alignment=no padding, took 1.000 ms]
[removing optimized code for: flush]
**** DEOPT: Then at bailout #3, address 0x0, frame size 32
;;; @23: branch.
[deoptimizing: begin 0x9a534ea9 Then @3]
translating Then => node=3, height=16
0x0025f698: [top + 64] <- 0x9aa04121 ; [sp + 80] 000000009AA04121 <undefined>
0x0025f690: [top + 56] <- 0xf2cf22b1 ; rbx 00000000F2CF22B1 <a Promise>
0x0025f688: [top + 48] <- 0xf2cf2309 ; [sp + 64] 00000000F2CF2309 <a Promise>
0x0025f680: [top + 40] <- 0x0286b4f5 ; caller's pc
0x0025f678: [top + 32] <- 0x0025f6d0 ; caller's fp
0x0025f670: [top + 24] <- 0x96e80d01; context
0x0025f668: [top + 16] <- 0x9a534ea9; function
0x0025f660: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025f658: [top + 0] <- 000000009AA04121 <undefined> ; literal
[deoptimizing: end 0x9a534ea9 Then => node=3, pc=0x0286b6da, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: Then]
-----------------------------------------------------------
Compiling method DoneEb using hydrogen
[optimizing: DoneEb / 9a534cf9 - took 0.000, 1.000, 0.000 ms]
**** DEOPT: DoneEb at bailout #2, address 0x0, frame size 8
;;; @21: branch.
[deoptimizing: begin 0x9a534cf9 DoneEb @2]
translating DoneEb => node=8, height=8
0x0025f5d0: [top + 48] <- 0x9aa04121 ; [sp + 48] 000000009AA04121 <undefined>
0x0025f5c8: [top + 40] <- 0xf2cf0059 ; [sp + 40] 00000000F2CF0059 <an Error>
0x0025f5c0: [top + 32] <- 0x0286bc9f ; caller's pc
0x0025f5b8: [top + 24] <- 0x0025f620 ; caller's fp
0x0025f5b0: [top + 16] <- 0x96e80d01; context
0x0025f5a8: [top + 8] <- 0x9a534cf9; function
0x0025f5a0: [top + 0] <- 0x9aa04101 ; rax 000000009AA04101 <null>
[deoptimizing: end 0x9a534cf9 DoneEb => node=8, pc=0x02b0d8b8, state=TOS_REG, alignment=no padding, took 0.000 ms]
[removing optimized code for: DoneEb]
**** DEOPT: requestFlushForNodeJS at bailout #3, address 0x0, frame size 24
;;; @19: branch.
[deoptimizing: begin 0x9a534b71 requestFlushForNodeJS @3]
translating requestFlushForNodeJS => node=12, height=16
0x0025f5c0: [top + 48] <- 0x9aa04121 ; [sp + 56] 000000009AA04121 <undefined>
0x0025f5b8: [top + 40] <- 0x02b2a2a3 ; caller's pc
0x0025f5b0: [top + 32] <- 0x0025f5e0 ; caller's fp
0x0025f5a8: [top + 24] <- 0x96e80d01; context
0x0025f5a0: [top + 16] <- 0x9a534b71; function
0x0025f598: [top + 8] <- 000000009AA04121 <undefined> ; literal
0x0025f590: [top + 0] <- 0xf2cf0971 ; rax 00000000F2CF0971 <a Domain>
[deoptimizing: end 0x9a534b71 requestFlushForNodeJS => node=12, pc=0x0288c345, state=TOS_REG, alignment=no padding, took 0.000 ms]
[removing optimized code for: requestFlushForNodeJS]
**** DEOPT: Assertion.be.Assertion.equal at bailout #2, address 0x0, frame size 16
;;; @47: gap.
[deoptimizing: begin 0xd19b54f9 Assertion.be.Assertion.equal @2]
translating Assertion.be.Assertion.equal => node=3, height=0
0x0025f4b8: [top + 40] <- 0xf2b51699 ; rbx 00000000F2B51699 <an Assertion>
0x0025f4b0: [top + 32] <- 0xf2cf0971 ; [sp + 48] 00000000F2CF0971 <a Domain>
0x0025f4a8: [top + 24] <- 0x0282863e ; caller's pc
0x0025f4a0: [top + 16] <- 0x0025f4e8 ; caller's fp
0x0025f498: [top + 8] <- 0xf2b601e1; context
0x0025f490: [top + 0] <- 0xd19b54f9; function
[deoptimizing: end 0xd19b54f9 Assertion.be.Assertion.equal => node=3, pc=0x028d71a5, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: Assertion.be.Assertion.equal]
-----------------------------------------------------------
Compiling method requestFlushForNodeJS using hydrogen
[optimizing: requestFlushForNodeJS / 9a534b71 - took 0.000, 1.000, 0.000 ms]
**** DEOPT: requestFlushForNodeJS at bailout #4, address 0x0, frame size 24
;;; @37: branch.
[deoptimizing: begin 0x9a534b71 requestFlushForNodeJS @4]
translating requestFlushForNodeJS => node=73, height=8
0x0025f0b8: [top + 40] <- 0x9aa04121 ; [sp + 56] 000000009AA04121 <undefined>
0x0025f0b0: [top + 32] <- 0x02b2868d ; caller's pc
0x0025f0a8: [top + 24] <- 0x0025f0e8 ; caller's fp
0x0025f0a0: [top + 16] <- 0x96e80d01; context
0x0025f098: [top + 8] <- 0x9a534b71; function
0x0025f090: [top + 0] <- 0xf2b71161 ; rax 00000000F2B71161 <a Domain>
[deoptimizing: end 0x9a534b71 requestFlushForNodeJS => node=73, pc=0x0288c35c, state=NO_REGISTERS, alignment=no padding, took 0.000 ms]
[removing optimized code for: requestFlushForNodeJS]
-----------------------------------------------------------
Compiling method flush using hydrogen
[optimizing: flush / 9a534c69 - took 1.000, 1.000, 0.000 ms]
-----------------------------------------------------------
Compiling method DoneEb using hydrogen
[optimizing: DoneEb / 9a534cf9 - took 0.000, 0.000, 0.000 ms]
**** DEOPT: flush at bailout #25, address 0x0, frame size 96
;;; @241: branch.
[deoptimizing: begin 0x9a534c69 flush @25]
translating flush => node=146, height=32
0x0025f6e0: [top + 64] <- 0xf2b73c79 ; [sp + 128] 00000000F2B73C79 <an Object>
0x0025f6d8: [top + 56] <- 0x028c7d37 ; caller's pc
0x0025f6d0: [top + 48] <- 0x0025f700 ; caller's fp
0x0025f6c8: [top + 40] <- 0x96e80d01; context
0x0025f6c0: [top + 32] <- 0x9a534c69; function
0x0025f6b8: [top + 24] <- 0x96ea8569 ; [sp + 64] 0000000096EA8569 <a TaskNode>
0x0025f6b0: [top + 16] <- 0xf2b73fb1 ; [sp + 48] 00000000F2B73FB1 <a Promise>
0x0025f6a8: [top + 8] <- 0xf2b74069 ; [sp + 40] 00000000F2B74069 <a Promise>
0x0025f6a0: [top + 0] <- 0x9a534ea9 ; [sp + 24] 000000009A534EA9 <JS Function Then>
translating Then => node=153, height=24
0x0025f698: [top + 72] <- 000000009AA04121 <undefined> ; literal
0x0025f690: [top + 64] <- 0xf2b73fb1 ; [sp + 48] 00000000F2B73FB1 <a Promise>
0x0025f688: [top + 56] <- 0xf2b74069 ; [sp + 40] 00000000F2B74069 <a Promise>
0x0025f680: [top + 48] <- 0x0286b4f5 ; caller's pc
0x0025f678: [top + 40] <- 0x0025f6d0 ; caller's fp
0x0025f670: [top + 32] <- 0x96e80d01; context
0x0025f668: [top + 24] <- 0x9a534ea9; function
0x0025f660: [top + 16] <- 0xf2b71161 ; [sp + 32] 00000000F2B71161 <a Domain>
0x0025f658: [top + 8] <- 0xf2b74021 ; [sp + 16] 00000000F2B74021 <JS Function>
0x0025f650: [top + 0] <- 0x9aa04161 ; rax 000000009AA04161 <true>
[deoptimizing: end 0x9a534ea9 Then => node=153, pc=0x0286b8d3, state=TOS_REG, alignment=no padding, took 1.000 ms]
[removing optimized code for: flush]
-----------------------------------------------------------
Compiling method Then using hydrogen
[optimizing: Then / 9a534ea9 - took 0.000, 1.000, 0.000 ms]

335

p.js

@@ -50,5 +50,5 @@ /*!

var m =
/at .+ \(([\s\S]+):(\d+):(?:\d+)\)$/.exec( stackLine ) ||
/at .+ \((.+):(\d+):(?:\d+)\)$/.exec( stackLine ) ||
/at ([^ ]+):(\d+):(?:\d+)$/.exec( stackLine ) ||
/@([\s\S]+):(\d+):(?:\d+)$/.exec( stackLine );
/@(.+):(\d+):(?:\d+)$/.exec( stackLine );

@@ -152,7 +152,4 @@ return m ? { fileName: m[1], lineNumber: Number(m[2]) } : null;

function TaskNode() {
this.task = null;
this.a = null;
this.b = null;
this.domain = null;
this.trace = null;
this.next = null;

@@ -181,16 +178,8 @@ }

currentTrace = h.trace;
if ( h.domain ) {
runInDomain( h.domain, h.task, h.a, h.b );
h.domain = null;
} else {
(1,h.task)( h.a, h.b );
}
h.task = null;
var a = h.a;
var b = h.b;
h.a = null;
h.b = null;
h.trace = null;
Then( a, b );
}

@@ -202,34 +191,7 @@

function beforeThrow() {
head.task = null;
head.a = null;
head.b = null;
head.domain = null;
head.trace = null;
requestFlush();
}
function runInDomain( domain, task, a, b ) {
if ( domain._disposed ) {
return;
}
domain.enter();
task( a, b );
domain.exit();
}
function queueTask( task, a, b ) {
queueTask_(
task, a, b,
isNodeJS ? process.domain : null,
P.longStackSupport ? getTrace() : null
);
}
function queueTask_( task, a, b, domain, trace ) {
function scheduleThen( a, b ) {
var node = tail.next;
if ( node === head ) {
node = new TaskNode();
tail.next = node;
tail.next = node = new TaskNode();
node.next = head;

@@ -242,7 +204,4 @@ } else {

node.task = task;
node.a = a;
node.b = b;
node.domain = domain;
node.trace = trace;

@@ -302,3 +261,3 @@ if ( !flushing ) {

handleError = function( e ) {
beforeThrow();
requestFlush();
throw e;

@@ -314,16 +273,2 @@ };

function tryCall( toCall, onError ) {
try {
toCall.call();
} catch ( e ) {
onError( e );
}
}
function asap( task ) {
queueTask( tryCall, task, handleError );
}
//__________________________________________________________________________

@@ -338,22 +283,20 @@

var OP_THEN = -2;
var OP_PROPAGATE = -3;
var OP_MULTIPLE = -4;
var OP_MULTIPLE = -3;
function ReportIfRejected( p ) {
if ( p._state === REJECTED ) {
queueTask_( reportError, p._value, handleError, p._domain, null );
function DoneEb( e ) {
if ( P.onerror ) {
(1,P.onerror)( e );
} else {
throw e;
}
}
function reportError( error, onError ) {
if ( P.onerror ) {
try {
(1,P.onerror)( error );
} catch ( e ) {
onError( e );
function ReportIfRejected( p ) {
if ( p._state === REJECTED ) {
if ( p._domain ) {
p._domain.enter();
}
} else {
onError( error );
handleError( p._value );
}

@@ -365,3 +308,3 @@ }

x :
Resolve( new Promise(), x, false );
Resolve( new Promise(), x );
}

@@ -371,2 +314,9 @@

function HandleSettled( p ) {
if ( p._pending ) {
HandlePending( p, p._op, p._pending );
p._pending = null;
}
}
function Fulfill( p, value ) {

@@ -380,6 +330,3 @@ if ( p._state ) {

if ( p._pending ) {
HandlePending( p, p._op, p._pending );
p._pending = null;
}
HandleSettled( p );
}

@@ -403,6 +350,3 @@

if ( p._pending ) {
HandlePending( p, p._op, p._pending );
p._pending = null;
}
HandleSettled( p );
}

@@ -419,9 +363,6 @@

if ( p._pending ) {
HandlePending( p, p._op, p._pending );
p._pending = null;
}
HandleSettled( p );
}
function Resolve( p, x, sync ) {
function Resolve( p, x ) {
if ( p._state ) {

@@ -432,48 +373,57 @@ return p;

if ( x instanceof Promise ) {
if ( x === p ) {
Reject( p, new TypeError("You can't resolve a promise with itself") );
ResolveWithPromise( p, x );
} else if ( x._state ) {
Propagate( x, p );
} else {
var type = typeof x;
if ( type === "object" && x !== null || type === "function" ) {
ResolveWithObject( p, x )
} else {
OnSettled( x, OP_PROPAGATE, p );
Fulfill( p, x );
}
}
} else if ( x !== Object(x) ) {
Fulfill( p, x );
return p;
}
} else if ( sync ) {
Assimilate( p, x );
function ResolveWithPromise( p, x ) {
if ( x === p ) {
Reject( p, new TypeError("You can't resolve a promise with itself") );
} else if ( x._state ) {
Propagate( x, p );
} else {
queueTask( Assimilate, p, x );
OnSettled( x, OP_THEN, p );
}
return p;
}
function Assimilate( p, x ) {
var r, then;
function ResolveWithObject( p, x ) {
var then = GetThen( p, x );
try {
then = x.then;
if ( typeof then === "function" ) {
TryResolver( resolverFor(p), then, x );
} catch ( e1 ) {
Reject( p, e1 );
return;
} else {
Fulfill( p, x );
}
}
if ( typeof then === "function" ) {
r = resolverFor( p );
function GetThen( p, x ) {
try {
return x.then;
try {
call.call( then, x, r.resolve, r.reject );
} catch ( e ) {
Reject( p, e );
return null;
}
}
} catch ( e2 ) {
r.reject( e2 );
}
function TryResolver( d, resolver, x ) {
try {
call.call( resolver, x, d.resolve, d.reject );
} else {
Fulfill( p, x );
} catch ( e ) {
d.reject( e );
}

@@ -483,31 +433,15 @@ }

function HandlePending( p, op, pending ) {
switch ( op ) {
case OP_CALL:
pending( p );
break;
if ( op === OP_CALL ) {
pending( p );
case OP_THEN:
queueTask_(
Then, p, pending,
p._domain || pending._domain,
pending._trace
);
break;
} else if ( op === OP_THEN ) {
scheduleThen( p, pending );
case OP_PROPAGATE:
queueTask_(
Propagate, p, pending,
null,
null
);
break;
} else if ( op === OP_MULTIPLE ) {
for ( var i = 0, l = pending.length; i < l; i += 2 ) {
HandlePending( p, pending[i], pending[i + 1] );
}
case OP_MULTIPLE:
for ( var i = 0, l = pending.length; i < l; i += 2 ) {
HandlePending( p, pending[i], pending[i + 1] );
}
break;
default:
pending( p, op );
} else {
pending( p, op );
}

@@ -534,3 +468,8 @@ }

function Then( parent, p ) {
var domain = parent._domain || p._domain;
currentTrace = p._trace;
var cb = parent._state === FULFILLED ? p._cb : p._eb;
p._cb = null;

@@ -544,2 +483,9 @@ p._eb = null;

} else if ( domain ) {
if ( !domain._disposed ) {
domain.enter();
HandleCallback( p, cb, parent._value );
domain.exit();
}
} else {

@@ -561,3 +507,3 @@ HandleCallback( p, cb, parent._value );

Resolve( p, x, true );
Resolve( p, x );
}

@@ -574,3 +520,3 @@

done = true;
Resolve( promise, y, false );
Resolve( promise, y );
}

@@ -625,4 +571,9 @@ },

OnSettled( this, OP_THEN, promise );
if ( this._state ) {
scheduleThen( this, promise );
} else {
OnSettled( this, OP_THEN, promise );
}
return promise;

@@ -638,2 +589,4 @@ };

p = p.then( null, DoneEb );
OnSettled( p, OP_CALL, ReportIfRejected );

@@ -727,4 +680,4 @@ };

var waiting = 0;
var output = new Array( len );
var waiting = len;

@@ -739,12 +692,3 @@ function onSettled( p, i ) {

for ( var i = 0; i < len; ++i ) {
if ( i in input ) {
var p = P( input[i] );
if ( p._state ) {
output[ i ] = p.inspect();
} else {
++waiting;
OnSettled( p, i, onSettled );
}
}
OnSettled( P(input[i]), i, onSettled );
}

@@ -769,29 +713,16 @@

var waiting = 0;
var output = new Array( len );
var waiting = len;
function onSettled( p, i ) {
if ( p._state === REJECTED ) {
Propagate( p, promise );
return;
}
output[ i ] = p._value;
if ( --waiting === 0 ) {
Fulfill( promise, output );
}
}
for ( var i = 0; i < len; ++i ) {
if ( i in input ) {
var p = P( input[i] );
if ( p._state === FULFILLED ) {
output[ i ] = p._value;
} else if ( p._state === REJECTED ) {
if ( output !== null ) {
if ( p._state === REJECTED ) {
output = null;
Propagate( p, promise );
break;
} else {
++waiting;
OnSettled( p, i, onSettled );
output[ i ] = p._value;
if ( --waiting === 0 ) {
Fulfill( promise, output );
}
}

@@ -801,2 +732,6 @@ }

for ( var i = 0; i < len; ++i ) {
OnSettled( P(input[i]), i, onSettled );
}
if ( waiting === 0 ) {

@@ -833,6 +768,42 @@ Fulfill( promise, output );

P.denodeify = denodeify;
function denodeify( f ) {
return function() {
var len = arguments.length;
var args = new Array( len + 1 );
for ( var i = 0; i < len; ++i ) {
args[i] = arguments[i];
}
args[i] = resolver;
function resolver( error, value ) {
if ( error ) {
d.reject( error );
} else {
d.resolve( value );
}
}
var d = defer();
apply.call( f, this, args );
return d.promise;
};
}
P.onerror = null;
P.nextTick = asap;
P.nextTick = function nextTick( task ) {
var p = new Promise();
Fulfill( p, task );
p = p.then( callValue );
OnSettled( p, OP_CALL, ReportIfRejected );
};
function callValue( value ) {
value.call();
}
var pEndingLine = captureLine();

@@ -839,0 +810,0 @@

2

p.min.js

@@ -1,1 +0,1 @@

(function(e){if(typeof module!=="undefined"&&module&&module.exports){module.exports=e()}else if(typeof define==="function"&&define.amd){define(e)}else{P=e()}})(function(){"use strict";var e=a(),n,t=null;function r(){var e=(new Error).stack;if(!e){return null}var n=[o(e,1)];if(t){n=n.concat(t);if(n.length===128){n.pop()}}return n}function i(e){var n=/at .+ \(([\s\S]+):(\d+):(?:\d+)\)$/.exec(e)||/at ([^ ]+):(\d+):(?:\d+)$/.exec(e)||/@([\s\S]+):(\d+):(?:\d+)$/.exec(e);return n?{fileName:n[1],lineNumber:Number(n[2])}:null}function a(){var e=(new Error).stack;if(!e){return 0}var t=e.split("\n");var r=t[0].indexOf("@")>0?t[1]:t[2];var a=i(r);if(!a){return 0}n=a.fileName;return a.lineNumber}function o(e,n){var t=e.split("\n");var r=[];for(var i=n|0,a=t.length;i<a;++i){var o=t[i];if(o&&!u(o)&&!l(o)){r.push(o)}}return r.join("\n")}function u(e){return e.indexOf("(module.js:")!==-1||e.indexOf("(node.js:")!==-1}function l(t){var r=i(t);return!!r&&r.fileName===n&&r.lineNumber>=e&&r.lineNumber<=pn}var f="\nFrom previous event:\n";function s(e){if(e instanceof Error&&e.stack&&e.stack.indexOf(f)===-1){e.stack=[o(e.stack,0)].concat(t||[]).join(f)}}var c=T(typeof process)&&process!=null&&{}.toString.call(process)==="[object process]",p=typeof setImmediate==="function",v=T(typeof MutationObserver)&&MutationObserver||T(typeof WebKitMutationObserver)&&WebKitMutationObserver,d=new S,_=d,h=false,m=0,y=c?$:v?K(O):W(O),b=[],g=W(N),w,k,x=T.call,j=T.apply;_.next=d;function S(){this.task=null;this.a=null;this.b=null;this.domain=null;this.trace=null;this.next=null}function T(e){return e==="object"||e==="function"}function N(){if(b.length){throw b.shift()}}function O(){while(d!==_){var e=d=d.next;if(m>=1024){_.next=_.next.next}else{++m}t=e.trace;if(e.domain){I(e.domain,e.task,e.a,e.b);e.domain=null}else{(1,e.task)(e.a,e.b)}e.task=null;e.a=null;e.b=null;e.trace=null}h=false;t=null}function E(){d.task=null;d.a=null;d.b=null;d.domain=null;d.trace=null;y()}function I(e,n,t,r){if(e._disposed){return}e.enter();n(t,r);e.exit()}function M(e,n,t){A(e,n,t,c?process.domain:null,L.longStackSupport?r():null)}function A(e,n,t,r,i){var a=_.next;if(a===d){a=new S;_.next=a;a.next=d}else{--m}_=a;a.task=e;a.a=n;a.b=t;a.domain=r;a.trace=i;if(!h){h=true;y()}}function $(){var e=process.domain;if(e){if(!k)k=(1,require)("domain");k.active=process.domain=null}if(h&&p){setImmediate(O)}else{process.nextTick(O)}if(e){k.active=process.domain=e}}function K(e){var n=1;var t=document.createTextNode("");var r=new v(e);r.observe(t,{characterData:true});return function(){n=-n;t.data=n}}function W(e){return function(){var n=setTimeout(r,0);var t=setInterval(r,50);function r(){clearTimeout(n);clearInterval(t);e()}}}if(c){w=function(e){E();throw e}}else{w=function(e){b.push(e);g()}}function q(e,n){try{e.call()}catch(t){n(t)}}function D(e){M(q,e,w)}var F=0;var P=1;var Y=2;var z=-1;var B=-2;var C=-3;var G=-4;function H(e){if(e._state===Y){A(J,e._value,w,e._domain,null)}}function J(e,n){if(L.onerror){try{(1,L.onerror)(e)}catch(t){n(t)}}else{n(e)}}function L(e){return e instanceof un?e:V(new un,e,false)}L.longStackSupport=false;function Q(e,n){if(e._state){return}e._state=P;e._value=n;if(e._pending){Z(e,e._op,e._pending);e._pending=null}}function R(e,n){if(e._state){return}if(t){s(n)}e._state=Y;e._value=n;if(c){e._domain=process.domain}if(e._pending){Z(e,e._op,e._pending);e._pending=null}}function U(e,n){if(n._state){return}n._state=e._state;n._value=e._value;n._domain=e._domain;if(n._pending){Z(n,n._op,n._pending);n._pending=null}}function V(e,n,t){if(e._state){return e}if(n instanceof un){if(n===e){R(e,new TypeError("You can't resolve a promise with itself"))}else if(n._state){U(n,e)}else{en(n,C,e)}}else if(n!==Object(n)){Q(e,n)}else if(t){X(e,n)}else{M(X,e,n)}return e}function X(e,n){var t,r;try{r=n.then}catch(i){R(e,i);return}if(typeof r==="function"){t=rn(e);try{x.call(r,n,t.resolve,t.reject)}catch(a){t.reject(a)}}else{Q(e,n)}}function Z(e,n,t){switch(n){case z:t(e);break;case B:A(nn,e,t,e._domain||t._domain,t._trace);break;case C:A(U,e,t,null,null);break;case G:for(var r=0,i=t.length;r<i;r+=2){Z(e,t[r],t[r+1])}break;default:t(e,n)}}function en(e,n,t){if(e._state){Z(e,n,t)}else if(!e._pending){e._pending=t;e._op=n}else if(e._op===G){e._pending.push(n,t)}else{e._pending=[e._op,e._pending,n,t];e._op=G}}function nn(e,n){var t=e._state===P?n._cb:n._eb;n._cb=null;n._eb=null;n._domain=null;n._trace=null;if(t===null){U(e,n)}else{tn(n,t,e._value)}}function tn(e,n,t){var r;try{r=n(t)}catch(i){R(e,i);return}V(e,r,true)}function rn(e){var n=false;return{promise:e,resolve:function(t){if(!n){n=true;V(e,t,false)}},reject:function(t){if(!n){n=true;R(e,t)}}}}L.defer=an;function an(){return rn(new un)}L.reject=on;function on(e){var n=new un;R(n,e);return n}function un(){this._state=0;this._value=void 0;this._domain=null;this._cb=null;this._eb=null;this._op=0;this._pending=null;this._trace=null}un.prototype.then=function(e,n){var t=new un;t._cb=typeof e==="function"?e:null;t._eb=typeof n==="function"?n:null;if(L.longStackSupport){t._trace=r()}if(c){t._domain=process.domain}en(this,B,t);return t};un.prototype.done=function(e,n){var t=this;if(e||n){t=t.then(e,n)}en(t,z,H)};un.prototype.fail=function(e){return this.then(null,e)};un.prototype.spread=function(e,n){return this.then(fn).then(function(n){return j.call(e,void 0,n)},n)};un.prototype.timeout=function(e,n){var i=new un;if(this._state!==F){U(this,i)}else{var a=L.longStackSupport?r():null;var o=setTimeout(function(){t=a;R(i,new Error(n||"Timed out after "+e+" ms"))},e);en(this,z,function(e){clearTimeout(o);U(e,i)})}return i};un.prototype.delay=function(e){var n=an();this.then(function(r){var i=t;setTimeout(function(){t=i;n.resolve(r)},e)},n.reject);return n.promise};un.prototype.all=function(){return this.then(fn)};un.prototype.allSettled=function(){return this.then(ln)};un.prototype.inspect=function(){switch(this._state){case F:return{state:"pending"};case P:return{state:"fulfilled",value:this._value};case Y:return{state:"rejected",reason:this._value};default:throw new TypeError("invalid state")}};un.prototype.nodeify=function(e){if(e){this.done(function(n){e(null,n)},e);return void 0}else{return this}};L.allSettled=ln;function ln(e){var n=new un;var t=e.length;if(typeof t!=="number"){R(n,new TypeError("input not array-like"));return n}var r=0;var i=new Array(t);function a(e,t){i[t]=e.inspect();if(--r===0){Q(n,i)}}for(var o=0;o<t;++o){if(o in e){var u=L(e[o]);if(u._state){i[o]=u.inspect()}else{++r;en(u,o,a)}}}if(r===0){Q(n,i)}return n}L.all=fn;function fn(e){var n=new un;var t=e.length;if(typeof t!=="number"){R(n,new TypeError("input not array-like"));return n}var r=0;var i=new Array(t);function a(e,t){if(e._state===Y){U(e,n);return}i[t]=e._value;if(--r===0){Q(n,i)}}for(var o=0;o<t;++o){if(o in e){var u=L(e[o]);if(u._state===P){i[o]=u._value}else if(u._state===Y){U(u,n);break}else{++r;en(u,o,a)}}}if(r===0){Q(n,i)}return n}L.spread=sn;function sn(e,n,t){return fn(e).then(function(e){return j.call(n,void 0,e)},t)}L.promised=cn;function cn(e){function n(n){return x.apply(e,n)}return function(){var e=arguments.length;var t=new Array(e+1);t[0]=this;for(var r=0;r<e;++r){t[r+1]=arguments[r]}return fn(t).then(n)}}L.onerror=null;L.nextTick=D;var pn=a();return L});
(function(e){if(typeof module!=="undefined"&&module&&module.exports){module.exports=e()}else if(typeof define==="function"&&define.amd){define(e)}else{P=e()}})(function(){"use strict";var e=o(),n,t=null;function r(){var e=(new Error).stack;if(!e){return null}var n=[u(e,1)];if(t){n=n.concat(t);if(n.length===128){n.pop()}}return n}function i(e){var n=/at .+ \((.+):(\d+):(?:\d+)\)$/.exec(e)||/at ([^ ]+):(\d+):(?:\d+)$/.exec(e)||/@(.+):(\d+):(?:\d+)$/.exec(e);return n?{fileName:n[1],lineNumber:Number(n[2])}:null}function o(){var e=(new Error).stack;if(!e){return 0}var t=e.split("\n");var r=t[0].indexOf("@")>0?t[1]:t[2];var o=i(r);if(!o){return 0}n=o.fileName;return o.lineNumber}function u(e,n){var t=e.split("\n");var r=[];for(var i=n|0,o=t.length;i<o;++i){var u=t[i];if(u&&!a(u)&&!f(u)){r.push(u)}}return r.join("\n")}function a(e){return e.indexOf("(module.js:")!==-1||e.indexOf("(node.js:")!==-1}function f(t){var r=i(t);return!!r&&r.fileName===n&&r.lineNumber>=e&&r.lineNumber<=vn}var l="\nFrom previous event:\n";function c(e){if(e instanceof Error&&e.stack&&e.stack.indexOf(l)===-1){e.stack=[u(e.stack,0)].concat(t||[]).join(l)}}var s=N(typeof process)&&process!=null&&{}.toString.call(process)==="[object process]",v=typeof setImmediate==="function",p=N(typeof MutationObserver)&&MutationObserver||N(typeof WebKitMutationObserver)&&WebKitMutationObserver,d=new T,h=d,_=false,m=0,y=s?A:p?I(E):M(E),b=[],w=M(S),g,x,j=N.call,k=N.apply;h.next=d;function T(){this.a=null;this.b=null;this.next=null}function N(e){return e==="object"||e==="function"}function S(){if(b.length){throw b.shift()}}function E(){while(d!==h){var e=d=d.next;if(m>=1024){h.next=h.next.next}else{++m}var n=e.a;var r=e.b;e.a=null;e.b=null;Z(n,r)}_=false;t=null}function O(e,n){var t=h.next;if(t===d){h.next=t=new T;t.next=d}else{--m}h=t;t.a=e;t.b=n;if(!_){_=true;y()}}function A(){var e=process.domain;if(e){if(!x)x=(1,require)("domain");x.active=process.domain=null}if(_&&v){setImmediate(E)}else{process.nextTick(E)}if(e){x.active=process.domain=e}}function I(e){var n=1;var t=document.createTextNode("");var r=new p(e);r.observe(t,{characterData:true});return function(){n=-n;t.data=n}}function M(e){return function(){var n=setTimeout(r,0);var t=setInterval(r,50);function r(){clearTimeout(n);clearInterval(t);e()}}}if(s){g=function(e){y();throw e}}else{g=function(e){b.push(e);w()}}var $=0;var K=1;var W=2;var q=-1;var D=-2;var F=-3;function P(e){if(z.onerror){(1,z.onerror)(e)}else{throw e}}function Y(e){if(e._state===W){if(e._domain){e._domain.enter()}g(e._value)}}function z(e){return e instanceof on?e:J(new on,e)}z.longStackSupport=false;function B(e){if(e._pending){V(e,e._op,e._pending);e._pending=null}}function C(e,n){if(e._state){return}e._state=K;e._value=n;B(e)}function G(e,n){if(e._state){return}if(t){c(n)}e._state=W;e._value=n;if(s){e._domain=process.domain}B(e)}function H(e,n){if(n._state){return}n._state=e._state;n._value=e._value;n._domain=e._domain;B(n)}function J(e,n){if(e._state){return e}if(n instanceof on){L(e,n)}else{var t=typeof n;if(t==="object"&&n!==null||t==="function"){Q(e,n)}else{C(e,n)}}return e}function L(e,n){if(n===e){G(e,new TypeError("You can't resolve a promise with itself"))}else if(n._state){H(n,e)}else{X(n,D,e)}}function Q(e,n){var t=R(e,n);if(typeof t==="function"){U(nn(e),t,n)}else{C(e,n)}}function R(e,n){try{return n.then}catch(t){G(e,t);return null}}function U(e,n,t){try{j.call(n,t,e.resolve,e.reject)}catch(r){e.reject(r)}}function V(e,n,t){if(n===q){t(e)}else if(n===D){O(e,t)}else if(n===F){for(var r=0,i=t.length;r<i;r+=2){V(e,t[r],t[r+1])}}else{t(e,n)}}function X(e,n,t){if(e._state){V(e,n,t)}else if(!e._pending){e._pending=t;e._op=n}else if(e._op===F){e._pending.push(n,t)}else{e._pending=[e._op,e._pending,n,t];e._op=F}}function Z(e,n){var r=e._domain||n._domain;t=n._trace;var i=e._state===K?n._cb:n._eb;n._cb=null;n._eb=null;n._domain=null;n._trace=null;if(i===null){H(e,n)}else if(r){if(!r._disposed){r.enter();en(n,i,e._value);r.exit()}}else{en(n,i,e._value)}}function en(e,n,t){var r;try{r=n(t)}catch(i){G(e,i);return}J(e,r)}function nn(e){var n=false;return{promise:e,resolve:function(t){if(!n){n=true;J(e,t)}},reject:function(t){if(!n){n=true;G(e,t)}}}}z.defer=tn;function tn(){return nn(new on)}z.reject=rn;function rn(e){var n=new on;G(n,e);return n}function on(){this._state=0;this._value=void 0;this._domain=null;this._cb=null;this._eb=null;this._op=0;this._pending=null;this._trace=null}on.prototype.then=function(e,n){var t=new on;t._cb=typeof e==="function"?e:null;t._eb=typeof n==="function"?n:null;if(z.longStackSupport){t._trace=r()}if(s){t._domain=process.domain}if(this._state){O(this,t)}else{X(this,D,t)}return t};on.prototype.done=function(e,n){var t=this;if(e||n){t=t.then(e,n)}t=t.then(null,P);X(t,q,Y)};on.prototype.fail=function(e){return this.then(null,e)};on.prototype.spread=function(e,n){return this.then(an).then(function(n){return k.call(e,void 0,n)},n)};on.prototype.timeout=function(e,n){var i=new on;if(this._state!==$){H(this,i)}else{var o=z.longStackSupport?r():null;var u=setTimeout(function(){t=o;G(i,new Error(n||"Timed out after "+e+" ms"))},e);X(this,q,function(e){clearTimeout(u);H(e,i)})}return i};on.prototype.delay=function(e){var n=tn();this.then(function(r){var i=t;setTimeout(function(){t=i;n.resolve(r)},e)},n.reject);return n.promise};on.prototype.all=function(){return this.then(an)};on.prototype.allSettled=function(){return this.then(un)};on.prototype.inspect=function(){switch(this._state){case $:return{state:"pending"};case K:return{state:"fulfilled",value:this._value};case W:return{state:"rejected",reason:this._value};default:throw new TypeError("invalid state")}};on.prototype.nodeify=function(e){if(e){this.done(function(n){e(null,n)},e);return void 0}else{return this}};z.allSettled=un;function un(e){var n=new on;var t=e.length;if(typeof t!=="number"){G(n,new TypeError("input not array-like"));return n}var r=new Array(t);var i=t;function o(e,t){r[t]=e.inspect();if(--i===0){C(n,r)}}for(var u=0;u<t;++u){X(z(e[u]),u,o)}if(i===0){C(n,r)}return n}z.all=an;function an(e){var n=new on;var t=e.length;if(typeof t!=="number"){G(n,new TypeError("input not array-like"));return n}var r=new Array(t);var i=t;function o(e,t){if(r!==null){if(e._state===W){r=null;H(e,n)}else{r[t]=e._value;if(--i===0){C(n,r)}}}}for(var u=0;u<t;++u){X(z(e[u]),u,o)}if(i===0){C(n,r)}return n}z.spread=fn;function fn(e,n,t){return an(e).then(function(e){return k.call(n,void 0,e)},t)}z.promised=ln;function ln(e){function n(n){return j.apply(e,n)}return function(){var e=arguments.length;var t=new Array(e+1);t[0]=this;for(var r=0;r<e;++r){t[r+1]=arguments[r]}return an(t).then(n)}}z.denodeify=cn;function cn(e){return function(){var n=arguments.length;var t=new Array(n+1);for(var r=0;r<n;++r){t[r]=arguments[r]}t[r]=i;function i(e,n){if(e){o.reject(e)}else{o.resolve(n)}}var o=tn();k.call(e,this,t);return o.promise}}z.onerror=null;z.nextTick=function pn(e){var n=new on;C(n,e);n=n.then(sn);X(n,q,Y)};function sn(e){e.call()}var vn=o();return z});

12

package.json
{
"name": "p-promise",
"version": "0.3.8",
"version": "0.4.0",
"description": "A simple Promises/A+ library.",

@@ -16,6 +16,8 @@ "author": "Robert Katić <robert.katic@gmail.com> (https://github.com/rkatic)",

"scripts": {
"posttest": "uglifyjs p.js -o p.min.js -m",
"test-own": "mocha -R spec -s 100 test/test.js",
"test-aplus": "promises-aplus-tests test/adapter",
"test": "promises-aplus-tests test/adapter --reporter dot && mocha -s 200 test/test.js"
"minify": "uglifyjs p.js -o p.min.js -m",
"test-own": "mocha --reporter dot -s 200 test/test.js",
"test-own-trace": "node -allow-natives-syntax test/test-and-trace.js",
"test-aplus": "promises-aplus-tests test/adapter --reporter dot",
"test": "npm run test-aplus && npm run test-own",
"test-local": "npm run test-aplus && npm run test-own-trace && npm run minify"
},

@@ -22,0 +24,0 @@ "keywords": [

3

README.md

@@ -18,3 +18,3 @@ [![Build Status](https://travis-ci.org/rkatic/p.png?branch=master)](https://travis-ci.org/rkatic/p)

- Simple.
- [Fast](http://jsperf.com/davy-jones-benchmark/29).
- [Fast](http://jsperf.com/davy-jones-benchmark/32).

@@ -46,1 +46,2 @@ ##API

- `promise.nodeify(nodeback)` :new:
- `promise.denodeify(aFunction)` :new:

2

run.js

@@ -13,1 +13,3 @@ var P = require ('./p');

}
// node --trace_opt --trace_deopt run.js

134

test/test.js
(function(){
"use strict";
var opt_tracing = typeof TRACE_FUNCTIONS !== "undefined";
if ( typeof P === "undefined" ) {
global.P = require("../p");
global.P = require(opt_tracing ? "./p" : "../p");
global.expect = require("expect.js");
require("mocha");
//require("mocha");
}
if ( opt_tracing ) {
TRACE_FUNCTIONS.stopAdding();
beforeEach(function() {
TRACE_FUNCTIONS.optimize();
});
afterEach(function() {
TRACE_FUNCTIONS.optimize();
});
}
var isNodeJS = typeof process === "object" && process &&

@@ -18,7 +32,54 @@ ({}).toString.call(process) === "[object process]";

function thenableSyncFulfillment( value ) {
return {
then: function( cb, eb ) {
cb( value );
}
};
}
function thenableSyncRejection( reason ) {
return {
then: function( cb, eb ) {
eb( reason );
}
};
}
function thenableFulfillment( value ) {
return {
then: function( cb, eb ) {
setTimeout(function() {
cb( value );
}, 0)
}
};
}
function thenableRejection( reason ) {
return {
then: function( cb, eb ) {
setTimeout(function() {
eb( reason );
}, 0)
}
};
}
var VALUES = ["", true, false, 0, 1, 2, -1, -2, {}, [], {x: 1}, [1,2,3], null, void 0, new Error()];
VALUES[ VALUES.length + 1 ] = "sparse";
VALUES.length++;
var FULLFILMENTS = VALUES.concat(
VALUES.map( P ),
VALUES.map( thenableFulfillment ),
VALUES.map( thenableSyncFulfillment )
);
var REJECTIONS = [].concat(
VALUES.map( P.reject ),
VALUES.map( thenableRejection ),
VALUES.map( thenableSyncRejection )
);
var FULLFILMENTS_AND_REJECTIONS = FULLFILMENTS.concat( REJECTIONS );
function map( array, f ) {

@@ -41,3 +102,3 @@ var array2 = new Array(array.length|0);

it("should return a promise", function() {
map(VALUES, function( value ) {
map(FULLFILMENTS_AND_REJECTIONS, function( value ) {
expect( P(value).constructor.name ).to.be("Promise");

@@ -102,3 +163,3 @@ });

it("resolves when passed an sparse array", function() {
it("resolves when passed an array", function() {
var toResolve = P.defer();

@@ -121,3 +182,3 @@ var array = VALUES.concat( toResolve.promise );

toReject.reject( theReason );
var array = VALUES.concat( toReject.promise )
var array = FULLFILMENTS.concat( toReject.promise )

@@ -130,3 +191,3 @@ return P.all( array )

var toRejectLater = P.defer();
var array = VALUES.concat( toRejectLater.promise );
var array = FULLFILMENTS.concat( toRejectLater.promise );
var promise = P.all( array );

@@ -142,2 +203,27 @@ toRejectLater.reject( theReason );

describe("allSettled", function() {
it("resolves when passed an empty array", function() {
return P.allSettled([]);
});
it("resolves when passed an array", function() {
var array = FULLFILMENTS_AND_REJECTIONS;
var promise = P.allSettled( array );
return promise.then(function( settled ) {
for ( var i = 0; i < settled.length; ++i ) {
var expectedValue = VALUES[ i % VALUES.length ];
if ( i < FULLFILMENTS.length ) {
expect( settled[i] ).to.be.eql( {state: "fulfilled", value: expectedValue} );
} else {
expect( settled[i] ).to.be.eql( {state: "rejected", reason: expectedValue} );
}
}
});
});
});
describe("spread", function() {

@@ -345,2 +431,34 @@

describe("denodeify", function() {
var fullfillment = P.denodeify(function( a, b, c, d, callback ) {
callback( a + b + c + d );
});
it("should fulfill if no error", function() {
var f = P.denodeify(function( a, b, c, d, callback ) {
callback( null, a + b + c + d );
});
return f( 1, 2, 3, 4 ).then(function( value ) {
expect( value ).to.be( 10 );
});
});
it("should reject on error", function() {
var theError = new Error();
var f = P.denodeify(function( a, b, c, d, callback ) {
callback( theError );
});
return f( 1, 2, 3, 4 ).then(fail, function( reason ) {
expect( reason ).to.be( theError );
});
});
});
if ( isNodeJS && !/v0\.8\./.test(process.version) ) describe("domain", function() {

@@ -347,0 +465,0 @@

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc