File Coverage

blib/lib/Data/CSel.pm

Criterion	Covered	Total	%
statement	206	248	83.0
branch	187	248	75.4
condition	17	44	38.6
subroutine	13	14	92.8
pod	3	3	100.0
total	426	557	76.4

package Data::CSel;

use 5.020000;
use strict;
use warnings;

use Code::Includable::Tree::NodeMethods;
#use List::Util qw(first);
use Scalar::Util qw(blessed refaddr looks_like_number);

use Exporter qw(import);

our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2022-06-07'; # DATE
our $DIST = 'Data-CSel'; # DIST
our $VERSION = '0.128'; # VERSION

our @EXPORT_OK = qw(
                       csel
                       csel_each
                       parse_csel
               );

our @CLASS_PREFIXES;

our $_i1;

sub _fail { die __PACKAGE__.": $_[0] at offset ".pos()."\n" }

our $RE =
    qr{
          (?&SELECTORS) (?{ $_ = $^R->[1] })

          (?(DEFINE)
              (?
                  (?{ [$^R, []] })
                  (?&SELECTOR) # [[$^R, []], $selector]
                  (?{ [$^R->[0][0], [$^R->[1]]] })
                  (?:
                      \s*,\s*
                      (?&SELECTOR)
                      (?{
                          push @{$^R->[0][1]}, $^R->[1];
                          $^R->[0];
                      })
                  )*
                  \s*
              ) # SELECTORS

              (?
                  (?{ [$^R, []] })
                  (?&SIMPLE_SELECTOR) # [[$^R, []], $simple_selector]
                  (?{ [$^R->[0][0], [$^R->[1]]] })
                  (?:
                      (\s*>\s*|\s*\+\s*|\s*~\s*|\s+)
                      (?{
                          my $comb = $^N;
                          $comb =~ s/^\s+//; $comb =~ s/\s+$//;
                          $comb = " " if $comb eq '';
                          push @{$^R->[1]}, {combinator=>$comb};
                          $^R;
                      })

                      (?&SIMPLE_SELECTOR)
                      (?{
                          push @{$^R->[0][1]}, $^R->[1];
                          $^R->[0];
                      })
                  )*
              ) # SELECTOR

              (?
                  (?:
                      (?:
                          # type selector + optional filters
                          ((?&TYPE_NAME))
                          (?{ [$^R, {type=>$^N}] })
                          (?:
                              (?&FILTER) # [[$^R, $simple_selector], $filter]
                              (?{
                                  push @{ $^R->[0][1]{filters} }, $^R->[1];
                                  $^R->[0];
                              })
                              (?:
                                  \s*
                                  (?&FILTER)
                                  (?{
                                      push @{ $^R->[0][1]{filters} }, $^R->[1];
                                      $^R->[0];
                                  })
                              )*
                          )?
                      )
                  |
                      (?:
                          # optional type selector + one or more filters
                          ((?&TYPE_NAME))?
                          (?{
                              # XXX sometimes $^N is ' '?
                              my $t = $^N // '*';
                              $t = '*' if $t eq ' ';
                              [$^R, {type=>$t}] })
                          (?&FILTER) # [[$^R, $simple_selector], $filter]
                          (?{
                              push @{ $^R->[0][1]{filters} }, $^R->[1];
                              $^R->[0];
                          })
                          (?:
                              \s*
                              (?&FILTER)
                              (?{
                                  push @{ $^R->[0][1]{filters} }, $^R->[1];
                                  $^R->[0];
                              })
                          )*
                      )
                  )
              ) # SIMPLE_SELECTOR

              (?
                  [A-Za-z_][A-Za-z0-9_]*(?:::[A-Za-z0-9_]+)*|\*
              )

              (?
                  (?{ [$^R, {}] })
                  (
                      (?&ATTR_SELECTOR) # [[$^R0, {}], [$attr, $op, $val]]
                      (?{
                          $^R->[0][1]{type}  = 'attr_selector';
                          $^R->[0][1]{attr}  = $^R->[1][0];
                          $^R->[0][1]{op}    = $^R->[1][1] if defined $^R->[1][1];
                          $^R->[0][1]{value} = $^R->[1][2] if @{ $^R->[1] } > 2;
                          $^R->[0];
                      })
                  |
                      \.((?&TYPE_NAME))
                      (?{
                          $^R->[1]{type}  = 'class_selector';
                          $^R->[1]{class} = $^N;
                          $^R;
                      })
                  |
                      \#(\w+)
                      (?{
                          $^R->[1]{type} = 'id_selector';
                          $^R->[1]{id}   = $^N;
                          $^R;
                      })
                  |
                      (?&PSEUDOCLASS) # [[$^R, {}], [$pseudoclass, \@args]]
                      (?{
                          $^R->[0][1]{type}         = 'pseudoclass';
                          $^R->[0][1]{pseudoclass}  = $^R->[1][0];
                          $^R->[0][1]{args}         = $^R->[1][1] if @{ $^R->[1] } > 1;
                          $^R->[0];
                      })
                  )
              ) # FILTER

              (?
                  \[\s*
                  (?{ [$^R, []] }) # [$^R, [$subjects, $op, $literal]]
                  (?&ATTR_SUBJECTS) # [[$^R, [{name=>$name, args=>$args}, ...]]
                  (?{
                      #use Data::Dmp; say "D:setting subjects: ", dmp $^R->[1];
                      push @{ $^R->[0][1] }, $^R->[1];
                      $^R->[0];
                  })

                  (?:
                      (
                          \s*(?:=~|!~)\s* |
                          \s*(?:!=|<>|>=?|<=?|==?)\s* |
                          \s++(?:eq|ne|lt|gt|le|ge)\s++ |
                          \s+(?:isnt|is|has|hasnt|in|notin)\s+
                      )
                      (?{
                          my $op = $^N;
                          $op =~ s/^\s+//; $op =~ s/\s+$//;
                          $^R->[1][1] = $op;
                          $^R;
                      })

                      (?:
                          (?&LITERAL) # [[$^R0, [$attr, $op]], $literal]
                          (?{
                              push @{ $^R->[0][1] }, $^R->[1];
                              $^R->[0];
                          })
                      |
                          (\w[^\s\]]*) # allow unquoted string
                          (?{
                              $^R->[1][2] = $^N;
                              $^R;
                          })
                      )
                  )?
                  \s*\]
              ) # ATTR_SELECTOR

              (?
                  [A-Za-z_][A-Za-z0-9_]*
              )

              (?
                  (?{ [$^R, []] }) # [$^R, [name, \@args]]
                  ((?&ATTR_NAME))
                  (?{
                      #say "D:pushing attribute subject: $^N";
                      push @{ $^R->[1] }, $^N;
                      $^R;
                  })
                  (?:
                      # attribute arguments
                      \s*\(\s* (*PRUNE)
                      (?{
                          $^R->[1][1] = [];
                          $^R;
                      })
                      (?:
                          (?&LITERAL)
                          (?{
                              #use Data::Dmp; say "D:pushing argument: ", dmp $^R->[1];
                              push @{ $^R->[0][1][1] }, $^R->[1];
                              $^R->[0];
                          })
                          (?:
                              \s*,\s*
                              (?&LITERAL)
                              (?{
                                  #use Data::Dmp; say "D:pushing argument: ", dmp $^R->[1];
                                  push @{ $^R->[0][1][1] }, $^R->[1];
                                  $^R->[0];
                              })
                          )*
                      )?
                      \s*\)\s*
                  )?
              ) # ATTR_SUBJECT

              (?
                  (?{ $_i1 = 0; [$^R, []] })
                  (?&ATTR_SUBJECT) # [[$^R, [$name, \@args]]
                  (?{
                      $_i1++;
                      unless ($_i1 > 1) { # to prevent backtracking from executing tihs code block twice
                          #say "D:pushing subject(1)";
                          push @{ $^R->[0][1] }, {
                              name => $^R->[1][0],
                              (args => $^R->[1][1]) x !!defined($^R->[1][1]),
                          };
                      }
                      $^R->[0];
                  })
                  (?:
                      \s*\.\s*
                      (?{ $_i1 = 0; $^R })
                      (?&ATTR_SUBJECT) # [[$^R, $name, \@args]]
                      (?{
                          $_i1++;
                          unless ($_i1 > 1) { # to prevent backtracking from executing this code block twice
                              #say "D:pushing subject(2)";
                              push @{ $^R->[0][1] }, {
                                  name => $^R->[1][0],
                                  (args => $^R->[1][1]) x !!defined($^R->[1][1]),
                              };
                          }
                          $^R->[0];
                      })
                  )*
              ) # ATTR_SUBJECTS

              (?
                  (?&LITERAL_ARRAY)
              |
                  (?&LITERAL_NUMBER)
              |
                  (?&LITERAL_STRING_DQUOTE)
              |
                  (?&LITERAL_STRING_SQUOTE)
              |
                  (?&LITERAL_REGEX)
              |
                  true (?{ [$^R, 1] })
              |
                  false (?{ [$^R, 0] })
              |
                  null (?{ [$^R, undef] })
              ) # LITERAL

              (?
                  \[\s*
                  (?{ [$^R, []] })
                  (?:
                      (?&LITERAL) # [[$^R, []], $val]
                      (?{ [$^R->[0][0], [$^R->[1]]] })
                      \s*
                      (?:
                          (?:
                              ,\s* (?&LITERAL)
                              (?{ push @{$^R->[0][1]}, $^R->[1]; $^R->[0] })
                          )*
                      |
                          (?: [^,\]]|\z ) (?{ _fail "Expected ',' or '\x5d'" })
                      )
                  )?
                  \s*
                  (?:
                      \]
                  |
                      (?:.|\z) (?{ _fail "Expected closing of array" })
                  )
              ) # LITERAL_ARRAY

              (?
                  (
                      -?
                      (?: 0 | [1-9]\d* )
                      (?: \. \d+ )?
                      (?: [eE] [-+]? \d+ )?
                  )
                  (?{ [$^R, 0+$^N] })
              )

              (?
                  (
                      "
                      (?:
                          [^\\"]+
                      |
                          \\ [0-7]{1,3}
                      |
                          \\ x [0-9A-Fa-f]{1,2}
                      |
                          \\ ["\\'tnrfbae]
                      )*
                      "
                  )
                  (?{ [$^R, eval $^N] })
              )

              (?
                  (
                      '
                      (?:
                          [^\\']+
                      |
                          \\ .
                      )*
                      '
                  )
                  (?{ [$^R, eval $^N] })
              )

              (?
                  (
                      (?:
                          (?:
                              /
                              (?:
                                  [^/\\]+
                              |
                                  \\ .
                              )*
                              /
                          ) |
                          (?:
                              qr\(
                              (?:
                                  [^\)\\]+
                              |
                                  \\ .
                              )*
                              \)
                          )
                      )
                      [ims]*
                  )
                  (?{ my $code = substr($^N, 0, 2) eq "qr" ? $^N : "qr$^N"; my $re = eval $code; die if $@; [$^R, $re] })
              )

              (?
                  [A-Za-z_][A-Za-z0-9_]*(?:-[A-Za-z0-9_]+)*
              )

              (?
                  :
                  (?:
                      (?:
                          (has|not)
                          (?{ [$^R, [$^N]] })
                          \(\s*
                          (?:
                              (?&LITERAL)
                              (?{
                                  push @{ $^R->[0][1][1] }, $^R->[1];
                                  $^R->[0];
                              })
                          |
                              ((?&SELECTORS))
                              (?{
                                  push @{ $^R->[0][1][1] }, $^N;
                                  $^R->[0];
                              })
                          )
                          \s*\)
                      )
                  |
                      (?:
                          ((?&PSEUDOCLASS_NAME))
                          (?{ [$^R, [$^N]] })
                          (?:
                              \(\s*
                              (?&LITERAL)
                              (?{
                                  push @{ $^R->[0][1][1] }, $^R->[1];
                                  $^R->[0];
                              })
                              (?:
                                  \s*,\s*
                                  (?&LITERAL)
                                  (?{
                                      push @{ $^R->[0][1][1] }, $^R->[1];
                                      $^R->[0];
                                  })
                              )*
                              \s*\)
                          )?
                      )
                  )
              ) # PSEUDOCLASS
          ) # DEFINE
  }x;

sub parse_csel {
    state $re = qr{\A\s*$RE\s*\z};

    local $_ = shift;
    local $^R;
    eval { $_ =~ $re } and return $_;
    die $@ if $@;
    return undef; ## no critic: Subroutines::ProhibitExplicitReturnUndef
}

sub _uniq_objects {
    my @uniq;
    my %mem;
    for (@_) {
        push @uniq, $_ unless $mem{refaddr($_)}++;
    }
    @uniq;
}

sub _simpsel {
    no warnings 'numeric', 'uninitialized';

    my ($opts, $simpsel, $is_recursive, @nodes) = @_;

    #use Data::Dmp; say "D: _simpsel(expr", dmp($simpsel), ", recursive=$is_recursive, nodes=[".join(",",map {$_->{id}} @nodes)."])";

    my @res;
    if ($is_recursive) {
        @res = (@nodes, map {Code::Includable::Tree::NodeMethods::descendants($_)} @nodes);
    } else {
        @res = @nodes;
    }
    #say "D:   intermediate result (after walk): [".join(",",map {$_->{id}} @res)."]";

    unless ($simpsel->{type} eq '*') {
        my @fres;

        my @types_to_match;
        for (@{ $opts->{class_prefixes} // [] }, @CLASS_PREFIXES) {
            push @types_to_match, $_ . (/::$/ ? "" : "::") . $simpsel->{type};
        }
        push @types_to_match, $simpsel->{type};

      ELEM:
        for my $o (@res) {
            my $ref = ref($o);
            for (@types_to_match) {
                if ($ref eq $_) {
                    push @fres, $o;
                    next ELEM;
                }
            }
        }
        @res = @fres;
    }

    @res = _uniq_objects(@res);
    #say "D:   intermediate result (after type): [".join(",",map {$_->{id}} @res)."]";

    for my $f (@{ $simpsel->{filters} // [] }) {
        last unless @res;

        my $type = $f->{type};

        if ($type eq 'attr_selector') {

            my @attrs = @{ $f->{attr} };
            my $op    = $f->{op};
            my $opv   = $f->{value};

            my @newres;
          ITEM:
            for my $o0 (@res) {
                my $o = $o0;
                for my $i (0..$#attrs) {
                    my $attr_name = $attrs[$i]{name};
                    my $attr_args = $attrs[$i]{args};
                    next ITEM unless blessed($o) && $o->can($attr_name);
                    if ($attr_args && $i == $#attrs) {
                        # T[meth()] means T[meth() is true]
                        unless ($op) {
                            $op = 'is';
                            $opv = 1;
                        }
                        $o = $o->$attr_name(@$attr_args);
                    } else {
                        $o = $o->$attr_name;
                    }
                }
                goto PASS unless $op;
                my $val = $o;

                if ($op eq '=' || $op eq '==') {
                    if (looks_like_number($opv)) {
                        next ITEM unless $val == $opv;
                    } else {
                        next ITEM unless $val eq $opv;
                    }
                } elsif ($op eq 'eq') {
                    next ITEM unless $val eq $opv;
                } elsif ($op eq '!=' || $op eq '<>') {
                    if (looks_like_number($opv)) {
                        next ITEM unless $val != $opv;
                    } else {
                        next ITEM unless $val ne $opv;
                    }
                } elsif ($op eq 'ne') {
                    next ITEM unless $val ne $opv;
                } elsif ($op eq '>') {
                    if (looks_like_number($opv)) {
                        next ITEM unless $val >  $opv;
                    } else {
                        next ITEM unless $val gt $opv;
                    }
                } elsif ($op eq 'gt') {
                    next ITEM unless $val gt $opv;
                } elsif ($op eq '>=') {
                    if (looks_like_number($opv)) {
                        next ITEM unless $val >=  $opv;
                    } else {
                        next ITEM unless $val ge $opv;
                    }
                } elsif ($op eq 'ge') {
                    next ITEM unless $val ge $opv;
                } elsif ($op eq '<') {
                    if (looks_like_number($opv)) {
                        next ITEM unless $val <  $opv;
                    } else {
                        next ITEM unless $val lt $opv;
                    }
                } elsif ($op eq 'lt') {
                    next ITEM unless $val lt $opv;
                } elsif ($op eq '<=') {
                    if (looks_like_number($opv)) {
                        next ITEM unless $val <= $opv;
                    } else {
                        next ITEM unless $val le $opv;
                    }
                } elsif ($op eq 'le') {
                    next ITEM unless $val le $opv;
                } elsif ($op eq 'is') {
                    if (!defined($opv)) {
                        next ITEM unless !defined($val);
                    } elsif ($opv) {
                        next ITEM unless $val;
                    } else {
                        next ITEM unless !$val;
                    }
                } elsif ($op eq 'isnt') {
                    if (!defined($opv)) {
                        next ITEM unless defined($val);
                    } elsif ($opv) {
                        next ITEM unless !$val;
                    } else {
                        next ITEM unless $val;
                    }
                } elsif ($op eq 'has') {
                    next ITEM unless defined $val && ref($val) eq 'ARRAY'
                        && defined $opv;
                    if (looks_like_number($opv)) {
                        next ITEM unless grep { $_ == $opv } @$val;
                    } else {
                        next ITEM unless grep { $_ eq $opv } @$val;
                    }
                } elsif ($op eq 'hasnt') {
                    next ITEM unless defined $val && ref($val) eq 'ARRAY'
                        && defined $opv;
                    if (looks_like_number($opv)) {
                        next ITEM if grep { $_ == $opv } @$val;
                    } else {
                        next ITEM if grep { $_ eq $opv } @$val;
                    }
                } elsif ($op eq 'in') {
                    next ITEM unless defined $val && defined $opv &&
                        ref($opv) eq 'ARRAY';
                    if (looks_like_number($val)) {
                        next ITEM unless grep { $_ == $val } @$opv;
                    } else {
                        next ITEM unless grep { $_ eq $val } @$opv;
                    }
                } elsif ($op eq 'notin') {
                    next ITEM unless defined $val && defined $opv &&
                        ref($opv) eq 'ARRAY';
                    if (looks_like_number($val)) {
                        next ITEM if grep { $_ == $val } @$opv;
                    } else {
                        next ITEM if grep { $_ eq $val } @$opv;
                    }
                } elsif ($op eq '=~') {
                    next ITEM unless $val =~ $opv;
                } elsif ($op eq '!~') {
                    next ITEM unless $val !~ $opv;
                } else {
                    die "BUG: Unsupported operator '$op' in attr_selector";
                }

              PASS:
                # pass all attribute filters, add to new result
                #say "D:    adding to result: ".$o->{id};
                push @newres, $o0;
            } # for each item
            @res = @newres;

        } elsif ($type eq 'class_selector') {

            my $class = $f->{class};

            my @classes_to_match;
            for (@{ $opts->{class_prefixes} // [] }, @CLASS_PREFIXES) {
                push @classes_to_match, $_ . (/::$/ ? "" : "::") . $class;
            }
            push @classes_to_match, $class;
            my @filtered_res;
          RES:
            for my $res (@res) {
                for (@classes_to_match) {
                    if ($res->isa($_)) {
                        push @filtered_res, $res;
                        next RES;
                    }
                }
            }
            @res = @filtered_res;

        } elsif ($type eq 'id_selector') {

            my $method = $opts->{id_method} // 'id';
            my $id     = $f->{id};

            @res = grep { $_->can($method) && $_->$method eq $id } @res;

        } elsif ($type eq 'pseudoclass') {

            my $pc = $f->{pseudoclass};

            if ($pc eq 'first') {
                @res = ($res[0]);
            } elsif ($pc eq 'last') {
                @res = ($res[-1]);
            } elsif ($pc eq 'first-child') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_first_child($_) } @res;
            } elsif ($pc eq 'last-child') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_last_child($_) } @res;
            } elsif ($pc eq 'only-child') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_only_child($_) } @res;
            } elsif ($pc eq 'nth-child') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_nth_child($_, $f->{args}[0]) } @res;
            } elsif ($pc eq 'nth-last-child') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_nth_last_child($_, $f->{args}[0]) } @res;
            } elsif ($pc eq 'first-of-type') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_first_child_of_type($_) } @res;
            } elsif ($pc eq 'last-of-type') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_last_child_of_type($_) } @res;
            } elsif ($pc eq 'only-of-type') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_only_child_of_type($_) } @res;
            } elsif ($pc eq 'nth-of-type') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_nth_child_of_type($_, $f->{args}[0]) } @res;
            } elsif ($pc eq 'nth-last-of-type') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_nth_last_child_of_type($_, $f->{args}[0]) } @res;
            } elsif ($pc eq 'root') {
                @res = grep { Code::Includable::Tree::NodeMethods::is_root($_) } @res;
            } elsif ($pc eq 'has-min-children') {
                @res = grep { Code::Includable::Tree::NodeMethods::has_min_children($_, $f->{args}[0]) } @res;
            } elsif ($pc eq 'has-max-children') {
                @res = grep { Code::Includable::Tree::NodeMethods::has_max_children($_, $f->{args}[0]) } @res;
            } elsif ($pc eq 'has-children-between') {
                @res = grep { Code::Includable::Tree::NodeMethods::has_children_between($_, $f->{args}[0], $f->{args}[1]) } @res;
            } elsif ($pc eq 'empty') {
                @res = grep { my @c = Code::Includable::Tree::NodeMethods::_children_as_list($_); !@c } @res;
            } elsif ($pc eq 'has') {
                @res = _uniq_objects(
                    map { reverse Code::Includable::Tree::NodeMethods::ancestors($_) }
                        csel($opts, $f->{args}[0], @res)
                    );
            } elsif ($pc eq 'not') {
                #say "D: res=(".join(",", map {$_->{id}} @res).")";
                my @matches = csel($opts, $f->{args}[0], @res);
                #say "D: all_matches=(".join(",", map {$_->{id}} @all_matches).")";
                my %matches_refaddrs;
                for (@matches) { $matches_refaddrs{refaddr($_)}++ }
                @res = grep { !$matches_refaddrs{refaddr($_)} } @res;
            } elsif ($pc eq 'parent') {
                @res = _uniq_objects(map { Code::Includable::Tree::NodeMethods::retrieve_parent($_) } @res);
            } else {
                die "Unsupported pseudo-class '$pc'";
            }

        }

        #say "D:   intermediate result (after filter): [".join(",",map {$_->{id}} @res)."]";
    } # for each filter
    @res;
}

sub _sel {
    my ($opts, $sel, @nodes) = @_;

    my @simpsels = @$sel;
    my @res;

    my $i = 0;
    while (@simpsels) {
        if ($i++ == 0) {
            my $simpsel = shift @simpsels;
            @res = _simpsel($opts, $simpsel, 1, @nodes);
        } else {
            my $combinator = shift @simpsels;
            my $simpsel = shift @simpsels;
            last unless @res;
            if ($combinator->{combinator} eq ' ') { # descendant
                @res = _simpsel($opts, $simpsel, 1,
                                map { Code::Includable::Tree::NodeMethods::_children_as_list($_) } @res);
            } elsif ($combinator->{combinator} eq '>') { # child
                @res = _simpsel($opts, $simpsel, 0,
                                map { Code::Includable::Tree::NodeMethods::_children_as_list($_) } @res);
            } elsif ($combinator->{combinator} eq '~') { # sibling
                @res = _simpsel($opts, $simpsel, 0,
                                map { Code::Includable::Tree::NodeMethods::next_siblings($_) } @res);
            } elsif ($combinator->{combinator} eq '+') { # adjacent sibling
                @res = _simpsel($opts, $simpsel, 0,
                                grep {defined}
                                    map { Code::Includable::Tree::NodeMethods::next_sibling($_) }
                                    @res);
            } else {
                die "BUG: Unknown combinator '$combinator->{combinator}'";
            }
        }
    }

    @res;
}

sub csel {
    my $opts;
    if (ref($_[0]) eq 'HASH') {
        $opts = shift;
    } else {
        $opts = {};
    }
    my $expr = shift;
    my @nodes = @_;

    my $pexpr = parse_csel($expr);
    $pexpr or die "Invalid CSel expression '$expr'";

    local $Code::Includable::Tree::NodeMethods::GET_PARENT_METHOD   = $opts->{get_parent_method}   if $opts->{get_parent_method};
    local $Code::Includable::Tree::NodeMethods::SET_PARENT_METHOD   = $opts->{set_parent_method}   if $opts->{set_parent_method};
    local $Code::Includable::Tree::NodeMethods::GET_CHILDREN_METHOD = $opts->{get_children_method} if $opts->{get_children_method};
    local $Code::Includable::Tree::NodeMethods::SET_CHILDREN_METHOD = $opts->{set_children_method} if $opts->{set_children_method};

    my @res = _uniq_objects(map { _sel($opts, $_, @nodes) } @$pexpr );

    if ($opts->{wrap}) {
        require Data::CSel::Selection;
        return Data::CSel::Selection->new(\@res);
    } else {
        return @res;
    }
}

sub csel_each(&;@) { ## no critic: Subroutines::ProhibitSubroutinePrototypes
    my $cb = shift;
    for my $node (csel(@_)) {
        local $_ = $node;
        $cb->($_);
    }
    undef;
}

1;
# ABSTRACT: Select tree node objects using CSS Selector-like syntax

__END__