pdfium 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f0a20b6dc310130f33f3fe36394b4cadc0bbf10
+  data.tar.gz: 5af66006fa995e366e59c4798e8585e20ca04914
+SHA512:
+  metadata.gz: bedd33815a4a6c4761a47b4c2f3679093c641554789cfa236365a2c6681352bca6c0e43b0a2a7b12ffdd1c29839c78d71cd3280bbc5e17afec52749e6f208677
+  data.tar.gz: 966a05f3938c7433a4ba925a7c8a07fe0093a02639f7272b11e38876a78879a9b06abb48aa213a2e92e203152e635d104faafda464c11216ae804890ef1068db

data/.gitignore

@@ -0,0 +1,9 @@
+.bundle
+Gemfile.lock
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+tmp
+test/pdfs

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.0

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pdfium.gemspec
+gemspec
+
+
+group :development do
+    gem 'pry-nav'
+end

data/Guardfile

@@ -0,0 +1,7 @@
+guard :minitest do
+    watch(%r{^test/(.*)_spec\.rb$})
+end
+
+guard 'rake', :task => 'buildtest' do
+    watch %r{ext/pdfium_ext/.*\.(cc|h)$}
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Nathan Stitt
+
+MIT License
+
+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,68 @@
+# Ruby bindings for Google's PDFium project
+
+This allows Ruby efficiently to extract information from PDF files.
+
+It currently has only very rudimantary PDF editing capabilities.
+
+RDoc documentation is also available and the test directory has examples of usage.
+
+## Open and saveing
+
+```ruby
+pdf = PDFium::Document.new("test.pdf")
+pdf.save
+```
+
+## Document information
+
+Page count:
+```ruby
+pdf.page_count
+```
+
+PDF Metadata:
+```ruby
+pdf.metadata
+```
+
+Returns a hash with keys = :title, :author :subject, :keywords, :creator, :producer, :creation_date, :mod_date
+
+
+
+## Bookmarks
+
+```ruby
+def print_bookmarks(list, indent=0)
+    list.bookmarks.each do | bm |
+        print ' ' * indent
+        puts bm.title
+        print_marks( bm.children )
+    end
+end
+print_bookmarks( pdf.bookmarks )
+```
+
+## Render page as an image
+
+```ruby
+pdf.each_page | page |
+    page.as_image(width: 800).save("test-{page.number}.png")
+end
+```
+
+## Extract embedded images from page
+```ruby
+doc = PDFium::Document.new("test.pdf")
+page = doc.page_at(0)
+page.images do |image|
+    img.save("page-0-image-#{image.index}.png")
+end
+```
+
+## Text access
+
+Text is returned as a UTF-16LE encoded string.  Future version may return position information as well
+
+```ruby
+pdf.page_at(0).text.encode!("ASCII-8BIT")
+```

data/Rakefile

@@ -0,0 +1,62 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rdoc/task'
+
+Rake::TestTask.new do |t|
+    t.libs << 'test'
+    t.pattern = "test/*_spec.rb"
+end
+
+RDOC_FILES = FileList["README.md",
+                      "lib/pdfium.rb",
+                      "lib/pdfium/*.rb",
+                      "ext/pdfium_ext/*.cc"
+                     ]
+Rake::RDocTask.new do |rd|
+    rd.main = "README.md"
+    rd.options << "--verbose"
+    rd.rdoc_files.include(RDOC_FILES)
+end
+
+
+require "bundler/gem_tasks"
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("pdfium_ext") do | ext |
+  ext.source_pattern = "*.cc"
+end
+
+task :buildtest => :compile do
+    Rake::Task["test"].invoke
+end
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'pdfium'
+  ARGV.clear
+  IRB.start
+end
+
+# valgrind and Ruby
+# http://blog.flavorjon.es/2009/06/easily-valgrind-gdb-your-ruby-c.html
+# http://blog.evanweaver.com/2008/02/05/valgrind-and-ruby/
+namespace :test do
+  # partial-loads-ok and undef-value-errors necessary to ignore
+  # spurious (and eminently ignorable) warnings from the ruby
+  # interpreter
+  VALGRIND_BASIC_OPTS = <<-EOS
+ --tool=memcheck
+ --dsymutil=yes \
+ --num-callers=50 --error-limit=no --leak-check=full \
+ --partial-loads-ok=yes --undef-value-errors=no
+  EOS
+
+  SUPRESS = ""# "--suppressions=./valgrind.supp"
+  desc "run test suite under valgrind with basic ruby options"
+  task :valgrind => :compile do
+    cmdline = "valgrind #{SUPRESS} #{VALGRIND_BASIC_OPTS} ruby rake test"
+    puts cmdline
+    system cmdline
+  end
+end

data/ext/pdfium_ext/bookmark.cc

@@ -0,0 +1,221 @@
+#include "pdfium.h"
+
+/////////////////////////////////////////////////////////////////////////
+// The Bookmark class
+/////////////////////////////////////////////////////////////////////////
+/*
+    * Document-class:  PDFium::Bookmark
+    *
+    * Bookmarks on a Document form a tree structure.
+    * Each can have siblings and children
+    *
+*/
+
+
+class Bookmark {
+  public:
+    Bookmark():
+        doc_wrapper(0),
+        bookmark(0){}
+    ~Bookmark(){
+        if (doc_wrapper)
+            doc_wrapper->release(this);
+        if (bookmark)
+            delete bookmark;
+    }
+    DocumentWrapper *doc_wrapper;
+    CPDF_Bookmark *bookmark;
+};
+
+// a utility method to extract the reference to the FPDF_DOCUMENT from the Ruby/C++ wrapping
+CPDF_Bookmark *
+RB2BM(VALUE self) {
+    Bookmark *bm;
+    Data_Get_Struct(self, Bookmark, bm);
+    return bm->bookmark;
+}
+
+static void
+bookmark_gc_free(Bookmark *bm) {
+    delete bm;
+}
+
+static VALUE
+bookmark_allocate(VALUE klass) {
+    auto bm = new Bookmark;
+    return Data_Wrap_Struct(klass, NULL, bookmark_gc_free, bm );
+}
+
+
+/*
+ * call-seq:
+ *   Bookmark.new
+ *
+ * Initializes a bookmark.  Not intended for direct use, but called
+ * internally from Document#bookmarks
+ */
+VALUE
+bookmark_initialize(VALUE self, VALUE options){
+    Bookmark *bm;
+    Data_Get_Struct(self, Bookmark, bm);
+    DocumentWrapper *doc;
+    CPDF_Bookmark bookmark;
+
+    if (TYPE(options) != T_HASH){
+        rb_raise(rb_eArgError, "no options given");
+        return Qnil;
+    }
+
+    VALUE  reference;
+    if ( !NIL_P(reference = RB::get_option(options,"document")) ){
+        // we're the first bookmark on a document
+        Data_Get_Struct(reference, DocumentWrapper, doc);
+        bookmark = CPDF_Bookmark(NULL);
+        CPDF_BookmarkTree tree(doc->document);
+        bm->bookmark = new CPDF_Bookmark( tree.GetFirstChild(bookmark).GetDict() );
+    } else if ( !NIL_P(reference = RB::get_option(options,"parent")) ){
+        // we're the first sibling on a parent bookmark
+        Bookmark *reference_bm;
+        Data_Get_Struct(reference, Bookmark, reference_bm);
+        doc = reference_bm->doc_wrapper;
+        bm->bookmark = new CPDF_Bookmark(reference_bm->bookmark->GetDict());
+    } else if ( !NIL_P(reference = RB::get_option(options,"sibling")) ){
+        // we're the next bookmark after a sibling bookmark
+        Bookmark *reference_bm;
+        Data_Get_Struct(reference, Bookmark, reference_bm);
+        doc = reference_bm->doc_wrapper;
+        CPDF_BookmarkTree tree(doc->document);
+        bm->bookmark = new CPDF_Bookmark( tree.GetNextSibling(*reference_bm->bookmark) );
+    } else {
+        rb_raise(rb_eArgError, "options must contain either :document, :parent or :sibling");
+        return Qnil;
+    }
+
+    bm->doc_wrapper = doc;
+    doc->retain(bm);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   children -> BookmarkList
+ *
+ * All Bookmarks that are children.  If the Bookmark has no children, an empty list is returned
+ */
+static VALUE
+bookmark_children(VALUE self)
+{
+    Bookmark *bm;
+    Data_Get_Struct(self, Bookmark, bm);
+
+    CPDF_BookmarkTree tree(bm->doc_wrapper->document);
+    CPDF_Bookmark child( tree.GetFirstChild(*bm->bookmark) );
+
+    VALUE args[1];
+
+    if (child.GetDict()){
+        args[0] = rb_hash_new();
+        rb_hash_aset(args[0], ID2SYM(rb_intern("parent")), self);
+        args[0] = rb_class_new_instance( 1, args, RB::Bookmark() );
+    } else {
+        args[0] = Qnil; //rb_class_new_instance( 1, args, T_NIL );
+    }
+    return rb_class_new_instance( 1, args, RB::BookmarkList() );
+
+}
+
+/*
+ * call-seq:
+ *   next_sibling -> Bookmark
+ *
+ * Returns the Bookmark that comes after this one
+ */
+static VALUE
+bookmark_next_sibling(VALUE self)
+{
+    Bookmark *bm;
+    Data_Get_Struct(self, Bookmark, bm);
+    CPDF_BookmarkTree tree(bm->doc_wrapper->document);
+    CPDF_Bookmark next = tree.GetNextSibling(*bm->bookmark);
+
+    if (next.GetDict()){
+        VALUE args[1];
+        args[0] = rb_hash_new();
+        rb_hash_aset(args[0], ID2SYM(rb_intern("sibling")), self);
+        return rb_class_new_instance( 1, args, RB::Bookmark() );
+    } else {
+        return Qnil;
+    }
+}
+
+
+/*
+ * call-seq:
+ *   title -> String encoded as UTF-16LE
+ *
+ * Returns the title of the bookmark in UTF-16LE format.
+ * This means that the string cannot be directly compared to a ASCII string, and must be converted.
+ *
+ *    bookmark.title.encode!("ASCII-8BIT")
+ *
+ */
+static VALUE
+bookmark_title(VALUE self)
+{
+    return RB::to_string( RB2BM(self)->GetTitle() );
+}
+
+/*
+ * call-seq:
+ *   destination -> Hash
+ *
+ * Returns the destination data of the bookmark.
+ * Only the destination type is tested.
+ * Bug reports and confirmation on the action type is appreciated.
+ */
+static VALUE
+bookmark_destination(VALUE self)
+{
+    Bookmark *bm;
+    Data_Get_Struct(self, Bookmark, bm);
+    auto doc =  bm->doc_wrapper->document;
+    VALUE hash=rb_hash_new();
+    CPDF_Dest dest = bm->bookmark->GetDest( doc );
+    if (dest){
+        rb_hash_aset(hash, ID2SYM( rb_intern("type") ), ID2SYM(rb_intern("destination")));
+        rb_hash_aset(hash, ID2SYM( rb_intern("page_number") ), INT2NUM(dest.GetPageIndex(doc)));
+    } else {
+        CPDF_Action action = bm->bookmark->GetAction();
+        if (action){
+            rb_hash_aset(hash, ID2SYM( rb_intern("type") ), ID2SYM(rb_intern("action")));
+            rb_hash_aset(hash, ID2SYM( rb_intern("action") ),
+                         rb_str_new2( action.GetTypeName().c_str() ) );
+            rb_hash_aset(hash, ID2SYM( rb_intern("uri") ),
+                         rb_str_new2( action.GetURI(doc).c_str() ) );
+        } else {
+            rb_hash_aset(hash, ID2SYM( rb_intern("type") ), ID2SYM(rb_intern("unknown")));
+        }
+    }
+    return hash;
+}
+
+VALUE
+define_bookmark_class(){
+
+#if RDOC_IS_STUPID_AND_CANNOT_PARSE_DOCUMENTATION
+    VALUE RB_PDFium = rb_define_module("PDFium");
+#endif
+    VALUE RB_PDFium = RB::PDFium();
+
+    VALUE RB_Bookmark = rb_define_class_under(RB_PDFium, "Bookmark",  rb_cObject);
+    rb_define_alloc_func(RB_Bookmark, bookmark_allocate);
+
+    rb_define_private_method (RB_Bookmark, "initialize",   RUBY_METHOD_FUNC(bookmark_initialize),  1);
+    rb_define_method         (RB_Bookmark, "title",        RUBY_METHOD_FUNC(bookmark_title),       0);
+    rb_define_method         (RB_Bookmark, "next_sibling", RUBY_METHOD_FUNC(bookmark_next_sibling),0);
+    rb_define_method         (RB_Bookmark, "children",     RUBY_METHOD_FUNC(bookmark_children),    0);
+    rb_define_method         (RB_Bookmark, "destination",  RUBY_METHOD_FUNC(bookmark_destination), 0);
+
+    return RB_Bookmark;
+}

data/ext/pdfium_ext/buffer_file_write.hpp

@@ -0,0 +1,27 @@
+// Implementation of FPDF_FILEWRITE into a file.
+class BufferFileWrite : public FPDF_FILEWRITE {
+public:
+    BufferFileWrite( const std::string &file ) :
+        _file( file, std::ios::out | std::ios::binary )
+    {
+        version = 1;
+        WriteBlock = &WriteBlockImpl;
+    }
+    ~BufferFileWrite() {
+        _file.close();
+    }
+
+private:
+    int DoWriteBlock(const void* data, unsigned long size){
+        _file.write(static_cast<const char*>(data), size);
+        return 1;
+    }
+    static int WriteBlockImpl(FPDF_FILEWRITE* this_file_write, const void* data,
+                              unsigned long size){
+        BufferFileWrite* mem_buffer_file_write =
+            static_cast<BufferFileWrite*>(this_file_write);
+        return mem_buffer_file_write->DoWriteBlock(data, size);
+    }
+
+    std::ofstream _file;
+};

data/ext/pdfium_ext/document.cc

@@ -0,0 +1,268 @@
+#include "document.h"
+#include "pdfium.h"
+#include <cstring>
+#include <iostream>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <fstream>
+#include <map>
+#include "buffer_file_write.hpp"
+
+/////////////////////////////////////////////////////////////////////////
+// The Document class                                                       //
+/////////////////////////////////////////////////////////////////////////
+/*
+    * Document-class:  PDFium::Document
+    *
+    * A Document represents a PDF file.
+    *
+*/
+
+
+// While you might think this would free the Document object it does not
+// Instead it simply marks the Document as no longer in use, and then it
+// will release itself when there are no Pages in use.
+// https://redmine.ruby-lang.org/issues/6292
+static void
+document_gc_free(DocumentWrapper* doc)
+{
+    DEBUG_MSG("GC Free Doc: " << doc);
+    // Note: we do not actually destroy the object yet.
+    // instead we mark it as unused and it will remove itself
+    // once all pages are finished
+    doc->markUnused();
+}
+
+static VALUE
+document_allocate(VALUE klass)
+{
+    DocumentWrapper *doc = new DocumentWrapper();
+    DEBUG_MSG("Alloc PDF: " << doc);
+    return Data_Wrap_Struct(klass, NULL, document_gc_free, doc );
+}
+
+
+/*
+ * call-seq:
+ *   Document.new( path_to_pdf_file ) -> Document
+ *   Document.new() -> An empty PDF Document with no pages
+ *
+ * Initializes a document either from a PDF file or creates a blank document
+ */
+VALUE
+document_initialize(int argc, VALUE *argv, VALUE self)
+{
+    DocumentWrapper* d;
+    Data_Get_Struct(self, DocumentWrapper, d);
+    if (argc){
+        VALUE path = RB::to_s(argv[0]); // call to_s in case it's a Pathname
+        d->document = (CPDF_Document*)FPDF_LoadDocument(StringValuePtr(path), NULL);
+    } else {
+        d->document = (CPDF_Document*)FPDF_CreateNewDocument();
+    }
+    if (! d->document ){
+        rb_raise(rb_eArgError, "Unable to create document: %s", PDFiumLastErrorString());
+    }
+    return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   Document.from_memory( pdf_data ) -> Document
+ *
+ * Initializes a document from a binary string.
+ *
+ * See Image#data for an example of reading a PDF directly from Amazon S3
+ * and writing it's images completely in memory.
+ */
+static VALUE
+document_from_memory(VALUE klass, VALUE data){
+    DocumentWrapper *doc = new DocumentWrapper();
+    VALUE instance = Data_Wrap_Struct(klass, NULL, document_gc_free, doc );
+    doc->document = (CPDF_Document*)FPDF_LoadMemDocument(RSTRING_PTR(data), RSTRING_LEN(data),NULL);
+    return instance;
+}
+
+/*
+ * call-seq:
+ *   page_count -> Fixnum
+ *
+ * Returns the number of pages on a Document
+ */
+static VALUE
+document_page_count(VALUE self)
+{
+    return INT2NUM( RB2DOC(self)->GetPageCount() );
+}
+
+// Not documented in favor of the Document#pages[] access
+/* :nodoc: */
+static VALUE
+document_page_at(VALUE self, VALUE rb_page_index)
+{
+    return rb_funcall(RB::Page(), rb_intern("open"), 2, self, rb_page_index);
+}
+
+/*
+ * call-seq:
+ *   pages -> PDFium::PageList
+ *
+ * Returns a collection of all the pages on the document as a PDFium::PageList. Pages
+ * are lazily loaded.
+ *
+ */
+static VALUE
+document_pages(VALUE self)
+{
+    VALUE args[1];
+    args[0] = self;
+    return rb_class_new_instance( 1, args, RB::PageList() );
+}
+
+// creates and yields a page.  Not documented since all access
+// should got through the Pageist interface via the Document#pages method
+/* :nodoc: */
+static VALUE
+document_each_page(VALUE self)
+{
+    auto doc = RB2DOC(self);
+    auto count = doc->GetPageCount();
+    for (int pg=0; pg < count; pg++){
+        VALUE page = document_page_at(self, INT2FIX(pg));
+        rb_yield(page);
+        PageWrapper *pw;
+        Data_Get_Struct(page, PageWrapper, pw);
+        pw->unload();
+    }
+    return self;
+}
+
+
+
+/*
+ * call-seq:
+ *   bookmarks -> Bookmarks
+ *
+ * Retrieves the first Bookmark for a document
+ */
+static VALUE
+document_bookmarks(VALUE self)
+{
+    VALUE args[1];
+    args[0] = rb_hash_new();
+    rb_hash_aset(args[0], ID2SYM(rb_intern("document")), self);
+    VALUE bm = rb_class_new_instance( 1, args, RB::Bookmark() );
+    args[0] = bm;
+    return rb_class_new_instance( 1, args, RB::BookmarkList() );
+}
+
+
+
+
+/*
+ * call-seq:
+ *   save -> Document
+ *
+ * Saves document to a PDF file.  This method isn't terribly useful since there aren't
+ * (yet) methods to add content to pages.
+ */
+static VALUE
+document_save(VALUE self, VALUE _path)
+{
+    auto doc = RB2DOC(self);
+    VALUE path = RB::to_s(_path); // call to_s in case it's a Pathname
+    BufferFileWrite output_file_write(StringValuePtr(path));
+    FPDF_SaveAsCopy(doc, &output_file_write, FPDF_REMOVE_SECURITY);
+    return self;
+}
+
+
+/*
+  call-seq:
+    metadata -> Hash
+
+ Retrieves and optionally sets the metadata on a document. Returns a hash with the following keys:
+
+   :title, :author :subject, :keywords, :creator, :producer, :creation_date, :mod_date
+
+ An empty Hash will be returned if the metadata cannot be read
+
+ All values in the hash are encoded as UTF-16LE strings.
+
+ If caled with a block, the values will be passed to it and updates written back to the Document
+
+ === Example
+    pdf = PDFium::Document.new( "test.pdf" )
+    pdf.metadata do | md |
+        md[:title]  = "My Awesome PDF"
+        md[:author] = "Nathan Stitt"
+    end
+    pdf.metadata[:author] # => "Nathan Stitt"
+
+ */
+VALUE
+document_metadata(int argc, VALUE *argv, VALUE self)
+{
+    auto doc = RB2DOC(self);
+    VALUE metadata = rb_hash_new();
+    CPDF_Dictionary* info = doc->GetInfo();
+    if (!info)
+        return metadata;
+
+    VALUE block;
+    rb_scan_args(argc, argv, "0&", &block);
+
+    std::map<std::string, std::string> keys = {
+        { "Title",        "title"  },
+        { "Author",       "author" },
+        { "Subject",      "subject" },
+        { "Keywords",     "keywords"},
+        { "Creator",      "creator" },
+        { "Producer",     "producer"},
+        { "CreationDate", "creation_date" },
+        { "ModDate",      "mod_date" }
+    };
+
+    for (auto& kv : keys) {
+        rb_hash_aset(metadata,
+                     ID2SYM( rb_intern( kv.second.c_str() ) ),
+                     RB::to_string( info->GetUnicodeText( kv.first.c_str() ) )
+                     );
+    }
+
+    if (RTEST(block)){
+        rb_yield( metadata );
+        for (auto& kv : keys) {
+            VALUE value = RB::get_option(metadata, kv.second);
+            auto bs = CFX_ByteString( RSTRING_PTR(value), RSTRING_LEN(value) );
+            info->SetAtString(kv.first.c_str(), bs);
+        }
+    }
+
+    return metadata;
+}
+
+VALUE
+define_document_class()
+{
+    VALUE RB_PDFium = RB::PDFium();
+
+    // The Document class definition and methods
+    VALUE RB_Document = rb_define_class_under(RB_PDFium, "Document",  rb_cObject);
+
+    rb_define_alloc_func(RB_Document, document_allocate);
+
+    rb_define_singleton_method(RB_Document, "from_memory", RUBY_METHOD_FUNC(document_from_memory), 1);
+
+    rb_define_private_method (RB_Document, "initialize", RUBY_METHOD_FUNC(document_initialize), -1);
+    rb_define_method         (RB_Document, "page_count", RUBY_METHOD_FUNC(document_page_count),  0);
+    rb_define_method         (RB_Document, "page_at",    RUBY_METHOD_FUNC(document_page_at),     1);
+    rb_define_method         (RB_Document, "each_page",  RUBY_METHOD_FUNC(document_each_page),   0);
+    rb_define_method         (RB_Document, "pages",      RUBY_METHOD_FUNC(document_pages),       0);
+    rb_define_method         (RB_Document, "metadata",   RUBY_METHOD_FUNC(document_metadata),   -1);
+    rb_define_method         (RB_Document, "bookmarks",  RUBY_METHOD_FUNC(document_bookmarks),   0);
+    rb_define_method         (RB_Document, "save",       RUBY_METHOD_FUNC(document_save),        1);
+    return RB_Document;
+}