checkoff 0.219.0 → 0.221.0

data/sorbet/rbi/gems/{nokogiri@1.16.7.rbi → nokogiri@1.17.0.rbi}

@@ -37,25 +37,18 @@
 # source://nokogiri//lib/nokogiri.rb#38
 module Nokogiri
   class << self
-    # source://nokogiri//lib/nokogiri/html4.rb#10
-    def HTML(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/html4.rb#7
+    def HTML(*_arg0, **_arg1, &_arg2); end
 
-    # :call-seq:
-    #   HTML4(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block) → Nokogiri::HTML4::Document
-    #
-    # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
+    # Convenience method for Nokogiri::HTML4::Document.parse
     #
-    # source://nokogiri//lib/nokogiri/html4.rb#10
-    def HTML4(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/html4.rb#7
+    def HTML4(*_arg0, **_arg1, &_arg2); end
 
-    # Since v1.12.0
-    #
-    # ⚠ HTML5 functionality is not available when running JRuby.
-    #
-    # Parse an HTML5 document. Convenience method for {Nokogiri::HTML5::Document.parse}
+    # Convenience method for Nokogiri::HTML5::Document.parse
     #
-    # source://nokogiri//lib/nokogiri/html5.rb#30
-    def HTML5(input, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
+    # source://nokogiri//lib/nokogiri/html5.rb#28
+    def HTML5(*_arg0, **_arg1, &_arg2); end
 
     # Parse a document and add the Slop decorator.  The Slop decorator
     # implements method_missing such that methods may be used instead of CSS
@@ -74,19 +67,15 @@ module Nokogiri
     # source://nokogiri//lib/nokogiri.rb#91
     def Slop(*args, &block); end
 
-    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+    # Convenience method for Nokogiri::XML::Document.parse
     #
-    # source://nokogiri//lib/nokogiri/xml.rb#7
-    def XML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/xml.rb#6
+    def XML(*_arg0, **_arg1, &_arg2); end
 
-    # Create a Nokogiri::XSLT::Stylesheet with +stylesheet+.
+    # Convenience method for Nokogiri::XSLT.parse
     #
-    # Example:
-    #
-    #   xslt = Nokogiri::XSLT(File.read(ARGV[0]))
-    #
-    # source://nokogiri//lib/nokogiri/xslt.rb#13
-    def XSLT(stylesheet, modules = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/xslt.rb#7
+    def XSLT(*_arg0, **_arg1, &_arg2); end
 
     # source://nokogiri//lib/nokogiri.rb#96
     def install_default_aliases; end
@@ -133,37 +122,77 @@ module Nokogiri::CSS
     def parse(selector); end
 
     # :call-seq:
-    #   xpath_for(selector) → String
-    #   xpath_for(selector [, prefix:] [, visitor:] [, ns:]) → String
+    #   xpath_for(selector_list) → Array<String>
+    #   xpath_for(selector_list [, prefix:] [, ns:] [, visitor:] [, cache:]) → Array<String>
+    #
+    # Translate a CSS selector list to the equivalent XPath expressions.
+    #
+    # 💡 Note that translated queries are cached by default for performance concerns.
     #
-    # Translate a CSS selector to the equivalent XPath query.
+    # ⚠ Users should prefer Nokogiri::XML::Searchable#css, which is mixed into all document and
+    # node classes, for querying documents with CSS selectors. This method is the underlying
+    # mechanism used by XML::Searchable and is provided solely for advanced users to translate
+    # \CSS selectors to XPath directly.
+    #
+    # Also see Nokogiri::XML::Searchable#css for documentation on supported CSS selector features,
+    # some extended syntax that Nokogiri supports, and advanced CSS features like pseudo-class
+    # functions.
     #
     # [Parameters]
-    # - +selector+ (String) The CSS selector to be translated into XPath
+    # - +selector_list+ (String)
+    #
+    #   The CSS selector to be translated into XPath. This is always a String, but that string
+    #   value may be a {selector list}[https://www.w3.org/TR/selectors-4/#grouping] (see
+    #   examples).
     #
+    # [Keyword arguments]
     # - +prefix:+ (String)
     #
-    #   The XPath prefix for the query, see Nokogiri::XML::XPath for some options. Default is
-    #   +XML::XPath::GLOBAL_SEARCH_PREFIX+.
+    #   The XPath expression prefix which determines the search context. See Nokogiri::XML::XPath
+    #   for standard options. Default is +XPath::GLOBAL_SEARCH_PREFIX+.
+    #
+    # - +ns:+ (Hash<String ⇒ String>, nil)
+    #
+    #   Namespaces that are referenced in the query, if any. This is a hash where the keys are the
+    #   namespace prefix and the values are the namespace URIs. Default is +nil+ indicating an
+    #   empty set of namespaces.
     #
     # - +visitor:+ (Nokogiri::CSS::XPathVisitor)
     #
-    #   The visitor class to use to transform the AST into XPath. Default is
-    #   +Nokogiri::CSS::XPathVisitor.new+.
+    #   Use this XPathVisitor object to transform the CSS AST into XPath expressions. See
+    #   Nokogiri::CSS::XPathVisitor for more information on some of the complex behavior that can
+    #   be customized for your document type. Default is +Nokogiri::CSS::XPathVisitor.new+.
+    #
+    #   ⚠ Note that this option is mutually exclusive with +prefix+ and +ns+. If +visitor+ is
+    #   provided, +prefix+ and +ns+ must not be present.
+    #
+    # - +cache:+ (Boolean)
+    #
+    #   Whether to use the SelectorCache for the translated query to ensure that repeated queries
+    #   don't incur the overhead of re-parsing the selector. Default is +true+.
+    #
+    # [Returns] (Array<String>) The equivalent set of XPath expressions for +selector_list+
     #
-    # - +ns:+ (Hash<String ⇒ String>)
+    # *Example* with a simple selector:
     #
-    #   The namespaces that are referenced in the query, if any. This is a hash where the keys are
-    #   the namespace prefix and the values are the namespace URIs. Default is an empty Hash.
+    #   Nokogiri::CSS.xpath_for("div") # => ["//div"]
     #
-    # [Returns] (String) The equivalent XPath query for +selector+
+    # *Example* with a compound selector:
     #
-    # 💡 Note that translated queries are cached for performance concerns.
+    #   Nokogiri::CSS.xpath_for("div.xl") # => ["//div[contains(concat(' ',normalize-space(@class),' '),' xl ')]"]
+    #
+    # *Example* with a complex selector:
+    #
+    #   Nokogiri::CSS.xpath_for("h1 + div") # => ["//h1/following-sibling::*[1]/self::div"]
+    #
+    # *Example* with a selector list:
+    #
+    #   Nokogiri::CSS.xpath_for("h1, h2, h3") # => ["//h1", "//h2", "//h3"]
     #
     # @raise [TypeError]
     #
-    # source://nokogiri//lib/nokogiri/css.rb#42
-    def xpath_for(selector, options = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/css.rb#83
+    def xpath_for(selector, options = T.unsafe(nil), prefix: T.unsafe(nil), visitor: T.unsafe(nil), ns: T.unsafe(nil), cache: T.unsafe(nil)); end
   end
 end
 
@@ -183,23 +212,23 @@ class Nokogiri::CSS::Node
 
   # Find a node by type using +types+
   #
-  # source://nokogiri//lib/nokogiri/css/node.rb#32
+  # source://nokogiri//lib/nokogiri/css/node.rb#36
   def find_by_type(types); end
 
   # Convert to array
   #
-  # source://nokogiri//lib/nokogiri/css/node.rb#49
+  # source://nokogiri//lib/nokogiri/css/node.rb#53
   def to_a; end
 
   # Convert to_type
   #
-  # source://nokogiri//lib/nokogiri/css/node.rb#42
+  # source://nokogiri//lib/nokogiri/css/node.rb#46
   def to_type; end
 
   # Convert this CSS node to xpath with +prefix+ using +visitor+
   #
   # source://nokogiri//lib/nokogiri/css/node.rb#26
-  def to_xpath(prefix, visitor); end
+  def to_xpath(visitor); end
 
   # Get the type of this node
   #
@@ -227,233 +256,228 @@ Nokogiri::CSS::Node::ALLOW_COMBINATOR_ON_SELF = T.let(T.unsafe(nil), Array)
 
 # source://nokogiri//lib/nokogiri/css/parser_extras.rb#7
 class Nokogiri::CSS::Parser < ::Racc::Parser
-  # Create a new CSS parser with respect to +namespaces+
-  #
   # @return [Parser] a new instance of Parser
   #
-  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#60
-  def initialize(namespaces = T.unsafe(nil)); end
+  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#8
+  def initialize; end
 
   # reduce 0 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#361
+  # source://nokogiri//lib/nokogiri/css/parser.rb#363
   def _reduce_1(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#407
+  # source://nokogiri//lib/nokogiri/css/parser.rb#409
   def _reduce_10(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#412
+  # source://nokogiri//lib/nokogiri/css/parser.rb#414
   def _reduce_11(val, _values, result); end
 
   # reduce 12 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#424
+  # source://nokogiri//lib/nokogiri/css/parser.rb#426
   def _reduce_13(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#429
+  # source://nokogiri//lib/nokogiri/css/parser.rb#431
   def _reduce_14(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#434
+  # source://nokogiri//lib/nokogiri/css/parser.rb#436
   def _reduce_15(val, _values, result); end
 
   # reduce 16 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#441
+  # source://nokogiri//lib/nokogiri/css/parser.rb#443
   def _reduce_17(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#446
+  # source://nokogiri//lib/nokogiri/css/parser.rb#448
   def _reduce_18(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#451
+  # source://nokogiri//lib/nokogiri/css/parser.rb#453
   def _reduce_19(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#367
+  # source://nokogiri//lib/nokogiri/css/parser.rb#369
   def _reduce_2(val, _values, result); end
 
   # reduce 20 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#458
+  # source://nokogiri//lib/nokogiri/css/parser.rb#460
   def _reduce_21(val, _values, result); end
 
   # reduce 22 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#465
+  # source://nokogiri//lib/nokogiri/css/parser.rb#467
   def _reduce_23(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#470
+  # source://nokogiri//lib/nokogiri/css/parser.rb#472
   def _reduce_24(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#475
+  # source://nokogiri//lib/nokogiri/css/parser.rb#477
   def _reduce_25(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#482
+  # source://nokogiri//lib/nokogiri/css/parser.rb#484
   def _reduce_26(val, _values, result); end
 
   # reduce 27 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#489
+  # source://nokogiri//lib/nokogiri/css/parser.rb#491
   def _reduce_28(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#495
+  # source://nokogiri//lib/nokogiri/css/parser.rb#497
   def _reduce_29(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#372
+  # source://nokogiri//lib/nokogiri/css/parser.rb#374
   def _reduce_3(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#501
+  # source://nokogiri//lib/nokogiri/css/parser.rb#503
   def _reduce_30(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#507
+  # source://nokogiri//lib/nokogiri/css/parser.rb#509
   def _reduce_31(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#512
+  # source://nokogiri//lib/nokogiri/css/parser.rb#514
   def _reduce_32(val, _values, result); end
 
   # reduce 33 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#519
+  # source://nokogiri//lib/nokogiri/css/parser.rb#521
   def _reduce_34(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#525
+  # source://nokogiri//lib/nokogiri/css/parser.rb#527
   def _reduce_35(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#531
+  # source://nokogiri//lib/nokogiri/css/parser.rb#533
   def _reduce_36(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#537
+  # source://nokogiri//lib/nokogiri/css/parser.rb#539
   def _reduce_37(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#543
+  # source://nokogiri//lib/nokogiri/css/parser.rb#545
   def _reduce_38(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#549
+  # source://nokogiri//lib/nokogiri/css/parser.rb#551
   def _reduce_39(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#377
+  # source://nokogiri//lib/nokogiri/css/parser.rb#379
   def _reduce_4(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#554
+  # source://nokogiri//lib/nokogiri/css/parser.rb#556
   def _reduce_40(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#559
+  # source://nokogiri//lib/nokogiri/css/parser.rb#561
   def _reduce_41(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#564
+  # source://nokogiri//lib/nokogiri/css/parser.rb#566
   def _reduce_42(val, _values, result); end
 
   # reduce 44 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#573
+  # source://nokogiri//lib/nokogiri/css/parser.rb#575
   def _reduce_45(val, _values, result); end
 
   # reduce 46 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#590
+  # source://nokogiri//lib/nokogiri/css/parser.rb#592
   def _reduce_47(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#600
+  # source://nokogiri//lib/nokogiri/css/parser.rb#602
   def _reduce_48(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#616
+  # source://nokogiri//lib/nokogiri/css/parser.rb#618
   def _reduce_49(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#382
+  # source://nokogiri//lib/nokogiri/css/parser.rb#384
   def _reduce_5(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#636
+  # source://nokogiri//lib/nokogiri/css/parser.rb#638
   def _reduce_50(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#642
+  # source://nokogiri//lib/nokogiri/css/parser.rb#644
   def _reduce_51(val, _values, result); end
 
   # reduce 53 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#651
+  # source://nokogiri//lib/nokogiri/css/parser.rb#653
   def _reduce_54(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#657
+  # source://nokogiri//lib/nokogiri/css/parser.rb#659
   def _reduce_55(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#663
+  # source://nokogiri//lib/nokogiri/css/parser.rb#665
   def _reduce_56(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#669
+  # source://nokogiri//lib/nokogiri/css/parser.rb#671
   def _reduce_57(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#675
+  # source://nokogiri//lib/nokogiri/css/parser.rb#677
   def _reduce_58(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#387
+  # source://nokogiri//lib/nokogiri/css/parser.rb#389
   def _reduce_6(val, _values, result); end
 
   # reduce 63 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#691
+  # source://nokogiri//lib/nokogiri/css/parser.rb#693
   def _reduce_64(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#696
+  # source://nokogiri//lib/nokogiri/css/parser.rb#698
   def _reduce_65(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#701
+  # source://nokogiri//lib/nokogiri/css/parser.rb#703
   def _reduce_66(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#706
+  # source://nokogiri//lib/nokogiri/css/parser.rb#708
   def _reduce_67(val, _values, result); end
 
   # reduce 68 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#713
+  # source://nokogiri//lib/nokogiri/css/parser.rb#715
   def _reduce_69(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#392
+  # source://nokogiri//lib/nokogiri/css/parser.rb#394
   def _reduce_7(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#718
+  # source://nokogiri//lib/nokogiri/css/parser.rb#720
   def _reduce_70(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#723
+  # source://nokogiri//lib/nokogiri/css/parser.rb#725
   def _reduce_71(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#728
+  # source://nokogiri//lib/nokogiri/css/parser.rb#730
   def _reduce_72(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#733
+  # source://nokogiri//lib/nokogiri/css/parser.rb#735
   def _reduce_73(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#738
+  # source://nokogiri//lib/nokogiri/css/parser.rb#740
   def _reduce_74(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#743
+  # source://nokogiri//lib/nokogiri/css/parser.rb#745
   def _reduce_75(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#748
+  # source://nokogiri//lib/nokogiri/css/parser.rb#750
   def _reduce_76(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#397
+  # source://nokogiri//lib/nokogiri/css/parser.rb#399
   def _reduce_8(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser.rb#402
+  # source://nokogiri//lib/nokogiri/css/parser.rb#404
   def _reduce_9(val, _values, result); end
 
   # reduce 81 omitted
   #
-  # source://nokogiri//lib/nokogiri/css/parser.rb#764
+  # source://nokogiri//lib/nokogiri/css/parser.rb#766
   def _reduce_none(val, _values, result); end
 
-  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#89
-  def cache_key(query, prefix, visitor); end
-
-  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#71
+  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#18
   def next_token; end
 
   # On CSS parser error, raise an exception
   #
   # @raise [SyntaxError]
   #
-  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#84
+  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#30
   def on_error(error_token_id, error_value, value_stack); end
 
-  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#66
+  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#13
   def parse(string); end
 
   # source://nokogiri//lib/nokogiri/css/parser.rb#26
@@ -462,58 +486,46 @@ class Nokogiri::CSS::Parser < ::Racc::Parser
   # source://nokogiri//lib/nokogiri/css/parser.rb#30
   def unescape_css_string(str); end
 
-  # Get the xpath for +string+ using +options+
+  # Get the xpath for +selector+ using +visitor+
   #
-  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#76
-  def xpath_for(string, prefix, visitor); end
+  # source://nokogiri//lib/nokogiri/css/parser_extras.rb#23
+  def xpath_for(selector, visitor); end
+end
 
-  class << self
-    # Get the css selector in +string+ from the cache
-    #
-    # source://nokogiri//lib/nokogiri/css/parser_extras.rb#25
-    def [](string); end
+# source://nokogiri//lib/nokogiri/css/parser.rb#279
+Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
 
-    # Set the css selector in +string+ in the cache to +value+
-    #
-    # source://nokogiri//lib/nokogiri/css/parser_extras.rb#32
-    def []=(string, value); end
+# source://nokogiri//lib/nokogiri/css/parser.rb#357
+Nokogiri::CSS::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
 
-    # Return a thread-local boolean indicating whether the CSS-to-XPath cache is active. (Default is `true`.)
+# source://nokogiri//lib/nokogiri/css/parser.rb#296
+Nokogiri::CSS::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+
+# source://nokogiri//lib/nokogiri/css/selector_cache.rb#5
+module Nokogiri::CSS::SelectorCache
+  class << self
+    # Retrieve the cached XPath expressions for the key
     #
-    # @return [Boolean]
+    # source://nokogiri//lib/nokogiri/css/selector_cache.rb#11
+    def [](key); end
+
+    # Insert the XPath expressions `value` at the cache key
     #
-    # source://nokogiri//lib/nokogiri/css/parser_extras.rb#15
-    def cache_on?; end
+    # source://nokogiri//lib/nokogiri/css/selector_cache.rb#16
+    def []=(key, value); end
 
     # Clear the cache
     #
-    # source://nokogiri//lib/nokogiri/css/parser_extras.rb#39
+    # source://nokogiri//lib/nokogiri/css/selector_cache.rb#21
     def clear_cache(create_new_object = T.unsafe(nil)); end
 
-    # Set a thread-local boolean to turn cacheing on and off. Truthy values turn the cache on, falsey values turn the cache off.
+    # Construct a unique key cache key
     #
-    # source://nokogiri//lib/nokogiri/css/parser_extras.rb#20
-    def set_cache(value); end
-
-    # Execute +block+ without cache
-    #
-    # source://nokogiri//lib/nokogiri/css/parser_extras.rb#50
-    def without_cache(&block); end
+    # source://nokogiri//lib/nokogiri/css/selector_cache.rb#32
+    def key(selector:, visitor:); end
   end
 end
 
-# source://nokogiri//lib/nokogiri/css/parser_extras.rb#8
-Nokogiri::CSS::Parser::CACHE_SWITCH_NAME = T.let(T.unsafe(nil), Symbol)
-
-# source://nokogiri//lib/nokogiri/css/parser.rb#279
-Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
-
-# source://nokogiri//lib/nokogiri/css/parser.rb#355
-Nokogiri::CSS::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
-
-# source://nokogiri//lib/nokogiri/css/parser.rb#295
-Nokogiri::CSS::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
-
 # source://nokogiri//lib/nokogiri/css/syntax_error.rb#6
 class Nokogiri::CSS::SyntaxError < ::Nokogiri::SyntaxError; end
 
@@ -587,83 +599,106 @@ class Nokogiri::CSS::XPathVisitor
   #
   # @return [XPathVisitor] a new instance of XPathVisitor
   #
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#57
-  def initialize(builtins: T.unsafe(nil), doctype: T.unsafe(nil)); end
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#69
+  def initialize(builtins: T.unsafe(nil), doctype: T.unsafe(nil), prefix: T.unsafe(nil), namespaces: T.unsafe(nil)); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#267
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#297
   def accept(node); end
 
+  # The visitor configuration set via the +builtins:+ keyword argument to XPathVisitor.new.
+  #
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#48
+  def builtins; end
+
   # :call-seq: config() → Hash
   #
   # [Returns]
   #   a Hash representing the configuration of the XPathVisitor, suitable for use as
   #   part of the CSS cache key.
   #
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#74
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#93
   def config; end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#263
+  # The visitor configuration set via the +doctype:+ keyword argument to XPathVisitor.new.
+  #
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#51
+  def doctype; end
+
+  # The visitor configuration set via the +namespaces:+ keyword argument to XPathVisitor.new.
+  #
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#57
+  def namespaces; end
+
+  # The visitor configuration set via the +prefix:+ keyword argument to XPathVisitor.new.
+  #
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#54
+  def prefix; end
+
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#293
   def visit_attrib_name(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#154
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#175
   def visit_attribute_condition(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#234
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#256
   def visit_child_selector(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#215
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#237
   def visit_class_condition(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#219
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#241
   def visit_combinator(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#240
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#262
   def visit_conditional_selector(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#234
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#256
   def visit_descendant_selector(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#234
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#256
   def visit_direct_adjacent_selector(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#245
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#267
   def visit_element_name(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#234
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#256
   def visit_following_selector(node); end
 
   # :stopdoc:
   #
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#79
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#98
   def visit_function(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#149
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#170
   def visit_id(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#140
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#161
   def visit_not(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#190
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#211
   def visit_pseudo_class(node); end
 
   private
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#328
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#364
   def css_class(hay, needle); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#273
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#309
   def html5_element_name_needs_namespace_handling(node); end
 
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#318
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#354
   def is_of_type_pseudo_class?(node); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#280
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#316
   def nth(node, options = T.unsafe(nil)); end
 
-  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#304
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#340
   def read_a_and_positive_b(values); end
+
+  # source://nokogiri//lib/nokogiri/css/xpath_visitor.rb#303
+  def validate_xpath_function_name(name); end
 end
 
 # Enum to direct XPathVisitor when to use Nokogiri builtin XPath functions.
@@ -782,7 +817,7 @@ module Nokogiri::Decorators::Slop
 
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/decorators/slop.rb#37
+  # source://nokogiri//lib/nokogiri/decorators/slop.rb#35
   def respond_to_missing?(name, include_private = T.unsafe(nil)); end
 end
 
@@ -815,8 +850,8 @@ Nokogiri::EncodingHandler::USEFUL_ALIASES = T.let(T.unsafe(nil), Hash)
 # source://nokogiri//lib/nokogiri/gumbo.rb#4
 module Nokogiri::Gumbo
   class << self
-    def fragment(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5); end
-    def parse(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5); end
+    def fragment(*_arg0); end
+    def parse(*_arg0); end
   end
 end
 
@@ -848,18 +883,18 @@ Nokogiri::HTML = Nokogiri::HTML4
 # 💡 Before v1.12.0, Nokogiri::HTML4 did not exist, and Nokogiri::HTML was the module/namespace
 # for parsing HTML.
 #
-# source://nokogiri//lib/nokogiri/html4.rb#19
+# source://nokogiri//lib/nokogiri/html4.rb#16
 module Nokogiri::HTML4
   class << self
-    # Parse a fragment from +string+ in to a NodeSet.
+    # Convenience method for Nokogiri::HTML4::DocumentFragment.parse
     #
-    # source://nokogiri//lib/nokogiri/html4.rb#29
-    def fragment(string, encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/html4.rb#24
+    def fragment(*_arg0, **_arg1, &_arg2); end
 
-    # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
+    # Convenience method for Nokogiri::HTML4::Document.parse
     #
-    # source://nokogiri//lib/nokogiri/html4.rb#23
-    def parse(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/html4.rb#19
+    def parse(*_arg0, **_arg1, &_arg2); end
   end
 end
 
@@ -987,37 +1022,129 @@ class Nokogiri::HTML4::Document < ::Nokogiri::XML::Document
   class << self
     def new(*_arg0); end
 
-    # Parse HTML.  +string_or_io+ may be a String, or any object that
-    # responds to _read_ and _close_ such as an IO, or StringIO.
-    # +url+ is resource where this document is located.  +encoding+ is the
-    # encoding that should be used when processing the document. +options+
-    # is a number that sets options in the parser, such as
-    # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
-    # Nokogiri::XML::ParseOptions.
+    # :call-seq:
+    #   parse(input) { |options| ... } => Nokogiri::HTML4::Document
+    #
+    # Parse \HTML4 input from a String or IO object, and return a new HTML4::Document.
+    #
+    # [Required Parameters]
+    # - +input+ (String | IO) The content to be parsed.
+    #
+    # [Optional Keyword Arguments]
+    # - +url:+ (String) The base URI for this document.
+    #
+    #   document. When not provided, the encoding will be determined based on the document
+    #   content.
+    #
+    # - +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+    #   behaviors during parsing. See ParseOptions for more information. The default value is
+    #   +ParseOptions::DEFAULT_HTML+.
+    #
+    # [Yields]
+    #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+    #   can be configured before parsing. See Nokogiri::XML::ParseOptions for more information.
+    #
+    # [Returns] Nokogiri::HTML4::Document
     #
     # @yield [options]
     #
-    # source://nokogiri//lib/nokogiri/html4/document.rb#172
-    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/html4/document.rb#189
+    def parse(input, url_ = T.unsafe(nil), encoding_ = T.unsafe(nil), options_ = T.unsafe(nil), url: T.unsafe(nil), encoding: T.unsafe(nil), options: T.unsafe(nil)); end
 
     def read_io(_arg0, _arg1, _arg2, _arg3); end
     def read_memory(_arg0, _arg1, _arg2, _arg3); end
   end
 end
 
-# source://nokogiri//lib/nokogiri/html4/document_fragment.rb#7
+# source://nokogiri//lib/nokogiri/html4/document_fragment.rb#51
 class Nokogiri::HTML4::DocumentFragment < ::Nokogiri::XML::DocumentFragment
+  # :call-seq:
+  #   new(document) { |options| ... } → HTML4::DocumentFragment
+  #   new(document, input) { |options| ... } → HTML4::DocumentFragment
+  #   new(document, input, context:, options:) { |options| ... } → HTML4::DocumentFragment
+  #
+  # Parse \HTML4 fragment input from a String, and return a new HTML4::DocumentFragment.
+  #
+  # 💡 It's recommended to use either HTML4::DocumentFragment.parse or XML::Node#parse rather
+  # than call this method directly.
+  #
+  # [Required Parameters]
+  # - +document+ (HTML4::Document) The parent document to associate the returned fragment with.
+  #
+  # [Optional Parameters]
+  # - +input+ (String) The content to be parsed.
+  #
+  # [Optional Keyword Arguments]
+  # - +context:+ (Nokogiri::XML::Node) The <b>context node</b> for the subtree created. See
+  #   below for more information.
+  #
+  # - +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+  #   behaviors during parsing. See ParseOptions for more information. The default value is
+  #   +ParseOptions::DEFAULT_HTML+.
+  #
+  # [Yields]
+  #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+  #   can be configured before parsing. See ParseOptions for more information.
+  #
+  # [Returns] HTML4::DocumentFragment
+  #
+  # === Context \Node
+  #
+  # If a context node is specified using +context:+, then the fragment will be created by
+  # calling XML::Node#parse on that node, so the parser will behave as if that Node is the
+  # parent of the fragment subtree.
+  #
   # @return [DocumentFragment] a new instance of DocumentFragment
   # @yield [options]
   #
-  # source://nokogiri//lib/nokogiri/html4/document_fragment.rb#27
-  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end
+  # source://nokogiri//lib/nokogiri/html4/document_fragment.rb#134
+  def initialize(document, input = T.unsafe(nil), context_ = T.unsafe(nil), options_ = T.unsafe(nil), context: T.unsafe(nil), options: T.unsafe(nil)); end
 
   class << self
-    # Create a Nokogiri::XML::DocumentFragment from +tags+, using +encoding+
+    # :call-seq:
+    #   parse(input) { |options| ... } → HTML4::DocumentFragment
+    #
+    # Parse \HTML4 fragment input from a String, and return a new HTML4::DocumentFragment. This
+    # method creates a new, empty HTML4::Document to contain the fragment.
+    #
+    # [Required Parameters]
+    # - +input+ (String | IO) The content to be parsed.
+    #
+    # [Optional Keyword Arguments]
+    #   document. When not provided, the encoding will be determined based on the document
+    #   content.
+    #
+    # - +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+    #   behaviors during parsing. See ParseOptions for more information. The default value is
+    #   +ParseOptions::DEFAULT_HTML+.
+    #
+    # [Yields]
+    #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+    #   can be configured before parsing. See ParseOptions for more information.
+    #
+    # [Returns] HTML4::DocumentFragment
+    #
+    # *Example:* Parsing a string
+    #
+    #   fragment = HTML4::DocumentFragment.parse("<div>Hello World</div>")
+    #
+    # *Example:* Parsing an IO
+    #
+    #   fragment = File.open("fragment.html") do |file|
+    #     HTML4::DocumentFragment.parse(file)
+    #   end
     #
-    # source://nokogiri//lib/nokogiri/html4/document_fragment.rb#8
-    def parse(tags, encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # *Example:* Specifying encoding
+    #
+    #
+    # *Example:* Setting parse options dynamically
+    #
+    #   HTML4::DocumentFragment.parse("<div>Hello World") do |options|
+    #     options.huge.pedantic
+    #   end
+    #
+    # source://nokogiri//lib/nokogiri/html4/document_fragment.rb#52
+    def parse(input, encoding_ = T.unsafe(nil), options_ = T.unsafe(nil), encoding: T.unsafe(nil), options: T.unsafe(nil), &block); end
   end
 end
 
@@ -1490,10 +1617,11 @@ end
 
 # Instance of Nokogiri::HTML4::EntityLookup
 #
-# source://nokogiri//lib/nokogiri/html4.rb#35
+# source://nokogiri//lib/nokogiri/html4.rb#30
 Nokogiri::HTML4::NamedCharacters = T.let(T.unsafe(nil), Nokogiri::HTML4::EntityLookup)
 
-# Nokogiri lets you write a SAX parser to process HTML but get HTML correction features.
+# Nokogiri provides a SAX parser to process HTML4 which will provide HTML recovery
+# ("autocorrection") features.
 #
 # See Nokogiri::HTML4::SAX::Parser for a basic example of using a SAX parser with HTML.
 #
@@ -1502,60 +1630,51 @@ Nokogiri::HTML4::NamedCharacters = T.let(T.unsafe(nil), Nokogiri::HTML4::EntityL
 # source://nokogiri//lib/nokogiri/html4/sax/parser_context.rb#5
 module Nokogiri::HTML4::SAX; end
 
-# This class lets you perform SAX style parsing on HTML with HTML error correction.
+# This parser is a SAX style parser that reads its input as it deems necessary. The parser
+# takes a Nokogiri::XML::SAX::Document, an optional encoding, then given an HTML input, sends
+# messages to the Nokogiri::XML::SAX::Document.
+#
+# ⚠ This is an HTML4 parser and so may not support some HTML5 features and behaviors.
 #
 # Here is a basic usage example:
 #
-#   class MyDoc < Nokogiri::XML::SAX::Document
+#   class MyHandler < Nokogiri::XML::SAX::Document
 #     def start_element name, attributes = []
 #       puts "found a #{name}"
 #     end
 #   end
 #
-#   parser = Nokogiri::HTML4::SAX::Parser.new(MyDoc.new)
-#   parser.parse(File.read(ARGV[0], mode: 'rb'))
+#   parser = Nokogiri::HTML4::SAX::Parser.new(MyHandler.new)
 #
-# For more information on SAX parsers, see Nokogiri::XML::SAX
+#   # Hand an IO object to the parser, which will read the HTML from the IO.
+#   File.open(path_to_html) do |f|
+#     parser.parse(f)
+#   end
 #
-# source://nokogiri//lib/nokogiri/html4/sax/parser.rb#29
+# For more information on \SAX parsers, see Nokogiri::XML::SAX or the parent class
+# Nokogiri::XML::SAX::Parser.
+#
+# Also see Nokogiri::XML::SAX::Document for the available events.
+#
+# source://nokogiri//lib/nokogiri/html4/sax/parser.rb#44
 class Nokogiri::HTML4::SAX::Parser < ::Nokogiri::XML::SAX::Parser
-  # Parse a file with +filename+
-  #
-  # @raise [ArgumentError]
-  # @yield [ctx]
-  #
-  # source://nokogiri//lib/nokogiri/html4/sax/parser.rb#51
-  def parse_file(filename, encoding = T.unsafe(nil)); end
-
-  # Parse given +io+
-  #
-  # @yield [ctx]
-  #
-  # source://nokogiri//lib/nokogiri/html4/sax/parser.rb#41
-  def parse_io(io, encoding = T.unsafe(nil)); end
+  private
 
-  # Parse html stored in +data+ using +encoding+
-  #
-  # @raise [TypeError]
-  # @yield [ctx]
-  #
-  # source://nokogiri//lib/nokogiri/html4/sax/parser.rb#30
-  def parse_memory(data, encoding = T.unsafe(nil)); end
+  def initialize_native; end
 end
 
-# Context for HTML SAX parsers. This class is usually not instantiated by the user. Instead,
-# you should be looking at Nokogiri::HTML4::SAX::Parser
+# Context object to invoke the HTML4 SAX parser on the SAX::Document handler.
+#
+# 💡 This class is usually not instantiated by the user. Use Nokogiri::HTML4::SAX::Parser
+# instead.
 #
-# source://nokogiri//lib/nokogiri/html4/sax/parser_context.rb#9
+# source://nokogiri//lib/nokogiri/html4/sax/parser_context.rb#11
 class Nokogiri::HTML4::SAX::ParserContext < ::Nokogiri::XML::SAX::ParserContext
   def parse_with(_arg0); end
 
   class << self
-    def file(_arg0, _arg1); end
-    def memory(_arg0, _arg1); end
-
-    # source://nokogiri//lib/nokogiri/html4/sax/parser_context.rb#10
-    def new(thing, encoding = T.unsafe(nil)); end
+    def native_file(_arg0, _arg1); end
+    def native_memory(_arg0, _arg1); end
   end
 end
 
@@ -1604,34 +1723,36 @@ end
 
 # == Usage
 #
-# ⚠ HTML5 functionality is not available when running JRuby.
-#
 # Parse an HTML5 document:
 #
-#   doc = Nokogiri.HTML5(string)
+#   doc = Nokogiri.HTML5(input)
 #
 # Parse an HTML5 fragment:
 #
-#   fragment = Nokogiri::HTML5.fragment(string)
+#   fragment = Nokogiri::HTML5.fragment(input)
+#
+# ⚠ HTML5 functionality is not available when running JRuby.
 #
 # == Parsing options
 #
-# The document and fragment parsing methods support options that are different from Nokogiri's.
+# The document and fragment parsing methods support options that are different from
+# Nokogiri::HTML4::Document or Nokogiri::XML::Document.
 #
-# - <tt>Nokogiri.HTML5(html, url = nil, encoding = nil, options = {})</tt>
-# - <tt>Nokogiri::HTML5.parse(html, url = nil, encoding = nil, options = {})</tt>
-# - <tt>Nokogiri::HTML5::Document.parse(html, url = nil, encoding = nil, options = {})</tt>
-# - <tt>Nokogiri::HTML5.fragment(html, encoding = nil, options = {})</tt>
-# - <tt>Nokogiri::HTML5::DocumentFragment.parse(html, encoding = nil, options = {})</tt>
 #
-# The three currently supported options are +:max_errors+, +:max_tree_depth+ and
-# +:max_attributes+, described below.
+# The four currently supported parse options are
 #
-# === Error reporting
+# - +max_errors:+ (Integer, default 0) Maximum number of parse errors to report in HTML5::Document#errors.
+# - +max_tree_depth:+ (Integer, default +Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH+) Maximum tree depth to parse.
+# - +max_attributes:+ (Integer, default +Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES+) Maximum number of attributes to parse per element.
+# - +parse_noscript_content_as_text:+ (Boolean, default false) When enabled, parse +noscript+ tag content as text, mimicking the behavior of web browsers.
+#
+# These options are explained in the following sections.
+#
+# === Error reporting: +max_errors:+
 #
 # Nokogiri contains an experimental HTML5 parse error reporting facility. By default, no parse
 # errors are reported but this can be configured by passing the +:max_errors+ option to
-# {HTML5.parse} or {HTML5.fragment}.
+# HTML5.parse or HTML5.fragment.
 #
 # For example, this script:
 #
@@ -1657,20 +1778,21 @@ end
 #
 # Using <tt>max_errors: -1</tt> results in an unlimited number of errors being returned.
 #
-# The errors returned by {HTML5::Document#errors} are instances of {Nokogiri::XML::SyntaxError}.
+# The errors returned by HTML5::Document#errors are instances of Nokogiri::XML::SyntaxError.
 #
-# The {https://html.spec.whatwg.org/multipage/parsing.html#parse-errors HTML standard} defines a
+# The {HTML standard}[https://html.spec.whatwg.org/multipage/parsing.html#parse-errors] defines a
 # number of standard parse error codes. These error codes only cover the "tokenization" stage of
 # parsing HTML. The parse errors in the "tree construction" stage do not have standardized error
 # codes (yet).
 #
-# As a convenience to Nokogiri users, the defined error codes are available via
-# {Nokogiri::XML::SyntaxError#str1} method.
+# As a convenience to Nokogiri users, the defined error codes are available
+# via Nokogiri::XML::SyntaxError#str1 method.
 #
 #   doc = Nokogiri::HTML5.parse('<span/>Hi there!</span foo=bar />', max_errors: 10)
 #   doc.errors.each do |err|
 #     puts("#{err.line}:#{err.column}: #{err.str1}")
 #   end
+#   doc = Nokogiri::HTML5.parse('<span/>Hi there!</span foo=bar />',
 #   # => 1:1: generic-parser
 #   #    1:1: non-void-html-element-start-tag-with-trailing-solidus
 #   #    1:17: end-tag-with-trailing-solidus
@@ -1683,40 +1805,75 @@ end
 # are not part of Nokogiri's public API. That is, these are subject to change without Nokogiri's
 # major version number changing. These may be stabilized in the future.
 #
-# === Maximum tree depth
+# === Maximum tree depth: +max_tree_depth:+
 #
 # The maximum depth of the DOM tree parsed by the various parsing methods is configurable by the
 # +:max_tree_depth+ option. If the depth of the tree would exceed this limit, then an
-# {::ArgumentError} is thrown.
+# +ArgumentError+ is thrown.
 #
-# This limit (which defaults to <tt>Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH = 400</tt>) can be
-# removed by giving the option <tt>max_tree_depth: -1</tt>.
+# This limit (which defaults to +Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH+) can be removed by
+# giving the option <tt>max_tree_depth: -1</tt>.
 #
 #   html = '<!DOCTYPE html>' + '<div>' * 1000
 #   doc = Nokogiri.HTML5(html)
 #   # raises ArgumentError: Document tree depth limit exceeded
 #   doc = Nokogiri.HTML5(html, max_tree_depth: -1)
 #
-# === Attribute limit per element
+# === Attribute limit per element: +max_attributes:+
 #
 # The maximum number of attributes per DOM element is configurable by the +:max_attributes+
-# option. If a given element would exceed this limit, then an {::ArgumentError} is thrown.
+# option. If a given element would exceed this limit, then an +ArgumentError+ is thrown.
 #
-# This limit (which defaults to <tt>Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES = 400</tt>) can be
-# removed by giving the option <tt>max_attributes: -1</tt>.
+# This limit (which defaults to +Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES+) can be removed by
+# giving the option <tt>max_attributes: -1</tt>.
 #
-#   html = '<!DOCTYPE html><div ' + (1..1000).map { |x| "attr-#{x}" }.join(' ') + '>'
+#   html = '<!DOCTYPE html><div ' + (1..1000).map { |x| "attr-#{x}" }.join(' # ') + '>'
 #   # "<!DOCTYPE html><div attr-1 attr-2 attr-3 ... attr-1000>"
 #   doc = Nokogiri.HTML5(html)
 #   # raises ArgumentError: Attributes per element limit exceeded
+#
 #   doc = Nokogiri.HTML5(html, max_attributes: -1)
+#   # parses successfully
+#
+# === Parse +noscript+ elements' content as text: +parse_noscript_content_as_text:+
+#
+# By default, the content of +noscript+ elements is parsed as HTML elements. Browsers that
+# support scripting parse the content of +noscript+ elements as raw text.
+#
+# The +:parse_noscript_content_as_text+ option causes Nokogiri to parse the content of +noscript+
+# elements as a single text node.
+#
+#   html = "<!DOCTYPE html><noscript><meta charset='UTF-8'><link rel=stylesheet href=!></noscript>"
+#   doc = Nokogiri::HTML5.parse(html, parse_noscript_content_as_text: true)
+#   pp doc.at_xpath("/html/head/noscript")
+#   # => #(Element:0x878c {
+#   #        name = "noscript",
+#   #        children = [ #(Text "<meta charset='UTF-8'><link rel=stylesheet href=!>")]
+#   #      })
+#
+# In contrast, <tt>parse_noscript_content_as_text: false</tt> (the default) causes the +noscript+
+# element in the previous example to have two children, a +meta+ element and a +link+ element.
+#
+#   doc = Nokogiri::HTML5.parse(html)
+#   puts doc.at_xpath("/html/head/noscript")
+#   # => #(Element:0x96b4 {
+#   #      name = "noscript",
+#   #      children = [
+#   #        #(Element:0x97e0 { name = "meta", attribute_nodes = [ #(Attr:0x990c { name = "charset", value = "UTF-8" })] }),
+#   #        #(Element:0x9b00 {
+#   #          name = "link",
+#   #          attribute_nodes = [
+#   #            #(Attr:0x9c2c { name = "rel", value = "stylesheet" }),
+#   #            #(Attr:0x9dd0 { name = "href", value = "!" })]
+#   #          })]
+#   #      })
 #
 # == HTML Serialization
 #
-# After parsing HTML, it may be serialized using any of the {Nokogiri::XML::Node} serialization
-# methods. In particular, {XML::Node#serialize}, {XML::Node#to_html}, and {XML::Node#to_s} will
+# After parsing HTML, it may be serialized using any of the Nokogiri::XML::Node serialization
+# methods. In particular, XML::Node#serialize, XML::Node#to_html, and XML::Node#to_s will
 # serialize a given node and its children. (This is the equivalent of JavaScript's
-# +Element.outerHTML+.) Similarly, {XML::Node#inner_html} will serialize the children of a given
+# +Element.outerHTML+.) Similarly, XML::Node#inner_html will serialize the children of a given
 # node. (This is the equivalent of JavaScript's +Element.innerHTML+.)
 #
 #   doc = Nokogiri::HTML5("<!DOCTYPE html><span>Hello world!</span>")
@@ -1724,12 +1881,12 @@ end
 #   # => <!DOCTYPE html><html><head></head><body><span>Hello world!</span></body></html>
 #
 # Due to quirks in how HTML is parsed and serialized, it's possible for a DOM tree to be
-# serialized and then re-parsed, resulting in a different DOM.  Mostly, this happens with DOMs
+# serialized and then re-parsed, resulting in a different DOM. Mostly, this happens with DOMs
 # produced from invalid HTML. Unfortunately, even valid HTML may not survive serialization and
 # re-parsing.
 #
-# In particular, a newline at the start of +pre+, +listing+, and +textarea+ elements is ignored by
-# the parser.
+# In particular, a newline at the start of +pre+, +listing+, and +textarea+
+# elements is ignored by the parser.
 #
 #   doc = Nokogiri::HTML5(<<-EOF)
 #   <!DOCTYPE html>
@@ -1758,81 +1915,117 @@ end
 #
 # == Encodings
 #
-# Nokogiri always parses HTML5 using {https://en.wikipedia.org/wiki/UTF-8 UTF-8}; however, the
+# Nokogiri always parses HTML5 using {UTF-8}[https://en.wikipedia.org/wiki/UTF-8]; however, the
 # encoding of the input can be explicitly selected via the optional +encoding+ parameter. This is
 # most useful when the input comes not from a string but from an IO object.
 #
 # When serializing a document or node, the encoding of the output string can be specified via the
 # +:encoding+ options. Characters that cannot be encoded in the selected encoding will be encoded
-# as {https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references HTML numeric
-# entities}.
+# as {HTML numeric
+# entities}[https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references].
 #
 #   frag = Nokogiri::HTML5.fragment('<span>아는 길도 물어가라</span>')
 #   puts html
 #   # => <span>&#xc544;&#xb294; &#xae38;&#xb3c4; &#xbb3c;&#xc5b4;&#xac00;&#xb77c;</span>
+#
 #   frag = Nokogiri::HTML5.fragment(html)
 #   puts frag.serialize
 #   # => <span>아는 길도 물어가라</span>
 #
-# (There's a {https://bugs.ruby-lang.org/issues/15033 bug} in all current versions of Ruby that
+# (There's a {bug}[https://bugs.ruby-lang.org/issues/15033] in all current versions of Ruby that
 # can cause the entity encoding to fail. Of the mandated supported encodings for HTML, the only
 # encoding I'm aware of that has this bug is <tt>'ISO-2022-JP'</tt>. We recommend avoiding this
 # encoding.)
 #
 # == Notes
 #
-# * The {Nokogiri::HTML5.fragment} function takes a string and parses it
-#   as a HTML5 document.  The +<html>+, +<head>+, and +<body>+ elements are
-#   removed from this document, and any children of these elements that remain
-#   are returned as a {Nokogiri::HTML5::DocumentFragment}.
+# * The Nokogiri::HTML5.fragment function takes a String or IO and parses it as a HTML5 document
+#   in a +body+ context. As a result, the +html+, +head+, and +body+ elements are removed from
+#   this document, and any children of these elements that remain are returned as a
+#   Nokogiri::HTML5::DocumentFragment; but you can pass in a different context (e.g., "html" to
+#   get +head+ and +body+ tags in the result).
 #
-# * The {Nokogiri::HTML5.parse} function takes a string and passes it to the
-#   <code>gumbo_parse_with_options</code> method, using the default options.
-#   The resulting Gumbo parse tree is then walked.
+# * The Nokogiri::HTML5.parse function takes a String or IO and passes it to the
+#   <code>gumbo_parse_with_options</code> method, using the default options.  The resulting Gumbo
+#   parse tree is then walked.
 #
 # * Instead of uppercase element names, lowercase element names are produced.
 #
-# * Instead of returning +unknown+ as the element name for unknown tags, the
-#   original tag name is returned verbatim.
+# * Instead of returning +unknown+ as the element name for unknown tags, the original tag name is
+#   returned verbatim.
 #
 # Since v1.12.0
 #
 # source://nokogiri//lib/nokogiri/html5/document.rb#23
 module Nokogiri::HTML5
   class << self
-    # Parse a fragment from +string+. Convenience method for
-    # {Nokogiri::HTML5::DocumentFragment.parse}.
+    # Convenience method for Nokogiri::HTML5::DocumentFragment.parse
     #
-    # source://nokogiri//lib/nokogiri/html5.rb#238
-    def fragment(string, encoding = T.unsafe(nil), **options); end
+    # source://nokogiri//lib/nokogiri/html5.rb#280
+    def fragment(*_arg0, **_arg1, &_arg2); end
 
-    # Parse an HTML 5 document. Convenience method for {Nokogiri::HTML5::Document.parse}
+    # Convenience method for Nokogiri::HTML5::Document.parse
     #
-    # source://nokogiri//lib/nokogiri/html5.rb#232
-    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
+    # source://nokogiri//lib/nokogiri/html5.rb#275
+    def parse(*_arg0, **_arg1, &_arg2); end
 
-    # source://nokogiri//lib/nokogiri/html5.rb#243
+    # source://nokogiri//lib/nokogiri/html5.rb#285
     def read_and_encode(string, encoding); end
 
     private
 
     # Charset sniffing is a complex and controversial topic that understandably isn't done _by
-    # default_ by the Ruby Net::HTTP library.  This being said, it is a very real problem for
+    # default_ by the Ruby Net::HTTP library. This being said, it is a very real problem for
     # consumers of HTML as the default for HTML is iso-8859-1, most "good" producers use utf-8, and
     # the Gumbo parser *only* supports utf-8.
     #
-    # Accordingly, Nokogiri::HTML4::Document.parse provides limited encoding detection.  Following
+    # Accordingly, Nokogiri::HTML4::Document.parse provides limited encoding detection. Following
     # this lead, Nokogiri::HTML5 attempts to do likewise, while attempting to more closely follow
     # the HTML5 standard.
     #
     # http://bugs.ruby-lang.org/issues/2567
     # http://www.w3.org/TR/html5/syntax.html#determining-the-character-encoding
     #
-    # source://nokogiri//lib/nokogiri/html5.rb#281
+    # source://nokogiri//lib/nokogiri/html5.rb#323
     def reencode(body, content_type = T.unsafe(nil)); end
   end
 end
 
+# Nokogiri HTML5 builder is used for building HTML documents. It is very similar to the
+# Nokogiri::XML::Builder.  In fact, you should go read the documentation for
+# Nokogiri::XML::Builder before reading this documentation.
+#
+# The construction behavior is identical to HTML4::Builder, but HTML5 documents implement the
+# [HTML5 standard's serialization
+# algorithm](https://www.w3.org/TR/2008/WD-html5-20080610/serializing.html).
+#
+# == Synopsis:
+#
+# Create an HTML5 document with a body that has an onload attribute, and a
+# span tag with a class of "bold" that has content of "Hello world".
+#
+#   builder = Nokogiri::HTML5::Builder.new do |doc|
+#     doc.html {
+#       doc.body(:onload => 'some_func();') {
+#         doc.span.bold {
+#           doc.text "Hello world"
+#         }
+#       }
+#     }
+#   end
+#   puts builder.to_html
+#
+# The HTML5 builder inherits from the XML builder, so make sure to read the
+# Nokogiri::XML::Builder documentation.
+#
+# source://nokogiri//lib/nokogiri/html5/builder.rb#34
+class Nokogiri::HTML5::Builder < ::Nokogiri::XML::Builder
+  # Convert the builder to HTML
+  #
+  # source://nokogiri//lib/nokogiri/html5/builder.rb#35
+  def to_html; end
+end
+
 # Since v1.12.0
 #
 # 💡 HTML5 functionality is not available when running JRuby.
@@ -1841,7 +2034,7 @@ end
 class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
   # @return [Document] a new instance of Document
   #
-  # source://nokogiri//lib/nokogiri/html5/document.rb#129
+  # source://nokogiri//lib/nokogiri/html5/document.rb#159
   def initialize(*args); end
 
   # :call-seq:
@@ -1854,21 +2047,22 @@ class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
   # - +markup+ (String) The HTML5 markup fragment to be parsed
   #
   # [Returns]
-  #   Nokogiri::HTML5::DocumentFragment. This object's children will be empty if `markup` is not passed, is empty, or is `nil`.
+  #   Nokogiri::HTML5::DocumentFragment. This object's children will be empty if +markup+ is not
+  #   passed, is empty, or is +nil+.
   #
-  # source://nokogiri//lib/nokogiri/html5/document.rb#147
+  # source://nokogiri//lib/nokogiri/html5/document.rb#178
   def fragment(markup = T.unsafe(nil)); end
 
   # Get the parser's quirks mode value. See HTML5::QuirksMode.
   #
-  # This method returns `nil` if the parser was not invoked (e.g., `Nokogiri::HTML5::Document.new`).
+  # This method returns +nil+ if the parser was not invoked (e.g., Nokogiri::HTML5::Document.new).
   #
   # Since v1.14.0
   #
   # source://nokogiri//lib/nokogiri/html5/document.rb#49
   def quirks_mode; end
 
-  # source://nokogiri//lib/nokogiri/html5/document.rb#151
+  # source://nokogiri//lib/nokogiri/html5/document.rb#182
   def to_xml(options = T.unsafe(nil), &block); end
 
   # Get the url name for this document, as passed into Document.parse, Document.read_io, or
@@ -1884,42 +2078,60 @@ class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
   #
   # See CSS::XPathVisitor for more information.
   #
-  # source://nokogiri//lib/nokogiri/html5/document.rb#163
+  # source://nokogiri//lib/nokogiri/html5/document.rb#194
   def xpath_doctype; end
 
   class << self
     # :call-seq:
-    #   parse(input)
-    #   parse(input, url=nil, encoding=nil, **options)
-    #   parse(input, url=nil, encoding=nil) { |options| ... }
+    #   parse(input) { |options| ... } → HTML5::Document
+    #   parse(input, **options) → HTML5::Document
     #
-    # Parse HTML5 input.
+    # Parse \HTML input with a parser compliant with the HTML5 spec. This method uses the
+    # parameter.
     #
-    # [Parameters]
-    # - +input+ may be a String, or any object that responds to _read_ and _close_ such as an
-    #   IO, or StringIO.
+    # [Required Parameters]
+    # - +input+ (String | IO) the \HTML content to be parsed.
+    #
+    # [Optional Parameters]
+    # - +url:+ (String) the base URI of the document.
+    #
+    # [Optional Keyword Arguments]
+    #   document. When not provided, the encoding will be determined based on the document
+    #   content.
+    #
+    # - +max_errors:+ (Integer) The maximum number of parse errors to record. (default
+    #   +Nokogiri::Gumbo::DEFAULT_MAX_ERRORS+ which is currently 0)
     #
-    # - +url+ (optional) is a String indicating the canonical URI where this document is located.
+    # - +max_tree_depth:+ (Integer) The maximum depth of the parse tree. (default
+    #   +Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH+)
     #
-    # - +encoding+ (optional) is the encoding that should be used when processing
-    #   the document.
+    # - +max_attributes:+ (Integer) The maximum number of attributes allowed on an
+    #   element. (default +Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES+)
     #
-    # - +options+ (optional) is a configuration Hash (or keyword arguments) to set options
-    #   during parsing. The three currently supported options are +:max_errors+,
-    #   +:max_tree_depth+ and +:max_attributes+, described at Nokogiri::HTML5.
+    # - +parse_noscript_content_as_text:+ (Boolean) Whether to parse the content of +noscript+
+    #   elements as text. (default +false+)
     #
-    #   ⚠ Note that these options are different than those made available by
-    #   Nokogiri::XML::Document and Nokogiri::HTML4::Document.
+    # See rdoc-ref:HTML5@Parsing+options for a complete description of these parsing options.
+    #
+    # [Yields]
+    #   If present, the block will be passed a Hash object to modify with parse options before the
+    #   input is parsed. See rdoc-ref:HTML5@Parsing+options for a list of available options.
     #
-    # - +block+ (optional) is passed a configuration Hash on which parse options may be set. See
-    #   Nokogiri::HTML5 for more information and usage.
     #
     # [Returns] Nokogiri::HTML5::Document
     #
+    # *Example:* Parse a string with a specific encoding and custom max errors limit.
+    #
+    #
+    # *Example:* Parse a string setting the +:parse_noscript_content_as_text+ option using the
+    # configuration block parameter.
+    #
+    #   Nokogiri::HTML5::Document.parse(input) { |c| c[:parse_noscript_content_as_text] = true }
+    #
     # @yield [options]
     #
-    # source://nokogiri//lib/nokogiri/html5/document.rb#80
-    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
+    # source://nokogiri//lib/nokogiri/html5/document.rb#103
+    def parse(string_or_io, url_ = T.unsafe(nil), encoding_ = T.unsafe(nil), url: T.unsafe(nil), encoding: T.unsafe(nil), **options, &block); end
 
     # Create a new document from an IO object.
     #
@@ -1927,8 +2139,8 @@ class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
     #
     # @raise [ArgumentError]
     #
-    # source://nokogiri//lib/nokogiri/html5/document.rb#101
-    def read_io(io, url = T.unsafe(nil), encoding = T.unsafe(nil), **options); end
+    # source://nokogiri//lib/nokogiri/html5/document.rb#129
+    def read_io(io, url_ = T.unsafe(nil), encoding_ = T.unsafe(nil), url: T.unsafe(nil), encoding: T.unsafe(nil), **options); end
 
     # Create a new document from a String.
     #
@@ -1936,13 +2148,13 @@ class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
     #
     # @raise [ArgumentError]
     #
-    # source://nokogiri//lib/nokogiri/html5/document.rb#110
-    def read_memory(string, url = T.unsafe(nil), encoding = T.unsafe(nil), **options); end
+    # source://nokogiri//lib/nokogiri/html5/document.rb#138
+    def read_memory(string, url_ = T.unsafe(nil), encoding_ = T.unsafe(nil), url: T.unsafe(nil), encoding: T.unsafe(nil), **options); end
 
     private
 
-    # source://nokogiri//lib/nokogiri/html5/document.rb#118
-    def do_parse(string_or_io, url, encoding, options); end
+    # source://nokogiri//lib/nokogiri/html5/document.rb#146
+    def do_parse(string_or_io, url, encoding, **options); end
   end
 end
 
@@ -1952,57 +2164,136 @@ end
 #
 # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#27
 class Nokogiri::HTML5::DocumentFragment < ::Nokogiri::HTML4::DocumentFragment
-  # Create a document fragment.
+  # :call-seq:
+  #   new(document, input, **options) → HTML5::DocumentFragment
+  #
+  # Parse \HTML5 fragment input from a String, and return a new HTML5::DocumentFragment.
+  #
+  # 💡 It's recommended to use either HTML5::DocumentFragment.parse or HTML5::Node#fragment
+  # rather than call this method directly.
+  #
+  # [Required Parameters]
+  # - +document+ (HTML5::Document) The parent document to associate the returned fragment with.
+  #
+  # [Optional Parameters]
+  # - +input+ (String) The content to be parsed.
+  #
+  # [Optional Keyword Arguments]
+  #   used when processing the document. When not provided, the encoding will be determined
+  #   based on the document content. Also see Nokogiri::HTML5 for a longer explanation of how
+  #   encoding is handled by the parser.
+  #
+  # - +context:+ (String | Nokogiri::XML::Node) The node, or the name of an HTML5 element, in
+  #   which to parse the document fragment. (default +"body"+)
+  #
+  # - +max_errors:+ (Integer) The maximum number of parse errors to record. (default
+  #   +Nokogiri::Gumbo::DEFAULT_MAX_ERRORS+ which is currently 0)
+  #
+  # - +max_tree_depth:+ (Integer) The maximum depth of the parse tree. (default
+  #   +Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH+)
+  #
+  # - +max_attributes:+ (Integer) The maximum number of attributes allowed on an
+  #   element. (default +Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES+)
+  #
+  # - +parse_noscript_content_as_text:+ (Boolean) Whether to parse the content of +noscript+
+  #   elements as text. (default +false+)
+  #
+  # See rdoc-ref:HTML5@Parsing+options for a complete description of these parsing options.
+  #
+  # [Returns] HTML5::DocumentFragment
+  #
+  # === Context \Node
+  #
+  # If a context node is specified using +context:+, then the parser will behave as if that
+  # Node, or a hypothetical tag named as specified, is the parent of the fragment subtree.
   #
   # @return [DocumentFragment] a new instance of DocumentFragment
   #
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#39
-  def initialize(doc, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#144
+  def initialize(doc, input = T.unsafe(nil), context_ = T.unsafe(nil), positional_options_hash = T.unsafe(nil), context: T.unsafe(nil), **options); end
 
   # Returns the value of attribute document.
   #
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#28
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#88
   def document; end
 
   # Sets the attribute document
   #
   # @param value the value to set the attribute document to.
   #
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#28
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#88
   def document=(_arg0); end
 
   # Returns the value of attribute errors.
   #
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#29
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#89
   def errors; end
 
   # Sets the attribute errors
   #
   # @param value the value to set the attribute errors to.
   #
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#29
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#89
   def errors=(_arg0); end
 
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#65
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#175
   def extract_params(params); end
 
   # Get the parser's quirks mode value. See HTML5::QuirksMode.
   #
-  # This method returns `nil` if the parser was not invoked (e.g., `Nokogiri::HTML5::DocumentFragment.new(doc)`).
+  # This method returns `nil` if the parser was not invoked (e.g.,
+  # `Nokogiri::HTML5::DocumentFragment.new(doc)`).
   #
   # Since v1.14.0
   #
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#36
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#97
   def quirks_mode; end
 
-  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#51
+  # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#169
   def serialize(options = T.unsafe(nil), &block); end
 
   class << self
-    # Parse a document fragment from +tags+, returning a Nodeset.
+    # :call-seq:
+    #   parse(input, **options) → HTML5::DocumentFragment
+    #
+    # Parse \HTML5 fragment input from a String, and return a new HTML5::DocumentFragment. This
+    # method creates a new, empty HTML5::Document to contain the fragment.
+    #
+    # [Parameters]
+    # - +input+ (String | IO) The HTML5 document fragment to parse.
+    #
+    # [Optional Keyword Arguments]
+    #   used when processing the document. When not provided, the encoding will be determined
+    #   based on the document content. Also see Nokogiri::HTML5 for a longer explanation of how
+    #   encoding is handled by the parser.
+    #
+    # - +context:+ (String | Nokogiri::XML::Node) The node, or the name of an HTML5 element, "in
+    #   context" of which to parse the document fragment. See below for more
+    #   information. (default +"body"+)
+    #
+    # - +max_errors:+ (Integer) The maximum number of parse errors to record. (default
+    #   +Nokogiri::Gumbo::DEFAULT_MAX_ERRORS+ which is currently 0)
+    #
+    # - +max_tree_depth:+ (Integer) The maximum depth of the parse tree. (default
+    #   +Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH+)
+    #
+    # - +max_attributes:+ (Integer) The maximum number of attributes allowed on an
+    #   element. (default +Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES+)
+    #
+    # - +parse_noscript_content_as_text:+ (Boolean) Whether to parse the content of +noscript+
+    #   elements as text. (default +false+)
     #
-    # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#58
-    def parse(tags, encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    # See rdoc-ref:HTML5@Parsing+options for a complete description of these parsing options.
+    #
+    # [Returns] Nokogiri::HTML5::DocumentFragment
+    #
+    # === Context \Node
+    #
+    # If a context node is specified using +context:+, then the parser will behave as if that
+    # Node, or a hypothetical tag named as specified, is the parent of the fragment subtree.
+    #
+    # source://nokogiri//lib/nokogiri/html5/document_fragment.rb#69
+    def parse(input, encoding_ = T.unsafe(nil), positional_options_hash = T.unsafe(nil), encoding: T.unsafe(nil), **options); end
   end
 end
 
@@ -2065,6 +2356,7 @@ Nokogiri::LIBXML_COMPILED_VERSION = T.let(T.unsafe(nil), String)
 Nokogiri::LIBXML_ICONV_ENABLED = T.let(T.unsafe(nil), TrueClass)
 Nokogiri::LIBXML_LOADED_VERSION = T.let(T.unsafe(nil), String)
 Nokogiri::LIBXML_MEMORY_MANAGEMENT = T.let(T.unsafe(nil), String)
+Nokogiri::LIBXML_ZLIB_ENABLED = T.let(T.unsafe(nil), TrueClass)
 Nokogiri::LIBXSLT_COMPILED_VERSION = T.let(T.unsafe(nil), String)
 Nokogiri::LIBXSLT_DATETIME_ENABLED = T.let(T.unsafe(nil), TrueClass)
 Nokogiri::LIBXSLT_LOADED_VERSION = T.let(T.unsafe(nil), String)
@@ -2172,38 +2464,41 @@ class Nokogiri::VersionInfo
   end
 end
 
-# source://nokogiri//lib/nokogiri/xml.rb#12
+# source://nokogiri//lib/nokogiri/xml.rb#11
 module Nokogiri::XML
   class << self
-    # Parse an XML document using the Nokogiri::XML::Reader API.  See
-    # Nokogiri::XML::Reader for mor information
+    # Convenience method for Nokogiri::XML::Reader.new
     #
-    # @yield [options]
-    #
-    # source://nokogiri//lib/nokogiri/xml.rb#23
-    def Reader(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/xml.rb#21
+    def Reader(*_arg0, **_arg1, &_arg2); end
 
-    # Create a new Nokogiri::XML::RelaxNG document from +string_or_io+.
-    # See Nokogiri::XML::RelaxNG for an example.
+    # :call-seq:
+    #   RelaxNG(input) → Nokogiri::XML::RelaxNG
+    #   RelaxNG(input, options:) → Nokogiri::XML::RelaxNG
+    #
+    # Convenience method for Nokogiri::XML::RelaxNG.new
     #
-    # source://nokogiri//lib/nokogiri/xml/relax_ng.rb#9
-    def RelaxNG(string_or_io, options = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/xml/relax_ng.rb#11
+    def RelaxNG(*_arg0, **_arg1, &_arg2); end
 
-    # Create a new Nokogiri::XML::Schema object using a +string_or_io+
-    # object.
+    # :call-seq:
+    #   Schema(input) → Nokogiri::XML::Schema
+    #   Schema(input, parse_options) → Nokogiri::XML::Schema
+    #
+    # Convenience method for Nokogiri::XML::Schema.new
     #
-    # source://nokogiri//lib/nokogiri/xml/schema.rb#9
-    def Schema(string_or_io, options = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/xml/schema.rb#11
+    def Schema(*_arg0, **_arg1, &_arg2); end
 
-    # Parse a fragment from +string+ in to a NodeSet.
+    # Convenience method for Nokogiri::XML::DocumentFragment.parse
     #
-    # source://nokogiri//lib/nokogiri/xml.rb#42
-    def fragment(string, options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/xml.rb#31
+    def fragment(*_arg0, **_arg1, &_arg2); end
 
-    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+    # Convenience method for Nokogiri::XML::Document.parse
     #
-    # source://nokogiri//lib/nokogiri/xml.rb#36
-    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    # source://nokogiri//lib/nokogiri/xml.rb#26
+    def parse(*_arg0, **_arg1, &_arg2); end
   end
 end
 
@@ -2729,28 +3024,40 @@ class Nokogiri::XML::DTD < ::Nokogiri::XML::Node
   def validate(_arg0); end
 end
 
-# Nokogiri::XML::Document is the main entry point for dealing with XML documents.  The Document
-# is created by parsing an XML document.  See Nokogiri::XML::Document.parse for more information
-# on parsing.
+# Nokogiri::XML::Document is the main entry point for dealing with \XML documents. The Document
+# is created by parsing \XML content from a String or an IO object. See
+# Nokogiri::XML::Document.parse for more information on parsing.
 #
-# For searching a Document, see Nokogiri::XML::Searchable#css and
-# Nokogiri::XML::Searchable#xpath
+# Document inherits a great deal of functionality from its superclass Nokogiri::XML::Node, so
+# please read that class's documentation as well.
 #
 # source://nokogiri//lib/nokogiri/xml/document.rb#17
 class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   # @return [Document] a new instance of Document
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#177
+  # source://nokogiri//lib/nokogiri/xml/document.rb#190
   def initialize(*args); end
 
-  # source://nokogiri//lib/nokogiri/xml/document.rb#393
+  # source://nokogiri//lib/nokogiri/xml/document.rb#437
   def <<(node_or_tags); end
 
-  # source://nokogiri//lib/nokogiri/xml/document.rb#393
+  # source://nokogiri//lib/nokogiri/xml/document.rb#437
   def add_child(node_or_tags); end
 
   def canonicalize(*_arg0); end
-  def clone(*_arg0); end
+
+  # :call-seq:
+  #   clone → Nokogiri::XML::Document
+  #   clone(level) → Nokogiri::XML::Document
+  #
+  # Clone this node.
+  #
+  # [Parameters]
+  # - +level+ (optional Integer). 0 is a shallow copy, 1 (the default) is a deep copy.
+  # [Returns] The new Nokogiri::XML::Document
+  #
+  # source://nokogiri//lib/nokogiri/xml/document.rb#223
+  def clone(level = T.unsafe(nil)); end
 
   # :call-seq:
   #   collect_namespaces() → Hash<String(Namespace#prefix) ⇒ String(Namespace#href)>
@@ -2788,17 +3095,17 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   #   {"xmlns:foo" => "baz"}
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#316
+  # source://nokogiri//lib/nokogiri/xml/document.rb#361
   def collect_namespaces; end
 
   # Create a CDATA Node containing +string+
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#261
+  # source://nokogiri//lib/nokogiri/xml/document.rb#306
   def create_cdata(string, &block); end
 
   # Create a Comment Node containing +string+
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#266
+  # source://nokogiri//lib/nokogiri/xml/document.rb#311
   def create_comment(string, &block); end
 
   # :call-seq:
@@ -2849,14 +3156,14 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   #   doc.create_element("div") { |node| node["class"] = "blue" if before_noon? }
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#231
+  # source://nokogiri//lib/nokogiri/xml/document.rb#276
   def create_element(name, *contents_or_attrs, &block); end
 
   def create_entity(*_arg0); end
 
   # Create a Text Node with +string+
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#256
+  # source://nokogiri//lib/nokogiri/xml/document.rb#301
   def create_text_node(string, &block); end
 
   # :call-seq: deconstruct_keys(array_of_names) → Hash
@@ -2898,25 +3205,37 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   #  Since v1.14.0
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#457
+  # source://nokogiri//lib/nokogiri/xml/document.rb#501
   def deconstruct_keys(keys); end
 
   # Apply any decorators to +node+
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#364
+  # source://nokogiri//lib/nokogiri/xml/document.rb#409
   def decorate(node); end
 
   # Get the list of decorators given +key+
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#323
+  # source://nokogiri//lib/nokogiri/xml/document.rb#368
   def decorators(key); end
 
   # A reference to +self+
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#276
+  # source://nokogiri//lib/nokogiri/xml/document.rb#321
   def document; end
 
-  def dup(*_arg0); end
+  # :call-seq:
+  #   dup → Nokogiri::XML::Document
+  #   dup(level) → Nokogiri::XML::Document
+  #
+  # Duplicate this node.
+  #
+  # [Parameters]
+  # - +level+ (optional Integer). 0 is a shallow copy, 1 (the default) is a deep copy.
+  # [Returns] The new Nokogiri::XML::Document
+  #
+  # source://nokogiri//lib/nokogiri/xml/document.rb#207
+  def dup(level = T.unsafe(nil)); end
+
   def encoding; end
   def encoding=(_arg0); end
 
@@ -2924,25 +3243,25 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   # [Returns] Array<Nokogiri::XML::SyntaxError>
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#128
+  # source://nokogiri//lib/nokogiri/xml/document.rb#141
   def errors; end
 
   # The errors found while parsing a document.
   #
   # [Returns] Array<Nokogiri::XML::SyntaxError>
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#128
+  # source://nokogiri//lib/nokogiri/xml/document.rb#141
   def errors=(_arg0); end
 
   # Create a Nokogiri::XML::DocumentFragment from +tags+
   # Returns an empty fragment if +tags+ is nil.
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#385
+  # source://nokogiri//lib/nokogiri/xml/document.rb#429
   def fragment(tags = T.unsafe(nil)); end
 
   # The name of this document.  Always returns "document"
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#271
+  # source://nokogiri//lib/nokogiri/xml/document.rb#316
   def name; end
 
   # When `true`, reparented elements without a namespace will inherit their new parent's
@@ -2991,7 +3310,7 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   # Since v1.12.4
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#175
+  # source://nokogiri//lib/nokogiri/xml/document.rb#188
   def namespace_inheritance; end
 
   # When `true`, reparented elements without a namespace will inherit their new parent's
@@ -3040,12 +3359,12 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   # Since v1.12.4
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#175
+  # source://nokogiri//lib/nokogiri/xml/document.rb#188
   def namespace_inheritance=(_arg0); end
 
   # Get the hash of namespaces on the root Nokogiri::XML::Node
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#378
+  # source://nokogiri//lib/nokogiri/xml/document.rb#422
   def namespaces; end
 
   def remove_namespaces!; end
@@ -3067,18 +3386,18 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #   irb> doc.slop!
   #   ... which does absolutely nothing.
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#353
+  # source://nokogiri//lib/nokogiri/xml/document.rb#398
   def slop!; end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1286
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1364
   def to_xml(*args, &block); end
 
   def url; end
 
-  # Validate this Document against it's DTD.  Returns a list of errors on
+  # Validate this Document against its DTD.  Returns a list of errors on
   # the document or +nil+ when there is no DTD.
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#331
+  # source://nokogiri//lib/nokogiri/xml/document.rb#376
   def validate; end
 
   def version; end
@@ -3090,46 +3409,53 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
   #
   # See XPathVisitor for more information.
   #
-  # source://nokogiri//lib/nokogiri/xml/document.rb#413
+  # source://nokogiri//lib/nokogiri/xml/document.rb#457
   def xpath_doctype; end
 
+  protected
+
+  def initialize_copy_with_args(_arg0, _arg1); end
+
   private
 
-  # source://nokogiri//lib/nokogiri/xml/document.rb#465
+  # source://nokogiri//lib/nokogiri/xml/document.rb#509
   def inspect_attributes; end
 
   class << self
     def new(*_arg0); end
 
-    # Parse an XML file.
+    # call-seq:
+    #   parse(input) { |options| ... } => Nokogiri::XML::Document
+    #
+    # Parse \XML input from a String or IO object, and return a new XML::Document.
     #
-    # +string_or_io+ may be a String, or any object that responds to
-    # _read_ and _close_ such as an IO, or StringIO.
+    # 🛡 By default, Nokogiri treats documents as untrusted, and so does not attempt to load DTDs
+    # or access the network. See Nokogiri::XML::ParseOptions for a complete list of options; and
+    # that module's DEFAULT_XML constant for what's set (and not set) by default.
     #
-    # +url+ (optional) is the URI where this document is located.
+    # [Required Parameters]
+    # - +input+ (String | IO) The content to be parsed.
     #
-    # +encoding+ (optional) is the encoding that should be used when processing
-    # the document.
+    # [Optional Keyword Arguments]
+    # - +url:+ (String) The base URI for this document.
     #
-    # +options+ (optional) is a configuration object that sets options during
-    # parsing, such as Nokogiri::XML::ParseOptions::RECOVER. See the
-    # Nokogiri::XML::ParseOptions for more information.
+    #   document. When not provided, the encoding will be determined based on the document
+    #   content.
     #
-    # +block+ (optional) is passed a configuration object on which
-    # parse options may be set.
+    # - +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+    #   behaviors during parsing. See ParseOptions for more information. The default value is
+    #   +ParseOptions::DEFAULT_XML+.
     #
-    # By default, Nokogiri treats documents as untrusted, and so
-    # does not attempt to load DTDs or access the network. See
-    # Nokogiri::XML::ParseOptions for a complete list of options;
-    # and that module's DEFAULT_XML constant for what's set (and not
-    # set) by default.
+    # [Yields]
+    #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+    #   can be configured before parsing. See Nokogiri::XML::ParseOptions for more information.
     #
-    # Nokogiri.XML() is a convenience method which will call this method.
+    # [Returns] Nokogiri::XML::Document
     #
     # @yield [options]
     #
-    # source://nokogiri//lib/nokogiri/xml/document.rb#48
-    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
+    # source://nokogiri//lib/nokogiri/xml/document.rb#56
+    def parse(string_or_io, url_ = T.unsafe(nil), encoding_ = T.unsafe(nil), options_ = T.unsafe(nil), url: T.unsafe(nil), encoding: T.unsafe(nil), options: T.unsafe(nil)); end
 
     def read_io(_arg0, _arg1, _arg2, _arg3); end
     def read_memory(_arg0, _arg1, _arg2, _arg3); end
@@ -3138,12 +3464,12 @@ class Nokogiri::XML::Document < ::Nokogiri::XML::Node
 
     # @return [Boolean]
     #
-    # source://nokogiri//lib/nokogiri/xml/document.rb#83
+    # source://nokogiri//lib/nokogiri/xml/document.rb#96
     def empty_doc?(string_or_io); end
   end
 end
 
-# source://nokogiri//lib/nokogiri/xml/document.rb#463
+# source://nokogiri//lib/nokogiri/xml/document.rb#507
 Nokogiri::XML::Document::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
 
 # source://nokogiri//lib/nokogiri/xml/document.rb#19
@@ -3159,19 +3485,58 @@ Nokogiri::XML::Document::NCNAME_RE = T.let(T.unsafe(nil), Regexp)
 # source://nokogiri//lib/nokogiri/xml/document.rb#18
 Nokogiri::XML::Document::NCNAME_START_CHAR = T.let(T.unsafe(nil), String)
 
-# source://nokogiri//lib/nokogiri/xml/document_fragment.rb#8
+# source://nokogiri//lib/nokogiri/xml/document.rb#23
+Nokogiri::XML::Document::OBJECT_CLONE_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://nokogiri//lib/nokogiri/xml/document.rb#22
+Nokogiri::XML::Document::OBJECT_DUP_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# DocumentFragment represents a fragment of an \XML document. It provides the same functionality
+# exposed by XML::Node and can be used to contain one or more \XML subtrees.
+#
+# source://nokogiri//lib/nokogiri/xml/document_fragment.rb#11
 class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
-  # Create a new DocumentFragment from +tags+.
+  # :call-seq:
+  #   new(document, input=nil) { |options| ... } → DocumentFragment
+  #   new(document, input=nil, context:, options:) → DocumentFragment
+  #
+  # Parse \XML fragment input from a String, and return a new DocumentFragment that is
+  # associated with the given +document+.
+  #
+  # 💡 It's recommended to use either XML::DocumentFragment.parse or Node#parse rather than call
+  # this method directly.
+  #
+  # [Required Parameters]
+  # - +document+ (XML::Document) The parent document to associate the returned fragment with.
+  #
+  # [Optional Parameters]
+  # - +input+ (String) The content to be parsed.
+  #
+  # [Optional Keyword Arguments]
+  # - +context:+ (Nokogiri::XML::Node) The <b>context node</b> for the subtree created. See
+  #   below for more information.
+  #
+  # - +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+  #   behaviors during parsing. See ParseOptions for more information. The default value is
+  #   +ParseOptions::DEFAULT_XML+.
+  #
+  # [Yields]
+  #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+  #   can be configured before parsing. See ParseOptions for more information.
+  #
+  # [Returns] XML::DocumentFragment
+  #
+  # === Context \Node
   #
-  #  If +ctx+ is present, it is used as a context node for the
-  #  subtree created, e.g., namespaces will be resolved relative
-  #  to +ctx+.
+  # If a context node is specified using +context:+, then the fragment will be created by
+  # calling Node#parse on that node, so the parser will behave as if that Node is the parent of
+  # the fragment subtree, and will resolve namespaces relative to that node.
   #
   # @return [DocumentFragment] a new instance of DocumentFragment
   # @yield [options]
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#19
-  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#85
+  def initialize(document, tags = T.unsafe(nil), context_ = T.unsafe(nil), options_ = T.unsafe(nil), context: T.unsafe(nil), options: T.unsafe(nil)); end
 
   # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
   #
@@ -3180,7 +3545,7 @@ class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
   #
   # For more information see Nokogiri::XML::Searchable#css
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#102
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#173
   def css(*args); end
 
   # :call-seq: deconstruct() → Array
@@ -3224,79 +3589,112 @@ class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
   #
   #  Since v1.14.0
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#190
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#261
   def deconstruct; end
 
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#42
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#113
   def dup; end
 
   # A list of Nokogiri::XML::SyntaxError found when parsing a document
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#136
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#207
   def errors; end
 
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#140
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#211
   def errors=(things); end
 
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#144
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#215
   def fragment(data); end
 
   # return the name for DocumentFragment
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#54
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#125
   def name; end
 
+  # The options used to parse the document fragment. Returns the value of any options that were
+  # passed into the constructor as a parameter or set in a config block, else the default
+  # options for the specific subclass.
+  #
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#12
+  def parse_options; end
+
   # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
   #
   # Search this fragment for +paths+. +paths+ must be one or more XPath or CSS queries.
   #
   # For more information see Nokogiri::XML::Searchable#search
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#121
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#192
   def search(*rules); end
 
   # Convert this DocumentFragment to a string
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#60
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#131
   def serialize; end
 
   # Convert this DocumentFragment to html
   # See Nokogiri::XML::NodeSet#to_html
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#67
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#138
   def to_html(*args); end
 
   # Convert this DocumentFragment to a string
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#60
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#131
   def to_s; end
 
   # Convert this DocumentFragment to xhtml
   # See Nokogiri::XML::NodeSet#to_xhtml
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#79
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#150
   def to_xhtml(*args); end
 
   # Convert this DocumentFragment to xml
   # See Nokogiri::XML::NodeSet#to_xml
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#91
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#162
   def to_xml(*args); end
 
   private
 
   # fix for issue 770
   #
-  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#197
+  # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#268
   def namespace_declarations(ctx); end
 
   class << self
-    def new(*_arg0); end
+    def native_new(_arg0); end
 
-    # Create a Nokogiri::XML::DocumentFragment from +tags+
+    # Wrapper method to separate the concerns of:
+    # - the native object allocator's parameter (it only requires `document`)
+    # - the initializer's parameters
+    #
+    # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#42
+    def new(document, *_arg1, **_arg2, &_arg3); end
+
+    # :call-seq:
+    #   parse(input) { |options| ... } → XML::DocumentFragment
+    #   parse(input, options:) → XML::DocumentFragment
+    #
+    # Parse \XML fragment input from a String, and return a new XML::DocumentFragment. This
+    # method creates a new, empty XML::Document to contain the fragment.
     #
-    # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#9
-    def parse(tags, options = T.unsafe(nil), &block); end
+    # [Required Parameters]
+    # - +input+ (String) The content to be parsed.
+    #
+    # [Optional Keyword Arguments]
+    # - +options+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+    #   behaviors during parsing. See ParseOptions for more information. The default value is
+    #   +ParseOptions::DEFAULT_XML+.
+    #
+    # [Yields]
+    #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+    #   can be configured before parsing. See Nokogiri::XML::ParseOptions for more information.
+    #
+    # [Returns] Nokogiri::XML::DocumentFragment
+    #
+    # source://nokogiri//lib/nokogiri/xml/document_fragment.rb#35
+    def parse(tags, options_ = T.unsafe(nil), options: T.unsafe(nil), &block); end
   end
 end
 
@@ -3566,18 +3964,18 @@ class Nokogiri::XML::Node
   #
   # Also see related method +add_child+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#256
+  # source://nokogiri//lib/nokogiri/xml/node.rb#292
   def <<(node_or_tags); end
 
   # Compare two Node objects with respect to their Document.  Nodes from
   # different documents cannot be compared.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1262
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1340
   def <=>(other); end
 
   # Test to see if this Node is equal to +other+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1252
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1330
   def ==(other); end
 
   # :call-seq: [](name) → (String, nil)
@@ -3610,7 +4008,7 @@ class Nokogiri::XML::Node
   #   doc.at_css("child").attribute_with_ns("size", "http://example.com/widths").value
   #   # => "broad"
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#512
+  # source://nokogiri//lib/nokogiri/xml/node.rb#587
   def [](name); end
 
   # :call-seq: []=(name, value) → value
@@ -3647,12 +4045,12 @@ class Nokogiri::XML::Node
   #   #    "  <child width:size=\"broad\"></child>\n" +
   #   #    "</root>\n"
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#550
+  # source://nokogiri//lib/nokogiri/xml/node.rb#625
   def []=(name, value); end
 
   # Accept a visitor.  This method calls "visit" on +visitor+ with self.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1246
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1324
   def accept(visitor); end
 
   # Add +node_or_tags+ as a child of this Node.
@@ -3665,7 +4063,7 @@ class Nokogiri::XML::Node
   #
   # Also see related method +<<+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#148
+  # source://nokogiri//lib/nokogiri/xml/node.rb#184
   def add_child(node_or_tags); end
 
   # :call-seq: add_class(names) → self
@@ -3709,7 +4107,7 @@ class Nokogiri::XML::Node
   #   node                                  # => <div></div>
   #   node.add_class(["section", "header"]) # => <div class="section header"></div>
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#715
+  # source://nokogiri//lib/nokogiri/xml/node.rb#790
   def add_class(names); end
 
   def add_namespace(_arg0, _arg1); end
@@ -3727,7 +4125,7 @@ class Nokogiri::XML::Node
   #
   # @raise [ArgumentError]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#288
+  # source://nokogiri//lib/nokogiri/xml/node.rb#324
   def add_next_sibling(node_or_tags); end
 
   # Insert +node_or_tags+ before this Node (as a sibling).
@@ -3742,7 +4140,7 @@ class Nokogiri::XML::Node
   #
   # @raise [ArgumentError]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#271
+  # source://nokogiri//lib/nokogiri/xml/node.rb#307
   def add_previous_sibling(node_or_tags); end
 
   # Insert +node_or_tags+ after this node (as a sibling).
@@ -3754,13 +4152,13 @@ class Nokogiri::XML::Node
   #
   # Also see related method +add_next_sibling+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#318
+  # source://nokogiri//lib/nokogiri/xml/node.rb#354
   def after(node_or_tags); end
 
   # Get a list of ancestor Node for this Node.  If +selector+ is given,
   # the ancestors must match +selector+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1215
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1293
   def ancestors(selector = T.unsafe(nil)); end
 
   # :call-seq: append_class(names) → self
@@ -3802,7 +4200,7 @@ class Nokogiri::XML::Node
   #   node.append_class(["section", "header"]) # => <div class="section header"></div>
   #   node.append_class(["section", "header"]) # => <div class="section header section header"></div>
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#759
+  # source://nokogiri//lib/nokogiri/xml/node.rb#834
   def append_class(names); end
 
   # :call-seq: [](name) → (String, nil)
@@ -3835,7 +4233,7 @@ class Nokogiri::XML::Node
   #   doc.at_css("child").attribute_with_ns("size", "http://example.com/widths").value
   #   # => "broad"
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#512
+  # source://nokogiri//lib/nokogiri/xml/node.rb#587
   def attr(name); end
 
   def attribute(_arg0); end
@@ -3896,7 +4294,7 @@ class Nokogiri::XML::Node
   #   #        value = "tall"
   #   #        })}
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#609
+  # source://nokogiri//lib/nokogiri/xml/node.rb#684
   def attributes; end
 
   # Insert +node_or_tags+ before this node (as a sibling).
@@ -3908,19 +4306,19 @@ class Nokogiri::XML::Node
   #
   # Also see related method +add_previous_sibling+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#304
+  # source://nokogiri//lib/nokogiri/xml/node.rb#340
   def before(node_or_tags); end
 
   def blank?; end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1414
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1492
   def canonicalize(mode = T.unsafe(nil), inclusive_namespaces = T.unsafe(nil), with_comments = T.unsafe(nil)); end
 
   # Returns true if this is a CDATA
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1136
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1214
   def cdata?; end
 
   def child; end
@@ -3933,7 +4331,7 @@ class Nokogiri::XML::Node
   #
   # Also see related method +inner_html=+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#349
+  # source://nokogiri//lib/nokogiri/xml/node.rb#385
   def children=(node_or_tags); end
 
   # :call-seq: classes() → Array<String>
@@ -3955,24 +4353,77 @@ class Nokogiri::XML::Node
   #   node         # => <div class="section title header"></div>
   #   node.classes # => ["section", "title", "header"]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#669
+  # source://nokogiri//lib/nokogiri/xml/node.rb#744
   def classes; end
 
-  def clone(*_arg0); end
+  # :call-seq:
+  #   clone → Nokogiri::XML::Node
+  #   clone(level) → Nokogiri::XML::Node
+  #   clone(level, new_parent_doc) → Nokogiri::XML::Node
+  #
+  # Clone this node.
+  #
+  # [Parameters]
+  # - +level+ (optional Integer). 0 is a shallow copy, 1 (the default) is a deep copy.
+  # - +new_parent_doc+
+  #   The new node's parent Document. Defaults to the the Document of the current node.
+  # [Returns] The new Nokogiri::XML::Node
+  #
+  # source://nokogiri//lib/nokogiri/xml/node.rb#162
+  def clone(level = T.unsafe(nil), new_parent_doc = T.unsafe(nil)); end
 
   # Returns true if this is a Comment
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1131
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1209
   def comment?; end
 
   def content; end
 
-  # Set the Node's content to a Text node containing +string+. The string gets XML escaped, not
-  # interpreted as markup.
+  # call-seq:
+  #   content=(input)
+  #
+  # Set the content of this node to +input+.
+  #
+  # [Parameters]
+  # - +input+ (String) The new content for this node. Input is considered to be raw content, and
+  #   so will be entity-escaped in the final DOM string.
+  #
+  # [Example]
+  # Note how entities are handled:
+  #
+  #   doc = Nokogiri::HTML::Document.parse(<<~HTML)
+  #     <html>
+  #       <body>
+  #         <div id="first">asdf</div>
+  #         <div id="second">asdf</div>
+  #   HTML
+  #
+  #   text_node = doc.at_css("div#first").children.first
+  #   div_node = doc.at_css("div#second")
+  #
+  #   value = "You &amp; Me"
+  #
+  #   text_node.content = value
+  #   div_node.content = value
+  #
+  #   doc.css("div").to_html
+  #   # => "<div id=\"first\">You &amp;amp; Me</div>
+  #   #     <div id=\"second\">You &amp;amp; Me</div>"
+  #
+  # For content that is already entity-escaped, use CGI::unescapeHTML to decode it:
+  #
+  #   text_node.content = CGI::unescapeHTML(value)
+  #   div_node.content = CGI::unescapeHTML(value)
+  #
+  #   doc.css("div").to_html
+  #   # => "<div id=\"first\">You &amp; Me</div>
+  #   #     <div id=\"second\">You &amp; Me</div>"
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#411
+  # See also: #native_content=
+  #
+  # source://nokogiri//lib/nokogiri/xml/node.rb#487
   def content=(string); end
 
   def create_external_subset(_arg0, _arg1, _arg2); end
@@ -3980,9 +4431,11 @@ class Nokogiri::XML::Node
 
   # Get the path to this node as a CSS expression
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1206
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1284
   def css_path; end
 
+  def data_ptr?; end
+
   # :call-seq: deconstruct_keys(array_of_names) → Hash
   #
   #  Returns a hash describing the Node, to use in pattern matching.
@@ -4032,12 +4485,12 @@ class Nokogiri::XML::Node
   #
   #  Since v1.14.0
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1475
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1553
   def deconstruct_keys(keys); end
 
   # Decorate this node with the decorators set up in this node's Document
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#132
+  # source://nokogiri//lib/nokogiri/xml/node.rb#168
   def decorate!; end
 
   # Adds a default namespace supplied as a string +url+ href, to self.
@@ -4046,18 +4499,18 @@ class Nokogiri::XML::Node
   # now show up in #attributes, but when this node is serialized to XML an
   # "xmlns" attribute will appear. See also #namespace and #namespace=
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#427
+  # source://nokogiri//lib/nokogiri/xml/node.rb#503
   def default_namespace=(url); end
 
   # Remove the attribute named +name+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#643
+  # source://nokogiri//lib/nokogiri/xml/node.rb#718
   def delete(name); end
 
   # Fetch the Nokogiri::HTML4::ElementDescription for this node.  Returns
   # nil on XML documents and on unknown tags.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1173
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1251
   def description; end
 
   # Do xinclude substitution on the subtree below node. If given a block, a
@@ -4066,7 +4519,7 @@ class Nokogiri::XML::Node
   #
   # @yield [options]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#454
+  # source://nokogiri//lib/nokogiri/xml/node.rb#530
   def do_xinclude(options = T.unsafe(nil)); end
 
   def document; end
@@ -4075,28 +4528,42 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1151
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1229
   def document?; end
 
-  def dup(*_arg0); end
+  # :call-seq:
+  #   dup → Nokogiri::XML::Node
+  #   dup(level) → Nokogiri::XML::Node
+  #   dup(level, new_parent_doc) → Nokogiri::XML::Node
+  #
+  # Duplicate this node.
+  #
+  # [Parameters]
+  # - +level+ (optional Integer). 0 is a shallow copy, 1 (the default) is a deep copy.
+  # - +new_parent_doc+ (optional Nokogiri::XML::Document)
+  #   The new node's parent Document. Defaults to the the Document of the current node.
+  # [Returns] The new Nokogiri::XML::Node
+  #
+  # source://nokogiri//lib/nokogiri/xml/node.rb#144
+  def dup(level = T.unsafe(nil), new_parent_doc = T.unsafe(nil)); end
 
   # Iterate over each attribute name and value pair for this Node.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#635
+  # source://nokogiri//lib/nokogiri/xml/node.rb#710
   def each; end
 
   # Returns true if this is an Element node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1187
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1265
   def elem?; end
 
   # Returns true if this is an Element node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1187
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1265
   def element?; end
 
   def element_children; end
@@ -4115,7 +4582,7 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1166
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1244
   def fragment?; end
 
   # :call-seq: [](name) → (String, nil)
@@ -4148,7 +4615,7 @@ class Nokogiri::XML::Node
   #   doc.at_css("child").attribute_with_ns("size", "http://example.com/widths").value
   #   # => "broad"
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#512
+  # source://nokogiri//lib/nokogiri/xml/node.rb#587
   def get_attribute(name); end
 
   def has_attribute?(_arg0); end
@@ -4157,7 +4624,7 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1146
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1224
   def html?; end
 
   # Get the inner_html for this node's Node#children
@@ -4180,7 +4647,7 @@ class Nokogiri::XML::Node
   #
   # Also see related method +children=+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#338
+  # source://nokogiri//lib/nokogiri/xml/node.rb#374
   def inner_html=(node_or_tags); end
 
   # :section:
@@ -4191,7 +4658,7 @@ class Nokogiri::XML::Node
 
   # Get the attribute names for this Node.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#629
+  # source://nokogiri//lib/nokogiri/xml/node.rb#704
   def keys; end
 
   # :call-seq:
@@ -4245,7 +4712,7 @@ class Nokogiri::XML::Node
   #
   # Since v1.11.0
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#892
+  # source://nokogiri//lib/nokogiri/xml/node.rb#967
   def kwattr_add(attribute_name, keywords); end
 
   # :call-seq:
@@ -4294,7 +4761,7 @@ class Nokogiri::XML::Node
   #
   # Since v1.11.0
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#945
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1020
   def kwattr_append(attribute_name, keywords); end
 
   # :call-seq:
@@ -4333,7 +4800,7 @@ class Nokogiri::XML::Node
   #
   # Since v1.11.0
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#988
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1063
   def kwattr_remove(attribute_name, keywords); end
 
   # :call-seq:
@@ -4362,7 +4829,7 @@ class Nokogiri::XML::Node
   #
   # Since v1.11.0
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#838
+  # source://nokogiri//lib/nokogiri/xml/node.rb#913
   def kwattr_values(attribute_name); end
 
   def lang; end
@@ -4375,7 +4842,7 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1015
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1090
   def matches?(selector); end
 
   def name; end
@@ -4388,7 +4855,7 @@ class Nokogiri::XML::Node
   # for this node. You probably want #default_namespace= instead, or perhaps
   # #add_namespace_definition with a nil prefix argument.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#437
+  # source://nokogiri//lib/nokogiri/xml/node.rb#513
   def namespace=(ns); end
 
   def namespace_definitions; end
@@ -4431,7 +4898,7 @@ class Nokogiri::XML::Node
   #   #     "xmlns"=>"http://example.com/root",
   #   #     "xmlns:in_scope"=>"http://example.com/in_scope"}
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1122
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1200
   def namespaces; end
 
   def native_content=(_arg0); end
@@ -4449,7 +4916,7 @@ class Nokogiri::XML::Node
   #
   # @raise [ArgumentError]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#288
+  # source://nokogiri//lib/nokogiri/xml/node.rb#324
   def next=(node_or_tags); end
 
   def next_element; end
@@ -4461,7 +4928,7 @@ class Nokogiri::XML::Node
 
   # Set the parent Node for this Node
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#417
+  # source://nokogiri//lib/nokogiri/xml/node.rb#493
   def parent=(parent_node); end
 
   # Parse +string_or_io+ as a document fragment within the context of
@@ -4470,7 +4937,7 @@ class Nokogiri::XML::Node
   #
   # @yield [options]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1030
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1105
   def parse(string_or_io, options = T.unsafe(nil)); end
 
   def path; end
@@ -4486,7 +4953,7 @@ class Nokogiri::XML::Node
   #
   # Also see related method +add_child+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#168
+  # source://nokogiri//lib/nokogiri/xml/node.rb#204
   def prepend_child(node_or_tags); end
 
   def previous; end
@@ -4503,7 +4970,7 @@ class Nokogiri::XML::Node
   #
   # @raise [ArgumentError]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#271
+  # source://nokogiri//lib/nokogiri/xml/node.rb#307
   def previous=(node_or_tags); end
 
   def previous_element; end
@@ -4513,21 +4980,21 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1156
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1234
   def processing_instruction?; end
 
   # Is this a read only node?
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1181
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1259
   def read_only?; end
 
   def remove; end
 
   # Remove the attribute named +name+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#643
+  # source://nokogiri//lib/nokogiri/xml/node.rb#718
   def remove_attribute(name); end
 
   # :call-seq:
@@ -4576,7 +5043,7 @@ class Nokogiri::XML::Node
   #   node                                    # => <div class="section header float"></div>
   #   node.remove_class(["section", "float"]) # => <div class="header"></div>
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#809
+  # source://nokogiri//lib/nokogiri/xml/node.rb#884
   def remove_class(names = T.unsafe(nil)); end
 
   # Replace this Node with +node_or_tags+.
@@ -4589,7 +5056,7 @@ class Nokogiri::XML::Node
   #
   # Also see related method +swap+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#369
+  # source://nokogiri//lib/nokogiri/xml/node.rb#405
   def replace(node_or_tags); end
 
   # Serialize Node using +options+. Save options can also be set using a block.
@@ -4604,7 +5071,7 @@ class Nokogiri::XML::Node
   #     config.format.as_xml
   #   end
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1286
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1364
   def serialize(*args, &block); end
 
   # :call-seq: []=(name, value) → value
@@ -4641,7 +5108,7 @@ class Nokogiri::XML::Node
   #   #    "  <child width:size=\"broad\"></child>\n" +
   #   #    "</root>\n"
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#550
+  # source://nokogiri//lib/nokogiri/xml/node.rb#625
   def set_attribute(name, value); end
 
   # Swap this Node for +node_or_tags+
@@ -4653,7 +5120,7 @@ class Nokogiri::XML::Node
   #
   # Also see related method +replace+.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#403
+  # source://nokogiri//lib/nokogiri/xml/node.rb#439
   def swap(node_or_tags); end
 
   def text; end
@@ -4662,7 +5129,7 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1161
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1239
   def text?; end
 
   # Serialize this Node to HTML
@@ -4672,13 +5139,13 @@ class Nokogiri::XML::Node
   # See Node#write_to for a list of +options+.  For formatted output,
   # use Node#to_xhtml instead.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1313
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1391
   def to_html(options = T.unsafe(nil)); end
 
   # Turn this node in to a string.  If the document is HTML, this method
   # returns html.  If the document is XML, this method returns XML.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1196
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1274
   def to_s; end
 
   def to_str; end
@@ -4688,7 +5155,7 @@ class Nokogiri::XML::Node
   #
   # See Node#write_to for a list of +options+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1334
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1412
   def to_xhtml(options = T.unsafe(nil)); end
 
   # Serialize this Node to XML using +options+
@@ -4696,7 +5163,7 @@ class Nokogiri::XML::Node
   #
   # See Node#write_to for a list of +options+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1323
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1401
   def to_xml(options = T.unsafe(nil)); end
 
   # Yields self and all children to +block+ recursively.
@@ -4704,7 +5171,7 @@ class Nokogiri::XML::Node
   # @yield [_self]
   # @yieldparam _self [Nokogiri::XML::Node] the object that the method was called on
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1239
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1317
   def traverse(&block); end
 
   def type; end
@@ -4714,12 +5181,12 @@ class Nokogiri::XML::Node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#623
+  # source://nokogiri//lib/nokogiri/xml/node.rb#698
   def value?(value); end
 
   # Get the attribute values for this Node.
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#617
+  # source://nokogiri//lib/nokogiri/xml/node.rb#692
   def values; end
 
   # :call-seq:
@@ -4766,14 +5233,14 @@ class Nokogiri::XML::Node
   #   #   <div><a>asdf</a></div>
   #   # </body></html>
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#223
+  # source://nokogiri//lib/nokogiri/xml/node.rb#259
   def wrap(node_or_tags); end
 
   # Write Node as HTML to +io+ with +options+
   #
   # See Node#write_to for a list of +options+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1391
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1469
   def write_html_to(io, options = T.unsafe(nil)); end
 
   # :call-seq:
@@ -4807,7 +5274,7 @@ class Nokogiri::XML::Node
   #
   # See Node#write_to for a list of +options+
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1399
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1477
   def write_xhtml_to(io, options = T.unsafe(nil)); end
 
   # Write Node as XML to +io+ with +options+
@@ -4816,23 +5283,25 @@ class Nokogiri::XML::Node
   #
   # See Node#write_to for a list of options
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1409
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1487
   def write_xml_to(io, options = T.unsafe(nil)); end
 
   # Returns true if this is an XML::Document node
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1141
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1219
   def xml?; end
 
   protected
 
   # @raise [ArgumentError]
   #
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1489
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1567
   def coerce(data); end
 
+  def initialize_copy_with_args(_arg0, _arg1, _arg2); end
+
   private
 
   def add_child_node(_arg0); end
@@ -4843,7 +5312,7 @@ class Nokogiri::XML::Node
   def add_next_sibling_node(_arg0); end
   def add_previous_sibling_node(_arg0); end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1523
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1601
   def add_sibling(next_or_previous, node_or_tags); end
 
   def compare(_arg0); end
@@ -4852,10 +5321,10 @@ class Nokogiri::XML::Node
   def html_standard_serialize(_arg0); end
   def in_context(_arg0, _arg1); end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1562
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1633
   def inspect_attributes; end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1511
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1589
   def keywordify(keywords); end
 
   def native_write_to(_arg0, _arg1, _arg2, _arg3); end
@@ -4865,10 +5334,10 @@ class Nokogiri::XML::Node
   def set(_arg0, _arg1); end
   def set_namespace(_arg0); end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1548
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1623
   def to_format(save_option, options); end
 
-  # source://nokogiri//lib/nokogiri/xml/node.rb#1555
+  # source://nokogiri//lib/nokogiri/xml/node.rb#1628
   def write_format_to(save_option, io, options); end
 
   class << self
@@ -4896,10 +5365,10 @@ Nokogiri::XML::Node::CDATA_SECTION_NODE = T.let(T.unsafe(nil), Integer)
 # source://nokogiri//lib/nokogiri/xml/node.rb#77
 Nokogiri::XML::Node::COMMENT_NODE = T.let(T.unsafe(nil), Integer)
 
-# source://nokogiri//lib/nokogiri/xml/node.rb#1422
+# source://nokogiri//lib/nokogiri/xml/node.rb#1500
 Nokogiri::XML::Node::DECONSTRUCT_KEYS = T.let(T.unsafe(nil), Array)
 
-# source://nokogiri//lib/nokogiri/xml/node.rb#1423
+# source://nokogiri//lib/nokogiri/xml/node.rb#1501
 Nokogiri::XML::Node::DECONSTRUCT_METHODS = T.let(T.unsafe(nil), Hash)
 
 # DOCB document node type
@@ -4957,7 +5426,7 @@ Nokogiri::XML::Node::ENTITY_REF_NODE = T.let(T.unsafe(nil), Integer)
 # source://nokogiri//lib/nokogiri/xml/node.rb#87
 Nokogiri::XML::Node::HTML_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
 
-# source://nokogiri//lib/nokogiri/xml/node.rb#1566
+# source://nokogiri//lib/nokogiri/xml/node.rb#1637
 Nokogiri::XML::Node::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
 
 # Namespace declaration type
@@ -5116,9 +5585,6 @@ Nokogiri::XML::Node::SaveOptions::NO_XHTML = T.let(T.unsafe(nil), Integer)
 # source://nokogiri//lib/nokogiri/xml/node.rb#67
 Nokogiri::XML::Node::TEXT_NODE = T.let(T.unsafe(nil), Integer)
 
-# source://nokogiri//lib/nokogiri/xml/node.rb#1545
-Nokogiri::XML::Node::USING_LIBXML_WITH_BROKEN_SERIALIZATION = T.let(T.unsafe(nil), FalseClass)
-
 # XInclude end type
 #
 # source://nokogiri//lib/nokogiri/xml/node.rb#101
@@ -5129,11 +5595,15 @@ Nokogiri::XML::Node::XINCLUDE_END = T.let(T.unsafe(nil), Integer)
 # source://nokogiri//lib/nokogiri/xml/node.rb#99
 Nokogiri::XML::Node::XINCLUDE_START = T.let(T.unsafe(nil), Integer)
 
-# A NodeSet contains a list of Nokogiri::XML::Node objects.  Typically
-# a NodeSet is return as a result of searching a Document via
-# Nokogiri::XML::Searchable#css or Nokogiri::XML::Searchable#xpath
+# A NodeSet is an Enumerable that contains a list of Nokogiri::XML::Node objects.
 #
-# source://nokogiri//lib/nokogiri/xml/node_set.rb#10
+# Typically a NodeSet is returned as a result of searching a Document via
+# Nokogiri::XML::Searchable#css or Nokogiri::XML::Searchable#xpath.
+#
+# Note that the `#dup` and `#clone` methods perform shallow copies; these methods do not copy
+# the Nodes contained in the NodeSet (similar to how Array and other Enumerable classes work).
+#
+# source://nokogiri//lib/nokogiri/xml/node_set.rb#14
 class Nokogiri::XML::NodeSet
   include ::Nokogiri::XML::Searchable
   include ::Enumerable
@@ -5144,7 +5614,7 @@ class Nokogiri::XML::NodeSet
   # @yield [_self]
   # @yieldparam _self [Nokogiri::XML::NodeSet] the object that the method was called on
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#20
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#22
   def initialize(document, list = T.unsafe(nil)); end
 
   # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
@@ -5158,7 +5628,7 @@ class Nokogiri::XML::NodeSet
   #
   #   node_set.at(3) # same as node_set[3]
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#119
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#121
   def %(*args); end
 
   def &(_arg0); end
@@ -5170,7 +5640,7 @@ class Nokogiri::XML::NodeSet
   # of elements and if each element is equal to the corresponding
   # element in the other NodeSet
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#393
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#395
   def ==(other); end
 
   def [](*_arg0); end
@@ -5180,12 +5650,12 @@ class Nokogiri::XML::NodeSet
   #
   # See Nokogiri::XML::Node#add_class for more information.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#139
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#141
   def add_class(name); end
 
   # Insert +datum+ after the last Node in this NodeSet
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#69
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#71
   def after(datum); end
 
   # Append the class attribute +name+ to all Node objects in the
@@ -5193,7 +5663,7 @@ class Nokogiri::XML::NodeSet
   #
   # See Nokogiri::XML::Node#append_class for more information.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#151
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#153
   def append_class(name); end
 
   # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
@@ -5207,7 +5677,7 @@ class Nokogiri::XML::NodeSet
   #
   #   node_set.at(3) # same as node_set[3]
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#119
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#121
   def at(*args); end
 
   # Set attributes on each Node in the NodeSet, or get an
@@ -5242,7 +5712,7 @@ class Nokogiri::XML::NodeSet
   #
   #   node_set.attr("class") { |node| node.name }
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#203
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#205
   def attr(key, value = T.unsafe(nil), &block); end
 
   # Set attributes on each Node in the NodeSet, or get an
@@ -5277,22 +5747,20 @@ class Nokogiri::XML::NodeSet
   #
   #   node_set.attr("class") { |node| node.name }
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#203
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#205
   def attribute(key, value = T.unsafe(nil), &block); end
 
   # Insert +datum+ before the first Node in this NodeSet
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#63
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#65
   def before(datum); end
 
   # Returns a new NodeSet containing all the children of all the nodes in
   # the NodeSet
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#406
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#408
   def children; end
 
-  def clone; end
-
   # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
   #
   # Search this node set for CSS +rules+. +rules+ must be one or more CSS
@@ -5300,7 +5768,7 @@ class Nokogiri::XML::NodeSet
   #
   # For more information see Nokogiri::XML::Searchable#css
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#83
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#85
   def css(*args); end
 
   # :call-seq: deconstruct() → Array
@@ -5309,55 +5777,53 @@ class Nokogiri::XML::NodeSet
   #
   #  Since v1.14.0
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#440
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#442
   def deconstruct; end
 
   def delete(_arg0); end
 
   # The Document this NodeSet is associated with
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#15
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#19
   def document; end
 
   # The Document this NodeSet is associated with
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#15
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#19
   def document=(_arg0); end
 
-  def dup; end
-
   # Iterate over each node, yielding  to +block+
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#231
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#233
   def each; end
 
   # Is this NodeSet empty?
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#45
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#47
   def empty?; end
 
   # Filter this list for nodes that match +expr+
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#130
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#132
   def filter(expr); end
 
   # Get the first element of the NodeSet.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#29
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#31
   def first(n = T.unsafe(nil)); end
 
   def include?(_arg0); end
 
   # Returns the index of the first node in self that is == to +node+ or meets the given block. Returns nil if no match is found.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#51
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#53
   def index(node = T.unsafe(nil)); end
 
   # Get the inner html of all contained Node objects
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#260
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#262
   def inner_html(*args); end
 
   # Get the inner text of all contained Node objects
@@ -5373,17 +5839,17 @@ class Nokogiri::XML::NodeSet
   #
   # See Nokogiri::XML::Node#content for more information.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#253
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#255
   def inner_text; end
 
-  # Return a nicely formated string representation
+  # Return a nicely formatted string representation
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#427
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#429
   def inspect; end
 
   # Get the last element of the NodeSet.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#39
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#41
   def last; end
 
   def length; end
@@ -5391,7 +5857,7 @@ class Nokogiri::XML::NodeSet
   # Removes the last element from set and returns it, or +nil+ if
   # the set is empty
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#374
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#376
   def pop; end
 
   def push(_arg0); end
@@ -5399,12 +5865,12 @@ class Nokogiri::XML::NodeSet
 
   # Remove the attributed named +name+ from all Node objects in the NodeSet
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#223
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#225
   def remove_attr(name); end
 
   # Remove the attributed named +name+ from all Node objects in the NodeSet
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#223
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#225
   def remove_attribute(name); end
 
   # Remove the class attribute +name+ from all Node objects in the
@@ -5412,13 +5878,13 @@ class Nokogiri::XML::NodeSet
   #
   # See Nokogiri::XML::Node#remove_class for more information.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#163
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#165
   def remove_class(name = T.unsafe(nil)); end
 
   # Returns a new NodeSet containing all the nodes in the NodeSet
   # in reverse order
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#417
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#419
   def reverse; end
 
   # Set attributes on each Node in the NodeSet, or get an
@@ -5453,13 +5919,13 @@ class Nokogiri::XML::NodeSet
   #
   #   node_set.attr("class") { |node| node.name }
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#203
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#205
   def set(key, value = T.unsafe(nil), &block); end
 
   # Returns the first element of the NodeSet and removes it.  Returns
   # +nil+ if the set is empty.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#383
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#385
   def shift; end
 
   def size; end
@@ -5478,7 +5944,7 @@ class Nokogiri::XML::NodeSet
   #
   # See Nokogiri::XML::Node#content for more information.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#253
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#255
   def text; end
 
   def to_a; end
@@ -5486,22 +5952,22 @@ class Nokogiri::XML::NodeSet
 
   # Convert this NodeSet to HTML
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#341
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#343
   def to_html(*args); end
 
   # Convert this NodeSet to a string.
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#335
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#337
   def to_s; end
 
   # Convert this NodeSet to XHTML
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#358
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#360
   def to_xhtml(*args); end
 
   # Convert this NodeSet to XML
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#364
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#366
   def to_xml(*args); end
 
   def unlink; end
@@ -5570,7 +6036,7 @@ class Nokogiri::XML::NodeSet
   #   #      <div><a>d</a></div>
   #   #    </body></html>
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#328
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#330
   def wrap(node_or_tags); end
 
   # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
@@ -5580,13 +6046,17 @@ class Nokogiri::XML::NodeSet
   #
   # For more information see Nokogiri::XML::Searchable#xpath
   #
-  # source://nokogiri//lib/nokogiri/xml/node_set.rb#99
+  # source://nokogiri//lib/nokogiri/xml/node_set.rb#101
   def xpath(*args); end
 
   def |(_arg0); end
+
+  private
+
+  def initialize_copy(_arg0); end
 end
 
-# source://nokogiri//lib/nokogiri/xml/node_set.rb#444
+# source://nokogiri//lib/nokogiri/xml/node_set.rb#446
 Nokogiri::XML::NodeSet::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
 
 # Struct representing an {XML Schema Notation}[https://www.w3.org/TR/xml/#Notations]
@@ -5611,7 +6081,7 @@ module Nokogiri::XML::PP::Node
   # source://nokogiri//lib/nokogiri/xml/pp/node.rb#10
   def inspect; end
 
-  # source://nokogiri//lib/nokogiri/xml/pp/node.rb#27
+  # source://nokogiri//lib/nokogiri/xml/pp/node.rb#32
   def pretty_print(pp); end
 end
 
@@ -5997,7 +6467,7 @@ Nokogiri::XML::ParseOptions::DTDVALID = T.let(T.unsafe(nil), Integer)
 
 # Relax any hardcoded limit from the parser. Off by default.
 #
-# ⚠ There may be a performance penalty when this option is set.
+# ⚠ <b>It is UNSAFE to set this option</b> when parsing untrusted documents.
 #
 # source://nokogiri//lib/nokogiri/xml/parse_options.rb#144
 Nokogiri::XML::ParseOptions::HUGE = T.let(T.unsafe(nil), Integer)
@@ -6102,41 +6572,42 @@ class Nokogiri::XML::ProcessingInstruction < ::Nokogiri::XML::Node
   end
 end
 
-# Nokogiri::XML::Reader parses an XML document similar to the way a cursor would move. The
-# Reader is given an XML document, and yields nodes to an each block.
+# The Reader parser allows you to effectively pull parse an \XML document.  Once instantiated,
+# call Nokogiri::XML::Reader#each to iterate over each node.
+#
+# Nokogiri::XML::Reader parses an \XML document similar to the way a cursor would move. The
+# Reader is given an \XML document, and yields nodes to an each block.
 #
-# The Reader parser might be good for when you need the speed and low memory usage of the SAX
-# parser, but do not want to write a Document handler.
+# The Reader parser might be good for when you need the speed and low memory usage of a \SAX
+# parser, but do not want to write a SAX::Document handler.
 #
 # Here is an example of usage:
 #
-#     reader = Nokogiri::XML::Reader(<<-eoxml)
+#     reader = Nokogiri::XML::Reader.new <<~XML
 #       <x xmlns:tenderlove='http://tenderlovemaking.com/'>
 #         <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
 #       </x>
-#     eoxml
+#     XML
 #
 #     reader.each do |node|
-#
 #       # node is an instance of Nokogiri::XML::Reader
 #       puts node.name
-#
 #     end
 #
 # ⚠ Nokogiri::XML::Reader#each can only be called once! Once the cursor moves through the entire
 # document, you must parse the document again. It may be better to capture all information you
 # need during a single iteration.
 #
-# ⚠ libxml2 does not support error recovery in the Reader parser. The `RECOVER` ParseOption is
+# ⚠ libxml2 does not support error recovery in the Reader parser. The +RECOVER+ ParseOption is
 # ignored. If a syntax error is encountered during parsing, an exception will be raised.
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#33
+# source://nokogiri//lib/nokogiri/xml/reader.rb#34
 class Nokogiri::XML::Reader
   include ::Enumerable
 
   # @return [Reader] a new instance of Reader
   #
-  # source://nokogiri//lib/nokogiri/xml/reader.rb#80
+  # source://nokogiri//lib/nokogiri/xml/reader.rb#114
   def initialize(source, url = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   def attribute(_arg0); end
@@ -6151,7 +6622,7 @@ class Nokogiri::XML::Reader
   # [Returns]
   #   (Hash<String, String>) Attribute names and values, and namespace prefixes and hrefs.
   #
-  # source://nokogiri//lib/nokogiri/xml/reader.rb#93
+  # source://nokogiri//lib/nokogiri/xml/reader.rb#126
   def attributes; end
 
   def attributes?; end
@@ -6161,7 +6632,7 @@ class Nokogiri::XML::Reader
 
   # Move the cursor through the document yielding the cursor to the block
   #
-  # source://nokogiri//lib/nokogiri/xml/reader.rb#99
+  # source://nokogiri//lib/nokogiri/xml/reader.rb#132
   def each; end
 
   def empty_element?; end
@@ -6169,12 +6640,12 @@ class Nokogiri::XML::Reader
 
   # A list of errors encountered while parsing
   #
-  # source://nokogiri//lib/nokogiri/xml/reader.rb#73
+  # source://nokogiri//lib/nokogiri/xml/reader.rb#74
   def errors; end
 
   # A list of errors encountered while parsing
   #
-  # source://nokogiri//lib/nokogiri/xml/reader.rb#73
+  # source://nokogiri//lib/nokogiri/xml/reader.rb#74
   def errors=(_arg0); end
 
   def inner_xml; end
@@ -6189,9 +6660,9 @@ class Nokogiri::XML::Reader
   def read; end
   def self_closing?; end
 
-  # The XML source
+  # The \XML source
   #
-  # source://nokogiri//lib/nokogiri/xml/reader.rb#76
+  # source://nokogiri//lib/nokogiri/xml/reader.rb#77
   def source; end
 
   def state; end
@@ -6202,119 +6673,146 @@ class Nokogiri::XML::Reader
   class << self
     def from_io(*_arg0); end
     def from_memory(*_arg0); end
+
+    # :call-seq:
+    #   Reader.new(input) { |options| ... } → Reader
+    #
+    # Create a new Reader to parse an \XML document.
+    #
+    # [Required Parameters]
+    # - +input+ (String | IO): The \XML document to parse.
+    #
+    # [Optional Parameters]
+    # - +url:+ (String) The base URL of the document.
+    # - +options:+ (Integer | ParseOptions) Options to control the parser behavior.
+    #   Defaults to +ParseOptions::STRICT+.
+    #
+    # [Yields]
+    # If present, the block will be passed a Nokogiri::XML::ParseOptions object to modify before
+    # the fragment is parsed. See Nokogiri::XML::ParseOptions for more information.
+    #
+    # @yield [options]
+    #
+    # source://nokogiri//lib/nokogiri/xml/reader.rb#99
+    def new(string_or_io, url_ = T.unsafe(nil), encoding_ = T.unsafe(nil), options_ = T.unsafe(nil), url: T.unsafe(nil), encoding: T.unsafe(nil), options: T.unsafe(nil)); end
   end
 end
 
 # Attribute node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#40
+# source://nokogiri//lib/nokogiri/xml/reader.rb#41
 Nokogiri::XML::Reader::TYPE_ATTRIBUTE = T.let(T.unsafe(nil), Integer)
 
 # CDATA node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#44
+# source://nokogiri//lib/nokogiri/xml/reader.rb#45
 Nokogiri::XML::Reader::TYPE_CDATA = T.let(T.unsafe(nil), Integer)
 
 # Comment node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#52
+# source://nokogiri//lib/nokogiri/xml/reader.rb#53
 Nokogiri::XML::Reader::TYPE_COMMENT = T.let(T.unsafe(nil), Integer)
 
 # Document node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#54
+# source://nokogiri//lib/nokogiri/xml/reader.rb#55
 Nokogiri::XML::Reader::TYPE_DOCUMENT = T.let(T.unsafe(nil), Integer)
 
 # Document Fragment node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#58
+# source://nokogiri//lib/nokogiri/xml/reader.rb#59
 Nokogiri::XML::Reader::TYPE_DOCUMENT_FRAGMENT = T.let(T.unsafe(nil), Integer)
 
 # Document Type node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#56
+# source://nokogiri//lib/nokogiri/xml/reader.rb#57
 Nokogiri::XML::Reader::TYPE_DOCUMENT_TYPE = T.let(T.unsafe(nil), Integer)
 
 # Element node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#38
+# source://nokogiri//lib/nokogiri/xml/reader.rb#39
 Nokogiri::XML::Reader::TYPE_ELEMENT = T.let(T.unsafe(nil), Integer)
 
 # Element end node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#66
+# source://nokogiri//lib/nokogiri/xml/reader.rb#67
 Nokogiri::XML::Reader::TYPE_END_ELEMENT = T.let(T.unsafe(nil), Integer)
 
 # Entity end node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#68
+# source://nokogiri//lib/nokogiri/xml/reader.rb#69
 Nokogiri::XML::Reader::TYPE_END_ENTITY = T.let(T.unsafe(nil), Integer)
 
 # Entity node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#48
+# source://nokogiri//lib/nokogiri/xml/reader.rb#49
 Nokogiri::XML::Reader::TYPE_ENTITY = T.let(T.unsafe(nil), Integer)
 
 # Entity Reference node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#46
+# source://nokogiri//lib/nokogiri/xml/reader.rb#47
 Nokogiri::XML::Reader::TYPE_ENTITY_REFERENCE = T.let(T.unsafe(nil), Integer)
 
-# source://nokogiri//lib/nokogiri/xml/reader.rb#36
+# source://nokogiri//lib/nokogiri/xml/reader.rb#37
 Nokogiri::XML::Reader::TYPE_NONE = T.let(T.unsafe(nil), Integer)
 
 # Notation node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#60
+# source://nokogiri//lib/nokogiri/xml/reader.rb#61
 Nokogiri::XML::Reader::TYPE_NOTATION = T.let(T.unsafe(nil), Integer)
 
 # PI node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#50
+# source://nokogiri//lib/nokogiri/xml/reader.rb#51
 Nokogiri::XML::Reader::TYPE_PROCESSING_INSTRUCTION = T.let(T.unsafe(nil), Integer)
 
 # Significant Whitespace node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#64
+# source://nokogiri//lib/nokogiri/xml/reader.rb#65
 Nokogiri::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE = T.let(T.unsafe(nil), Integer)
 
 # Text node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#42
+# source://nokogiri//lib/nokogiri/xml/reader.rb#43
 Nokogiri::XML::Reader::TYPE_TEXT = T.let(T.unsafe(nil), Integer)
 
 # Whitespace node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#62
+# source://nokogiri//lib/nokogiri/xml/reader.rb#63
 Nokogiri::XML::Reader::TYPE_WHITESPACE = T.let(T.unsafe(nil), Integer)
 
-# XML Declaration node type
+# \XML Declaration node type
 #
-# source://nokogiri//lib/nokogiri/xml/reader.rb#70
+# source://nokogiri//lib/nokogiri/xml/reader.rb#71
 Nokogiri::XML::Reader::TYPE_XML_DECLARATION = T.let(T.unsafe(nil), Integer)
 
-# Nokogiri::XML::RelaxNG is used for validating XML against a
-# RelaxNG schema.
+# Nokogiri::XML::RelaxNG is used for validating \XML against a RELAX NG schema definition.
 #
-# == Synopsis
+# 🛡 <b>Do not use this class for untrusted schema documents.</b> RELAX NG input is always
+# treated as *trusted*, meaning that the underlying parsing libraries <b>will access network
+# resources</b>. This is counter to Nokogiri's "untrusted by default" security policy, but is an
+# unfortunate limitation of the underlying libraries.
 #
-# Validate an XML document against a RelaxNG schema.  Loop over the errors
-# that are returned and print them out:
+# *Example:* Determine whether an \XML document is valid.
 #
-#   schema  = Nokogiri::XML::RelaxNG(File.open(ADDRESS_SCHEMA_FILE))
-#   doc     = Nokogiri::XML(File.open(ADDRESS_XML_FILE))
+#   schema = Nokogiri::XML::RelaxNG.new(File.read(RELAX_NG_FILE))
+#   doc = Nokogiri::XML::Document.parse(File.read(XML_FILE))
+#   schema.valid?(doc) # Boolean
 #
-#   schema.validate(doc).each do |error|
-#     puts error.message
-#   end
+# *Example:* Validate an \XML document against a \RelaxNG schema, and capture any errors that are found.
+#
+#   schema = Nokogiri::XML::RelaxNG.new(File.open(RELAX_NG_FILE))
+#   doc = Nokogiri::XML::Document.parse(File.open(XML_FILE))
+#   errors = schema.validate(doc) # Array<SyntaxError>
 #
-# The list of errors are Nokogiri::XML::SyntaxError objects.
+# *Example:* Validate an \XML document using a Document containing a RELAX NG schema definition.
 #
-# NOTE: RelaxNG input is always treated as TRUSTED documents, meaning that they will cause the
-# underlying parsing libraries to access network resources. This is counter to Nokogiri's
-# "untrusted by default" security policy, but is a limitation of the underlying libraries.
+#   schema_doc = Nokogiri::XML::Document.parse(File.read(RELAX_NG_FILE))
+#   schema = Nokogiri::XML::RelaxNG.from_document(schema_doc)
+#   doc = Nokogiri::XML::Document.parse(File.open(XML_FILE))
+#   schema.valid?(doc) # Boolean
 #
-# source://nokogiri//lib/nokogiri/xml/relax_ng.rb#35
+# source://nokogiri//lib/nokogiri/xml/relax_ng.rb#59
 class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema
   private
 
@@ -6322,25 +6820,59 @@ class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema
 
   class << self
     def from_document(*_arg0); end
-    def read_memory(*_arg0); end
+
+    # :call-seq:
+    #   new(input) → Nokogiri::XML::RelaxNG
+    #   new(input, options:) → Nokogiri::XML::RelaxNG
+    #
+    # Parse a RELAX NG schema definition from a String or IO to create a new Nokogiri::XML::RelaxNG.
+    #
+    # [Parameters]
+    # - +input+ (String | IO) RELAX NG schema definition
+    # - +options:+ (Nokogiri::XML::ParseOptions)
+    #   Defaults to Nokogiri::XML::ParseOptions::DEFAULT_SCHEMA ⚠ Unused
+    #
+    # [Returns] Nokogiri::XML::RelaxNG
+    #
+    # ⚠ +parse_options+ is currently unused by this method and is present only as a placeholder for
+    # future functionality.
+    #
+    # Also see convenience method Nokogiri::XML::RelaxNG()
+    #
+    # source://nokogiri//lib/nokogiri/xml/relax_ng.rb#60
+    def new(input, parse_options_ = T.unsafe(nil), options: T.unsafe(nil)); end
+
+    # :call-seq:
+    #   read_memory(input) → Nokogiri::XML::RelaxNG
+    #   read_memory(input, options:) → Nokogiri::XML::RelaxNG
+    #
+    # Convenience method for Nokogiri::XML::RelaxNG.new.
+    #
+    # source://nokogiri//lib/nokogiri/xml/relax_ng.rb#69
+    def read_memory(*_arg0, **_arg1, &_arg2); end
   end
 end
 
-# SAX Parsers are event driven parsers. Nokogiri provides two different event based parsers when
-# dealing with XML. If you want to do SAX style parsing using HTML, check out
-# Nokogiri::HTML4::SAX.
+# SAX Parsers are event-driven parsers.
+#
+# Two SAX parsers for XML are available, a parser that reads from a string or IO object as it
+# feels necessary, and a parser that you explicitly feed XML in chunks. If you want to let
+# Nokogiri deal with reading your XML, use the Nokogiri::XML::SAX::Parser. If you want to have
+# fine grain control over the XML input, use the Nokogiri::XML::SAX::PushParser.
+#
+# If you want to do SAX style parsing of HTML, check out Nokogiri::HTML4::SAX.
 #
 # The basic way a SAX style parser works is by creating a parser, telling the parser about the
 # events we're interested in, then giving the parser some XML to process. The parser will notify
 # you when it encounters events you said you would like to know about.
 #
-# To register for events, you simply subclass Nokogiri::XML::SAX::Document, and implement the
-# methods for which you would like notification.
+# To register for events, subclass Nokogiri::XML::SAX::Document and implement the methods for
+# which you would like notification.
 #
 # For example, if I want to be notified when a document ends, and when an element starts, I
 # would write a class like this:
 #
-#   class MyDocument < Nokogiri::XML::SAX::Document
+#   class MyHandler < Nokogiri::XML::SAX::Document
 #     def end_document
 #       puts "the document has ended"
 #     end
@@ -6353,7 +6885,7 @@ end
 # Then I would instantiate a SAX parser with this document, and feed the parser some XML
 #
 #   # Create a new parser
-#   parser = Nokogiri::XML::SAX::Parser.new(MyDocument.new)
+#   parser = Nokogiri::XML::SAX::Parser.new(MyHandler.new)
 #
 #   # Feed the parser some XML
 #   parser.parse(File.open(ARGV[0]))
@@ -6361,133 +6893,254 @@ end
 # Now my document handler will be called when each node starts, and when then document ends. To
 # see what kinds of events are available, take a look at Nokogiri::XML::SAX::Document.
 #
-# Two SAX parsers for XML are available, a parser that reads from a string or IO object as it
-# feels necessary, and a parser that lets you spoon feed it XML. If you want to let Nokogiri
-# deal with reading your XML, use the Nokogiri::XML::SAX::Parser. If you want to have fine grain
-# control over the XML input, use the Nokogiri::XML::SAX::PushParser.
-#
-# source://nokogiri//lib/nokogiri/xml/sax/document.rb#45
+# source://nokogiri//lib/nokogiri/xml/sax.rb#46
 module Nokogiri::XML::SAX; end
 
-# This class is used for registering types of events you are interested in handling. All of
-# the methods on this class are available as possible events while parsing an XML document. To
-# register for any particular event, just subclass this class and implement the methods you
-# are interested in knowing about.
+# :markup: markdown
+#
+# The SAX::Document class is used for registering types of events you are interested in
+# handling. All of the methods on this class are available as possible events while parsing an
+# \XML document. To register for any particular event, subclass this class and implement the
+# methods you are interested in knowing about.
 #
 # To only be notified about start and end element events, write a class like this:
 #
-#   class MyDocument < Nokogiri::XML::SAX::Document
-#     def start_element name, attrs = []
-#       puts "#{name} started!"
-#     end
+#     class MyHandler < Nokogiri::XML::SAX::Document
+#       def start_element name, attrs = []
+#         puts "#{name} started!"
+#       end
 #
-#     def end_element name
-#       puts "#{name} ended"
+#       def end_element name
+#         puts "#{name} ended"
+#       end
 #     end
-#   end
 #
-# You can use this event handler for any SAX style parser included with Nokogiri. See
-# Nokogiri::XML::SAX, and Nokogiri::HTML4::SAX.
+# You can use this event handler for any SAX-style parser included with Nokogiri.
+#
+# See also:
+#
+# - Nokogiri::XML::SAX
+# - Nokogiri::HTML4::SAX
+#
+# ### Entity Handling
+#
+# ⚠ Entity handling is complicated in a SAX parser! Please read this section carefully if
+# you're not getting the behavior you expect.
+#
+# Entities will be reported to the user via callbacks to #characters, to #reference, or
+# possibly to both. The behavior is determined by a combination of _entity type_ and the value
+# of ParserContext#replace_entities. (Recall that the default value of
+# ParserContext#replace_entities is `false`.)
+#
+# ⚠ <b>It is UNSAFE to set ParserContext#replace_entities to `true`</b> when parsing untrusted
+# documents.
 #
-# source://nokogiri//lib/nokogiri/xml/sax/document.rb#66
+# 💡 For more information on entity types, see [Wikipedia's page on
+# DTDs](https://en.wikipedia.org/wiki/Document_type_definition#Entity_declarations).
+#
+# | Entity type                          | #characters                        | #reference                          |
+# |--------------------------------------|------------------------------------|-------------------------------------|
+# | Char ref (e.g., <tt>&#146;</tt>)     | always                             | never                               |
+# | Predefined (e.g., <tt>&amp;</tt>)    | always                             | never                               |
+# | Undeclared †                         | never                              | <tt>#replace_entities == false</tt> |
+# | Internal                             | always                             | <tt>#replace_entities == false</tt> |
+# | External †                           | <tt>#replace_entities == true</tt> | <tt>#replace_entities == false</tt> |
+#
+# &nbsp;
+#
+# † In the case where the replacement text for the entity is unknown (e.g., an undeclared entity
+# or an external entity that could not be resolved because of network issues), then the
+# replacement text will not be reported. If ParserContext#replace_entities is `true`, this
+# means the #characters callback will not be invoked. If ParserContext#replace_entities is
+# `false`, then the #reference callback will be invoked, but with `nil` for the `content`
+# argument.
+#
+# source://nokogiri//lib/nokogiri/xml/sax/document.rb#65
 class Nokogiri::XML::SAX::Document
   # Called when cdata blocks are found
-  # +string+ contains the cdata content
+  # [Parameters]
+  # - +string+ contains the cdata content
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#155
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#245
   def cdata_block(string); end
 
-  # Characters read between a tag. This method might be called multiple
-  # times given one contiguous string of characters.
+  # Called when character data is parsed, and for parsed entities when
+  # ParserContext#replace_entities is +true+.
+  #
+  # [Parameters]
+  # - +string+ contains the character data or entity replacement text
   #
-  # +string+ contains the character data
+  # ⚠ Please see Document@Entity+Handling for important information about how entities are handled.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#131
+  # ⚠ This method might be called multiple times for a contiguous string of characters.
+  #
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#201
   def characters(string); end
 
   # Called when comments are encountered
-  # +string+ contains the comment data
+  # [Parameters]
+  # - +string+ contains the comment data
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#137
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#224
   def comment(string); end
 
-  # Called when document ends parsing
+  # Called when document ends parsing.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#79
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#83
   def end_document; end
 
-  # Called at the end of an element
-  # +name+ is the tag name
+  # Called at the end of an element.
+  #
+  # [Parameters]
+  # - +name+ (String) the name of the element being closed
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#93
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#122
   def end_element(name); end
 
-  # Called at the end of an element
-  # +name+ is the element's name
-  # +prefix+ is the namespace prefix associated with the element
-  # +uri+ is the associated namespace URI
+  # Called at the end of an element.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#120
+  # [Parameters]
+  # - +name+ (String) is the name of the element
+  # - +prefix+ (String, nil) is the namespace prefix for the element
+  # - +uri+ (String, nil) is the associated URI for the element's namespace
+  #
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#185
   def end_element_namespace(name, prefix = T.unsafe(nil), uri = T.unsafe(nil)); end
 
   # Called on document errors
-  # +string+ contains the error
+  # [Parameters]
+  # - +string+ contains the error
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#149
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#238
   def error(string); end
 
   # Called when processing instructions are found
-  # +name+ is the target of the instruction
-  # +content+ is the value of the instruction
+  # [Parameters]
+  # - +name+ is the target of the instruction
+  # - +content+ is the value of the instruction
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#162
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#253
   def processing_instruction(name, content); end
 
-  # Called when document starts parsing
+  # Called when a parsed entity is referenced and not replaced.
+  #
+  # [Parameters]
+  # - +name+ (String) is the name of the entity
+  # - +content+ (String, nil) is the replacement text for the entity, if known
+  #
+  # ⚠ Please see Document@Entity+Handling for important information about how entities are handled.
+  #
+  # ⚠ An internal entity may result in a call to both #characters and #reference.
+  #
+  # Since v1.17.0
+  #
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#217
+  def reference(name, content); end
+
+  # Called when document starts parsing.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#74
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#78
   def start_document; end
 
-  # Called at the beginning of an element
-  # * +name+ is the name of the tag
-  # * +attrs+ are an assoc list of namespaces and attributes, e.g.:
+  # Called at the beginning of an element.
+  #
+  # [Parameters]
+  # - +name+ (String) the name of the element
+  # - +attrs+ (Array<Array<String>>) an assoc list of namespace declarations and attributes, e.g.:
   #     [ ["xmlns:foo", "http://sample.net"], ["size", "large"] ]
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#87
+  # 💡If you're dealing with XML and need to handle namespaces, use the
+  # #start_element_namespace method instead.
+  #
+  # Note that the element namespace and any attribute namespaces are not provided, and so any
+  # namespaced elements or attributes will be returned as strings including the prefix:
+  #
+  #   parser.parse(<<~XML)
+  #     <root xmlns:foo='http://foo.example.com/' xmlns='http://example.com/'>
+  #       <foo:bar foo:quux="xxx">hello world</foo:bar>
+  #     </root>
+  #   XML
+  #
+  #   assert_pattern do
+  #     parser.document.start_elements => [
+  #       ["root", [["xmlns:foo", "http://foo.example.com/"], ["xmlns", "http://example.com/"]]],
+  #       ["foo:bar", [["foo:quux", "xxx"]]],
+  #     ]
+  #   end
+  #
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#113
   def start_element(name, attrs = T.unsafe(nil)); end
 
-  # Called at the beginning of an element
-  # +name+ is the element name
-  # +attrs+ is a list of attributes
-  # +prefix+ is the namespace prefix for the element
-  # +uri+ is the associated namespace URI
-  # +ns+ is a hash of namespace prefix:urls associated with the element
+  # Called at the beginning of an element.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#103
+  # [Parameters]
+  # - +name+ (String) is the name of the element
+  # - +attrs+ (Array<Attribute>) is an array of structs with the following properties:
+  #   - +localname+ (String) the local name of the attribute
+  #   - +value+ (String) the value of the attribute
+  #   - +prefix+ (String, nil) the namespace prefix of the attribute
+  #   - +uri+ (String, nil) the namespace URI of the attribute
+  # - +prefix+ (String, nil) is the namespace prefix for the element
+  # - +uri+ (String, nil) is the associated URI for the element's namespace
+  # - +ns+ (Array<Array<String, String>>) is an assoc list of namespace declarations on the element
+  #
+  # 💡If you're dealing with HTML or don't care about namespaces, try #start_element instead.
+  #
+  # [Example]
+  #   it "start_elements_namespace is called with namespaced attributes" do
+  #     parser.parse(<<~XML)
+  #       <root xmlns:foo='http://foo.example.com/'>
+  #         <foo:a foo:bar='hello' />
+  #       </root>
+  #     XML
+  #
+  #     assert_pattern do
+  #       parser.document.start_elements_namespace => [
+  #         [
+  #           "root",
+  #           [],
+  #           nil, nil,
+  #           [["foo", "http://foo.example.com/"]], # namespace declarations
+  #         ], [
+  #           "a",
+  #           [Nokogiri::XML::SAX::Parser::Attribute(localname: "bar", prefix: "foo", uri: "http://foo.example.com/", value: "hello")], # prefixed attribute
+  #           "foo", "http://foo.example.com/", # prefix and uri for the "a" element
+  #           [],
+  #         ]
+  #       ]
+  #     end
+  #   end
+  #
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#166
   def start_element_namespace(name, attrs = T.unsafe(nil), prefix = T.unsafe(nil), uri = T.unsafe(nil), ns = T.unsafe(nil)); end
 
   # Called on document warnings
-  # +string+ contains the warning
+  # [Parameters]
+  # - +string+ contains the warning
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#143
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#231
   def warning(string); end
 
-  # Called when an XML declaration is parsed
+  # Called when an \XML declaration is parsed.
+  #
+  # [Parameters]
+  # - +version+ (String) the version attribute
+  # - +encoding+ (String, nil) the encoding of the document if present, else +nil+
+  # - +standalone+ ("yes", "no", nil) the standalone attribute if present, else +nil+
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#69
+  # source://nokogiri//lib/nokogiri/xml/sax/document.rb#73
   def xmldecl(version, encoding, standalone); end
 end
 
-# This parser is a SAX style parser that reads it's input as it
-# deems necessary.  The parser takes a Nokogiri::XML::SAX::Document,
-# an optional encoding, then given an XML input, sends messages to
-# the Nokogiri::XML::SAX::Document.
+# This parser is a SAX style parser that reads its input as it deems necessary. The parser
+# takes a Nokogiri::XML::SAX::Document, an optional encoding, then given an XML input, sends
+# messages to the Nokogiri::XML::SAX::Document.
 #
 # Here is an example of using this parser:
 #
 #   # Create a subclass of Nokogiri::XML::SAX::Document and implement
 #   # the events we care about:
-#   class MyDoc < Nokogiri::XML::SAX::Document
+#   class MyHandler < Nokogiri::XML::SAX::Document
 #     def start_element name, attrs = []
 #       puts "starting: #{name}"
 #     end
@@ -6497,89 +7150,165 @@ end
 #     end
 #   end
 #
-#   # Create our parser
-#   parser = Nokogiri::XML::SAX::Parser.new(MyDoc.new)
+#   parser = Nokogiri::XML::SAX::Parser.new(MyHandler.new)
 #
-#   # Send some XML to the parser
-#   parser.parse(File.open(ARGV[0]))
+#   # Hand an IO object to the parser, which will read the XML from the IO.
+#   File.open(path_to_xml) do |f|
+#     parser.parse(f)
+#   end
+#
+# For more information about \SAX parsers, see Nokogiri::XML::SAX.
+#
+# Also see Nokogiri::XML::SAX::Document for the available events.
 #
-# For more information about SAX parsers, see Nokogiri::XML::SAX.  Also
-# see Nokogiri::XML::SAX::Document for the available events.
+# For \HTML documents, use the subclass Nokogiri::HTML4::SAX::Parser.
 #
-# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#34
+# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#38
 class Nokogiri::XML::SAX::Parser
-  # Create a new Parser with +doc+ and +encoding+
+  include ::Nokogiri::ClassResolver
+
+  # :call-seq:
+  #   new ⇒ SAX::Parser
+  #   new(handler) ⇒ SAX::Parser
+  #   new(handler, encoding) ⇒ SAX::Parser
+  #
+  # Create a new Parser.
+  #
+  # [Parameters]
+  # - +handler+ (optional Nokogiri::XML::SAX::Document) The document that will receive
+  #   events. Will create a new Nokogiri::XML::SAX::Document if not given, which is accessible
+  #   through the #document attribute.
+  # - +encoding+ (optional Encoding, String, nil) An Encoding or encoding name to use when
+  #   parsing the input. (default +nil+ for auto-detection)
   #
   # @return [Parser] a new instance of Parser
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#72
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#95
   def initialize(doc = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   # The Nokogiri::XML::SAX::Document where events will be sent.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#66
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#75
   def document; end
 
   # The Nokogiri::XML::SAX::Document where events will be sent.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#66
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#75
   def document=(_arg0); end
 
   # The encoding beings used for this document.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#69
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#78
   def encoding; end
 
   # The encoding beings used for this document.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#69
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#78
   def encoding=(_arg0); end
 
-  # Parse given +thing+ which may be a string containing xml, or an
-  # IO object.
+  # :call-seq:
+  #   parse(input) { |parser_context| ... }
+  #
+  # Parse the input, sending events to the SAX::Document at #document.
+  #
+  # [Parameters]
+  # - +input+ (String, IO) The input to parse.
+  #
+  # If +input+ quacks like a readable IO object, this method forwards to Parser.parse_io,
+  # otherwise it forwards to Parser.parse_memory.
+  #
+  # [Yields]
+  # If a block is given, the underlying ParserContext object will be yielded. This can be used
+  # to set options on the parser context before parsing begins.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#81
-  def parse(thing, &block); end
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#119
+  def parse(input, &block); end
 
-  # Parse a file with +filename+
+  # :call-seq:
+  #   parse_file(filename) { |parser_context| ... }
+  #   parse_file(filename, encoding) { |parser_context| ... }
+  #
+  # Parse a file.
+  #
+  # [Parameters]
+  # - +filename+ (String) The path to the file to be parsed.
+  # - +encoding+ (optional Encoding, String, nil) An Encoding or encoding name to use when
+  #   parsing the input, or +nil+ for auto-detection. (default #encoding)
+  #
+  # [Yields]
+  # If a block is given, the underlying ParserContext object will be yielded. This can be used
+  # to set options on the parser context before parsing begins.
   #
   # @raise [ArgumentError]
   # @yield [ctx]
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#99
-  def parse_file(filename); end
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#187
+  def parse_file(filename, encoding = T.unsafe(nil)); end
 
-  # Parse given +io+
+  # :call-seq:
+  #   parse_io(io) { |parser_context| ... }
+  #   parse_io(io, encoding) { |parser_context| ... }
+  #
+  # Parse an input stream.
+  #
+  # [Parameters]
+  # - +io+ (IO) The readable IO object from which to read input
+  # - +encoding+ (optional Encoding, String, nil) An Encoding or encoding name to use when
+  #   parsing the input, or +nil+ for auto-detection. (default #encoding)
+  #
+  # [Yields]
+  # If a block is given, the underlying ParserContext object will be yielded. This can be used
+  # to set options on the parser context before parsing begins.
   #
   # @yield [ctx]
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#91
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#143
   def parse_io(io, encoding = T.unsafe(nil)); end
 
+  # :call-seq:
+  #   parse_memory(input) { |parser_context| ... }
+  #   parse_memory(input, encoding) { |parser_context| ... }
+  #
+  # Parse an input string.
+  #
+  # [Parameters]
+  # - +input+ (String) The input string to be parsed.
+  # - +encoding+ (optional Encoding, String, nil) An Encoding or encoding name to use when
+  #   parsing the input, or +nil+ for auto-detection. (default #encoding)
+  #
+  # [Yields]
+  # If a block is given, the underlying ParserContext object will be yielded. This can be used
+  # to set options on the parser context before parsing begins.
+  #
   # @yield [ctx]
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#109
-  def parse_memory(data); end
+  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#165
+  def parse_memory(input, encoding = T.unsafe(nil)); end
 
   private
 
-  # source://nokogiri//lib/nokogiri/xml/sax/parser.rb#117
-  def check_encoding(encoding); end
+  def initialize_native; end
 end
 
-# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#35
+# Structure used for marshalling attributes for some callbacks in XML::SAX::Document.
+#
+# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#43
 class Nokogiri::XML::SAX::Parser::Attribute < ::Struct; end
 
-# Encodinds this parser supports
-#
-# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#39
+# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#46
 Nokogiri::XML::SAX::Parser::ENCODINGS = T.let(T.unsafe(nil), Hash)
 
-# Context for XML SAX parsers.  This class is usually not instantiated
-# by the user.  Instead, you should be looking at
-# Nokogiri::XML::SAX::Parser
+# pure ASCII
 #
-# source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#10
+# source://nokogiri//lib/nokogiri/xml/sax/parser.rb#71
+Nokogiri::XML::SAX::Parser::REVERSE_ENCODINGS = T.let(T.unsafe(nil), Hash)
+
+# Context object to invoke the XML SAX parser on the SAX::Document handler.
+#
+# 💡 This class is usually not instantiated by the user. Use Nokogiri::XML::SAX::Parser
+# instead.
+#
+# source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#11
 class Nokogiri::XML::SAX::ParserContext
   def column; end
   def line; end
@@ -6590,12 +7319,91 @@ class Nokogiri::XML::SAX::ParserContext
   def replace_entities=(_arg0); end
 
   class << self
-    def file(_arg0); end
-    def io(_arg0, _arg1); end
-    def memory(_arg0); end
+    # :call-seq:
+    #   file(path)
+    #   file(path, encoding)
+    #
+    # Create a parser context for the file at +path+.
+    #
+    # [Parameters]
+    # - +path+ (String) The path to the input file
+    # - +encoding+ (optional) (Encoding, String) The +Encoding+ to use, or the name of an encoding to
+    #   use (default +nil+, encoding will be autodetected)
+    #
+    # [Returns] Nokogiri::XML::SAX::ParserContext
+    #
+    # 💡 Calling this method directly is discouraged. Use Nokogiri::XML::SAX::Parser.parse_file which
+    # is more convenient for most use cases.
+    #
+    # source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#97
+    def file(input, encoding = T.unsafe(nil)); end
+
+    # :call-seq:
+    #   io(input)
+    #   io(input, encoding)
+    #
+    # Create a parser context for an +input+ IO which will assume +encoding+
+    #
+    # [Parameters]
+    # - +io+ (IO) The readable IO object from which to read input
+    # - +encoding+ (optional) (Encoding) The +Encoding+ to use, or the name of an
+    #   encoding to use (default +nil+, encoding will be autodetected)
+    #
+    # [Returns] Nokogiri::XML::SAX::ParserContext
+    #
+    # 💡 Calling this method directly is discouraged. Use Nokogiri::XML::SAX::Parser parse
+    # methods which are more convenient for most use cases.
+    #
+    # source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#56
+    def io(input, encoding = T.unsafe(nil)); end
+
+    # :call-seq:
+    #   memory(input)
+    #   memory(input, encoding)
+    #
+    # Create a parser context for the +input+ String.
+    #
+    # [Parameters]
+    # - +input+ (String) The input string to be parsed.
+    # - +encoding+ (optional) (Encoding, String) The +Encoding+ to use, or the name of an encoding to
+    #   use (default +nil+, encoding will be autodetected)
+    #
+    # [Returns] Nokogiri::XML::SAX::ParserContext
+    #
+    # 💡 Calling this method directly is discouraged. Use Nokogiri::XML::SAX::Parser parse methods
+    # which are more convenient for most use cases.
+    #
+    # source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#77
+    def memory(input, encoding = T.unsafe(nil)); end
 
-    # source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#11
-    def new(thing, encoding = T.unsafe(nil)); end
+    def native_file(_arg0, _arg1); end
+    def native_io(_arg0, _arg1); end
+    def native_memory(_arg0, _arg1); end
+
+    # :call-seq:
+    #   new(input)
+    #   new(input, encoding)
+    #
+    # Create a parser context for an IO or a String. This is a shorthand method for
+    # ParserContext.io and ParserContext.memory.
+    #
+    # [Parameters]
+    # - +input+ (IO, String) A String or a readable IO object
+    # - +encoding+ (optional) (Encoding) The +Encoding+ to use, or the name of an
+    #   encoding to use (default +nil+, encoding will be autodetected)
+    #
+    # If +input+ quacks like a readable IO object, this method forwards to ParserContext.io,
+    # otherwise it forwards to ParserContext.memory.
+    #
+    # [Returns] Nokogiri::XML::SAX::ParserContext
+    #
+    # source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#31
+    def new(input, encoding = T.unsafe(nil)); end
+
+    private
+
+    # source://nokogiri//lib/nokogiri/xml/sax/parser_context.rb#101
+    def resolve_encoding(encoding); end
   end
 end
 
@@ -6651,7 +7459,10 @@ class Nokogiri::XML::SAX::PushParser
   # Finish the parsing.  This method is only necessary for
   # Nokogiri::XML::SAX::Document#end_document to be called.
   #
-  # source://nokogiri//lib/nokogiri/xml/sax/push_parser.rb#55
+  # ⚠ Note that empty documents are treated as an error when using the libxml2-based
+  # implementation (CRuby), but are fine when using the Xerces-based implementation (JRuby).
+  #
+  # source://nokogiri//lib/nokogiri/xml/sax/push_parser.rb#58
   def finish; end
 
   def options; end
@@ -6671,66 +7482,112 @@ class Nokogiri::XML::SAX::PushParser
   def native_write(_arg0, _arg1); end
 end
 
-# Nokogiri::XML::Schema is used for validating XML against a schema
-# (usually from an xsd file).
+# Nokogiri::XML::Schema is used for validating \XML against an \XSD schema definition.
 #
-# == Synopsis
+# ⚠ Since v1.11.0, Schema treats inputs as *untrusted* by default, and so external entities are
+# not resolved from the network (+http://+ or +ftp://+). When parsing a trusted document, the
+# caller may turn off the +NONET+ option via the ParseOptions to (re-)enable external entity
+# resolution over a network connection.
 #
-# Validate an XML document against a Schema.  Loop over the errors that
-# are returned and print them out:
+# 🛡 Before v1.11.0, documents were "trusted" by default during schema parsing which was counter
+# to Nokogiri's "untrusted by default" security policy.
 #
-#   xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
-#   doc = Nokogiri::XML(File.read(PO_XML_FILE))
+# *Example:* Determine whether an \XML document is valid.
 #
-#   xsd.validate(doc).each do |error|
-#     puts error.message
-#   end
+#   schema = Nokogiri::XML::Schema.new(File.read(XSD_FILE))
+#   doc = Nokogiri::XML::Document.parse(File.read(XML_FILE))
+#   schema.valid?(doc) # Boolean
+#
+# *Example:* Validate an \XML document against an \XSD schema, and capture any errors that are found.
+#
+#   schema = Nokogiri::XML::Schema.new(File.read(XSD_FILE))
+#   doc = Nokogiri::XML::Document.parse(File.read(XML_FILE))
+#   errors = schema.validate(doc) # Array<SyntaxError>
 #
-# The list of errors are Nokogiri::XML::SyntaxError objects.
+# *Example:* Validate an \XML document using a Document containing an \XSD schema definition.
 #
-# NOTE: As of v1.11.0, Schema treats inputs as UNTRUSTED by default, and so external entities
-# are not resolved from the network (`http://` or `ftp://`). Previously, parsing treated
-# documents as "trusted" by default which was counter to Nokogiri's "untrusted by default"
-# security policy. If a document is trusted, then the caller may turn off the NONET option via
-# the ParseOptions to re-enable external entity resolution over a network connection.
+#   schema_doc = Nokogiri::XML::Document.parse(File.read(RELAX_NG_FILE))
+#   schema = Nokogiri::XML::Schema.from_document(schema_doc)
+#   doc = Nokogiri::XML::Document.parse(File.read(XML_FILE))
+#   schema.valid?(doc) # Boolean
 #
-# source://nokogiri//lib/nokogiri/xml/schema.rb#37
+# source://nokogiri//lib/nokogiri/xml/schema.rb#45
 class Nokogiri::XML::Schema
-  # Errors while parsing the schema file
+  # The errors found while parsing the \XSD
   #
-  # source://nokogiri//lib/nokogiri/xml/schema.rb#39
+  # [Returns] Array<Nokogiri::XML::SyntaxError>
+  #
+  # source://nokogiri//lib/nokogiri/xml/schema.rb#49
   def errors; end
 
-  # Errors while parsing the schema file
+  # The errors found while parsing the \XSD
+  #
+  # [Returns] Array<Nokogiri::XML::SyntaxError>
   #
-  # source://nokogiri//lib/nokogiri/xml/schema.rb#39
+  # source://nokogiri//lib/nokogiri/xml/schema.rb#49
   def errors=(_arg0); end
 
-  # The Nokogiri::XML::ParseOptions used to parse the schema
+  # The options used to parse the schema
   #
-  # source://nokogiri//lib/nokogiri/xml/schema.rb#41
+  # [Returns] Nokogiri::XML::ParseOptions
+  #
+  # source://nokogiri//lib/nokogiri/xml/schema.rb#54
   def parse_options; end
 
-  # The Nokogiri::XML::ParseOptions used to parse the schema
+  # The options used to parse the schema
+  #
+  # [Returns] Nokogiri::XML::ParseOptions
   #
-  # source://nokogiri//lib/nokogiri/xml/schema.rb#41
+  # source://nokogiri//lib/nokogiri/xml/schema.rb#54
   def parse_options=(_arg0); end
 
-  # Returns true if +thing+ is a valid Nokogiri::XML::Document or
-  # file.
+  # :call-seq: valid?(input) → Boolean
+  #
+  # Validate +input+ and return a Boolean indicating whether the document is valid
+  #
+  # [Parameters]
+  # - +input+ (Nokogiri::XML::Document | String)
+  #   A parsed document, or a string containing a local filename.
+  #
+  # [Returns] Boolean
+  #
+  # *Example:* Validate an existing XML::Document
+  #
+  #   schema = Nokogiri::XML::Schema.new(File.read(XSD_FILE))
+  #   return unless schema.valid?(document)
+  #
+  # *Example:* Validate an \XML document on disk
+  #
+  #   schema = Nokogiri::XML::Schema.new(File.read(XSD_FILE))
+  #   return unless schema.valid?("/path/to/file.xml")
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/schema.rb#68
-  def valid?(thing); end
+  # source://nokogiri//lib/nokogiri/xml/schema.rb#135
+  def valid?(input); end
 
-  # Validate +thing+ against this schema.  +thing+ can be a
-  # Nokogiri::XML::Document object, or a filename.  An Array of
-  # Nokogiri::XML::SyntaxError objects found while validating the
-  # +thing+ is returned.
+  # :call-seq: validate(input) → Array<SyntaxError>
   #
-  # source://nokogiri//lib/nokogiri/xml/schema.rb#55
-  def validate(thing); end
+  # Validate +input+ and return any errors that are found.
+  #
+  # [Parameters]
+  # - +input+ (Nokogiri::XML::Document | String)
+  #   A parsed document, or a string containing a local filename.
+  #
+  # [Returns] Array<SyntaxError>
+  #
+  # *Example:* Validate an existing XML::Document, and capture any errors that are found.
+  #
+  #   schema = Nokogiri::XML::Schema.new(File.read(XSD_FILE))
+  #   errors = schema.validate(document)
+  #
+  # *Example:* Validate an \XML document on disk, and capture any errors that are found.
+  #
+  #   schema = Nokogiri::XML::Schema.new(File.read(XSD_FILE))
+  #   errors = schema.validate("/path/to/file.xml")
+  #
+  # source://nokogiri//lib/nokogiri/xml/schema.rb#104
+  def validate(input); end
 
   private
 
@@ -6740,13 +7597,30 @@ class Nokogiri::XML::Schema
   class << self
     def from_document(*_arg0); end
 
-    # Create a new Nokogiri::XML::Schema object using a +string_or_io+
-    # object.
+    # :call-seq:
+    #   new(input) → Nokogiri::XML::Schema
+    #   new(input, parse_options) → Nokogiri::XML::Schema
+    #
+    # Parse an \XSD schema definition from a String or IO to create a new Nokogiri::XML::Schema
+    #
+    # [Parameters]
+    # - +input+ (String | IO) \XSD schema definition
+    # - +parse_options+ (Nokogiri::XML::ParseOptions)
+    #   Defaults to Nokogiri::XML::ParseOptions::DEFAULT_SCHEMA
     #
-    # source://nokogiri//lib/nokogiri/xml/schema.rb#46
-    def new(string_or_io, options = T.unsafe(nil)); end
+    # [Returns] Nokogiri::XML::Schema
+    #
+    # source://nokogiri//lib/nokogiri/xml/schema.rb#69
+    def new(input, parse_options_ = T.unsafe(nil), parse_options: T.unsafe(nil)); end
 
-    def read_memory(*_arg0); end
+    # :call-seq:
+    #   read_memory(input) → Nokogiri::XML::Schema
+    #   read_memory(input, parse_options) → Nokogiri::XML::Schema
+    #
+    # Convenience method for Nokogiri::XML::Schema.new
+    #
+    # source://nokogiri//lib/nokogiri/xml/schema.rb#78
+    def read_memory(*_arg0, **_arg1, &_arg2); end
   end
 end
 
@@ -6978,7 +7852,7 @@ module Nokogiri::XML::Searchable
   # source://nokogiri//lib/nokogiri/xml/searchable.rb#241
   def css_rules_to_xpath(rules, ns); end
 
-  # source://nokogiri//lib/nokogiri/xml/searchable.rb#259
+  # source://nokogiri//lib/nokogiri/xml/searchable.rb#257
   def extract_params(params); end
 
   # source://nokogiri//lib/nokogiri/xml/searchable.rb#229
@@ -7004,97 +7878,113 @@ Nokogiri::XML::Searchable::LOOKS_LIKE_XPATH = T.let(T.unsafe(nil), Regexp)
 class Nokogiri::XML::SyntaxError < ::Nokogiri::SyntaxError
   # Returns the value of attribute code.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#10
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#23
   def code; end
 
   # Returns the value of attribute column.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#18
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#40
   def column; end
 
   # Returns the value of attribute domain.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#9
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#22
   def domain; end
 
   # return true if this is an error
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#34
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#56
   def error?; end
 
   # return true if this error is fatal
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#40
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#62
   def fatal?; end
 
   # Returns the value of attribute file.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#12
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#25
   def file; end
 
   # Returns the value of attribute int1.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#17
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#39
   def int1; end
 
   # Returns the value of attribute level.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#11
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#24
   def level; end
 
   # Returns the value of attribute line.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#13
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#26
   def line; end
 
   # return true if this is a non error
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#22
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#44
   def none?; end
 
+  # The XPath path of the node that caused the error when validating a `Nokogiri::XML::Document`.
+  #
+  # This attribute will only be non-nil when the error is emitted by `Schema#validate` on
+  # Document objects. It will return `nil` for DOM parsing errors and for errors emitted during
+  # Schema validation of files.
+  #
+  # ⚠ `#path` is not supported on JRuby, where it will always return `nil`.
+  #
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#35
+  def path; end
+
   # Returns the value of attribute str1.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#14
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#36
   def str1; end
 
   # Returns the value of attribute str2.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#15
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#37
   def str2; end
 
   # Returns the value of attribute str3.
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#16
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#38
   def str3; end
 
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#44
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#66
   def to_s; end
 
   # return true if this is a warning
   #
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#28
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#50
   def warning?; end
 
   private
 
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#53
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#75
   def level_to_s; end
 
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#65
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#87
   def location_to_s; end
 
   # @return [Boolean]
   #
-  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#61
+  # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#83
   def nil_or_zero?(attribute); end
+
+  class << self
+    # source://nokogiri//lib/nokogiri/xml/syntax_error.rb#10
+    def aggregate(errors); end
+  end
 end
 
 # source://nokogiri//lib/nokogiri/xml/text.rb#5
@@ -7109,17 +7999,17 @@ end
 
 # Original C14N 1.0 spec canonicalization
 #
-# source://nokogiri//lib/nokogiri/xml.rb#14
+# source://nokogiri//lib/nokogiri/xml.rb#13
 Nokogiri::XML::XML_C14N_1_0 = T.let(T.unsafe(nil), Integer)
 
 # C14N 1.1 spec canonicalization
 #
-# source://nokogiri//lib/nokogiri/xml.rb#18
+# source://nokogiri//lib/nokogiri/xml.rb#17
 Nokogiri::XML::XML_C14N_1_1 = T.let(T.unsafe(nil), Integer)
 
 # Exclusive C14N 1.0 spec canonicalization
 #
-# source://nokogiri//lib/nokogiri/xml.rb#16
+# source://nokogiri//lib/nokogiri/xml.rb#15
 Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0 = T.let(T.unsafe(nil), Integer)
 
 # source://nokogiri//lib/nokogiri/xml/xpath.rb#5
@@ -7171,7 +8061,7 @@ end
 # See Nokogiri::XSLT::Stylesheet for creating and manipulating
 # Stylesheet object.
 #
-# source://nokogiri//lib/nokogiri/xslt.rb#21
+# source://nokogiri//lib/nokogiri/xslt.rb#15
 module Nokogiri::XSLT
   class << self
     # :call-seq:
@@ -7227,7 +8117,7 @@ module Nokogiri::XSLT
     #   #    "  <reverse>raB</reverse>\n" +
     #   #    "</reversed>\n"
     #
-    # source://nokogiri//lib/nokogiri/xslt.rb#76
+    # source://nokogiri//lib/nokogiri/xslt.rb#70
     def parse(string, modules = T.unsafe(nil)); end
 
     # :call-seq:
@@ -7241,7 +8131,7 @@ module Nokogiri::XSLT
     #
     # [Returns] Array of string parameters, with quotes correctly escaped for use with XSLT::Stylesheet.transform
     #
-    # source://nokogiri//lib/nokogiri/xslt.rb#100
+    # source://nokogiri//lib/nokogiri/xslt.rb#94
     def quote_params(params); end
 
     def register(_arg0, _arg1); end