A lot of samples are missing / unaccounted for#285

I'm trying to generate a flame graph of my heap implementation: ```js class BinaryHeap { array; comparator; constructor(comparator) { this.array = []; this.comparator = comparator; } static getParentIndex(index) { return (index - 1) >> 1; } static getLeftChildIndex(index) { return 2 * index + 1; } static getRightChildIndex(index) { return 2 * index + 2; } #swap(index1, index2) { [this.array[index1], this.array[index2]] = [ this.array[index2], this.array[index1], ]; } #compare(index1, index2) { return this.comparator(this.array[index1], this.array[index2]); } siftDown(index) { const value = this.array[index]; const end = BinaryHeap.getParentIndex(this.array.length - 1); while (index <= end) { let left = BinaryHeap.getLeftChildIndex(index); let right = BinaryHeap.getRightChildIndex(index); let childIndex = right >= this.array.length || this.#compare(left, right) < 0 ? left : right; if (this.comparator(value, this.array[childIndex]) < 0) break; this.array[index] = this.array[childIndex]; index = childIndex; } this.array[index] = value; } siftUp(index) { const value = this.array[index]; let parentIndex = BinaryHeap.getParentIndex(index); while ( parentIndex >= 0 && this.comparator(this.array[parentIndex], value) > 0 ) { this.array[index] = this.array[parentIndex]; index = parentIndex; parentIndex = BinaryHeap.getParentIndex(index); } this.array[index] = value; } pop() { if (this.array.length === 0) return; if (this.array.length === 1) return this.array.pop(); this.#swap(0, this.array.length - 1); const value = this.array.pop(); this.siftDown(0); return value; } push(item) { this.array.push(item); this.siftUp(this.array.length - 1); } } function compareFn(a, b) { return a - b; } const heap = new BinaryHeap(compareFn); for (let i = 0; i < 10_000_000; i++) { heap.push(i) } for (let i = 0; i < 10_000_000; i++) { heap.pop() } ``` but a the resulting flamegraph from `0x -o heap.js` shows that the pop/siftDown and push/siftUp methods are only sampled once or sometimes even never, out of 102 times. Most of the other samples are part of a huge *(anonymous) block, which I thought could be the global execution context, but the push and pop functions aren't on top of that block, so it must be something else right? Where are these samples taken? Why is so much unaccounted for or sampled in this big *(anonymous) block?  Moving the code over to a html file and using chrome's built-in performance profiler and flame graph visualizer, I get a much better result, which is closer to what I expected to get from 0x: