class Nokogiri::XML::NodeSet

def ==(other)
  return false unless other.is_a?(Nokogiri::XML::NodeSet)
  return false unless length == other.length
  each_with_index do |node, i|
    return false unless node == other[i]
  end
  true
end

def add_class(name)
  each do |el|
    el.add_class(name)
  end
  self
end

def after(datum)
  last.after(datum)
end

def append_class(name)
  each do |el|
    el.append_class(name)
  end
  self
end

def at(*args)
  if args.length == 1 && args.first.is_a?(Numeric)
    return self[args.first]
  end
  super(*args)
end

def attr(key, value = nil, &block)
  unless key.is_a?(Hash) || (key && (value || block))
    return first&.attribute(key)
  end
  hash = key.is_a?(Hash) ? key : { key => value }
  hash.each do |k, v|
    each do |node|
      node[k] = v || yield(node)
    end
  end
  self
end

def before(datum)
  first.before(datum)
end

def children
  node_set = NodeSet.new(document)
  each do |node|
    node.children.each { |n| node_set.push(n) }
  end
  node_set
end

def css(*args)
  rules, handler, ns, _ = extract_params(args)
  paths = css_rules_to_xpath(rules, ns)
  inject(NodeSet.new(document)) do |set, node|
    set + xpath_internal(node, paths, handler, ns, nil)
  end
end

def deconstruct
  to_a
end

def each: () -> Nokogiri::XML::NodeSet

def each
  return to_enum unless block_given?
  0.upto(length - 1) do |x|
    yield self[x]
  end
  self
end

def empty?
  length == 0
end

def filter(expr)
  find_all { |node| node.matches?(expr) }
end

def first: (?nil n) -> nil

def first(n = nil)
  return self[0] unless n
  list = []
  [n, length].min.times { |i| list << self[i] }
  list
end

def index(node = nil)
  if node
    warn("given block not used") if block_given?
    each_with_index { |member, j| return j if member == node }
  elsif block_given?
    each_with_index { |member, j| return j if yield(member) }
  end
  nil
end

def initialize: (Nokogiri::HTML4::Document document, ? list) -> void

def initialize(document, list = [])
  @document = document
  document.decorate(self)
  list.each { |x| self << x }
  yield self if block_given?
end

def inner_html(*args)
  collect { |j| j.inner_html(*args) }.join("")
end

def inner_text
  collect(&:inner_text).join("")
end

def inspect
  "[#{map(&:inspect).join(", ")}]"
end

def last
  self[-1]
end

def pop
  return nil if length == 0
  delete(last)
end

def remove_attr(name)
  each { |el| el.delete(name) }
  self
end

def remove_class(name = nil)
  each do |el|
    el.remove_class(name)
  end
  self
end

def reverse
  node_set = NodeSet.new(document)
  (length - 1).downto(0) do |x|
    node_set.push(self[x])
  end
  node_set
end

def shift
  return nil if length == 0
  delete(first)
end

def to_html(*args)
  if Nokogiri.jruby?
    options = args.first.is_a?(Hash) ? args.shift : {}
    options[:save_with] ||= Node::SaveOptions::DEFAULT_HTML
    args.insert(0, options)
  end
  if empty?
    encoding = (args.first.is_a?(Hash) ? args.first[:encoding] : nil)
    encoding ||= document.encoding
    encoding.nil? ? "" : "".encode(encoding)
  else
    map { |x| x.to_html(*args) }.join
  end
end

def to_s
  map(&:to_s).join
end

def to_xhtml(*args)
  map { |x| x.to_xhtml(*args) }.join
end

def to_xml(*args)
  map { |x| x.to_xml(*args) }.join
end

def wrap(node_or_tags)
  map { |node| node.wrap(node_or_tags) }
  self
end

def xpath(*args)
  paths, handler, ns, binds = extract_params(args)
  inject(NodeSet.new(document)) do |set, node|
    set + xpath_internal(node, paths, handler, ns, binds)
  end
end