moxml 0.1.21 → 0.1.23

data/lib/compat/opal/rexml/parsers/baseparser.rb

@@ -0,0 +1,1016 @@
+# frozen_string_literal: true
+
+require "rexml/parseexception"
+require "rexml/undefinednamespaceexception"
+require "rexml/security"
+require "rexml/source"
+require "set"
+require "strscan"
+
+module REXML
+  module Parsers
+    unless [].respond_to?(:tally)
+      module EnumerableTally
+        refine Enumerable do
+          def tally
+            counts = {}
+            each do |item|
+              counts[item] ||= 0
+              counts[item] += 1
+            end
+            counts
+          end
+        end
+      end
+      using EnumerableTally
+    end
+
+    if StringScanner::Version < "3.0.8"
+      module StringScannerCaptures
+        refine StringScanner do
+          def captures
+            values_at(*(1...size))
+          end
+        end
+      end
+      using StringScannerCaptures
+    end
+
+    # = Using the Pull Parser
+    # <em>This API is experimental, and subject to change.</em>
+    #  parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )
+    #  while parser.has_next?
+    #    res = parser.next
+    #    puts res[1]['att'] if res.start_tag? and res[0] == 'b'
+    #  end
+    # See the PullEvent class for information on the content of the results.
+    # The data is identical to the arguments passed for the various events to
+    # the StreamListener API.
+    #
+    # Notice that:
+    #  parser = PullParser.new( "<a>BAD DOCUMENT" )
+    #  while parser.has_next?
+    #    res = parser.next
+    #    raise res[1] if res.error?
+    #  end
+    #
+    # Nat Price gave me some good ideas for the API.
+    class BaseParser
+      LETTER = "A-Za-z"
+      DIGIT = "0-9"
+
+      COMBININGCHAR = "" # TODO
+      EXTENDER = ""      # TODO
+
+      NCNAME_STR = "[#{LETTER}_][-A-Za-z0-9._#{COMBININGCHAR}#{EXTENDER}]*".freeze
+      QNAME_STR = "(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})".freeze
+      QNAME = /(#{QNAME_STR})/
+
+      # Just for backward compatibility. For example, kramdown uses this.
+      # It's not used in REXML.
+      UNAME_STR = "(?:#{NCNAME_STR}:)?#{NCNAME_STR}".freeze
+
+      NAMECHAR = '[\-\w\.:]'
+      NAME = "([\\w:]#{NAMECHAR}*)".freeze
+      NMTOKEN = "(?:#{NAMECHAR})+".freeze
+      NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*".freeze
+      REFERENCE = "&(?:#{NAME};|#\\d+;|#x[0-9a-fA-F]+;)".freeze
+      REFERENCE_RE = /#{REFERENCE}/
+
+      DOCTYPE_START = /^\s*<!DOCTYPE\s/um
+      DOCTYPE_END = /^\s*\]\s*>/um
+      ATTRIBUTE_PATTERN = /\s*(#{QNAME_STR})\s*=\s*(["'])(.*?)\4/um
+      COMMENT_START = /^<!--/u
+      COMMENT_PATTERN = /<!--(.*?)-->/um
+      CDATA_START = /^<!\[CDATA\[/u
+      CDATA_END = /^\s*\]\s*>/um
+      CDATA_PATTERN = /<!\[CDATA\[(.*?)\]\]>/um
+      XMLDECL_START = /^<\?xml\s/u
+      XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>/um
+      INSTRUCTION_START = /^<\?/u
+      INSTRUCTION_PATTERN = /<\?#{NAME}(\s+.*?)?\?>/um
+      TAG_MATCH = /^<((?:#{QNAME_STR}))/um
+      CLOSE_MATCH = /^\s*<\/(#{QNAME_STR})\s*>/um
+
+      VERSION = /\bversion\s*=\s*["'](.*?)['"]/um
+      ENCODING = /\bencoding\s*=\s*["'](.*?)['"]/um
+      STANDALONE = /\bstandalone\s*=\s*["'](.*?)['"]/um
+
+      ENTITY_START = /^\s*<!ENTITY/
+      ELEMENTDECL_START = /^\s*<!ELEMENT/um
+      ELEMENTDECL_PATTERN = /^\s*(<!ELEMENT.*?)>/um
+      SYSTEMENTITY = /^\s*(%.*?;)\s*$/um
+      ENUMERATION = "\\(\\s*#{NMTOKEN}(?:\\s*\\|\\s*#{NMTOKEN})*\\s*\\)".freeze
+      NOTATIONTYPE = "NOTATION\\s+\\(\\s*#{NAME}(?:\\s*\\|\\s*#{NAME})*\\s*\\)".freeze
+      ENUMERATEDTYPE = "(?:(?:#{NOTATIONTYPE})|(?:#{ENUMERATION}))".freeze
+      ATTTYPE = "(CDATA|ID|IDREF|IDREFS|ENTITY|ENTITIES|NMTOKEN|NMTOKENS|#{ENUMERATEDTYPE})".freeze
+      ATTVALUE = "(?:\"((?:[^<&\"]|#{REFERENCE})*)\")|(?:'((?:[^<&']|#{REFERENCE})*)')".freeze
+      DEFAULTDECL = "(#REQUIRED|#IMPLIED|(?:(#FIXED\\s+)?#{ATTVALUE}))".freeze
+      ATTDEF = "\\s+#{NAME}\\s+#{ATTTYPE}\\s+#{DEFAULTDECL}".freeze
+      ATTDEF_RE = /#{ATTDEF}/
+      ATTLISTDECL_START = /^\s*<!ATTLIST/um
+      ATTLISTDECL_PATTERN = /^\s*<!ATTLIST\s+#{NAME}(?:#{ATTDEF})*\s*>/um
+
+      TEXT_PATTERN = /^([^<]*)/um
+
+      # Entity constants
+      PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
+      SYSTEMLITERAL = %{((?:"[^"]*")|(?:'[^']*'))}
+      PUBIDLITERAL = %{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}.freeze
+      EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))".freeze
+      NDATADECL = "\\s+NDATA\\s+#{NAME}".freeze
+      PEREFERENCE = "%#{NAME};".freeze
+      ENTITYVALUE = %{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}.freeze
+      PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})".freeze
+      ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))".freeze
+      PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>".freeze
+      GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>".freeze
+      ENTITYDECL = /\s*(?:#{GEDECL})|\s*(?:#{PEDECL})/um
+
+      NOTATIONDECL_START = /^\s*<!NOTATION/um
+      EXTERNAL_ID_PUBLIC = /^\s*PUBLIC\s+#{PUBIDLITERAL}\s+#{SYSTEMLITERAL}\s*/um
+      EXTERNAL_ID_SYSTEM = /^\s*SYSTEM\s+#{SYSTEMLITERAL}\s*/um
+      PUBLIC_ID = /^\s*PUBLIC\s+#{PUBIDLITERAL}\s*/um
+
+      EREFERENCE = /&(?!#{NAME};)/
+
+      DEFAULT_ENTITIES = {
+        "gt" => [/&gt;/, "&gt;", ">", />/],
+        "lt" => [/&lt;/, "&lt;", "<", /</],
+        "quot" => [/&quot;/, "&quot;", '"', /"/],
+        "apos" => [/&apos;/, "&apos;", "'", /'/],
+      }.freeze
+
+      module Private
+        PEREFERENCE_PATTERN = /#{PEREFERENCE}/um
+        TAG_PATTERN = /((?:#{QNAME_STR}))\s*/um
+        CLOSE_PATTERN = /(#{QNAME_STR})\s*>/um
+        EQUAL_PATTERN = /\s*=\s*/um
+        ATTLISTDECL_END = /\s+#{NAME}(?:#{ATTDEF})*\s*>/um
+        NAME_PATTERN = /#{NAME}/um
+        GEDECL_PATTERN = "\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>".freeze
+        PEDECL_PATTERN = "\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>".freeze
+        ENTITYDECL_PATTERN = /(?:#{GEDECL_PATTERN})|(?:#{PEDECL_PATTERN})/um
+        CARRIAGE_RETURN_NEWLINE_PATTERN = /\r\n?/
+        CHARACTER_REFERENCES = /&#((?:\d+)|(?:x[a-fA-F0-9]+));/
+        DEFAULT_ENTITIES_PATTERNS = {}
+        default_entities = ["gt", "lt", "quot", "apos", "amp"]
+        default_entities.each do |term|
+          DEFAULT_ENTITIES_PATTERNS[term] = /&#{term};/
+        end
+        DEFAULT_ENTITIES_PATTERNS.freeze
+        XML_PREFIXED_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
+      end
+      private_constant :Private
+
+      def initialize(source)
+        self.stream = source
+        @listeners = []
+        @prefixes = Set.new
+        @entity_expansion_count = 0
+        @entity_expansion_limit = Security.entity_expansion_limit
+        @entity_expansion_text_limit = Security.entity_expansion_text_limit
+        @source.ensure_buffer
+        @version = nil
+      end
+
+      def add_listener(listener)
+        @listeners << listener
+      end
+
+      attr_reader :source, :entity_expansion_count
+      attr_writer :entity_expansion_limit, :entity_expansion_text_limit
+
+      def stream=(source)
+        @source = SourceFactory.create_from(source)
+        reset
+      end
+
+      def reset
+        @closed = nil
+        @have_root = false
+        @document_status = nil
+        @tags = []
+        @stack = []
+        @entities = []
+        @namespaces = { "xml" => Private::XML_PREFIXED_NAMESPACE }
+        @namespaces_restore_stack = []
+      end
+
+      def position
+        if @source.respond_to? :position
+          @source.position
+        else
+          # FIXME
+          0
+        end
+      end
+
+      # Returns true if there are no more events
+      def empty?
+        (@source.empty? and @stack.empty?)
+      end
+
+      # Returns true if there are more events.  Synonymous with !empty?
+      def has_next?
+        !(@source.empty? and @stack.empty?)
+      end
+
+      # Push an event back on the head of the stream.  This method
+      # has (theoretically) infinite depth.
+      def unshift(token)
+        @stack.unshift(token)
+      end
+
+      # Peek at the +depth+ event in the stack.  The first element on the stack
+      # is at depth 0.  If +depth+ is -1, will parse to the end of the input
+      # stream and return the last event, which is always :end_document.
+      # Be aware that this causes the stream to be parsed up to the +depth+
+      # event, so you can effectively pre-parse the entire document (pull the
+      # entire thing into memory) using this method.
+      def peek(depth = 0)
+        raise %[Illegal argument "#{depth}"] if depth < -1
+
+        temp = []
+        if depth == -1
+          temp.push(pull) until empty?
+        else
+          while @stack.size + temp.size < depth + 1
+            temp.push(pull)
+          end
+        end
+        @stack += temp if temp.size.positive?
+        @stack[depth]
+      end
+
+      # Returns the next event.  This is a +PullEvent+ object.
+      def pull
+        @source.drop_parsed_content
+
+        pull_event.tap do |event|
+          @listeners.each do |listener|
+            listener.receive event
+          end
+        end
+      end
+
+      def pull_event
+        if @closed
+          x = @closed
+          @closed = nil
+          return [:end_element, x]
+        end
+        if empty?
+          if @document_status == :in_doctype
+            raise ParseException.new("Malformed DOCTYPE: unclosed", @source)
+          end
+
+          unless @tags.empty?
+            path = "/#{@tags.join('/')}"
+            raise ParseException.new("Missing end tag for '#{path}'", @source)
+          end
+
+          unless @document_status == :in_element
+            raise ParseException.new("Malformed XML: No root element", @source)
+          end
+
+          return [:end_document]
+        end
+        return @stack.shift if @stack.size.positive?
+
+        # STDERR.puts @source.encoding
+        # STDERR.puts "BUFFER = #{@source.buffer.inspect}"
+
+        @source.ensure_buffer
+        if @document_status == nil
+          start_position = @source.position
+          if @source.match?("<?", true)
+            return process_instruction
+          elsif @source.match?("<!", true)
+            if @source.match?("--", true)
+              return [:comment, process_comment]
+            elsif @source.match?("DOCTYPE", true)
+              base_error_message = "Malformed DOCTYPE"
+              unless @source.skip_spaces
+                message = if @source.match?(">")
+                            "#{base_error_message}: name is missing"
+                          else
+                            "#{base_error_message}: invalid name"
+                          end
+                @source.position = start_position
+                raise REXML::ParseException.new(message, @source)
+              end
+              name = parse_name(base_error_message)
+              @source.skip_spaces
+              if @source.match?("[", true)
+                id = [nil, nil, nil]
+                @document_status = :in_doctype
+              elsif @source.match?(">", true)
+                id = [nil, nil, nil]
+                @document_status = :after_doctype
+                @source.ensure_buffer
+              else
+                id = parse_id(base_error_message,
+                              accept_external_id: true,
+                              accept_public_id: false)
+                if id[0] == "SYSTEM"
+                  # For backward compatibility
+                  id[1] = id[2]
+                  id[2] = nil
+                end
+                @source.skip_spaces
+                if @source.match?("[", true)
+                  @document_status = :in_doctype
+                elsif @source.match?(">", true)
+                  @document_status = :after_doctype
+                  @source.ensure_buffer
+                else
+                  message = "#{base_error_message}: garbage after external ID"
+                  raise REXML::ParseException.new(message, @source)
+                end
+              end
+              args = [:start_doctype, name, *id]
+              if @document_status == :after_doctype
+                @source.skip_spaces
+                @stack << [:end_doctype]
+              end
+              return args
+            else
+              message = "Invalid XML"
+              raise REXML::ParseException.new(message, @source)
+            end
+          end
+        end
+        if @document_status == :in_doctype
+          @source.skip_spaces
+          start_position = @source.position
+          if @source.match?("<!", true)
+            if @source.match?("ELEMENT", true)
+              md = @source.match(/(.*?)>/um, true)
+              if md.nil?
+                raise REXML::ParseException.new("Bad ELEMENT declaration!",
+                                                @source)
+              end
+
+              return [:elementdecl, "<!ELEMENT#{md[1]}"]
+            elsif @source.match?("ENTITY", true)
+              match_data = @source.match(Private::ENTITYDECL_PATTERN, true)
+              unless match_data
+                raise REXML::ParseException.new("Malformed entity declaration",
+                                                @source)
+              end
+
+              match = [:entitydecl, *match_data.captures.compact]
+              ref = false
+              if match[1] == "%"
+                ref = true
+                match.delete_at 1
+              end
+              # Now we have to sort out what kind of entity reference this is
+              case match[2]
+              when "SYSTEM"
+                # External reference
+                match[3] = match[3][1..-2] # PUBID
+                match.delete_at(4) if match.size > 4 # Chop out NDATA decl
+                # match is [ :entity, name, SYSTEM, pubid(, ndata)? ]
+              when "PUBLIC"
+                # External reference
+                match[3] = match[3][1..-2] # PUBID
+                match[4] = match[4][1..-2] # HREF
+                match.delete_at(5) if match.size > 5 # Chop out NDATA decl
+                # match is [ :entity, name, PUBLIC, pubid, href(, ndata)? ]
+              when Private::PEREFERENCE_PATTERN
+                raise REXML::ParseException.new(
+                  "Parameter entity references forbidden in internal subset: #{match[2]}", @source
+                )
+              else
+                match[2] = match[2][1..-2]
+                match.pop if match.size == 4
+                # match is [ :entity, name, value ]
+              end
+              match << "%" if ref
+              return match
+            elsif @source.match?("ATTLIST", true)
+              md = @source.match(Private::ATTLISTDECL_END, true)
+              if md.nil?
+                raise REXML::ParseException.new("Bad ATTLIST declaration!",
+                                                @source)
+              end
+
+              element = md[1]
+              contents = "<!ATTLIST#{md[0]}"
+
+              pairs = {}
+              values = md[0].strip.scan(ATTDEF_RE)
+              values.each do |attdef|
+                unless attdef[3] == "#IMPLIED"
+                  attdef.compact!
+                  val = attdef[3]
+                  val = attdef[4] if val == "#FIXED "
+                  pairs[attdef[0]] = val
+                  if attdef[0] =~ /^xmlns:(.*)/
+                    @namespaces[$1] = val
+                  end
+                end
+              end
+              return [:attlistdecl, element, pairs, contents]
+            elsif @source.match?("NOTATION", true)
+              base_error_message = "Malformed notation declaration"
+              unless @source.skip_spaces
+                message = if @source.match?(">")
+                            "#{base_error_message}: name is missing"
+                          else
+                            "#{base_error_message}: invalid name"
+                          end
+                @source.position = start_position
+                raise REXML::ParseException.new(message, @source)
+              end
+              name = parse_name(base_error_message)
+              id = parse_id(base_error_message,
+                            accept_external_id: true,
+                            accept_public_id: true)
+              @source.skip_spaces
+              unless @source.match?(">", true)
+                message = "#{base_error_message}: garbage before end >"
+                raise REXML::ParseException.new(message, @source)
+              end
+              return [:notationdecl, name, *id]
+            elsif @source.match?("--", true)
+              return [:comment, process_comment]
+            else
+              raise REXML::ParseException.new(
+                "Malformed node: Started with '<!' but not a comment nor ELEMENT,ENTITY,ATTLIST,NOTATION", @source
+              )
+            end
+          elsif match = @source.match(/(%.*?;)\s*/um, true)
+            return [:externalentity, match[1]]
+          elsif @source.match?(/\]\s*>/um, true)
+            @document_status = :after_doctype
+            return [:end_doctype]
+          else
+            raise ParseException.new("Malformed DOCTYPE: invalid declaration",
+                                     @source)
+          end
+        end
+        if @document_status == :after_doctype
+          @source.skip_spaces
+        end
+        begin
+          start_position = @source.position
+          if @source.match?("<", true)
+            # :text's read_until may remain only "<" in buffer. In the
+            # case, buffer is empty here. So we need to fill buffer
+            # here explicitly.
+            @source.ensure_buffer
+            if @source.match?("/", true)
+              @namespaces_restore_stack.pop
+              last_tag = @tags.pop
+              md = @source.match(Private::CLOSE_PATTERN, true)
+              if md && !last_tag
+                message = "Unexpected top-level end tag (got '#{md[1]}')"
+                raise REXML::ParseException.new(message, @source)
+              end
+              if md.nil? || (last_tag != md[1])
+                message = "Missing end tag for '#{last_tag}'"
+                message += " (got '#{md[1]}')" if md
+                @source.position = start_position if md.nil?
+                raise REXML::ParseException.new(message, @source)
+              end
+              [:end_element, last_tag]
+            elsif @source.match?("!", true)
+              # STDERR.puts "SOURCE BUFFER = #{source.buffer}, #{source.buffer.size}"
+              if @source.match?("--", true)
+                [:comment, process_comment]
+              elsif @source.match?("[CDATA[", true)
+                text = @source.read_until("]]>")
+                unless text.end_with?("]]>")
+                  raise REXML::ParseException.new(
+                    "Malformed CDATA: Missing end ']]>'", @source
+                  )
+                end
+
+                text = text[0...-3]
+                [:cdata, text]
+              else
+                raise REXML::ParseException.new(
+                  "Malformed node: Started with '<!' but not a comment nor CDATA", @source
+                )
+              end
+            elsif @source.match?("?", true)
+              process_instruction
+            else
+              # Get the next tag
+              md = @source.match(Private::TAG_PATTERN, true)
+              unless md
+                @source.position = start_position
+                raise REXML::ParseException.new(
+                  "malformed XML: missing tag start", @source
+                )
+              end
+              tag = md[1]
+              @document_status = :in_element
+              @prefixes.clear
+              @prefixes << md[2] if md[2]
+              push_namespaces_restore
+              attributes, closed = parse_attributes(@prefixes)
+              # Verify that all of the prefixes have been defined
+              @prefixes.each do |prefix|
+                unless @namespaces.key?(prefix)
+                  raise UndefinedNamespaceException.new(prefix, @source, self)
+                end
+              end
+
+              if closed
+                @closed = tag
+                pop_namespaces_restore
+              else
+                if @tags.empty? && @have_root
+                  raise ParseException.new(
+                    "Malformed XML: Extra tag at the end of the document (got '<#{tag}')", @source
+                  )
+                end
+
+                @tags.push(tag)
+              end
+              @have_root = true
+              [:start_element, tag, attributes]
+            end
+          else
+            text = @source.read_until("<")
+            if text.end_with?("<")
+              text = text[0...-1]
+              @source.position -= "<".bytesize
+            end
+            if @tags.empty?
+              unless /^\s*$/.match?(text)
+                if @have_root
+                  raise ParseException.new(
+                    "Malformed XML: Extra content at the end of the document (got '#{text}')", @source
+                  )
+                else
+                  raise ParseException.new(
+                    "Malformed XML: Content at the start of the document (got '#{text}')", @source
+                  )
+                end
+              end
+              return pull_event if @have_root
+            end
+            [:text, text]
+          end
+        rescue REXML::UndefinedNamespaceException
+          raise
+        rescue REXML::ParseException
+          raise
+        rescue StandardError => e
+          raise REXML::ParseException.new("Exception parsing",
+                                          @source, self, e || $!)
+        end
+        # NOTE: The end of the method never runs, because it is unreachable.
+        #       All branches of code above have explicit unconditional return or raise statements.
+      end
+      private :pull_event
+
+      def entity(reference, entities)
+        return unless entities
+
+        value = entities[reference]
+        return if value.nil?
+
+        record_entity_expansion
+        unnormalize(value, entities)
+      end
+
+      # Escapes all possible entities
+      def normalize(input, entities = nil, entity_filter = nil)
+        copy = input.clone
+        # Doing it like this rather than in a loop improves the speed
+        copy.gsub!(EREFERENCE, "&amp;")
+        if entities
+          entities.each do |key, value|
+            unless entity_filter && entity_filter.include?(entity)
+              copy.gsub!(value, "&#{key};")
+            end
+          end
+        end
+        copy.gsub!(EREFERENCE, "&amp;")
+        DEFAULT_ENTITIES.each_value do |value|
+          copy.gsub!(value[3], value[1])
+        end
+        copy
+      end
+
+      # Unescapes all possible entities
+      def unnormalize(string, entities = nil, filter = nil)
+        rv = if string.include?("\r")
+               string.gsub(Private::CARRIAGE_RETURN_NEWLINE_PATTERN, "\n")
+             else
+               string.dup
+             end
+        matches = rv.scan(REFERENCE_RE)
+        return rv if matches.empty?
+
+        rv.gsub!(Private::CHARACTER_REFERENCES) do
+          m = $1
+          code_point = if m.start_with?("x")
+                         Integer(m[1..], 16)
+                       else
+                         Integer(m, 10)
+                       end
+          [code_point].pack("U*")
+        end
+        matches.collect! { |x| x[0] }.compact!
+        if filter
+          matches.reject! do |entity_reference|
+            filter.include?(entity_reference)
+          end
+        end
+        if matches.size.positive?
+          matches.tally.each do |entity_reference, n|
+            entity_expansion_count_before = @entity_expansion_count
+            entity_value = entity(entity_reference, entities)
+            if entity_value
+              if n > 1
+                entity_expansion_count_delta =
+                  @entity_expansion_count - entity_expansion_count_before
+                record_entity_expansion(entity_expansion_count_delta * (n - 1))
+              end
+              re = Private::DEFAULT_ENTITIES_PATTERNS[entity_reference] || /&#{entity_reference};/
+              rv.gsub!(re, entity_value)
+              if rv.bytesize > @entity_expansion_text_limit
+                raise "entity expansion has grown too large"
+              end
+            else
+              er = DEFAULT_ENTITIES[entity_reference]
+              rv.gsub!(er[0], er[2]) if er
+            end
+          end
+          rv.gsub!(Private::DEFAULT_ENTITIES_PATTERNS["amp"], "&")
+        end
+        rv
+      end
+
+      private
+
+      def add_namespace(prefix, uri)
+        @namespaces_restore_stack.last[prefix] = @namespaces[prefix]
+        if uri.nil?
+          @namespaces.delete(prefix)
+        else
+          @namespaces[prefix] = uri
+        end
+      end
+
+      def push_namespaces_restore
+        namespaces_restore = {}
+        @namespaces_restore_stack.push(namespaces_restore)
+        namespaces_restore
+      end
+
+      def pop_namespaces_restore
+        namespaces_restore = @namespaces_restore_stack.pop
+        namespaces_restore.each do |prefix, uri|
+          if uri.nil?
+            @namespaces.delete(prefix)
+          else
+            @namespaces[prefix] = uri
+          end
+        end
+      end
+
+      def record_entity_expansion(delta = 1)
+        @entity_expansion_count += delta
+        if @entity_expansion_count > @entity_expansion_limit
+          raise "number of entity expansions exceeded, processing aborted."
+        end
+      end
+
+      def need_source_encoding_update?(xml_declaration_encoding)
+        return false if xml_declaration_encoding.nil?
+        return false if /^UTF-16$/i.match?(xml_declaration_encoding)
+
+        true
+      end
+
+      def normalize_xml_declaration_encoding(xml_declaration_encoding)
+        /^UTF-16(?:BE|LE)$/i.match?(xml_declaration_encoding) ? "UTF-16" : nil
+      end
+
+      def parse_name(base_error_message)
+        md = @source.match(Private::NAME_PATTERN, true)
+        unless md
+          message = if @source.match?(/\S/um)
+                      "#{base_error_message}: invalid name"
+                    else
+                      "#{base_error_message}: name is missing"
+                    end
+          raise REXML::ParseException.new(message, @source)
+        end
+        md[0]
+      end
+
+      def parse_id(base_error_message,
+                   accept_external_id:,
+                   accept_public_id:)
+        if accept_external_id && (md = @source.match(EXTERNAL_ID_PUBLIC, true))
+          pubid = system = nil
+          pubid_literal = md[1]
+          pubid = pubid_literal[1..-2] if pubid_literal # Remove quote
+          system_literal = md[2]
+          system = system_literal[1..-2] if system_literal # Remove quote
+          ["PUBLIC", pubid, system]
+        elsif accept_public_id && (md = @source.match(PUBLIC_ID, true))
+          pubid = nil
+          pubid_literal = md[1]
+          pubid = pubid_literal[1..-2] if pubid_literal # Remove quote
+          ["PUBLIC", pubid, nil]
+        elsif accept_external_id && (md = @source.match(EXTERNAL_ID_SYSTEM,
+                                                        true))
+          system = nil
+          system_literal = md[1]
+          system = system_literal[1..-2] if system_literal # Remove quote
+          ["SYSTEM", nil, system]
+        else
+          details = parse_id_invalid_details(accept_external_id: accept_external_id,
+                                             accept_public_id: accept_public_id)
+          message = "#{base_error_message}: #{details}"
+          raise REXML::ParseException.new(message, @source)
+        end
+      end
+
+      def parse_id_invalid_details(accept_external_id:,
+                                   accept_public_id:)
+        public = /^\s*PUBLIC/um
+        system = /^\s*SYSTEM/um
+        if (accept_external_id || accept_public_id) && @source.match?(/#{public}/um)
+          if @source.match?(/#{public}(?:\s+[^'"]|\s*[\[>])/um)
+            return "public ID literal is missing"
+          end
+          unless @source.match?(/#{public}\s+#{PUBIDLITERAL}/um)
+            return "invalid public ID literal"
+          end
+
+          if accept_public_id
+            if @source.match?(/#{public}\s+#{PUBIDLITERAL}\s+[^'"]/um)
+              return "system ID literal is missing"
+            end
+            unless @source.match?(/#{public}\s+#{PUBIDLITERAL}\s+#{SYSTEMLITERAL}/um)
+              return "invalid system literal"
+            end
+
+            "garbage after system literal"
+          else
+            "garbage after public ID literal"
+          end
+        elsif accept_external_id && @source.match?(/#{system}/um)
+          if @source.match?(/#{system}(?:\s+[^'"]|\s*[\[>])/um)
+            return "system literal is missing"
+          end
+          unless @source.match?(/#{system}\s+#{SYSTEMLITERAL}/um)
+            return "invalid system literal"
+          end
+
+          "garbage after system literal"
+        else
+          unless @source.match?(/^\s*(?:PUBLIC|SYSTEM)\s/um)
+            return "invalid ID type"
+          end
+
+          "ID type is missing"
+        end
+      end
+
+      def process_comment
+        text = @source.read_until("-->")
+        unless text.end_with?("-->")
+          raise REXML::ParseException.new(
+            "Unclosed comment: Missing end '-->'", @source
+          )
+        end
+
+        text = text[0...-3]
+
+        if text.include?("--") || text.end_with?("-")
+          raise REXML::ParseException.new("Malformed comment", @source)
+        end
+
+        text
+      end
+
+      def process_instruction
+        name = parse_name("Malformed XML: Invalid processing instruction node")
+        if name == "xml"
+          xml_declaration
+        else # PITarget
+          if @source.skip_spaces # e.g. <?name content?>
+            start_position = @source.position
+            content = @source.read_until("?>")
+            unless content.end_with?("?>")
+              @source.position = start_position
+              raise ParseException.new(
+                "Malformed XML: Unclosed processing instruction: <#{name}>", @source
+              )
+            end
+            content = content[0...-2]
+          else # e.g. <?name?>
+            content = nil
+            unless @source.match?("?>", true)
+              raise ParseException.new(
+                "Malformed XML: Unclosed processing instruction: <#{name}>", @source
+              )
+            end
+          end
+          [:processing_instruction, name, content]
+        end
+      end
+
+      def xml_declaration
+        unless @version.nil?
+          raise ParseException.new(
+            "Malformed XML: XML declaration is duplicated", @source
+          )
+        end
+        if @document_status
+          raise ParseException.new(
+            "Malformed XML: XML declaration is not at the start", @source
+          )
+        end
+        unless @source.skip_spaces
+          raise ParseException.new(
+            "Malformed XML: XML declaration misses spaces before version", @source
+          )
+        end
+        unless @source.match?("version", true)
+          raise ParseException.new(
+            "Malformed XML: XML declaration misses version", @source
+          )
+        end
+
+        @version = parse_attribute_value_with_equal("xml")
+        unless @source.skip_spaces
+          unless @source.match?("?>", true)
+            raise ParseException.new("Malformed XML: Unclosed XML declaration",
+                                     @source)
+          end
+
+          encoding = normalize_xml_declaration_encoding(@source.encoding)
+          return [:xmldecl, @version, encoding, nil] # e.g. <?xml version="1.0"?>
+        end
+
+        if @source.match?("encoding", true)
+          encoding = parse_attribute_value_with_equal("xml")
+          unless @source.skip_spaces
+            unless @source.match?("?>", true)
+              raise ParseException.new(
+                "Malformed XML: Unclosed XML declaration", @source
+              )
+            end
+
+            if need_source_encoding_update?(encoding)
+              @source.encoding = encoding
+            end
+            encoding ||= normalize_xml_declaration_encoding(@source.encoding)
+            return [:xmldecl, @version, encoding, nil] # e.g. <?xml version="1.1" encoding="UTF-8"?>
+          end
+        end
+
+        if @source.match?("standalone", true)
+          standalone = parse_attribute_value_with_equal("xml")
+          case standalone
+          when "yes", "no"
+          else
+            raise ParseException.new(
+              "Malformed XML: XML declaration standalone is not yes or no : <#{standalone}>", @source
+            )
+          end
+        end
+        @source.skip_spaces
+        unless @source.match?("?>", true)
+          raise ParseException.new("Malformed XML: Unclosed XML declaration",
+                                   @source)
+        end
+
+        if need_source_encoding_update?(encoding)
+          @source.encoding = encoding
+        end
+        encoding ||= normalize_xml_declaration_encoding(@source.encoding)
+
+        # e.g. <?xml version="1.0" ?>
+        #      <?xml version="1.1" encoding="UTF-8" ?>
+        #      <?xml version="1.1" standalone="yes"?>
+        #      <?xml version="1.1" encoding="UTF-8" standalone="yes" ?>
+        [:xmldecl, @version, encoding, standalone]
+      end
+
+      if StringScanner::Version < "3.1.1"
+        def scan_quote
+          @source.match(/(['"])/, true)&.[](1)
+        end
+      else
+        def scan_quote
+          case @source.peek_byte
+          when 34 # '"'.ord
+            @source.scan_byte
+            '"'
+          when 39 # "'".ord
+            @source.scan_byte
+            "'"
+          end
+        end
+      end
+
+      def parse_attribute_value_with_equal(name)
+        unless @source.match?(Private::EQUAL_PATTERN, true)
+          message = "Missing attribute equal: <#{name}>"
+          raise REXML::ParseException.new(message, @source)
+        end
+        unless quote = scan_quote
+          message = "Missing attribute value start quote: <#{name}>"
+          raise REXML::ParseException.new(message, @source)
+        end
+        start_position = @source.position
+        value = @source.read_until(quote)
+        unless value.end_with?(quote)
+          @source.position = start_position
+          message = "Missing attribute value end quote: <#{name}>: <#{quote}>"
+          raise REXML::ParseException.new(message, @source)
+        end
+        value[0...-1]
+      end
+
+      def parse_attributes(prefixes)
+        attributes = {}
+        expanded_names = {}
+        closed = false
+        loop do
+          if @source.match?(">", true)
+            return attributes, closed
+          elsif @source.match?("/>", true)
+            closed = true
+            return attributes, closed
+          elsif match = @source.match(QNAME, true)
+            name = match[1]
+            prefix = match[2]
+            local_part = match[3]
+            value = parse_attribute_value_with_equal(name)
+            @source.skip_spaces
+            if prefix == "xmlns"
+              if local_part == "xml"
+                if value != Private::XML_PREFIXED_NAMESPACE
+                  msg = "The 'xml' prefix must not be bound to any other namespace " +
+                    "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
+                  raise REXML::ParseException.new(msg, @source, self)
+                end
+              elsif local_part == "xmlns"
+                msg = "The 'xmlns' prefix must not be declared " +
+                  "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
+                raise REXML::ParseException.new(msg, @source, self)
+              end
+              add_namespace(local_part, value)
+            elsif prefix
+              prefixes << prefix unless prefix == "xml"
+            end
+
+            if attributes[name]
+              msg = "Duplicate attribute #{name.inspect}"
+              raise REXML::ParseException.new(msg, @source, self)
+            end
+
+            unless prefix == "xmlns"
+              uri = @namespaces[prefix]
+              expanded_name = [uri, local_part]
+              existing_prefix = expanded_names[expanded_name]
+              if existing_prefix
+                message = "Namespace conflict in adding attribute \"#{local_part}\": Prefix \"#{existing_prefix}\" = \"#{uri}\" and prefix \"#{prefix}\" = \"#{uri}\""
+                raise REXML::ParseException.new(message, @source, self)
+              end
+              expanded_names[expanded_name] = prefix
+            end
+
+            attributes[name] = value
+          else
+            message = "Invalid attribute name: <#{@source.buffer.split(%r{[/>\s]}).first}>"
+            raise REXML::ParseException.new(message, @source)
+          end
+        end
+      end
+    end
+  end
+end
+
+#   case event[0]
+#   when :start_element
+#   when :text
+#   when :end_element
+#   when :processing_instruction
+#   when :cdata
+#   when :comment
+#   when :xmldecl
+#   when :start_doctype
+#   when :end_doctype
+#   when :externalentity
+#   when :elementdecl
+#   when :entity
+#   when :attlistdecl
+#   when :notationdecl
+#   when :end_doctype
+#   end