NodeIterator

[sjorsdonkers]

https://developer.mozilla.org/en-US/docs/Web/API/Document/createNodeIterator
Does not reuse the TreeWalker implementation as there are several subtle differences

TreeWalker is likely not handling its edges cases correctly, those are not addressed in this PR except fixing, get_filter(), _previous_node() going beyond the root and functions returning *parser.Node instead of Node.Union

[sjorsdonkers]

Edit: Fixed
Warnings when fetching: https://www.airbnb.com/

Error is raised when calling this filter function:

let e;
for (!r && document.body && (r = document.createNodeIterator(document.body, NodeFilter.SHOW_ELEMENT, (e => {
        return t = e, f.includes(t.tagName) || t.hasAttribute("data-lcp-candidate") ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
        var t
    }))); e = r?.nextNode();) h(e);
n(N)

TBD if this is related to the TreeWalker NodeIterator impl or something unrelated

[karlseguin]

I'll look at the PR more completely in a bit, but I do think the issue is likely related to the implementation of the NodeIterator.

When I debug this, I see that the callback is called with a Node (as well as other elements), despite the code using the NodeFilter.SHOW_ELEMENT; which I assume means that it should only iterate element nodes. But, because an underlying Node is passed, the call to tagName returns undefined (which is ok), and the call to hasAttribute fails - which is where the code fails.

Without looking at the implementation, I assume it's either emitting a node when it shouldn't (because of the filter), or it's emitting an element as a node without going through the toInterface call.

[karlseguin]

A Zig-ish alternative to this is @bitCast the u32 into a packed struct:

pub const WhatToShow = packed struct {
    element: bool,
    attribute: bool,
    text: bool,
    cdata: bool,
    entity_reference: bool,
    entity: bool,
    processing_instruction: bool,
    comment: bool,
    document: bool,
    document_type: bool,
    document_fragment: bool,
    notation: bool,
    _: u20,
};

pub fn verify(what_to_show: u32, filter: ?Env.Function, node: *parser.Node) !VerifyResult {
    const node_type = try parser.nodeType(node);
     // or WhatToShow.fromBitmask(what_to_show) if you want to encapsulate it
    const wts: WhatToShow = @bitCast(what_to_show);
   
   if (!switch (node_type) {
      .attribute => wts.atribute,
      , ....
     })

[sjorsdonkers]

Thanks! Good to know.
In this case I'm inclined to leave it as it was. Just fewer loc.
If you do feel strongly about I would also change the u32 stored in the NodeIterator and TreeWalker, and cast it back when that property is accessed. Otherwise I'll leave it as is.

[karlseguin]

LGTM