nokogiri 1.9.1 → 1.15.3

data/lib/nokogiri/html4/encoding_reader.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module HTML4
+    # Libxml2's parser has poor support for encoding detection.  First, it does not recognize the
+    # HTML5 style meta charset declaration.  Secondly, even if it successfully detects an encoding
+    # hint, it does not re-decode or re-parse the preceding part which may be garbled.
+    #
+    # EncodingReader aims to perform advanced encoding detection beyond what Libxml2 does, and to
+    # emulate rewinding of a stream and make Libxml2 redo parsing from the start when an encoding
+    # hint is found.
+
+    # :nodoc: all
+    class EncodingReader
+      class EncodingFound < StandardError
+        attr_reader :found_encoding
+
+        def initialize(encoding)
+          @found_encoding = encoding
+          super(format("encoding found: %s", encoding))
+        end
+      end
+
+      class SAXHandler < Nokogiri::XML::SAX::Document
+        attr_reader :encoding
+
+        def initialize
+          @encoding = nil
+          super()
+        end
+
+        def start_element(name, attrs = [])
+          return unless name == "meta"
+
+          attr = Hash[attrs]
+          (charset = attr["charset"]) &&
+            (@encoding = charset)
+          (http_equiv = attr["http-equiv"]) &&
+            http_equiv.match(/\AContent-Type\z/i) &&
+            (content = attr["content"]) &&
+            (m = content.match(/;\s*charset\s*=\s*([\w-]+)/)) &&
+            (@encoding = m[1])
+        end
+      end
+
+      class JumpSAXHandler < SAXHandler
+        def initialize(jumptag)
+          @jumptag = jumptag
+          super()
+        end
+
+        def start_element(name, attrs = [])
+          super
+          throw(@jumptag, @encoding) if @encoding
+          throw(@jumptag, nil) if /\A(?:div|h1|img|p|br)\z/.match?(name)
+        end
+      end
+
+      def self.detect_encoding(chunk)
+        (m = chunk.match(/\A(<\?xml[ \t\r\n][^>]*>)/)) &&
+          (return Nokogiri.XML(m[1]).encoding)
+
+        if Nokogiri.jruby?
+          (m = chunk.match(/(<meta\s)(.*)(charset\s*=\s*([\w-]+))(.*)/i)) &&
+            (return m[4])
+          catch(:encoding_found) do
+            Nokogiri::HTML4::SAX::Parser.new(JumpSAXHandler.new(:encoding_found)).parse(chunk)
+            nil
+          end
+        else
+          handler = SAXHandler.new
+          parser = Nokogiri::HTML4::SAX::PushParser.new(handler)
+          begin
+            parser << chunk
+          rescue
+            Nokogiri::SyntaxError
+          end
+          handler.encoding
+        end
+      end
+
+      def initialize(io)
+        @io = io
+        @firstchunk = nil
+        @encoding_found = nil
+      end
+
+      # This method is used by the C extension so that
+      # Nokogiri::HTML4::Document#read_io() does not leak memory when
+      # EncodingFound is raised.
+      attr_reader :encoding_found
+
+      def read(len)
+        # no support for a call without len
+
+        unless @firstchunk
+          (@firstchunk = @io.read(len)) || (return nil)
+
+          # This implementation expects that the first call from
+          # htmlReadIO() is made with a length long enough (~1KB) to
+          # achieve advanced encoding detection.
+          if (encoding = EncodingReader.detect_encoding(@firstchunk))
+            # The first chunk is stored for the next read in retry.
+            raise @encoding_found = EncodingFound.new(encoding)
+          end
+        end
+        @encoding_found = nil
+
+        ret = @firstchunk.slice!(0, len)
+        if (len -= ret.length) > 0
+          (rest = @io.read(len)) && ret << (rest)
+        end
+        if ret.empty?
+          nil
+        else
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/{html → html4}/entity_lookup.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Nokogiri
-  module HTML
+  module HTML4
     class EntityDescription < Struct.new(:value, :name, :description); end
 
     class EntityLookup
       ###
       # Look up entity with +name+
-      def [] name
+      def [](name)
         (val = get(name)) && val.value
       end
     end

data/lib/nokogiri/{html → html4}/sax/parser.rb

@@ -1,17 +1,16 @@
+# frozen_string_literal: true
+
 module Nokogiri
-  module HTML
+  module HTML4
     ###
-    # Nokogiri lets you write a SAX parser to process HTML but get HTML
-    # correction features.
+    # Nokogiri lets you write a SAX parser to process HTML but get HTML correction features.
     #
-    # See Nokogiri::HTML::SAX::Parser for a basic example of using a
-    # SAX parser with HTML.
+    # See Nokogiri::HTML4::SAX::Parser for a basic example of using a SAX parser with HTML.
     #
     # For more information on SAX parsers, see Nokogiri::XML::SAX
     module SAX
       ###
-      # This class lets you perform SAX style parsing on HTML with HTML
-      # error correction.
+      # This class lets you perform SAX style parsing on HTML with HTML error correction.
       #
       # Here is a basic usage example:
       #
@@ -21,40 +20,42 @@ module Nokogiri
       #     end
       #   end
       #
-      #   parser = Nokogiri::HTML::SAX::Parser.new(MyDoc.new)
+      #   parser = Nokogiri::HTML4::SAX::Parser.new(MyDoc.new)
       #   parser.parse(File.read(ARGV[0], mode: 'rb'))
       #
       # For more information on SAX parsers, see Nokogiri::XML::SAX
       class Parser < Nokogiri::XML::SAX::Parser
         ###
         # Parse html stored in +data+ using +encoding+
-        def parse_memory data, encoding = 'UTF-8'
-          raise ArgumentError unless data
-          return unless data.length > 0
+        def parse_memory(data, encoding = "UTF-8")
+          raise TypeError unless String === data
+          return if data.empty?
+
           ctx = ParserContext.memory(data, encoding)
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
         ###
         # Parse given +io+
-        def parse_io io, encoding = 'UTF-8'
+        def parse_io(io, encoding = "UTF-8")
           check_encoding(encoding)
           @encoding = encoding
           ctx = ParserContext.io(io, ENCODINGS[encoding])
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
         ###
         # Parse a file with +filename+
-        def parse_file filename, encoding = 'UTF-8'
+        def parse_file(filename, encoding = "UTF-8")
           raise ArgumentError unless filename
           raise Errno::ENOENT unless File.exist?(filename)
           raise Errno::EISDIR if File.directory?(filename)
+
           ctx = ParserContext.file(filename, encoding)
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
       end
     end

data/lib/nokogiri/html4/sax/parser_context.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module HTML4
+    module SAX
+      ###
+      # Context for HTML SAX parsers. This class is usually not instantiated by the user. Instead,
+      # you should be looking at Nokogiri::HTML4::SAX::Parser
+      class ParserContext < Nokogiri::XML::SAX::ParserContext
+        def self.new(thing, encoding = "UTF-8")
+          if [:read, :close].all? { |x| thing.respond_to?(x) }
+            super
+          else
+            memory(thing, encoding)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/{html → html4}/sax/push_parser.rb

@@ -1,34 +1,35 @@
+# frozen_string_literal: true
+
 module Nokogiri
-  module HTML
+  module HTML4
     module SAX
       class PushParser
-        
-        # The Nokogiri::HTML::SAX::Document on which the PushParser will be
+        # The Nokogiri::HTML4::SAX::Document on which the PushParser will be
         # operating
         attr_accessor :document
-        
-        def initialize(doc = HTML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+
+        def initialize(doc = HTML4::SAX::Document.new, file_name = nil, encoding = "UTF-8")
           @document = doc
           @encoding = encoding
-          @sax_parser = HTML::SAX::Parser.new(doc, @encoding)
+          @sax_parser = HTML4::SAX::Parser.new(doc, @encoding)
 
           ## Create our push parser context
           initialize_native(@sax_parser, file_name, encoding)
         end
-        
+
         ###
         # Write a +chunk+ of HTML to the PushParser.  Any callback methods
         # that can be called will be called immediately.
-        def write chunk, last_chunk = false
+        def write(chunk, last_chunk = false)
           native_write(chunk, last_chunk)
         end
-        alias :<< :write
+        alias_method :<<, :write
 
         ###
         # Finish the parsing.  This method is only necessary for
-        # Nokogiri::HTML::SAX::Document#end_document to be called.
+        # Nokogiri::HTML4::SAX::Document#end_document to be called.
         def finish
-          write '', true
+          write("", true)
         end
       end
     end

data/lib/nokogiri/html4.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Nokogiri
+  class << self
+    # :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
+    def HTML4(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+      Nokogiri::HTML4::Document.parse(input, url, encoding, options, &block)
+    end
+  end
+
+  # Since v1.12.0
+  #
+  # 💡 Before v1.12.0, Nokogiri::HTML4 did not exist, and Nokogiri::HTML was the module/namespace
+  # for parsing HTML.
+  module HTML4
+    class << self
+      ###
+      # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
+      def parse(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+        Document.parse(input, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment(string, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+        HTML4::DocumentFragment.parse(string, encoding, options, &block)
+      end
+    end
+
+    # Instance of Nokogiri::HTML4::EntityLookup
+    NamedCharacters = EntityLookup.new
+  end
+end
+
+require_relative "html4/entity_lookup"
+require_relative "html4/document"
+require_relative "html4/document_fragment"
+require_relative "html4/encoding_reader"
+require_relative "html4/sax/parser_context"
+require_relative "html4/sax/parser"
+require_relative "html4/sax/push_parser"
+require_relative "html4/element_description"
+require_relative "html4/element_description_defaults"

data/lib/nokogiri/html5/document.rb

@@ -0,0 +1,168 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+#
+#  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require_relative "../html4/document"
+
+module Nokogiri
+  module HTML5
+    # Enum for the HTML5 parser quirks mode values. Values returned by HTML5::Document#quirks_mode
+    #
+    # See https://dom.spec.whatwg.org/#concept-document-quirks for more information on HTML5 quirks
+    # mode.
+    #
+    # Since v1.14.0
+    module QuirksMode
+      NO_QUIRKS = 0 # The document was parsed in "no-quirks" mode
+      QUIRKS = 1 # The document was parsed in "quirks" mode
+      LIMITED_QUIRKS = 2 # The document was parsed in "limited-quirks" mode
+    end
+
+    # Since v1.12.0
+    #
+    # 💡 HTML5 functionality is not available when running JRuby.
+    class Document < Nokogiri::HTML4::Document
+      # Get the url name for this document, as passed into Document.parse, Document.read_io, or
+      # Document.read_memory
+      attr_reader :url
+
+      # 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`).
+      #
+      # Since v1.14.0
+      attr_reader :quirks_mode
+
+      class << self
+        # :call-seq:
+        #   parse(input)
+        #   parse(input, url=nil, encoding=nil, **options)
+        #   parse(input, url=nil, encoding=nil) { |options| ... }
+        #
+        # Parse HTML5 input.
+        #
+        # [Parameters]
+        # - +input+ may be a String, or any object that responds to _read_ and _close_ such as an
+        #   IO, or StringIO.
+        #
+        # - +url+ (optional) is a String indicating the canonical URI where this document is located.
+        #
+        # - +encoding+ (optional) is the encoding that should be used when processing
+        #   the document.
+        #
+        # - +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.
+        #
+        #   ⚠ Note that these options are different than those made available by
+        #   Nokogiri::XML::Document and Nokogiri::HTML4::Document.
+        #
+        # - +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
+        #
+        def parse(string_or_io, url = nil, encoding = nil, **options, &block)
+          yield options if block
+          string_or_io = "" unless string_or_io
+
+          if string_or_io.respond_to?(:encoding) && string_or_io.encoding != Encoding::ASCII_8BIT
+            encoding ||= string_or_io.encoding.name
+          end
+
+          if string_or_io.respond_to?(:read) && string_or_io.respond_to?(:path)
+            url ||= string_or_io.path
+          end
+          unless string_or_io.respond_to?(:read) || string_or_io.respond_to?(:to_str)
+            raise ArgumentError, "not a string or IO object"
+          end
+
+          do_parse(string_or_io, url, encoding, options)
+        end
+
+        # Create a new document from an IO object.
+        #
+        # 💡 Most users should prefer Document.parse to this method.
+        def read_io(io, url = nil, encoding = nil, **options)
+          raise ArgumentError, "io object doesn't respond to :read" unless io.respond_to?(:read)
+
+          do_parse(io, url, encoding, options)
+        end
+
+        # Create a new document from a String.
+        #
+        # 💡 Most users should prefer Document.parse to this method.
+        def read_memory(string, url = nil, encoding = nil, **options)
+          raise ArgumentError, "string object doesn't respond to :to_str" unless string.respond_to?(:to_str)
+
+          do_parse(string, url, encoding, options)
+        end
+
+        private
+
+        def do_parse(string_or_io, url, encoding, options)
+          string = HTML5.read_and_encode(string_or_io, encoding)
+          max_attributes = options[:max_attributes] || Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES
+          max_errors = options[:max_errors] || options[:max_parse_errors] || Nokogiri::Gumbo::DEFAULT_MAX_ERRORS
+          max_depth = options[:max_tree_depth] || Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH
+          doc = Nokogiri::Gumbo.parse(string, url, max_attributes, max_errors, max_depth, self)
+          doc.encoding = "UTF-8"
+          doc
+        end
+      end
+
+      def initialize(*args) # :nodoc:
+        super
+        @url = nil
+        @quirks_mode = nil
+      end
+
+      # :call-seq:
+      #   fragment() → Nokogiri::HTML5::DocumentFragment
+      #   fragment(markup) → Nokogiri::HTML5::DocumentFragment
+      #
+      # Parse a HTML5 document fragment from +markup+, returning a Nokogiri::HTML5::DocumentFragment.
+      #
+      # [Properties]
+      # - +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`.
+      #
+      def fragment(markup = nil)
+        DocumentFragment.new(self, markup)
+      end
+
+      def to_xml(options = {}, &block) # :nodoc:
+        # Bypass XML::Document#to_xml which doesn't add
+        # XML::Node::SaveOptions::AS_XML like XML::Node#to_xml does.
+        XML::Node.instance_method(:to_xml).bind_call(self, options, &block)
+      end
+
+      # :call-seq:
+      #   xpath_doctype() → Nokogiri::CSS::XPathVisitor::DoctypeConfig
+      #
+      # [Returns] The document type which determines CSS-to-XPath translation.
+      #
+      # See CSS::XPathVisitor for more information.
+      def xpath_doctype
+        Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML5
+      end
+    end
+  end
+end

data/lib/nokogiri/html5/document_fragment.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+#
+#  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require_relative "../html4/document_fragment"
+
+module Nokogiri
+  module HTML5
+    # Since v1.12.0
+    #
+    # 💡 HTML5 functionality is not available when running JRuby.
+    class DocumentFragment < Nokogiri::HTML4::DocumentFragment
+      attr_accessor :document
+      attr_accessor :errors
+
+      # 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)`).
+      #
+      # Since v1.14.0
+      attr_reader :quirks_mode
+
+      # Create a document fragment.
+      def initialize(doc, tags = nil, ctx = nil, options = {}) # rubocop:disable Lint/MissingSuper
+        self.document = doc
+        self.errors = []
+        return self unless tags
+
+        max_attributes = options[:max_attributes] || Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES
+        max_errors = options[:max_errors] || Nokogiri::Gumbo::DEFAULT_MAX_ERRORS
+        max_depth = options[:max_tree_depth] || Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH
+        tags = Nokogiri::HTML5.read_and_encode(tags, nil)
+        Nokogiri::Gumbo.fragment(self, tags, ctx, max_attributes, max_errors, max_depth)
+      end
+
+      def serialize(options = {}, &block) # :nodoc:
+        # Bypass XML::Document.serialize which doesn't support options even
+        # though XML::Node.serialize does!
+        XML::Node.instance_method(:serialize).bind_call(self, options, &block)
+      end
+
+      # Parse a document fragment from +tags+, returning a Nodeset.
+      def self.parse(tags, encoding = nil, options = {})
+        doc = HTML5::Document.new
+        tags = HTML5.read_and_encode(tags, encoding)
+        doc.encoding = "UTF-8"
+        new(doc, tags, nil, options)
+      end
+
+      def extract_params(params) # :nodoc:
+        handler = params.find do |param|
+          ![Hash, String, Symbol].include?(param.class)
+        end
+        params -= [handler] if handler
+
+        hashes = []
+        while Hash === params.last || params.last.nil?
+          hashes << params.pop
+          break if params.empty?
+        end
+        ns, binds = hashes.reverse
+
+        ns ||=
+          begin
+            ns = {}
+            children.each { |child| ns.merge!(child.namespaces) }
+            ns
+          end
+
+        [params, handler, ns, binds]
+      end
+    end
+  end
+end
+# vim: set shiftwidth=2 softtabstop=2 tabstop=8 expandtab:

data/lib/nokogiri/html5/node.rb

@@ -0,0 +1,103 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+#
+#  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+#
+#  TODO: this whole file should go away. maybe make it a decorator?
+#
+require_relative "../xml/node"
+
+module Nokogiri
+  module HTML5
+    # Since v1.12.0
+    #
+    # 💡 HTML5 functionality is not available when running JRuby.
+    module Node
+      def inner_html(options = {})
+        return super(options) unless document.is_a?(HTML5::Document)
+
+        result = options[:preserve_newline] && prepend_newline? ? +"\n" : +""
+        result << children.map { |child| child.to_html(options) }.join
+        result
+      end
+
+      def write_to(io, *options)
+        return super(io, *options) unless document.is_a?(HTML5::Document)
+
+        options = options.first.is_a?(Hash) ? options.shift : {}
+        encoding = options[:encoding] || options[0]
+        if Nokogiri.jruby?
+          save_options = options[:save_with] || options[1]
+          indent_times = options[:indent] || 0
+        else
+          save_options = options[:save_with] || options[1] || XML::Node::SaveOptions::FORMAT
+          indent_times = options[:indent] || 2
+        end
+        indent_string = (options[:indent_text] || " ") * indent_times
+
+        config = XML::Node::SaveOptions.new(save_options.to_i)
+        yield config if block_given?
+
+        encoding = encoding.is_a?(Encoding) ? encoding.name : encoding
+
+        config_options = config.options
+        if config_options & (XML::Node::SaveOptions::AS_XML | XML::Node::SaveOptions::AS_XHTML) != 0
+          # Use Nokogiri's serializing code.
+          native_write_to(io, encoding, indent_string, config_options)
+        else
+          # Serialize including the current node.
+          html = html_standard_serialize(options[:preserve_newline] || false)
+          encoding ||= document.encoding || Encoding::UTF_8
+          io << html.encode(encoding, fallback: lambda { |c| "&#x#{c.ord.to_s(16)};" })
+        end
+      end
+
+      def fragment(tags)
+        return super(tags) unless document.is_a?(HTML5::Document)
+
+        DocumentFragment.new(document, tags, self)
+      end
+
+      private
+
+      # HTML elements can have attributes that contain colons.
+      # Nokogiri::XML::Node#[]= treats names with colons as a prefixed QName
+      # and tries to create an attribute in a namespace. This is especially
+      # annoying with attribute names like xml:lang since libxml2 will
+      # actually create the xml namespace if it doesn't exist already.
+      def add_child_node_and_reparent_attrs(node)
+        return super(node) unless document.is_a?(HTML5::Document)
+
+        # I'm not sure what this method is supposed to do. Reparenting
+        # namespaces is handled by libxml2, including child namespaces which
+        # this method wouldn't handle.
+        # https://github.com/sparklemotion/nokogiri/issues/1790
+        add_child_node(node)
+        # node.attribute_nodes.find_all { |a| a.namespace }.each do |attr|
+        #  attr.remove
+        #  ns = attr.namespace
+        #  a["#{ns.prefix}:#{attr.name}"] = attr.value
+        # end
+      end
+    end
+    # Monkey patch
+    XML::Node.prepend(HTML5::Node)
+  end
+end
+
+# vim: set shiftwidth=2 softtabstop=2 tabstop=8 expandtab: