Nokogiri_precompiled_aarch64_dedshit 1.14.5

data/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright 2008 -- 2023 by Mike Dalessio, Aaron Patterson, Yoko Harada, Akinori MUSHA, John Shahid, Karol Bucek, Sam Ruby, Craig Barnes, Stephen Checkoway, Lars Kanis, Sergio Arbeo, Timothy Elliott, Nobuyoshi Nakada, Charles Nutter, Patrick Mahoney.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,287 @@
+<div><img src="https://nokogiri.org/images/nokogiri-serif-black.png" align="right"/></div>
+
+# Nokogiri
+
+Nokogiri (鋸) makes it easy and painless to work with XML and HTML from Ruby. It provides a sensible, easy-to-understand API for [reading](https://nokogiri.org/tutorials/parsing_an_html_xml_document.html), writing, [modifying](https://nokogiri.org/tutorials/modifying_an_html_xml_document.html), and [querying](https://nokogiri.org/tutorials/searching_a_xml_html_document.html) documents. It is fast and standards-compliant by relying on native parsers like libxml2, libgumbo, and xerces.
+
+## Guiding Principles
+
+Some guiding principles Nokogiri tries to follow:
+
+- be secure-by-default by treating all documents as **untrusted** by default
+- be a **thin-as-reasonable layer** on top of the underlying parsers, and don't attempt to fix behavioral differences between the parsers
+
+
+## Features Overview
+
+- DOM Parser for XML, HTML4, and HTML5
+- SAX Parser for XML and HTML4
+- Push Parser for XML and HTML4
+- Document search via XPath 1.0
+- Document search via CSS3 selectors, with some jquery-like extensions
+- XSD Schema validation
+- XSLT transformation
+- "Builder" DSL for XML and HTML documents
+
+
+## Status
+
+[![Github Actions CI](https://github.com/sparklemotion/nokogiri/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/sparklemotion/nokogiri/actions/workflows/ci.yml)
+[![Appveyor CI](https://ci.appveyor.com/api/projects/status/xj2pqwvlxwuwgr06/branch/main?svg=true)](https://ci.appveyor.com/project/flavorjones/nokogiri/branch/main)
+
+[![Gem Version](https://badge.fury.io/rb/nokogiri.svg)](https://rubygems.org/gems/nokogiri)
+[![SemVer compatibility](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=nokogiri&package-manager=bundler&previous-version=1.11.7&new-version=1.12.5)](https://docs.github.com/en/code-security/supply-chain-security/managing-vulnerabilities-in-your-projects-dependencies/about-dependabot-security-updates#about-compatibility-scores)
+
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5344/badge)](https://bestpractices.coreinfrastructure.org/projects/5344)
+[![Tidelift dependencies](https://tidelift.com/badges/package/rubygems/nokogiri)](https://tidelift.com/subscription/pkg/rubygems-nokogiri?utm_source=rubygems-nokogiri&utm_medium=referral&utm_campaign=readme)
+
+
+## Support, Getting Help, and Reporting Issues
+
+All official documentation is posted at https://nokogiri.org (the source for which is at https://github.com/sparklemotion/nokogiri.org/, and we welcome contributions).
+
+### Reading
+
+Your first stops for learning more about Nokogiri should be:
+
+- [API Documentation](https://nokogiri.org/rdoc/index.html)
+- [Tutorials](https://nokogiri.org/tutorials/toc.html)
+- An excellent community-maintained [Cheat Sheet](https://github.com/sparklemotion/nokogiri/wiki/Cheat-sheet)
+
+
+### Ask For Help
+
+There are a few ways to ask exploratory questions:
+
+- The Nokogiri mailing list is active at https://groups.google.com/group/nokogiri-talk
+- Open an issue using the "Help Request" template at https://github.com/sparklemotion/nokogiri/issues
+
+Please do not mail the maintainers at their personal addresses.
+
+
+### Report A Bug
+
+The Nokogiri bug tracker is at https://github.com/sparklemotion/nokogiri/issues
+
+Please use the "Bug Report" or "Installation Difficulties" templates.
+
+
+### Security and Vulnerability Reporting
+
+Please report vulnerabilities at https://hackerone.com/nokogiri
+
+Full information and description of our security policy is in [`SECURITY.md`](SECURITY.md)
+
+
+### Semantic Versioning Policy
+
+Nokogiri follows [Semantic Versioning](https://semver.org/) (since 2017 or so). [![Dependabot's SemVer compatibility score for Nokogiri](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=nokogiri&package-manager=bundler&previous-version=1.11.7&new-version=1.12.5)](https://docs.github.com/en/code-security/supply-chain-security/managing-vulnerabilities-in-your-projects-dependencies/about-dependabot-security-updates#about-compatibility-scores)
+
+We bump `Major.Minor.Patch` versions following this guidance:
+
+`Major`: (we've never done this)
+
+- Significant backwards-incompatible changes to the public API that would require rewriting existing application code.
+- Some examples of backwards-incompatible changes we might someday consider for a Major release are at [`ROADMAP.md`](ROADMAP.md).
+
+`Minor`:
+
+- Features and bugfixes.
+- Updating packaged libraries for non-security-related reasons.
+- Dropping support for EOLed Ruby versions. [Some folks find this objectionable](https://github.com/sparklemotion/nokogiri/issues/1568), but [SemVer says this is OK if the public API hasn't changed](https://semver.org/#what-should-i-do-if-i-update-my-own-dependencies-without-changing-the-public-api).
+- Backwards-incompatible changes to internal or private methods and constants. These are detailed in the "Changes" section of each changelog entry.
+
+`Patch`:
+
+- Bugfixes.
+- Security updates.
+- Updating packaged libraries for security-related reasons.
+
+
+### Sponsorship
+
+You can help sponsor the maintainers of this software through one of these organizations:
+
+- [github.com/sponsors/flavorjones](https://github.com/sponsors/flavorjones)
+- [opencollective.com/nokogiri](https://opencollective.com/nokogiri)
+- [tidelift.com/subscription/pkg/rubygems-nokogiri](https://tidelift.com/subscription/pkg/rubygems-nokogiri?utm_source=rubygems-nokogiri&utm_medium=referral&utm_campaign=readme)
+
+
+## Installation
+
+Requirements:
+
+- Ruby >= 2.7
+- JRuby >= 9.4.0.0
+
+
+### Native Gems: Faster, more reliable installation
+
+"Native gems" contain pre-compiled libraries for a specific machine architecture. On supported platforms, this removes the need for compiling the C extension and the packaged libraries, or for system dependencies to exist. This results in **much faster installation** and **more reliable installation**, which as you probably know are the biggest headaches for Nokogiri users.
+
+### Supported Platforms
+
+Nokogiri ships pre-compiled, "native" gems for the following platforms:
+
+- Linux:
+  - `x86-linux` and `x86_64-linux` (req: `glibc >= 2.17`)
+  - `aarch64-linux` and `arm-linux` (req: `glibc >= 2.29`)
+  - Note that musl platforms like Alpine **are** supported
+- Darwin/MacOS: `x86_64-darwin` and `arm64-darwin`
+- Windows: `x86-mingw32`, `x64-mingw32`, and `x64-mingw-ucrt`
+- Java: any platform running JRuby 9.4 or higher
+
+To determine whether your system supports one of these gems, look at the output of `bundle platform` or `ruby -e 'puts Gem::Platform.local.to_s'`.
+
+If you're on a supported platform, either `gem install` or `bundle install` should install a native gem without any additional action on your part. This installation should only take a few seconds, and your output should look something like:
+
+``` sh
+$ gem install nokogiri
+Fetching nokogiri-1.11.0-x86_64-linux.gem
+Successfully installed nokogiri-1.11.0-x86_64-linux
+1 gem installed
+```
+
+
+### Other Installation Options
+
+Because Nokogiri is a C extension, it requires that you have a C compiler toolchain, Ruby development header files, and some system dependencies installed.
+
+The following may work for you if you have an appropriately-configured system:
+
+``` bash
+gem install nokogiri
+```
+
+If you have any issues, please visit [Installing Nokogiri](https://nokogiri.org/tutorials/installing_nokogiri.html) for more complete instructions and troubleshooting.
+
+
+## How To Use Nokogiri
+
+Nokogiri is a large library, and so it's challenging to briefly summarize it. We've tried to provide long, real-world examples at [Tutorials](https://nokogiri.org/tutorials/toc.html).
+
+### Parsing and Querying
+
+Here is example usage for parsing and querying a document:
+
+```ruby
+#! /usr/bin/env ruby
+
+require 'nokogiri'
+require 'open-uri'
+
+# Fetch and parse HTML document
+doc = Nokogiri::HTML(URI.open('https://nokogiri.org/tutorials/installing_nokogiri.html'))
+
+# Search for nodes by css
+doc.css('nav ul.menu li a', 'article h2').each do |link|
+  puts link.content
+end
+
+# Search for nodes by xpath
+doc.xpath('//nav//ul//li/a', '//article//h2').each do |link|
+  puts link.content
+end
+
+# Or mix and match
+doc.search('nav ul.menu li a', '//article//h2').each do |link|
+  puts link.content
+end
+```
+
+
+### Encoding
+
+Strings are always stored as UTF-8 internally.  Methods that return
+text values will always return UTF-8 encoded strings.  Methods that
+return a string containing markup (like `to_xml`, `to_html` and
+`inner_html`) will return a string encoded like the source document.
+
+__WARNING__
+
+Some documents declare one encoding, but actually use a different
+one. In these cases, which encoding should the parser choose?
+
+Data is just a stream of bytes. Humans add meaning to that stream. Any
+particular set of bytes could be valid characters in multiple
+encodings, so detecting encoding with 100% accuracy is not
+possible. `libxml2` does its best, but it can't be right all the time.
+
+If you want Nokogiri to handle the document encoding properly, your
+best bet is to explicitly set the encoding.  Here is an example of
+explicitly setting the encoding to EUC-JP on the parser:
+
+```ruby
+  doc = Nokogiri.XML('<foo><bar /></foo>', nil, 'EUC-JP')
+```
+
+
+## Technical Overview
+
+### Guiding Principles
+
+As noted above, two guiding principles of the software are:
+
+- be secure-by-default by treating all documents as **untrusted** by default
+- be a **thin-as-reasonable layer** on top of the underlying parsers, and don't attempt to fix behavioral differences between the parsers
+
+Notably, despite all parsers being standards-compliant, there are behavioral inconsistencies between the parsers used in the CRuby and JRuby implementations, and Nokogiri does not and should not attempt to remove these inconsistencies. Instead, we surface these differences in the test suite when they are important/semantic; or we intentionally write tests to depend only on the important/semantic bits (omitting whitespace from regex matchers on results, for example).
+
+
+### CRuby
+
+The Ruby (a.k.a., CRuby, MRI, YARV) implementation is a C extension that depends on libxml2 and libxslt (which in turn depend on zlib and possibly libiconv).
+
+These dependencies are met by default by Nokogiri's packaged versions of the libxml2 and libxslt source code, but a configuration option `--use-system-libraries` is provided to allow specification of alternative library locations. See [Installing Nokogiri](https://nokogiri.org/tutorials/installing_nokogiri.html) for full documentation.
+
+We provide native gems by pre-compiling libxml2 and libxslt (and potentially zlib and libiconv) and packaging them into the gem file. In this case, no compilation is necessary at installation time, which leads to faster and more reliable installation.
+
+See [`LICENSE-DEPENDENCIES.md`](LICENSE-DEPENDENCIES.md) for more information on which dependencies are provided in which native and source gems.
+
+
+### JRuby
+
+The Java (a.k.a. JRuby) implementation is a Java extension that depends primarily on Xerces and NekoHTML for parsing, though additional dependencies are on `isorelax`, `nekodtd`, `jing`, `serializer`, `xalan-j`, and `xml-apis`.
+
+These dependencies are provided by pre-compiled jar files packaged in the `java` platform gem.
+
+See [`LICENSE-DEPENDENCIES.md`](LICENSE-DEPENDENCIES.md) for more information on which dependencies are provided in which native and source gems.
+
+
+## Contributing
+
+See [`CONTRIBUTING.md`](CONTRIBUTING.md) for an intro guide to developing Nokogiri.
+
+
+## Code of Conduct
+
+We've adopted the Contributor Covenant code of conduct, which you can read in full in [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md).
+
+
+## License
+
+This project is licensed under the terms of the MIT license.
+
+See this license at [`LICENSE.md`](LICENSE.md).
+
+
+### Dependencies
+
+Some additional libraries may be distributed with your version of Nokogiri. Please see [`LICENSE-DEPENDENCIES.md`](LICENSE-DEPENDENCIES.md) for a discussion of the variations as well as the licenses thereof.
+
+
+## Authors
+
+- Mike Dalessio
+- Aaron Patterson
+- Yoko Harada
+- Akinori MUSHA
+- John Shahid
+- Karol Bucek
+- Sam Ruby
+- Craig Barnes
+- Stephen Checkoway
+- Lars Kanis
+- Sergio Arbeo
+- Timothy Elliott
+- Nobuyoshi Nakada

data/bin/nokogiri

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "open-uri"
+require "uri"
+require "rubygems"
+require "nokogiri"
+autoload :IRB, "irb"
+
+parse_class = Nokogiri
+encoding = nil
+
+# This module provides some tunables with the nokogiri CLI for use in
+# your ~/.nokogirirc.
+module Nokogiri
+  module CLI
+    class << self
+      # Specify the console engine, defaulted to IRB.
+      #
+      # call-seq:
+      #   require 'pry'
+      #   Nokogiri::CLI.console = Pry
+      attr_writer :console
+
+      def console
+        case @console
+        when Symbol
+          Kernel.const_get(@console)
+        else
+          @console
+        end
+      end
+
+      attr_accessor :rcfile
+    end
+
+    self.rcfile  = File.expand_path("~/.nokogirirc")
+    self.console = :IRB
+  end
+end
+
+def safe_read(uri_or_path)
+  uri = URI.parse(uri_or_path)
+  case uri
+  when URI::HTTP
+    uri.read
+  when URI::File
+    File.read(uri.path)
+  else
+    File.read(uri_or_path)
+  end
+end
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Nokogiri: an HTML, XML, SAX, and Reader parser"
+  opts.define_head("Usage: nokogiri <uri|path> [options]")
+  opts.separator("")
+  opts.separator("Examples:")
+  opts.separator("  nokogiri https://www.ruby-lang.org/")
+  opts.separator("  nokogiri ./public/index.html")
+  opts.separator("  curl -s http://www.nokogiri.org | nokogiri -e'p $_.css(\"h1\").length'")
+  opts.separator("")
+  opts.separator("Options:")
+
+  opts.on("--type type", "Parse as type: xml or html (default: auto)", [:xml, :html]) do |v|
+    parse_class = { xml: Nokogiri::XML, html: Nokogiri::HTML }[v]
+  end
+
+  opts.on("-C file", "Specifies initialization file to load (default #{Nokogiri::CLI.rcfile})") do |v|
+    Nokogiri::CLI.rcfile = v
+  end
+
+  opts.on("-E", "--encoding encoding", "Read as encoding (default: #{encoding || "none"})") do |v|
+    encoding = v
+  end
+
+  opts.on("-e command", "Specifies script from command-line.") do |v|
+    @script = v
+  end
+
+  opts.on("--rng <uri|path>", "Validate using this rng file.") do |v|
+    @rng = Nokogiri::XML::RelaxNG(safe_read(v))
+  end
+
+  opts.on_tail("-?", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts Nokogiri::VersionInfo.instance.to_markdown
+    exit
+  end
+end
+opts.parse!
+
+url = ARGV.shift
+
+if url.to_s.strip.empty? && $stdin.tty?
+  puts opts
+  exit 1
+end
+
+if File.file?(Nokogiri::CLI.rcfile)
+  load Nokogiri::CLI.rcfile
+end
+
+@doc = if url || $stdin.tty?
+  parse_class.parse(safe_read(url), url, encoding)
+else
+  parse_class.parse($stdin, nil, encoding)
+end
+
+$_ = @doc
+
+if @rng
+  @rng.validate(@doc).each do |error|
+    puts error.message
+  end
+elsif @script
+  begin
+    eval(@script, binding, "<main>") # rubocop:disable Security/Eval
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    warn("ERROR: Exception raised while evaluating '#{@script}'")
+    raise e
+  end
+else
+  puts "Your document is stored in @doc..."
+  Nokogiri::CLI.console.start
+end

data/dependencies.yml

@@ -0,0 +1,41 @@
+libxml2:
+  version: "2.10.4"
+  sha256: "ed0c91c5845008f1936739e4eee2035531c1c94742c6541f44ee66d885948d45"
+  # sha-256 hash provided in https://download.gnome.org/sources/libxml2/2.10/libxml2-2.10.4.sha256sum
+
+libxslt:
+  version: "1.1.37"
+  sha256: "3a4b27dc8027ccd6146725950336f1ec520928f320f144eb5fa7990ae6123ab4"
+  # sha-256 hash provided in https://download.gnome.org/sources/libxslt/1.1/libxslt-1.1.37.sha256sum
+
+zlib:
+  version: "1.2.13"
+  sha256: "b3a24de97a8fdbc835b9833169501030b8977031bcb54b3b3ac13740f846ab30"
+  # SHA-256 hash provided on http://zlib.net/
+
+libiconv:
+  version: "1.17"
+  sha256: "8f74213b56238c85a50a5329f77e06198771e70dd9a739779f4c02f65d971313"
+  # signature verified by following this path:
+  # - release announced at https://savannah.gnu.org/forum/forum.php?forum_id=10175
+  # - which links to https://savannah.gnu.org/users/haible as the releaser
+  # - which links to https://savannah.gnu.org/people/viewgpg.php?user_id=1871 as the gpg key
+  #
+  # So:
+  # - wget -q -O - https://savannah.gnu.org/people/viewgpg.php?user_id=1871 | gpg --import
+  #     gpg: key F5BE8B267C6A406D: 1 signature not checked due to a missing key
+  #     gpg: key F5BE8B267C6A406D: public key "Bruno Haible (Open Source Development) <bruno@clisp.org>" imported
+  #     gpg: Total number processed: 1
+  #     gpg:               imported: 1
+  #     gpg: marginals needed: 3  completes needed: 1  trust model: pgp
+  #     gpg: depth: 0  valid:   4  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 4u
+  #     gpg: next trustdb check due at 2024-05-09
+  # - gpg --verify libiconv-1.17.tar.gz.sig ports/archives/libiconv-1.17.tar.gz
+  #     gpg: Signature made Sun 15 May 2022 11:26:42 AM EDT
+  #     gpg:                using RSA key 9001B85AF9E1B83DF1BDA942F5BE8B267C6A406D
+  #     gpg: Good signature from "Bruno Haible (Open Source Development) <bruno@clisp.org>" [unknown]
+  #     gpg: WARNING: This key is not certified with a trusted signature!
+  #     gpg:          There is no indication that the signature belongs to the owner.
+  #     Primary key fingerprint: 9001 B85A F9E1 B83D F1BD  A942 F5BE 8B26 7C6A 406D
+  #
+  # And this sha256sum is calculated from that verified tarball.

data/ext/java/nokogiri/Html4Document.java

@@ -0,0 +1,157 @@
+package nokogiri;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Helpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import nokogiri.internals.HtmlDomParserContext;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+
+/**
+ * Class for Nokogiri::HTML4::Document.
+ *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name = "Nokogiri::HTML4::Document", parent = "Nokogiri::XML::Document")
+public class Html4Document extends XmlDocument
+{
+  private static final long serialVersionUID = 1L;
+
+  private static final String DEFAULT_CONTENT_TYPE = "html";
+  private static final String DEFAULT_PUBLIC_ID = "-//W3C//DTD HTML 4.01//EN";
+  private static final String DEFAULT_SYTEM_ID = "http://www.w3.org/TR/html4/strict.dtd";
+
+  private String parsed_encoding = null;
+
+  public
+  Html4Document(Ruby ruby, RubyClass klazz)
+  {
+    super(ruby, klazz);
+  }
+
+  public
+  Html4Document(Ruby runtime, Document document)
+  {
+    this(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"), document);
+  }
+
+  public
+  Html4Document(Ruby ruby, RubyClass klazz, Document doc)
+  {
+    super(ruby, klazz, doc);
+  }
+
+  @JRubyMethod(name = "new", meta = true, rest = true, required = 0)
+  public static IRubyObject
+  rbNew(ThreadContext context, IRubyObject klazz, IRubyObject[] args)
+  {
+    final Ruby runtime = context.runtime;
+    Html4Document htmlDocument;
+    try {
+      Document docNode = createNewDocument(runtime);
+      htmlDocument = (Html4Document) NokogiriService.HTML_DOCUMENT_ALLOCATOR.allocate(runtime, (RubyClass) klazz);
+      htmlDocument.setDocumentNode(context.runtime, docNode);
+    } catch (Exception ex) {
+      throw asRuntimeError(runtime, "couldn't create document: ", ex);
+    }
+
+    Helpers.invoke(context, htmlDocument, "initialize", args);
+
+    return htmlDocument;
+  }
+
+  public IRubyObject
+  getInternalSubset(ThreadContext context)
+  {
+    IRubyObject internalSubset = super.getInternalSubset(context);
+
+    // html documents are expected to have a default internal subset
+    // the default values are the same ones used when the following
+    // feature is turned on
+    // "http://cyberneko.org/html/features/insert-doctype"
+    // the reason we don't turn it on, is because it overrides the document's
+    // declared doctype declaration.
+
+    if (internalSubset.isNil()) {
+      internalSubset = XmlDtd.newEmpty(context.getRuntime(),
+                                       getDocument(),
+                                       context.getRuntime().newString(DEFAULT_CONTENT_TYPE),
+                                       context.getRuntime().newString(DEFAULT_PUBLIC_ID),
+                                       context.getRuntime().newString(DEFAULT_SYTEM_ID));
+      setInternalSubset(internalSubset);
+    }
+
+    return internalSubset;
+  }
+
+  @Override
+  void
+  init(Ruby runtime, Document document)
+  {
+    stabilizeTextContent(document);
+    document.normalize();
+    setInstanceVariable("@decorators", runtime.getNil());
+    if (document.getDocumentElement() != null) {
+      stabilizeAttrs(document.getDocumentElement());
+    }
+  }
+
+  private static void
+  stabilizeAttrs(Node node)
+  {
+    if (node.hasAttributes()) {
+      NamedNodeMap nodeMap = node.getAttributes();
+      for (int i = 0; i < nodeMap.getLength(); i++) {
+        Node n = nodeMap.item(i);
+        if (n instanceof Attr) {
+          stabilizeAttr((Attr) n);
+        }
+      }
+    }
+    NodeList children = node.getChildNodes();
+    for (int i = 0; i < children.getLength(); i++) {
+      stabilizeAttrs(children.item(i));
+    }
+  }
+
+  public void
+  setParsedEncoding(String encoding)
+  {
+    parsed_encoding = encoding;
+  }
+
+  public String
+  getPraedEncoding()
+  {
+    return parsed_encoding;
+  }
+
+  @JRubyMethod(meta = true, required = 4)
+  public static IRubyObject
+  read_io(ThreadContext context, IRubyObject klass, IRubyObject[] args)
+  {
+    HtmlDomParserContext ctx = new HtmlDomParserContext(context.runtime, args[2], args[3]);
+    ctx.setIOInputSource(context, args[0], args[1]);
+    return ctx.parse(context, (RubyClass) klass, args[1]);
+  }
+
+  @JRubyMethod(meta = true, required = 4)
+  public static IRubyObject
+  read_memory(ThreadContext context, IRubyObject klass, IRubyObject[] args)
+  {
+    HtmlDomParserContext ctx = new HtmlDomParserContext(context.runtime, args[2], args[3]);
+    ctx.setStringInputSource(context, args[0], args[1]);
+    return ctx.parse(context, (RubyClass) klass, args[1]);
+  }
+}