lightning_ui_kit 0.3.3 → 0.3.5

data/vendor/bundle/ruby/3.4.0/gems/nokogiri-1.19.3-x86_64-linux-gnu/lib/nokogiri/css/tokenizer.rex

@@ -0,0 +1,57 @@
+module Nokogiri
+module CSS
+# :nodoc: all
+class Tokenizer
+
+macro
+  nl        (\n|\r\n|\r|\f)
+  w         [\s]*
+  nonascii  [^\0-\177]
+  num       -?([0-9]+|[0-9]*\.[0-9]+)
+  unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s])?
+
+  escape    ({unicode}|\\[^\n\r\f0-9A-Fa-f])
+  nmchar    (?>[_A-Za-z0-9-]|{nonascii}|{escape})
+  nmstart   (?>[_A-Za-z]|{nonascii}|{escape})
+  name      {nmstart}{nmchar}*
+  ident     -?{name}
+  charref   {nmchar}+
+  string1   "(?>[^\n\r\f"\\]|\\?{nl}|{nonascii}|{escape})*"
+  string2   '(?>[^\n\r\f'\\]|\\?{nl}|{nonascii}|{escape})*'
+  string    ({string1}|{string2})
+
+rule
+
+# [:state]  pattern  [actions]
+
+            has\({w}         { [:HAS, text] }
+            {ident}\({w}     { [:FUNCTION, text] }
+            {ident}          { [:IDENT, text] }
+            \#{charref}      { [:HASH, text] }
+            {w}~={w}         { [:INCLUDES, text] }
+            {w}\|={w}        { [:DASHMATCH, text] }
+            {w}\^={w}        { [:PREFIXMATCH, text] }
+            {w}\$={w}        { [:SUFFIXMATCH, text] }
+            {w}\*={w}        { [:SUBSTRINGMATCH, text] }
+            {w}!={w}         { [:NOT_EQUAL, text] }
+            {w}={w}          { [:EQUAL, text] }
+            {w}\)            { [:RPAREN, text] }
+            \[{w}            { [:LSQUARE, text] }
+            {w}\]            { [:RSQUARE, text] }
+            {w}\+{w}         { [:PLUS, text] }
+            {w}>{w}          { [:GREATER, text] }
+            {w},{w}          { [:COMMA, text] }
+            {w}~{w}          { [:TILDE, text] }
+            \:not\({w}       { [:NOT, text] }
+            {num}            { [:NUMBER, text] }
+            {w}\/\/{w}       { [:DOUBLESLASH, text] }
+            {w}\/{w}         { [:SLASH, text] }
+
+            U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
+
+            [\s]+            { [:S, text] }
+            {string}         { [:STRING, text] }
+            .                { [text, text] }
+end
+end
+end

data/vendor/bundle/ruby/3.4.0/gems/nokogiri-1.19.3-x86_64-linux-gnu/lib/nokogiri/jruby/nokogiri_jars.rb

@@ -0,0 +1,48 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+begin
+  require 'jar_dependencies'
+rescue LoadError
+  require 'isorelax/isorelax/20030108/isorelax-20030108.jar'
+  require 'org/nokogiri/nekodtd/0.1.11.noko2/nekodtd-0.1.11.noko2.jar'
+  require 'net/sourceforge/htmlunit/neko-htmlunit/2.63.0/neko-htmlunit-2.63.0.jar'
+  require 'net/sf/saxon/Saxon-HE/12.7/Saxon-HE-12.7.jar'
+  require 'org/xmlresolver/xmlresolver/5.3.3/xmlresolver-5.3.3.jar'
+  require 'org/xmlresolver/xmlresolver/5.3.3/xmlresolver-5.3.3-data.jar'
+  require 'nu/validator/jing/20200702VNU/jing-20200702VNU.jar'
+  require 'xalan/serializer/2.7.3/serializer-2.7.3.jar'
+  require 'xalan/xalan/2.7.3/xalan-2.7.3.jar'
+  require 'xerces/xercesImpl/2.12.2/xercesImpl-2.12.2.jar'
+  require 'xml-apis/xml-apis/1.4.01/xml-apis-1.4.01.jar'
+end
+
+if defined? Jars
+  require_jar 'isorelax', 'isorelax', '20030108'
+  require_jar 'org.nokogiri', 'nekodtd', '0.1.11.noko2'
+  require_jar 'net.sourceforge.htmlunit', 'neko-htmlunit', '2.63.0'
+  require_jar 'net.sf.saxon', 'Saxon-HE', '12.7'
+  require_jar 'org.xmlresolver', 'xmlresolver', '5.3.3'
+  require_jar 'org.xmlresolver', 'xmlresolver', 'data', '5.3.3'
+  require_jar 'nu.validator', 'jing', '20200702VNU'
+  require_jar 'xalan', 'serializer', '2.7.3'
+  require_jar 'xalan', 'xalan', '2.7.3'
+  require_jar 'xerces', 'xercesImpl', '2.12.2'
+  require_jar 'xml-apis', 'xml-apis', '1.4.01'
+end
+
+module Nokogiri
+  # generated by the :vendor_jars rake task
+  JAR_DEPENDENCIES = {
+    "isorelax:isorelax" => "20030108",
+    "net.sf.saxon:Saxon-HE" => "12.7",
+    "net.sourceforge.htmlunit:neko-htmlunit" => "2.63.0",
+    "nu.validator:jing" => "20200702VNU",
+    "org.nokogiri:nekodtd" => "0.1.11.noko2",
+    "org.xmlresolver:xmlresolver" => "5.3.3",
+    "xalan:serializer" => "2.7.3",
+    "xalan:xalan" => "2.7.3",
+    "xerces:xercesImpl" => "2.12.2",
+    "xml-apis:xml-apis" => "1.4.01",
+  }.freeze
+  XERCES_VERSION = JAR_DEPENDENCIES["xerces:xercesImpl"]
+  NEKO_VERSION = JAR_DEPENDENCIES["net.sourceforge.htmlunit:neko-htmlunit"]
+end

data/vendor/bundle/ruby/3.4.0/gems/nokogiri-1.19.3-x86_64-linux-gnu/lib/nokogiri/version/constant.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  # The version of Nokogiri you are using
+  VERSION = "1.19.3"
+end

data/vendor/bundle/ruby/3.4.0/gems/nokogiri-1.19.3-x86_64-linux-gnu/lib/nokogiri/xml/parse_options.rb

@@ -0,0 +1,217 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    # Options that control the parsing behavior for XML::Document, XML::DocumentFragment,
+    # HTML4::Document, HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
+    #
+    # These options directly expose libxml2's parse options, which are all boolean in the sense that
+    # an option is "on" or "off".
+    #
+    # 💡 Note that HTML5 parsing has a separate, orthogonal set of options due to the nature of the
+    # HTML5 specification. See Nokogiri::HTML5.
+    #
+    # ⚠ Not all parse options are supported on JRuby. Nokogiri will attempt to invoke the equivalent
+    # behavior in Xerces/NekoHTML on JRuby when it's possible.
+    #
+    # == Setting and unsetting parse options
+    #
+    # You can build your own combinations of parse options by using any of the following methods:
+    #
+    # [ParseOptions method chaining]
+    #
+    #   Every option has an equivalent method in lowercase. You can chain these methods together to
+    #   set various combinations.
+    #
+    #     # Set the HUGE & PEDANTIC options
+    #     po = Nokogiri::XML::ParseOptions.new.huge.pedantic
+    #     doc = Nokogiri::XML::Document.parse(xml, nil, nil, po)
+    #
+    #   Every option has an equivalent <code>no{option}</code> method in lowercase. You can call these
+    #   methods on an instance of ParseOptions to unset the option.
+    #
+    #     # Set the HUGE & PEDANTIC options
+    #     po = Nokogiri::XML::ParseOptions.new.huge.pedantic
+    #
+    #     # later we want to modify the options
+    #     po.nohuge # Unset the HUGE option
+    #     po.nopedantic # Unset the PEDANTIC option
+    #
+    #   💡 Note that some options begin with "no" leading to the logical but perhaps unintuitive
+    #   double negative:
+    #
+    #     po.nocdata # Set the NOCDATA parse option
+    #     po.nonocdata # Unset the NOCDATA parse option
+    #
+    #   💡 Note that negation is not available for STRICT, which is itself a negation of all other
+    #   features.
+    #
+    #
+    # [Using Ruby Blocks]
+    #
+    #   Most parsing methods will accept a block for configuration of parse options, and we
+    #   recommend chaining the setter methods:
+    #
+    #     doc = Nokogiri::XML::Document.parse(xml) { |config| config.huge.pedantic }
+    #
+    #
+    # [ParseOptions constants]
+    #
+    #   You can also use the constants declared under Nokogiri::XML::ParseOptions to set various
+    #   combinations. They are bits in a bitmask, and so can be combined with bitwise operators:
+    #
+    #     po = Nokogiri::XML::ParseOptions.new(Nokogiri::XML::ParseOptions::HUGE | Nokogiri::XML::ParseOptions::PEDANTIC)
+    #     doc = Nokogiri::XML::Document.parse(xml, nil, nil, po)
+    #
+    class ParseOptions
+      # Strict parsing
+      STRICT      = 0
+
+      # Recover from errors. On by default for XML::Document, XML::DocumentFragment,
+      # HTML4::Document, HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
+      RECOVER     = 1 << 0
+
+      # Substitute entities. Off by default.
+      #
+      # ⚠ This option enables entity substitution, contrary to what the name implies.
+      #
+      # 🛡 <b>It is UNSAFE to set this option</b> when parsing untrusted documents.
+      NOENT       = 1 << 1
+
+      # Load external subsets. On by default for XSLT::Stylesheet.
+      #
+      # 🛡 <b>It is UNSAFE to set this option</b> when parsing untrusted documents.
+      DTDLOAD     = 1 << 2
+
+      # Default DTD attributes. On by default for XSLT::Stylesheet.
+      DTDATTR     = 1 << 3
+
+      # Validate with the DTD. Off by default.
+      DTDVALID    = 1 << 4
+
+      # Suppress error reports. On by default for HTML4::Document and HTML4::DocumentFragment
+      NOERROR     = 1 << 5
+
+      # Suppress warning reports. On by default for HTML4::Document and HTML4::DocumentFragment
+      NOWARNING   = 1 << 6
+
+      # Enable pedantic error reporting. Off by default.
+      PEDANTIC    = 1 << 7
+
+      # Remove blank nodes. Off by default.
+      NOBLANKS    = 1 << 8
+
+      # Use the SAX1 interface internally. Off by default.
+      SAX1        = 1 << 9
+
+      # Implement XInclude substitution. Off by default.
+      XINCLUDE    = 1 << 10
+
+      # Forbid network access. On by default for XML::Document, XML::DocumentFragment,
+      # HTML4::Document, HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
+      #
+      # 🛡 <b>It is UNSAFE to unset this option</b> when parsing untrusted documents.
+      NONET       = 1 << 11
+
+      # Do not reuse the context dictionary. Off by default.
+      NODICT      = 1 << 12
+
+      # Remove redundant namespaces declarations. Off by default.
+      NSCLEAN     = 1 << 13
+
+      # Merge CDATA as text nodes. On by default for XSLT::Stylesheet.
+      NOCDATA     = 1 << 14
+
+      # Do not generate XInclude START/END nodes. Off by default.
+      NOXINCNODE  = 1 << 15
+
+      # Compact small text nodes. Off by default.
+      #
+      # ⚠ No modification of the DOM tree is allowed after parsing.
+      COMPACT     = 1 << 16
+
+      # Parse using XML-1.0 before update 5. Off by default
+      OLD10       = 1 << 17
+
+      # Do not fixup XInclude xml:base uris. Off by default
+      NOBASEFIX   = 1 << 18
+
+      # Relax any hardcoded limit from the parser. Off by default.
+      #
+      # 🛡 <b>It is UNSAFE to set this option</b> when parsing untrusted documents.
+      HUGE        = 1 << 19
+
+      # Support line numbers up to <code>long int</code> (default is a <code>short int</code>). On
+      # by default for for XML::Document, XML::DocumentFragment, HTML4::Document,
+      # HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
+      BIG_LINES   = 1 << 22
+
+      # The options mask used by default for parsing XML::Document and XML::DocumentFragment
+      DEFAULT_XML  = RECOVER | NONET | BIG_LINES
+
+      # Shorthand options mask useful for parsing XSLT stylesheets:
+      # sets RECOVER, NONET, NOENT, DTDLOAD, DTDATTR, NOCDATA, BIG_LINES.
+      #
+      # 🛡 This option set includes `NOENT` and `DTDLOAD` which are unsafe for untrusted
+      # documents. <b>Do not parse untrusted XSLT stylesheets.</b> See Nokogiri::XSLT for more
+      # information.
+      DEFAULT_XSLT = RECOVER | NONET | NOENT | DTDLOAD | DTDATTR | NOCDATA | BIG_LINES
+
+      # The options mask used by default used for parsing HTML4::Document and HTML4::DocumentFragment
+      DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET | BIG_LINES
+
+      # The options mask used by default used for parsing XML::Schema
+      DEFAULT_SCHEMA = NONET | BIG_LINES
+
+      attr_accessor :options
+
+      def initialize(options = STRICT)
+        @options = options
+      end
+
+      constants.each do |constant|
+        next if constant.to_sym == :STRICT
+
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{constant.downcase}
+            @options |= #{constant}
+            self
+          end
+
+          def no#{constant.downcase}
+            @options &= ~#{constant}
+            self
+          end
+
+          def #{constant.downcase}?
+            #{constant} & @options == #{constant}
+          end
+        RUBY
+      end
+
+      def strict
+        @options &= ~RECOVER
+        self
+      end
+
+      def strict?
+        @options & RECOVER == STRICT
+      end
+
+      def ==(other)
+        other.to_i == to_i
+      end
+
+      alias_method :to_i, :options
+
+      def inspect
+        options = []
+        self.class.constants.each do |k|
+          options << k.downcase if send(:"#{k.downcase}?")
+        end
+        super.sub(/>$/, " " + options.join(", ") + ">")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/nokogiri-1.19.3-x86_64-linux-gnu/lib/nokogiri/xml/sax/document.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    module SAX
+      # :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 MyHandler < Nokogiri::XML::SAX::Document
+      #       def start_element name, attrs = []
+      #         puts "#{name} started!"
+      #       end
+      #
+      #       def end_element name
+      #         puts "#{name} ended"
+      #       end
+      #     end
+      #
+      # 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.
+      #
+      # 💡 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.
+      #
+      class Document
+        ###
+        # 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+
+        def xmldecl(version, encoding, standalone)
+        end
+
+        ###
+        # Called when document starts parsing.
+        def start_document
+        end
+
+        ###
+        # Called when document ends parsing.
+        def end_document
+        end
+
+        ###
+        # 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"] ]
+        #
+        # 💡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
+        #
+        def start_element(name, attrs = [])
+        end
+
+        ###
+        # Called at the end of an element.
+        #
+        # [Parameters]
+        # - +name+ (String) the name of the element being closed
+        #
+        def end_element(name)
+        end
+
+        ###
+        # Called at the beginning of an element.
+        #
+        # [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
+        #
+        def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = []) # rubocop:disable Metrics/ParameterLists
+          # Deal with SAX v1 interface
+          name = [prefix, name].compact.join(":")
+          attributes = ns.map do |ns_prefix, ns_uri|
+            [["xmlns", ns_prefix].compact.join(":"), ns_uri]
+          end + attrs.map do |attr|
+            [[attr.prefix, attr.localname].compact.join(":"), attr.value]
+          end
+          start_element(name, attributes)
+        end
+
+        ###
+        # Called at the end of an element.
+        #
+        # [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
+        #
+        def end_element_namespace(name, prefix = nil, uri = nil)
+          # Deal with SAX v1 interface
+          end_element([prefix, name].compact.join(":"))
+        end
+
+        ###
+        # 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
+        #
+        # ⚠ Please see Document@Entity+Handling for important information about how entities are handled.
+        #
+        # ⚠ This method might be called multiple times for a contiguous string of characters.
+        #
+        def characters(string)
+        end
+
+        ###
+        # 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
+        #
+        def reference(name, content)
+        end
+
+        ###
+        # Called when comments are encountered
+        # [Parameters]
+        # - +string+ contains the comment data
+        def comment(string)
+        end
+
+        ###
+        # Called on document warnings
+        # [Parameters]
+        # - +string+ contains the warning
+        def warning(string)
+        end
+
+        ###
+        # Called on document errors
+        # [Parameters]
+        # - +string+ contains the error
+        def error(string)
+        end
+
+        ###
+        # Called when cdata blocks are found
+        # [Parameters]
+        # - +string+ contains the cdata content
+        def cdata_block(string)
+        end
+
+        ###
+        # Called when processing instructions are found
+        # [Parameters]
+        # - +name+ is the target of the instruction
+        # - +content+ is the value of the instruction
+        def processing_instruction(name, content)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/nokogiri-1.19.3-x86_64-linux-gnu/lib/nokogiri/xslt/stylesheet.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XSLT
+    ###
+    # A Stylesheet represents an XSLT Stylesheet object. Stylesheet creation is done through
+    # Nokogiri::XSLT.parse (or the convenience method Nokogiri.XSLT). Here is an example of
+    # transforming an XML::Document with a Stylesheet:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #
+    #   xslt.transform(doc) # => Nokogiri::XML::Document
+    #
+    # 🛡 <b>This class does not support execution of untrusted stylesheets.</b> An untrusted
+    # stylesheet may consume a large amount of CPU, memory, or other system resources during
+    # transformation, and IO and file access are not restricted. See Nokogiri::XSLT for more
+    # information about the security implications of untrusted stylesheets.
+    #
+    # Many XSLT transformations include serialization behavior to emit a non-XML document. For these
+    # cases, please take care to invoke the #serialize method on the result of the transformation:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #   xslt.serialize(xslt.transform(doc)) # => String
+    #
+    # or use the #apply_to method, which is a shortcut for `serialize(transform(document))`:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #   xslt.apply_to(doc) # => String
+    #
+    # See Nokogiri::XSLT::Stylesheet#transform for more information and examples.
+    class Stylesheet
+      # :call-seq:
+      #   apply_to(document, params = []) -> String
+      #
+      # Apply an XSLT stylesheet to an XML::Document and serialize it properly. This method is
+      # equivalent to calling #serialize on the result of #transform.
+      #
+      # [Parameters]
+      # - +document+ is an instance of XML::Document to transform
+      # - +params+ is an array of strings used as XSLT parameters, passed into #transform
+      #
+      # [Returns]
+      #   A string containing the serialized result of the transformation.
+      #
+      # See Nokogiri::XSLT::Stylesheet#transform for more information and examples.
+      def apply_to(document, params = [])
+        serialize(transform(document, params))
+      end
+    end
+  end
+end