pd4ml 1.0.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4513a87a893692d3e313518c97d69173def7204292ecaa262eb673661b0c701
-  data.tar.gz: 9e6a2f7d64d1527a85b5cc223e55a0ffeee2d897e4775d34a72e4c54da47eaa7
+  metadata.gz: 5f3f328b0ad4e184f8d1b35bdf80f51c1e2708798e4e782a765e3c71d5d98ebc
+  data.tar.gz: 133a2003170431c83600e3d2eb7bdae3f12cb4af14c9edf365e38e95b9a9b25b
 SHA512:
-  metadata.gz: c0be94f471af6f9c4d4ac9ddb963220cfa20ec1a0098eaab566643ec6f2ec3639420cf5fe736ec9a06a5d9e873e585a63bc91c2a0afe2fb9dec1c3964adeb7fd
-  data.tar.gz: 11c4659971b4e152790e4418501d0c86815bbc977eb03860acff07107e96d99d3ac75f38ff23cb82e9c707b96e4557cf0e425d48b6c034db1223e076d8fe5a23
+  metadata.gz: fdd66e32394009f7a81e1a6cc5e51798bd0d798bde2463c0c5a2a81bf30b5c945afd1723a5a7fa2909e842a801606fdcfa7e5bdbedd9f43c46388d694525e6ff
+  data.tar.gz: f95260d4d7e77b25563a7f23f3ad00d58c6ed0a7e9f77b11d13f9a36e128e6878f951811b67e35d69bea5c4d2ee9f38a5772bab0e4d685540a7886e3535ad9db

data/README.md

@@ -29,11 +29,17 @@ Requirements:
 - Ruby 3.1 or later.
 - Java 8 or later, found through `PD4ML_JAVA`, `JAVA_HOME` or the `PATH`.
 
-PD4ML itself is downloaded from <https://pd4ml.com/maven2>: the most recent 4.x release, plus the
-Bouncy Castle jars it needs for encryption and signing. Every file is checked against its SHA-1
-checksum. The download happens with `pd4ml install`, or on first use (`PD4ML_AUTO_INSTALL=0`
-turns that off). Builds are stored per user (`%LOCALAPPDATA%\pd4ml-ruby`, `~/.cache/pd4ml-ruby`,
-or `PD4ML_HOME`).
+PD4ML itself is downloaded from <https://pd4ml.com/maven2>: by default the most recent release from
+4.2.0 on, plus the Bouncy Castle jars it needs for encryption and signing. Every file is checked
+against its SHA-1 checksum. The download happens with `pd4ml install`, or on first use
+(`PD4ML_AUTO_INSTALL=0` turns that off). Builds are stored per user
+(`%LOCALAPPDATA%\pd4ml-ruby`, `~/.cache/pd4ml-ruby`, or `PD4ML_HOME`).
+
+The gem's PD4ML 4.2 API (`read_eml`/`read_mht`, `add_allowed_resource_location`, XMP
+`add_metadata`, the DOM API) needs PD4ML 4.2. Until PD4ML 4.2.0 is released, the default is
+therefore the most recent 4.2.x development snapshot (4.2.0-SNAPSHOT). Once 4.2.0 is out, new
+installs take it, and `pd4ml install` updates existing ones. `pd4ml install 4.1.2` installs the
+current 4.1 release instead (the rest of the API works with it). See [Install PD4ML](docs/guide.md#22-install-pd4ml).
 
 To use a PD4ML jar of your own, set `PD4ML_CLASSPATH`, set `PD4ML_CLASSPATH_FILE`, or call
 `Pd4ml.configure(classpath: [...])`.
@@ -51,10 +57,16 @@ The gem adds Ruby I/O on top: paths, URLs, binary Strings and IO objects in and
 for progress listeners. Several processes can share one bridge server: run `pd4ml serve` and set
 `PD4ML_BRIDGE=tcp://127.0.0.1:8723`.
 
+With PD4ML 4.2, the gem also reads e-mail messages and saved web pages (`read_eml`, `read_mht`; DMS
+and UA editions),
+and gives access to the parsed document before it is written (`get_document`, `layout`: the DOM
+API of the DMS and UA editions, whose lists come back as Ruby Arrays). See the
+[guide](docs/guide.md#516-e-mail-messages-and-saved-web-pages).
+
 ## Command line
 
 ```
-pd4ml install [VERSION] [--snapshots]   download PD4ML (or update it)
+pd4ml install [VERSION] [--snapshots]   download PD4ML (default: 4.2, see above) or update it
 pd4ml list                              versions in the repository
 pd4ml version                           the PD4ML version in use
 pd4ml convert in.html out.pdf [--page-size A4 --landscape --spec pdf/a-2b ...]

data/docs/api.md

@@ -2,7 +2,7 @@
 
 _Generated by `tools/gen_api.rb` from the PD4ML Java classes - do not edit._
 
-Every public PD4ML class is a Ruby class in the `Pd4ml` module. Methods can be called by their Java name (`setPageSize`) or Ruby-style (`set_page_size`; `isDemoMode` as `demo_mode?`); both are listed below. Constants and static fields are Ruby constants or class methods (`Pd4ml::PageSize::A4`, `Pd4ml::LayoutEngine.v42`), public instance fields are read with `obj[:name]`. Java types appear as Ruby types: binary Strings for `byte[]` and `InputStream`, a path or URL String for `URL`/`File`, `JavaObject` for any other Java object. Descriptions of each method are in the [PD4ML manual](https://pd4ml.com/docs/pd4ml-manual.html).
+Every public PD4ML class is a Ruby class in the `Pd4ml` module. Methods can be called by their Java name (`setPageSize`) or Ruby-style (`set_page_size`; `isDemoMode` as `demo_mode?`); both are listed below. Constants and static fields are Ruby constants or class methods (`Pd4ml::PageSize::A4`, `Pd4ml::LayoutEngine.v42`), public instance fields are read with `obj[:name]`. Java types appear as Ruby types: binary Strings for `byte[]` and `InputStream`, a path or URL String for `URL`/`File`, `JavaObject` for any other Java object. The DOM API classes (`Pd4ml::Dom`: `PD4ML#get_document` and `PD4ML#layout` return them; v42 layout engine, DMS and UA editions) return Java lists and sets as Ruby Arrays, maps as Hashes. Descriptions of each method are in the [PD4ML manual](https://pd4ml.com/docs/pd4ml-manual.html).
 
 ## Pd4ml::PD4ML
 
@@ -78,6 +78,8 @@ keep_trailing_blank_pages?() -> true/false   # isKeepTrailingBlankPages
 test_termination() -> nil   # testTermination
 get_height(width: Integer) -> Integer   # getHeight
 get_document_title() -> String   # getDocumentTitle
+layout() -> Dom::Layout   # layout
+get_document() -> Dom::Document   # getDocument
 set_rendering_hints(hints: Hash) -> nil   # setRenderingHints
 dump(mode: Integer) -> String   # dump
 protect_physical_unit_dimensions(keep_physical_unit_dimensions: true/false) -> nil   # protectPhysicalUnitDimensions
@@ -85,10 +87,12 @@ Pd4ml::PD4ML.translate_to_pt(mm: Float) -> Float   # translateToPt
 Pd4ml::PD4ML.predict_scale(page_margins: PageMargins, page_size: PageSize, user_space: Integer) -> Float   # predictScale
 Pd4ml::PD4ML.predict_page_height(page_margins: PageMargins, page_size: PageSize, user_space: Integer) -> Integer   # predictPageHeight
 set_dynamic_data(map: Hash) -> nil   # setDynamicData
+add_allowed_resource_location(locations: String) -> nil   # addAllowedResourceLocation
 set_param(key: String, value: String) -> nil   # setParam
 get_last_render_info(key: String) -> Object   # getLastRenderInfo
 output_range(description: String) -> nil   # outputRange
 add_metadata(key: String, value: String, hide: true/false) -> nil   # addMetadata
+add_metadata(namespace_uri: String, prefix: String, key: String, value: String) -> nil   # addMetadata
 apply_kerning(enable: true/false) -> nil   # applyKerning
 enable_ligatures(enable: true/false) -> nil   # enableLigatures
 get_cache() -> Object   # getCache
@@ -119,7 +123,6 @@ async_resource_loader(thread_pool_size: Integer) -> nil   # asyncResourceLoader
 | `Pd4ml::Constants::PD4ML_EXTRA_RESOURCE_LOADERS` | String | static read-only |
 | `Pd4ml::Constants::PD4ML_DOCUMENT_VIEW_MODE` | String | static read-only |
 | `Pd4ml::Constants::PD4ML_DOCUMENT_DATE` | String | static read-only |
-| `Pd4ml::Constants::PD4ML_WORD_EDITABLE` | String | static read-only |
 | `Pd4ml::Constants::PD4ML_DOCUMENT_XMP_DATE` | String | static read-only |
 | `Pd4ml::Constants::PD4ML_FAKE_BROWSER` | String | static read-only |
 | `Pd4ml::Constants::PD4ML_CACHE_ENABLE` | String | static read-only |
@@ -398,6 +401,7 @@ requires_metadata() -> true/false   # requiresMetadata
 requires_output_internet() -> true/false   # requiresOutputInternet
 allows_external_hyperlinking() -> true/false   # allowsExternalHyperlinking
 requires_reliable_unicode_semantics() -> true/false   # requiresReliableUnicodeSemantics
+has_pdf_version() -> true/false   # hasPdfVersion
 get_pdf_version_label() -> String   # getPdfVersionLabel
 get_pdf_ext_level() -> Integer   # getPdfExtLevel
 get_pdfa_version() -> Integer   # getPdfaVersion
@@ -450,7 +454,7 @@ Pd4ml::PdfDocumentBase.compute_scope(scope: String, page_num: Integer) -> Array<
 
 ## Pd4ml::PdfDocument
 
-`com.pd4ml.PdfDocument`
+`com.pd4ml.PdfDocument` — also the methods of `Pd4ml::PdfDocumentBase`
 
 ```ruby
 Pd4ml::PdfDocument.new(bytes: String (binary), password: String)
@@ -544,3 +548,151 @@ error?() -> true/false   # isError
 warning?() -> true/false   # isWarning
 get_message() -> String   # getMessage
 ```
+
+## Pd4ml::Dom::Node
+
+`com.pd4ml.dom.Node` (DOM API)
+
+```ruby
+get_node_name() -> String   # getNodeName
+get_parent_node() -> Dom::Node   # getParentNode
+get_parent_element() -> Dom::Element   # getParentElement
+get_owner_document() -> Dom::Document   # getOwnerDocument
+get_child_nodes() -> Array<Dom::Node>   # getChildNodes
+has_child_nodes() -> true/false   # hasChildNodes
+get_first_child() -> Dom::Node   # getFirstChild
+get_last_child() -> Dom::Node   # getLastChild
+get_next_sibling() -> Dom::Node   # getNextSibling
+get_previous_sibling() -> Dom::Node   # getPreviousSibling
+get_text_content() -> String   # getTextContent
+set_text_content(text: String) -> nil   # setTextContent
+append_child(child: Dom::Node) -> Dom::Node   # appendChild
+insert_before(child: Dom::Node, ref: Dom::Node) -> Dom::Node   # insertBefore
+replace_child(replacement: Dom::Node, old: Dom::Node) -> Dom::Node   # replaceChild
+remove_child(child: Dom::Node) -> Dom::Node   # removeChild
+remove() -> nil   # remove
+clone_node(deep: true/false) -> Dom::Node   # cloneNode
+contains(other: Dom::Node) -> true/false   # contains
+to_html() -> String   # toHtml
+```
+
+## Pd4ml::Dom::Document
+
+`com.pd4ml.dom.Document` (DOM API) — also the methods of `Pd4ml::Dom::Node`
+
+```ruby
+get_document_element() -> Dom::Element   # getDocumentElement
+get_head() -> Dom::Element   # getHead
+get_body() -> Dom::Element   # getBody
+get_doctype() -> Dom::DocumentType   # getDoctype
+quirks_mode?() -> true/false   # isQuirksMode
+get_base_uri() -> String   # getBaseURI
+get_title() -> String   # getTitle
+get_element_by_id(id: String) -> Dom::Element   # getElementById
+get_elements_by_tag_name(name: String) -> Array<Dom::Element>   # getElementsByTagName
+get_elements_by_class_name(names: String) -> Array<Dom::Element>   # getElementsByClassName
+query_selector(selectors: String) -> Dom::Element   # querySelector
+query_selector_all(selectors: String) -> Array<Dom::Element>   # querySelectorAll
+create_element(tag_name: String) -> Dom::Element   # createElement
+create_text_node(data: String) -> Dom::Text   # createTextNode
+create_comment(data: String) -> Dom::Comment   # createComment
+set_text_content(text: String) -> nil   # setTextContent
+```
+
+## Pd4ml::Dom::Element
+
+`com.pd4ml.dom.Element` (DOM API) — also the methods of `Pd4ml::Dom::Node`
+
+```ruby
+get_tag_name() -> String   # getTagName
+get_attribute(name: String) -> String   # getAttribute
+has_attribute(name: String) -> true/false   # hasAttribute
+set_attribute(name: String, value: String) -> nil   # setAttribute
+remove_attribute(name: String) -> nil   # removeAttribute
+get_attributes() -> Hash   # getAttributes
+get_id() -> String   # getId
+set_id(id: String) -> nil   # setId
+get_class_name() -> String   # getClassName
+set_class_name(class_name: String) -> nil   # setClassName
+get_class_list() -> Array<String>   # getClassList
+has_class(name: String) -> true/false   # hasClass
+add_class(name: String) -> nil   # addClass
+remove_class(name: String) -> nil   # removeClass
+toggle_class(name: String) -> true/false   # toggleClass
+get_children() -> Array<Dom::Element>   # getChildren
+get_first_element_child() -> Dom::Element   # getFirstElementChild
+get_last_element_child() -> Dom::Element   # getLastElementChild
+get_next_element_sibling() -> Dom::Element   # getNextElementSibling
+get_previous_element_sibling() -> Dom::Element   # getPreviousElementSibling
+get_elements_by_tag_name(name: String) -> Array<Dom::Element>   # getElementsByTagName
+get_elements_by_class_name(names: String) -> Array<Dom::Element>   # getElementsByClassName
+query_selector(selectors: String) -> Dom::Element   # querySelector
+query_selector_all(selectors: String) -> Array<Dom::Element>   # querySelectorAll
+matches(selectors: String) -> true/false   # matches
+closest(selectors: String) -> Dom::Element   # closest
+get_inner_html() -> String   # getInnerHTML
+set_inner_html(html: String) -> nil   # setInnerHTML
+get_outer_html() -> String   # getOuterHTML
+set_outer_html(html: String) -> nil   # setOuterHTML
+set_text_content(text: String) -> nil   # setTextContent
+```
+
+## Pd4ml::Dom::Text
+
+`com.pd4ml.dom.Text` (DOM API) — also the methods of `Pd4ml::Dom::Node`
+
+```ruby
+get_data() -> String   # getData
+set_data(data: String) -> nil   # setData
+whitespace?() -> true/false   # isWhitespace
+set_text_content(text: String) -> nil   # setTextContent
+```
+
+## Pd4ml::Dom::Comment
+
+`com.pd4ml.dom.Comment` (DOM API) — also the methods of `Pd4ml::Dom::Node`
+
+```ruby
+get_data() -> String   # getData
+set_data(data: String) -> nil   # setData
+get_text_content() -> String   # getTextContent
+set_text_content(text: String) -> nil   # setTextContent
+```
+
+## Pd4ml::Dom::DocumentType
+
+`com.pd4ml.dom.DocumentType` (DOM API) — also the methods of `Pd4ml::Dom::Node`
+
+```ruby
+get_name() -> String   # getName
+get_public_id() -> String   # getPublicId
+get_system_id() -> String   # getSystemId
+set_text_content(text: String) -> nil   # setTextContent
+```
+
+## Pd4ml::Dom::Layout
+
+`com.pd4ml.dom.Layout` (DOM API)
+
+```ruby
+get_page_count() -> Integer   # getPageCount
+get_page_width(page: Integer) -> Float   # getPageWidth
+get_page_height(page: Integer) -> Float   # getPageHeight
+get_page_number(page: Integer) -> Integer   # getPageNumber
+get_boxes(element: Dom::Element) -> Array<Dom::LayoutBox>   # getBoxes
+get_pages(element: Dom::Element) -> Array<Integer>   # getPages
+get_computed_style(element: Dom::Element, property: String) -> String   # getComputedStyle
+element_at(page: Integer, x: Float, y: Float) -> Dom::Element   # elementAt
+```
+
+## Pd4ml::Dom::LayoutBox
+
+`com.pd4ml.dom.LayoutBox` (DOM API)
+
+```ruby
+get_page() -> Integer   # getPage
+get_x() -> Float   # getX
+get_y() -> Float   # getY
+get_width() -> Float   # getWidth
+get_height() -> Float   # getHeight
+```

data/docs/guide.md

@@ -34,7 +34,7 @@ The generated reference of every class and method is [api.md](api.md).
 | **Java 8 or later** | A JDK or JRE; an LTS release (17, 21) is recommended. The gem finds it through `PD4ML_JAVA`, then `JAVA_HOME`, then `java` on the `PATH`. |
 | **PD4ML** | Downloaded automatically on first use, or ahead of time with `pd4ml install` (see below); or any PD4ML build you point the gem at. |
 | **Network access** | Only for downloading PD4ML. Conversions need none, unless the HTML references remote resources. |
-| **A PD4ML license** | Optional for evaluation. Without one, PD4ML runs in evaluation mode and watermarks its output. See [Licensing](https://pd4ml.com/docs/#3.-licensing) and [5.18](#518-licensing). |
+| **A PD4ML license** | Optional for evaluation. Without one, PD4ML runs in evaluation mode and watermarks its output. See [Licensing](https://pd4ml.com/docs/#3.-licensing) and [5.21](#521-licensing). |
 
 Check Java with `java -version`. On a server without Java, install a JRE package (for example
 `apt install openjdk-21-jre-headless`) and, if it is not on the `PATH`, set `JAVA_HOME`. In
@@ -62,9 +62,9 @@ The gem contains the Ruby library and the bridge only. The PD4ML library itself
 PD4ML Maven repository (<https://pd4ml.com/maven2>), in one of two ways.
 
 **Automatically, on first use.** If no PD4ML build is installed or configured
-([2.3](#23-other-ways-to-provide-pd4ml)), the first use of PD4ML in a process downloads the most
-recent PD4ML 4.x release before starting Java. A warning on standard error reports it. So once the gem
-is installed, this is all it takes:
+([2.3](#23-other-ways-to-provide-pd4ml)), the first use of PD4ML in a process downloads PD4ML 4.2
+([which build](#which-build)) before starting Java. A warning on standard error reports it. So
+once the gem is installed, this is all it takes:
 
 <!-- no-test -->
 ```ruby
@@ -82,7 +82,7 @@ pd4ml install                 # with Bundler: bundle exec pd4ml install
 
 Either way, the gem:
 
-- downloads the most recent PD4ML 4.x release;
+- downloads PD4ML 4.2 ([which build](#which-build));
 - downloads the Bouncy Castle jars PD4ML needs for encryption and signing, from Maven Central;
 - checks every file against its published SHA-1 checksum;
 - stores them in a per-user cache directory: `%LOCALAPPDATA%\pd4ml-ruby` on Windows,
@@ -91,12 +91,29 @@ Either way, the gem:
 The gem then uses that build. Later runs do not check for newer PD4ML releases: run
 `pd4ml install` again to update. Updating the gem does not change the PD4ML build.
 
+<a id="which-build"></a>**Which build.** The gem needs PD4ML 4.2 for its 4.2 API: `read_eml` and
+`read_mht`, `add_allowed_resource_location`, `add_metadata` (XMP), and the DOM API
+(`get_document`, `layout`), as well as for the v42 layout engine ([4.3](#43-layout-engines)). So a
+plain `pd4ml install` (and the first use) takes:
+
+- the most recent PD4ML release from 4.2.0 on;
+- while 4.2.0 is not released yet, the most recent 4.2.x **development snapshot** (today
+  4.2.0-SNAPSHOT), because no release has the 4.2 API yet.
+
+Once 4.2.0 is released, new installs take it by themselves, and `pd4ml install` updates an
+existing snapshot install to it. Snapshots of later versions (4.3, 5.0) are never taken by
+default; `--snapshots` asks for them.
+
+The rest of the API works with older builds too: to stay on the current 4.1 release, install it
+explicitly (`pd4ml install 4.1.2`); the 4.2 methods then raise `Pd4ml::JavaError`
+(`NoSuchMethodException`).
+
 | Option | |
 |---|---|
-| *(none)* | the most recent 4.x release, or an update to it |
+| *(none)* | the most recent release from 4.2.0 on, else the most recent 4.2.x snapshot ([which build](#which-build)), or an update to it |
 | `--snapshots` | the most recent 4.x build, including development snapshots |
-| `pd4ml install 4.0.23fx2` | an exact version |
-| `--jakarta` | the `-jakarta` variant (for Jakarta EE / Servlet 6 environments) |
+| `pd4ml install 4.1.2` | an exact version (any release or snapshot the repository lists) |
+| `--jakarta` | for Jakarta EE / Servlet 6 environments: a `-jakarta` variant if one fits; PD4ML 4.2 has none (its builds contain the Jakarta tag library), so the same 4.2 build (an older `-jakarta` build by version, e.g. `pd4ml install 4.0.20fx3-jakarta`) |
 | `--home DIR` | install into `DIR` (default: `PD4ML_HOME`, else the cache directory) |
 | `--force` | download again |
 | `--no-bouncycastle` | skip the Bouncy Castle jars (encryption and signing will not work) |
@@ -252,6 +269,10 @@ such a build:
 - **Objects**: a Java object comes back as a `Pd4ml::JavaObject` with all its Java methods.
   Public fields: `obj[:width]` and `obj[:width] = value`. `to_s` is Java's `toString()`,
   `enum_name` an enum constant's name, `java_class` the class name.
+- **Collections**: a Java `List` or `Map` generally comes back as a `JavaObject` (`size`,
+  `get(i)`). The DOM API ([5.18](#518-modifying-the-document-before-conversion-dom-api)) is the
+  exception: its lists and sets come back as Ruby Arrays and its maps as Hashes. `call_java` returns
+  them as Java objects.
 - **Values**: Strings, Integers, Floats (`100.0` goes to Java as a float), `true`/`false`, `nil`,
   Symbols (as strings: `engine: :v40`), Arrays, Hashes (as Java `Map`s).
 - **Binary data**: a binary String (`File.binread`, `"...".b`, encoding ASCII-8BIT) goes to Java
@@ -529,9 +550,8 @@ The image formats are `PNG8`, `PNG24`, `TIFF` and `TIFF_COMPRESSED` (constants i
 The TIFF formats need Java 9 or later.
 The v42 engine does not support the multi-page TIFF formats yet; use the v40 engine for them.
 
-With the v42 engine, DOCX/RTF output can be made *editable*: positioned content becomes text
-boxes and form fields instead of pictures. To enable it, call
-`pd.set_param(Pd4ml::Constants::PD4ML_WORD_EDITABLE, 'true')`.
+With the v42 engine, DOCX/RTF output is *editable*: positioned content becomes text boxes
+and form fields, not pictures.
 
 ### 5.12 Interactive forms and multi-column layout
 
@@ -583,6 +603,7 @@ pd.set_log_level(1)                               # 0 (silent) .. 5
 pd.set_author_name('Reporting service')
 pd.set_document_title('Monthly statement')
 pd.add_metadata('StatementId', '2026-10', false)
+pd.add_metadata('http://www.w3.org/ns/tdmrep/', 'tdm', 'reservation', '1')   # XMP, a namespace of your own
 pd.read_html_string('<h1>Statement</h1>')
 pd.write_pdf('statement.pdf')
 pages = pd.get_last_render_info(Pd4ml::Constants::PD4ML_TOTAL_PAGES).to_i
@@ -593,6 +614,14 @@ itself. An error it raises comes out of the call that caused it, as a `Pd4ml::Ca
 The v42 engine currently reports fewer progress stages than v40. More in
 [extensibility and diagnostics](https://pd4ml.com/docs/#12.-extensibility-and-diagnostics).
 
+`add_metadata(key, value, hide)` adds a custom property to the PDF's XMP metadata, which viewers
+show among the custom document properties (`hide`: true keeps it out of their view).
+`add_metadata(namespace_uri, prefix, key, value)` (PD4ML 4.2) adds an XMP property in a
+namespace of your own; the example writes `<tdm:reservation>1</tdm:reservation>`, which tells
+text and data mining crawlers the rights are reserved (the W3C TDM Reservation Protocol). In PDF/A
+output, PD4ML declares the namespace in a PDF/A extension schema. A reserved prefix (`rdf`, `xmp`,
+`dc`, `pdf`, `pd4ml`...) raises `Pd4ml::JavaError` (`IllegalArgumentException`).
+
 ### 5.15 Working with existing PDFs
 
 ```ruby
@@ -621,7 +650,136 @@ PD4ML's PDF toolkit (signing, optimisation, XFDF) is described in
 [the PDF post-processing toolkit](https://pd4ml.com/docs/#15.-the-pdf-post-processing-toolkit)
 and is reachable through `Pd4ml::Java.type(...)`.
 
-### 5.16 Web applications
+### 5.16 E-mail messages and saved web pages
+
+> **Editions.** E-mail and saved web page input — `read_eml`/`read_mht`, and `read_html` for input it
+> recognizes as one of them — is part of the PD4ML **DMS and UA editions**. With an STD or PRO license it
+> works, but the output carries the "PD4ML EVALUATION MODE" banners.
+
+PD4ML 4.2 reads e-mail messages (`.eml`) and web pages saved as a single file (`.mht`, `.mhtml`)
+and writes them to any output format:
+
+```ruby
+require 'pd4ml'
+
+pd = Pd4ml::PD4ML.new
+pd.read_eml('message.eml')                 # a path or URL, or the message itself: File.binread, an IO
+pd.write_pdf('message.pdf')                # the attachments are embedded in the PDF
+
+page = Pd4ml::PD4ML.new
+page.read_mht('page.mht')                  # a saved web page, with its images, styles and fonts
+page.write_pdf('page.pdf')
+```
+
+- A message becomes a block with From, Date, To, Cc, Subject and the attachments, followed by its
+  body: the HTML version if there is one, otherwise the plain text, with the images it embeds. The
+  attached files are embedded in the PDF next to their names (PDF/A-1 and PDF/A-2 and the other
+  outputs keep only the names).
+- A saved page shows as it was saved, with the resources saved in the file; its links lead where
+  they led on the original page.
+- `read_html` recognizes these files too, by the `.eml`, `.mht` or `.mhtml` ending or by how the
+  content starts. For mail from outside your control, use `read_eml` and `read_mht`.
+- Of the resources a file refers to but does not contain, only `https://` ones are loaded.
+  `add_allowed_resource_location` ([5.17](#517-untrusted-html-restricting-resource-loading))
+  replaces that list. A file read from a path or URL must then be within the allowed locations
+  itself; one passed as content (a binary String or IO) need not be.
+- Scripts do not run, the content of frames is not shown, and encrypted (S/MIME, PGP) messages
+  are not decrypted.
+
+See [converting e-mail and saved web pages](https://pd4ml.com/docs/features/converting-e-mail-and-saved-web-pages.html).
+
+### 5.17 Untrusted HTML: restricting resource loading
+
+HTML from users, customers or other systems decides what PD4ML loads: `<img src="file:/etc/...">`
+reads local files, `http://169.254.169.254/...` calls services inside your network.
+`add_allowed_resource_location` (PD4ML 4.2) limits loading to the locations you list:
+
+```ruby
+require 'pd4ml'
+
+user_html = '<p>Comment <img src="file:/etc/hosts"> <img src="http://169.254.169.254/latest/meta-data/"></p>'
+pd = Pd4ml::PD4ML.new
+pd.add_allowed_resource_location('https://cdn.example.com/assets/')
+pd.add_allowed_resource_location('https://*.example.org/, file:/opt/app/templates/')
+pd.read_html_string(user_html, 'https://cdn.example.com/assets/')
+pd.write_pdf('comment.pdf')                # without the two images
+```
+
+- `locations` is a comma-separated list of URL prefixes; each call adds to the list. `*` matches
+  any characters except `/` (one host name or path segment). The comparison ignores case, and a
+  path containing `..` is always rejected.
+- It covers style sheets, images, web fonts and attachments, and the document itself when it is
+  read from a path or URL. `data:` URIs, `java:` resources and the font directories of `use_ttf`
+  are not affected.
+- A rejected resource is left out and the conversion goes on;
+  `set_error_policy(Pd4ml::ErrorPolicy::PEDANTIC)` makes it fail with a `Pd4ml::JavaError`
+  instead, and `set_log_level(Pd4ml::Constants::LOG_CACHE)` logs what was rejected.
+- With no location added, resources load from anywhere. Call it before `read_html`.
+
+See [restricting resource loading for untrusted HTML](https://pd4ml.com/docs/features/restricting-resource-loading-for-untrusted-html.html).
+
+### 5.18 Modifying the document before conversion (DOM API)
+
+With the v42 layout engine, the document `read_html` parsed can be read, queried with CSS
+selectors and changed before it is written; `layout` lays it out into pages without writing it
+and tells where each element ended up.
+
+> The DOM API (`get_document`, `layout` and the `Pd4ml::Dom` classes) is part of the **DMS and UA
+> editions** of PD4ML 4.2. Without a license it can be evaluated (the output carries the
+> evaluation watermark); with an STD or PRO license it works, but the output of a document it was
+> used on carries "PD4ML EVALUATION MODE" banners. See [editions](https://pd4ml.com/products/).
+
+```ruby
+require 'pd4ml'
+
+pd = Pd4ml::PD4ML.new                      # the v42 engine
+pd.read_html_string(<<~HTML)
+  <h1 id="title">Invoice</h1>
+  <table class="items"><tr><td>Consulting</td><td class="price">1 200,00</td></tr></table>
+  <img src="logo.png">
+  <div id="totals">Total: <span id="total"></span></div>
+HTML
+
+doc = pd.get_document
+doc.get_element_by_id('total').set_text_content('1 250,00 EUR')
+doc.query_selector_all('img:not([alt])').each { |img| img.set_attribute('alt', '') }   # a Ruby Array
+doc.query_selector('table.items').add_class('striped')
+note = doc.create_element('p')
+note.set_inner_html('Payable within <b>30 days</b>.')
+doc.get_body.append_child(note)
+
+layout = pd.layout                         # the pages as write_pdf would make them
+totals = doc.get_element_by_id('totals')
+totals.set_attribute('style', 'page-break-before: always') if layout.get_pages(totals).size > 1
+layout.get_boxes(totals).each do |box|
+  puts format('page %d: %.1f, %.1f, %.1f x %.1f pt', box.get_page, box.get_x, box.get_y, box.get_width, box.get_height)
+end
+puts "#{layout.get_page_count} page(s), total in #{layout.get_computed_style(totals, 'color')}"
+pd.write_pdf('invoice.pdf')
+```
+
+| | Methods (Ruby-style; the Java names work too) |
+|---|---|
+| `Dom::Document` (`pd.get_document`) | `get_element_by_id`, `query_selector`, `query_selector_all`, `get_elements_by_tag_name`, `get_elements_by_class_name`, `get_head`, `get_body`, `get_title`, `create_element`, `create_text_node`, `create_comment` |
+| `Dom::Node` (every node) | `get_parent_node`, `get_child_nodes`, `get_first_child`, `get_next_sibling`..., `append_child`, `insert_before`, `replace_child`, `remove_child`, `remove`, `clone_node`, `contains`, `get_text_content`, `set_text_content`, `to_html` |
+| `Dom::Element` | `get_attribute`, `set_attribute`, `remove_attribute`, `get_attributes` (a Hash), `get_id`, `get_class_list`, `add_class`, `remove_class`, `toggle_class`, `get_inner_html`, `set_inner_html`, `get_outer_html`, `set_outer_html`, `matches`, `closest`, `get_children`... and the queries of `Document` within the element |
+| `Dom::Layout` (`pd.layout`) | `get_page_count`, `get_page_width(page)`, `get_page_height(page)`, `get_page_number(page)`, `get_boxes(element)`, `get_pages(element)`, `get_computed_style(element, property)`, `element_at(page, x, y)` |
+| `Dom::LayoutBox` | `get_page`, `get_x`, `get_y`, `get_width`, `get_height` (PDF points from the top left corner of the page) |
+
+- Lists (`query_selector_all`, `get_child_nodes`, `get_boxes`, `get_pages`...) come back as Ruby
+  Arrays, `get_attributes` as a Hash. They are snapshots: removing or moving nodes while going
+  through one is safe.
+- Two objects for the same node are `==` (Java `equals`), but not necessarily the same object.
+- A layout is a snapshot too: after changing the document, call `layout` again. Pages are
+  numbered from 1.
+- Change the document before the first output; every later write lays out the changed document.
+- `get_document` and `layout` raise `Pd4ml::JavaError` (`IllegalStateException`) before
+  `read_html` or with the v40 engine.
+
+The full method list is in [api.md](api.md#pd4mldomnode); the PD4ML guide is
+[modifying the HTML document before conversion](https://pd4ml.com/docs/features/modifying-the-html-document-before-conversion.html).
+
+### 5.19 Web applications
 
 Rails controller, with the HTML from a view:
 
@@ -658,7 +816,7 @@ To pay the cost of starting Java at boot instead of on the first request, touch
 initializer (`Pd4ml.version`). Each Puma worker process starts its own bridge; set
 `PD4ML_BRIDGE` to share one bridge server between them.
 
-### 5.17 Batch conversion
+### 5.20 Batch conversion
 
 ```ruby
 require 'pd4ml'
@@ -674,7 +832,7 @@ end
 One bridge serves the whole loop. To convert in parallel, run several processes (each with its
 own bridge), or point them all at one bridge server.
 
-### 5.18 Licensing
+### 5.21 Licensing
 
 <!-- no-test -->
 ```ruby
@@ -709,8 +867,9 @@ Without a license, PD4ML is fully functional but marks its output. See
   differently than in the browser, set `set_html_width` to the width the page was designed for.
 - **Index fonts once** with `-configure.fonts`, instead of pointing `use_ttf` at a large
   unindexed directory on every conversion.
-- **Restrict what documents can load** when converting untrusted HTML. Use `set_param` with
-  `Constants::PD4ML_ALLOWED_RESOURCE_LOCATION` and `PD4ML_DISABLE_EXTERNAL_ATTACHMENTS`.
+- **Restrict what documents can load** when converting untrusted HTML, with
+  `add_allowed_resource_location` ([5.17](#517-untrusted-html-restricting-resource-loading)); also
+  consider `set_param(Pd4ml::Constants::PD4ML_DISABLE_EXTERNAL_ATTACHMENTS, 'true')`.
 - **Pin the build in production.** Use `pd4ml install <version>` or a `PD4ML_CLASSPATH` to a
   jar you keep, rather than following the latest release.
 
@@ -739,6 +898,7 @@ Without a license, PD4ML is fully functional but marks its output. See
 |---|---|
 | `Pd4ml::PD4ML` | the converter: `Pd4ml::PD4ML.new(license:, html_width:, engine:)`; every Java method of `com.pd4ml.PD4ML` |
 | `PageSize`, `PageMargins`, `Units`, `Dimensions`, `Constants`, `LayoutEngine`, `ErrorPolicy`, `PdfSpec`, `PdfDocument`, `ProgressListener`, `StatusMessage`, `ResourceProvider`, `CustomTag` | the PD4ML Java classes ([api.md](api.md)) |
+| `Dom::Document`, `Dom::Node`, `Dom::Element`, `Dom::Text`, `Dom::Comment`, `Dom::DocumentType`, `Dom::Layout`, `Dom::LayoutBox` | the DOM API classes, from `pd.get_document` and `pd.layout` ([5.18](#518-modifying-the-document-before-conversion-dom-api)); their lists come back as Arrays |
 | `html_to_pdf(source, target, base_url:, page_size:, page_margins:, spec:, engine:, html_width:)`, `open_pdf(source, password)`, `write_pdf(doc, target, password:, permissions:)`, `merge_pdfs(a, b, target)` | one-call conversion and PDF documents |
 | `version`, `layout_engines?`, `to_url(location)`, `pdf_spec(keyword)` | runtime helpers |
 | `configure(**options)`, `shutdown` | the bridge: `classpath:`, `java:`, `jvm_options:`, `server:`, `log_file:` |
@@ -752,6 +912,7 @@ Without a license, PD4ML is fully functional but marks its output. See
 |---|---|
 | `read_html(source, base_url = nil, encoding = nil)` | `source`: a path or URL (String, Pathname, URI), a binary String or IO, or a Java `URL`/`InputStream` |
 | `read_html_string(html, base_url = nil)` | the document as a String |
+| `read_eml(source)`, `read_mht(source)` | an e-mail message, a saved web page ([5.16](#516-e-mail-messages-and-saved-web-pages)), DMS and UA editions; `source` as for `read_html` |
 | `write_pdf(target = nil, spec: nil)` | `target`: a path or IO; none: returns a binary String. `spec`: a `PdfSpec`, a keyword (`'pdf/a-2b'`) or `'PDF'`/`'PDFA'`/`'PDFUA'` |
 | `write_docx(target = nil)`, `write_rtf(target = nil, rtf_wmf: false)` | as `write_pdf` |
 | `render_as_images(format)`, `render_png` | pages as encoded images (binary Strings); `render_as_images(dir, name, format)` writes files |

data/exe/pd4ml

@@ -5,11 +5,16 @@
 require 'optparse'
 require_relative '../lib/pd4ml'
 
+MINIMUM = Pd4ml::Installer::MINIMUM_VERSION
+LINE = MINIMUM.split('.')[0, 2].join('.')
 USAGE = <<~TEXT
   usage: pd4ml <command> [options]
 
     install [VERSION] [--snapshots] [--jakarta] [--home DIR] [--force] [--no-bouncycastle]
-                        download a PD4ML build (default: the most recent 4.* release), or update to it
+                        download a PD4ML build, or update to it. Default: the most recent
+                        release from #{MINIMUM} on; until #{MINIMUM} is out, the most recent #{LINE}.x
+                        snapshot (the gem's #{LINE} API needs PD4ML #{LINE}). --snapshots: the most
+                        recent 4.* build. VERSION: an exact one, e.g. 4.1.2
     list [--snapshots] [--jakarta]
                         the versions in the PD4ML repository (* the installed one)
     version             the PD4ML version the gem runs (downloads it on first use)

data/lib/pd4ml/bridge.rb

@@ -66,7 +66,7 @@ module Pd4ml
         unless entries
           entries = Installer.installed_classpath
           if entries.empty? && Installer.auto_install?
-            warn 'pd4ml: no PD4ML build installed yet: downloading the most recent release ' \
+            warn "pd4ml: no PD4ML build installed yet: downloading PD4ML #{Installer::MINIMUM_VERSION} or later " \
                  "(once; 'pd4ml install' updates it, PD4ML_AUTO_INSTALL=0 turns this off)"
             Installer.install
             entries = Installer.installed_classpath

data/lib/pd4ml/installer.rb

@@ -9,9 +9,10 @@ require 'time'
 module Pd4ml
   # Downloads a PD4ML build from the PD4ML Maven repository and makes it the gem's default:
   #
-  #   pd4ml install                    the most recent 4.* release
+  #   pd4ml install                    the most recent release from MINIMUM_VERSION (4.2.0) on;
+  #                                    until there is one, the most recent 4.2.x snapshot
   #   pd4ml install --snapshots        the most recent 4.* build, snapshots included
-  #   pd4ml install 4.0.23fx2          an exact version
+  #   pd4ml install 4.1.2              an exact version
   #
   # or Pd4ml.install from code. The jar is stored in the user's cache directory (PD4ML_HOME to
   # choose another) with the Bouncy Castle jars PD4ML needs for encryption and signing, every
@@ -26,6 +27,9 @@ module Pd4ml
     BOUNCYCASTLE = %w[bcprov-jdk18on bcpkix-jdk18on bcutil-jdk18on].freeze
     MANIFEST = 'installed.json'
     VERSION_PATTERN = /\A(\d+)\.(\d+)\.(\d+)(?:fx(\d+)(?:a(\d+))?)?(-jakarta)?(-SNAPSHOT)?\z/
+    # The oldest PD4ML a plain install takes: the gem's PD4ML 4.2 API (read_eml/read_mht,
+    # add_allowed_resource_location, add_metadata, the DOM API) needs it.
+    MINIMUM_VERSION = '4.2.0'
 
     module_function
 
@@ -54,20 +58,55 @@ module Pd4ml
       sort_versions(candidates).last
     end
 
+    # The version a plain install takes: the most recent release of the minimum's major line (4.*)
+    # at least `minimum`; while there is none, the most recent snapshot of the minimum's line
+    # (4.2.x for 4.2.0); while there is none of those either (the -jakarta variant has no 4.2
+    # build yet), the most recent 4.* release, as before. So installs move to the release once it
+    # is out, and snapshots of later lines (or a 5.x) are never picked by accident. With
+    # `jakarta`, a -jakarta variant by that rule if there is one, else the plain build of the same
+    # rule: PD4ML 4.2 publishes no -jakarta variant, its builds contain the Jakarta tag library
+    # (com.pd4ml.taglib.jakarta); only without either, the most recent -jakarta release.
+    def default_version(versions, jakarta: false, minimum: MINIMUM_VERSION)
+      min = version_key(minimum)
+      (jakarta ? [true, false] : [false]).each do |variant|
+        candidates = versions.select do |v|
+          k = version_key(v)
+          k && k[0] == min[0] && v.include?('-jakarta') == variant
+        end
+        releases = candidates.select { |v| !v.end_with?('-SNAPSHOT') && (version_key(v) <=> min) >= 0 }
+        return sort_versions(releases).last unless releases.empty?
+
+        snapshots = candidates.select { |v| v.end_with?('-SNAPSHOT') && version_key(v)[0, 2] == min[0, 2] }
+        return sort_versions(snapshots).last unless snapshots.empty?
+      end
+      select_version(versions, major: min[0], jakarta: jakarta)
+    end
+
     # The versions the repository lists.
     def available_versions(repository = REPOSITORY)
-      fetch("#{repository}/#{GROUP_PATH}/maven-metadata.xml").scan(%r{<version>([^<]+)</version>}).flatten.map(&:strip)
+      parse_versions(fetch("#{repository}/#{GROUP_PATH}/maven-metadata.xml"))
     end
 
+    # The versions a maven-metadata.xml document lists.
+    def parse_versions(xml) = xml.scan(%r{<version>([^<]+)</version>}).flatten.map(&:strip)
+
     # ------------------------------------------------------------------------------ install
 
     # Downloads a PD4ML build (unless already there) and makes it the default one; returns the
-    # jar's path. version: 'latest' (the most recent 4.* release; with snapshots: true, the most
-    # recent 4.* build) or an exact one such as '4.0.23fx2'.
+    # jar's path. version: 'latest' (default_version: the most recent release from MINIMUM_VERSION
+    # on, else the most recent 4.2.x snapshot; with snapshots: true, the most recent 4.* build) or
+    # an exact one such as '4.1.2' or '4.0.23fx2'.
     def install(version = 'latest', snapshots: false, jakarta: false, repository: REPOSITORY, home: nil,
                 force: false, quiet: false, bouncycastle: true)
       home ||= default_home
-      version = select_version(available_versions(repository), snapshots: snapshots, jakarta: jakarta) if version == 'latest'
+      if version == 'latest'
+        versions = available_versions(repository)
+        version = if snapshots
+                    select_version(versions, snapshots: true, jakarta: jakarta)
+                  else
+                    default_version(versions, jakarta: jakarta)
+                  end
+      end
       name = jar_name(version, repository)
       jar = File.join(home, name)
       download("#{repository}/#{GROUP_PATH}/#{version}/#{name}", jar, force, quiet)

data/lib/pd4ml/java.rb

@@ -42,7 +42,9 @@ module Pd4ml
 
   # A Java object living in the bridge. Call its Java methods by their Java names or in Ruby
   # style (`size.rotate`, `pd.set_page_size(...)`, `pd.demo_mode?`). Public fields: `obj[:width]`
-  # / `obj[:width] = v`. Released in Java when garbage collected.
+  # / `obj[:width] = v`. Released in Java when garbage collected. The DOM API's objects
+  # (com.pd4ml.dom) return their Java lists and sets as Ruby Arrays, maps as Hashes
+  # (`doc.query_selector_all('p').each { ... }`); `call_java` returns them as they are.
   class JavaObject < BasicObject
     def initialize(bridge, handle, java_class, enum_name)
       @bridge = bridge
@@ -110,7 +112,9 @@ module Pd4ml
       ::Kernel.raise ::NoMethodError, "set Java fields with obj[:#{name.to_s.chomp('=')}] = value" if name.to_s.end_with?('=')
       ::Kernel.raise ::ArgumentError, 'Java methods take no block' if block
 
-      @bridge.call(self, Naming.resolve(@bridge, @java_class, name, false), args)
+      result = @bridge.call(self, Naming.resolve(@bridge, @java_class, name, false), args)
+      # the DOM API's lists, sets and maps are snapshots: Ruby Arrays and Hashes
+      @java_class.start_with?('com.pd4ml.dom.') ? Java.to_ruby(result) : result
     end
 
     def respond_to_missing?(_name, _include_private = false) = true
@@ -205,5 +209,21 @@ module Pd4ml
 
       Bridge.get.proxy(iface, &block)
     end
+
+    # A Java collection (List, Set...) as a Ruby Array and a Java Map as a Hash, in one or two
+    # bridge calls; any other value as it is.
+    def self.to_ruby(value)
+      return value unless value.is_a?(JavaObject) && value.java_class.start_with?('java.util.')
+
+      if value.instance_of_java?('java.util.Collection')
+        value.call_java('toArray')
+      elsif value.instance_of_java?('java.util.Map')
+        keys = value.call_java('keySet').call_java('toArray')
+        values = value.call_java('values').call_java('toArray')
+        keys.zip(values).to_h
+      else
+        value
+      end
+    end
   end
 end

data/lib/pd4ml/pd4ml.rb

@@ -5,7 +5,9 @@ module Pd4ml
   # engine by default. Every Java method is available by its Java name or in Ruby style
   # (`set_page_size`, `add_style`, `use_ttf`); these take Ruby I/O: read_html (a path, URL or
   # binary String/IO), read_html_string, write_pdf/write_docx/write_rtf (the document returned as
-  # a binary String, or written to a path or IO), render_as_images and monitor_progress_with (a block).
+  # a binary String, or written to a path or IO), render_as_images and monitor_progress_with (a block);
+  # read_eml/read_mht (e-mail messages, saved web pages) as read_html. get_document and layout (the
+  # DOM API, v42 engine) return com.pd4ml.dom objects, whose lists come back as Ruby Arrays.
   #
   #   pd = Pd4ml::PD4ML.new
   #   pd.set_page_size(Pd4ml::PageSize::A4)
@@ -117,6 +119,24 @@ module Pd4ml
     end
     alias readHtmlString read_html_string
 
+    # Reads an e-mail message (.eml) to convert: its body, HTML if it has one, with the images it
+    # embeds, after a block with From, Date, To, Cc, Subject and the attachments, which are
+    # embedded in the PDF. `source` as for read_html: a path or URL, or the message itself (a
+    # binary String or IO). Of resources outside the message only https:// ones are loaded;
+    # add_allowed_resource_location replaces that. read_html recognizes messages too; this is the
+    # way for mail from outside your control. PD4ML 4.2 and later.
+    def read_eml(source)
+      read_mime('readEML', source)
+    end
+    alias readEML read_eml
+
+    # Reads a web page saved as a single file (.mht, .mhtml), with the images, style sheets and
+    # fonts saved in it; `source` as for read_eml. PD4ML 4.2 and later.
+    def read_mht(source)
+      read_mime('readMHT', source)
+    end
+    alias readMHT read_mht
+
     # -------------------------------------------------------------------------------- output
 
     # Writes the PDF: to `target` (a path or an IO), or returned as a binary String. spec: a
@@ -175,6 +195,16 @@ module Pd4ml
 
     private
 
+    def read_mime(method, source)
+      arg = if location?(source)
+              Pd4ml.to_url(source)
+            else
+              source.is_a?(JavaObject) ? source : Pd4ml.binary(source)
+            end
+      Bridge.get.call(@java, method, [arg])
+      nil
+    end
+
     def location?(source)
       source.is_a?(Pathname) || source.is_a?(URI::Generic) ||
         (source.is_a?(String) && source.encoding != Encoding::BINARY && !source.lstrip.start_with?('<')) ||

data/lib/pd4ml/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-module Pd4ml
-  VERSION = '1.0.1'
-end
+# frozen_string_literal: true
+
+module Pd4ml
+  VERSION = '1.1.2'
+end

data/lib/pd4ml.rb

@@ -35,6 +35,19 @@ module Pd4ml
   ResourceProvider = Java.type('com.pd4ml.ResourceProvider')
   CustomTag = Java.type('com.pd4ml.CustomTag')
 
+  # The DOM API (com.pd4ml.dom, PD4ML 4.2, v42 engine; DMS and UA editions): PD4ML#get_document and
+  # PD4ML#layout return its objects. Their Java lists and sets come back as Ruby Arrays, maps as Hashes.
+  module Dom
+    Node = Java.type('com.pd4ml.dom.Node')
+    Document = Java.type('com.pd4ml.dom.Document')
+    Element = Java.type('com.pd4ml.dom.Element')
+    Text = Java.type('com.pd4ml.dom.Text')
+    Comment = Java.type('com.pd4ml.dom.Comment')
+    DocumentType = Java.type('com.pd4ml.dom.DocumentType')
+    Layout = Java.type('com.pd4ml.dom.Layout')
+    LayoutBox = Java.type('com.pd4ml.dom.LayoutBox')
+  end
+
   FORMATS = %w[PDF PDFA PDFUA].freeze
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pd4ml
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.2
 platform: ruby
 authors:
 - PD4ML