diff --git a/src/odr/definitions.hpp b/src/odr/definitions.hpp
index 74a1ccb3..3627eac3 100644
--- a/src/odr/definitions.hpp
+++ b/src/odr/definitions.hpp
@@ -2,37 +2,10 @@
 
 #include <cstdint>
 
-namespace odr::internal::abstract {
-class ElementAdapter;
-} // namespace odr::internal::abstract
-
 namespace odr {
 
 using ElementIdentifier = std::uint64_t;
 
 static constexpr ElementIdentifier null_element_id{0};
 
-struct ElementHandle final {
-  const internal::abstract::ElementAdapter *adapter_ptr{nullptr};
-  ElementIdentifier identifier{null_element_id};
-
-  ElementHandle() = default;
-  ElementHandle(const internal::abstract::ElementAdapter *adapter_ptr_,
-                const ElementIdentifier identifier_)
-      : adapter_ptr(adapter_ptr_), identifier(identifier_) {}
-  ElementHandle(const internal::abstract::ElementAdapter &adapter_,
-                const ElementIdentifier identifier_)
-      : adapter_ptr(&adapter_), identifier(identifier_) {}
-
-  [[nodiscard]] const internal::abstract::ElementAdapter &adapter() const {
-    return *adapter_ptr;
-  }
-
-  [[nodiscard]] bool is_null() const { return identifier == null_element_id; }
-
-  bool operator==(const ElementHandle &other) const {
-    return adapter_ptr == other.adapter_ptr && identifier == other.identifier;
-  }
-};
-
 } // namespace odr
diff --git a/src/odr/document.cpp b/src/odr/document.cpp
index 60f6e1e0..23b0b98a 100644
--- a/src/odr/document.cpp
+++ b/src/odr/document.cpp
@@ -39,7 +39,7 @@ DocumentType Document::document_type() const noexcept {
 }
 
 Element Document::root_element() const {
-  return Element(m_impl->root_element());
+  return {m_impl->element_adapter(), m_impl->root_element()};
 }
 
 Filesystem Document::as_filesystem() const {
diff --git a/src/odr/document_element.cpp b/src/odr/document_element.cpp
index 1a9b94a0..36e7093c 100644
--- a/src/odr/document_element.cpp
+++ b/src/odr/document_element.cpp
@@ -12,9 +12,6 @@ namespace odr {
 
 Element::Element() = default;
 
-Element::Element(const ElementHandle &handle)
-    : m_adapter{handle.adapter_ptr}, m_identifier{handle.identifier} {}
-
 Element::Element(const internal::abstract::ElementAdapter *adapter,
                  const ElementIdentifier identifier)
     : m_adapter{adapter}, m_identifier{identifier} {}
@@ -30,23 +27,26 @@ ElementType Element::type() const {
 }
 
 Element Element::parent() const {
-  return exists_() ? Element(m_adapter->element_parent(m_identifier))
+  return exists_() ? Element(m_adapter, m_adapter->element_parent(m_identifier))
                    : Element();
 }
 
 Element Element::first_child() const {
-  return exists_() ? Element(m_adapter->element_first_child(m_identifier))
-                   : Element();
+  return exists_()
+             ? Element(m_adapter, m_adapter->element_first_child(m_identifier))
+             : Element();
 }
 
 Element Element::previous_sibling() const {
-  return exists_() ? Element(m_adapter->element_previous_sibling(m_identifier))
+  return exists_() ? Element(m_adapter,
+                             m_adapter->element_previous_sibling(m_identifier))
                    : Element();
 }
 
 Element Element::next_sibling() const {
-  return exists_() ? Element(m_adapter->element_next_sibling(m_identifier))
-                   : Element();
+  return exists_()
+             ? Element(m_adapter, m_adapter->element_next_sibling(m_identifier))
+             : Element();
 }
 
 bool Element::is_unique() const {
@@ -68,7 +68,8 @@ DocumentPath Element::document_path() const {
 
 Element Element::navigate_path(const DocumentPath &path) const {
   return exists_()
-             ? Element(m_adapter->element_navigate_path(m_identifier, path))
+             ? Element(m_adapter,
+                       m_adapter->element_navigate_path(m_identifier, path))
              : Element();
 }
 
@@ -168,17 +169,14 @@ Image Element::as_image() const {
 }
 
 ElementRange Element::children() const {
-  return {exists_()
-              ? ElementIterator(m_adapter->element_first_child(m_identifier))
-              : ElementIterator(),
+  return {exists_() ? ElementIterator(m_adapter, m_adapter->element_first_child(
+                                                     m_identifier))
+                    : ElementIterator(),
           ElementIterator()};
 }
 
 ElementIterator::ElementIterator() = default;
 
-ElementIterator::ElementIterator(const ElementHandle &handle)
-    : m_adapter{handle.adapter_ptr}, m_identifier{handle.identifier} {}
-
 ElementIterator::ElementIterator(
     const internal::abstract::ElementAdapter *adapter,
     const ElementIdentifier identifier)
@@ -188,10 +186,7 @@ Element ElementIterator::operator*() const { return {m_adapter, m_identifier}; }
 
 ElementIterator &ElementIterator::operator++() {
   if (exists_()) {
-    const auto [next_adapter, next_id] =
-        m_adapter->element_next_sibling(m_identifier);
-    m_adapter = next_adapter;
-    m_identifier = next_id;
+    m_identifier = m_adapter->element_next_sibling(m_identifier);
   }
   return *this;
 }
@@ -200,7 +195,7 @@ ElementIterator ElementIterator::operator++(int) const {
   if (!exists_()) {
     return {};
   }
-  return ElementIterator(m_adapter->element_next_sibling(m_identifier));
+  return {m_adapter, m_adapter->element_next_sibling(m_identifier)};
 }
 
 bool ElementIterator::exists_() const {
@@ -228,9 +223,9 @@ MasterPage TextRoot::first_master_page() const {
   if (!exists_()) {
     return {};
   }
-  const auto [master_page_adapter, master_page_id] =
+  const ElementIdentifier master_page_id =
       m_adapter2->text_root_first_master_page(m_identifier);
-  return {master_page_adapter, master_page_id,
+  return {m_adapter, master_page_id,
           m_adapter->master_page_adapter(master_page_id)};
 }
 
@@ -272,18 +267,21 @@ SheetCell Sheet::cell(const std::uint32_t column,
   if (!exists_()) {
     return {};
   }
-  const auto [cell_adapter, cell_id] =
+  const ElementIdentifier cell_id =
       m_adapter2->sheet_cell(m_identifier, column, row);
-  return {cell_adapter, cell_id, m_adapter->sheet_cell_adapter(cell_id)};
+  if (cell_id == null_element_id) {
+    return {};
+  }
+  return {m_adapter, cell_id, m_adapter->sheet_cell_adapter(cell_id)};
 }
 
 ElementRange Sheet::shapes() const {
   if (!exists_()) {
     return {};
   }
-  const auto [first_shape_adapter, first_shape_id] =
+  const ElementIdentifier first_shape_id =
       m_adapter2->sheet_first_shape(m_identifier);
-  return ElementRange(ElementIterator(first_shape_adapter, first_shape_id));
+  return ElementRange(ElementIterator(m_adapter, first_shape_id));
 }
 
 TableStyle Sheet::style() const {
@@ -397,29 +395,29 @@ TableRow Table::first_row() const {
   if (!exists_()) {
     return {};
   }
-  const auto [row_adapter, row_id] = m_adapter2->table_first_row(m_identifier);
-  return {row_adapter, row_id, m_adapter->table_row_adapter(row_id)};
+  const ElementIdentifier row_id = m_adapter2->table_first_row(m_identifier);
+  return {m_adapter, row_id, m_adapter->table_row_adapter(row_id)};
 }
 
 TableColumn Table::first_column() const {
   if (!exists_()) {
     return {};
   }
-  const auto [column_adapter, column_id] =
+  const ElementIdentifier column_id =
       m_adapter2->table_first_column(m_identifier);
-  return {column_adapter, column_id,
-          m_adapter->table_column_adapter(column_id)};
+  return {m_adapter, column_id, m_adapter->table_column_adapter(column_id)};
 }
 
 ElementRange Table::columns() const {
-  return exists_() ? ElementRange(ElementIterator(
-                         m_adapter2->table_first_column(m_identifier)))
-                   : ElementRange();
+  return exists_()
+             ? ElementRange(ElementIterator(
+                   m_adapter, m_adapter2->table_first_column(m_identifier)))
+             : ElementRange();
 }
 
 ElementRange Table::rows() const {
   return exists_() ? ElementRange(ElementIterator(
-                         m_adapter2->table_first_row(m_identifier)))
+                         m_adapter, m_adapter2->table_first_row(m_identifier)))
                    : ElementRange();
 }
 
diff --git a/src/odr/document_element.hpp b/src/odr/document_element.hpp
index b0e0b9fd..d7010cb2 100644
--- a/src/odr/document_element.hpp
+++ b/src/odr/document_element.hpp
@@ -142,7 +142,6 @@ enum class ValueType {
 class Element {
 public:
   Element();
-  explicit Element(const ElementHandle &handle);
   Element(const internal::abstract::ElementAdapter *adapter,
           ElementIdentifier identifier);
 
@@ -208,7 +207,6 @@ class ElementIterator {
   using iterator_category = std::forward_iterator_tag;
 
   ElementIterator();
-  explicit ElementIterator(const ElementHandle &handle);
   ElementIterator(const internal::abstract::ElementAdapter *adapter,
                   ElementIdentifier identifier);
 
@@ -248,8 +246,6 @@ class ElementRange {
 template <typename T> class ElementBase : public Element {
 public:
   ElementBase() = default;
-  ElementBase(const ElementHandle &handle, const T *adapter2)
-      : Element(handle), m_adapter2{adapter2} {}
   ElementBase(const internal::abstract::ElementAdapter *adapter,
               ElementIdentifier identifier, const T *adapter2)
       : Element(adapter, identifier), m_adapter2{adapter2} {}
diff --git a/src/odr/file.cpp b/src/odr/file.cpp
index 711f5c44..f9b384ec 100644
--- a/src/odr/file.cpp
+++ b/src/odr/file.cpp
@@ -74,8 +74,7 @@ std::vector<FileType> DecodedFile::list_file_types(const std::string &path,
 }
 
 std::string_view DecodedFile::mimetype(const std::string &path,
-                                       Logger &logger) {
-  (void)logger;
+                                       [[maybe_unused]] Logger &logger) {
   return internal::magic::mimetype(path);
 }
 
diff --git a/src/odr/internal/abstract/document.hpp b/src/odr/internal/abstract/document.hpp
index 7265f9b3..8aa03e6f 100644
--- a/src/odr/internal/abstract/document.hpp
+++ b/src/odr/internal/abstract/document.hpp
@@ -88,7 +88,10 @@ class Document {
   as_filesystem() const noexcept = 0;
 
   /// \return cursor to the root element of the document.
-  [[nodiscard]] virtual ElementHandle root_element() const = 0;
+  [[nodiscard]] virtual ElementIdentifier root_element() const = 0;
+
+  /// \return the element adapter for this document.
+  [[nodiscard]] virtual const ElementAdapter *element_adapter() const = 0;
 };
 
 class ElementAdapter {
@@ -98,15 +101,15 @@ class ElementAdapter {
   [[nodiscard]] virtual ElementType
   element_type(ElementIdentifier element_id) const = 0;
 
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   element_parent(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   element_first_child(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   element_last_child(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   element_previous_sibling(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   element_next_sibling(ElementIdentifier element_id) const = 0;
 
   [[nodiscard]] virtual bool
@@ -117,56 +120,102 @@ class ElementAdapter {
   element_is_editable(ElementIdentifier element_id) const = 0;
   [[nodiscard]] virtual DocumentPath
   element_document_path(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   element_navigate_path(ElementIdentifier element_id,
                         const DocumentPath &path) const = 0;
 
   [[nodiscard]] virtual const TextRootAdapter *
-  text_root_adapter(ElementIdentifier element_id) const = 0;
+  text_root_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const SlideAdapter *
-  slide_adapter(ElementIdentifier element_id) const = 0;
+  slide_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const PageAdapter *
-  page_adapter(ElementIdentifier element_id) const = 0;
+  page_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const SheetAdapter *
-  sheet_adapter(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual const SheetCellAdapter *
-  sheet_cell_adapter(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual const MasterPageAdapter *
-  master_page_adapter(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual const LineBreakAdapter *
-  line_break_adapter(ElementIdentifier element_id) const = 0;
+  sheet_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
+  [[nodiscard]] virtual const SheetCellAdapter *sheet_cell_adapter(
+      [[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
+  [[nodiscard]] virtual const MasterPageAdapter *master_page_adapter(
+      [[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
+  [[nodiscard]] virtual const LineBreakAdapter *line_break_adapter(
+      [[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const ParagraphAdapter *
-  paragraph_adapter(ElementIdentifier element_id) const = 0;
+  paragraph_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const SpanAdapter *
-  span_adapter(ElementIdentifier element_id) const = 0;
+  span_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const TextAdapter *
-  text_adapter(ElementIdentifier element_id) const = 0;
+  text_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const LinkAdapter *
-  link_adapter(ElementIdentifier element_id) const = 0;
+  link_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const BookmarkAdapter *
-  bookmark_adapter(ElementIdentifier element_id) const = 0;
+  bookmark_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const ListItemAdapter *
-  list_item_adapter(ElementIdentifier element_id) const = 0;
+  list_item_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const TableAdapter *
-  table_adapter(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual const TableColumnAdapter *
-  table_column_adapter(ElementIdentifier element_id) const = 0;
+  table_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
+  [[nodiscard]] virtual const TableColumnAdapter *table_column_adapter(
+      [[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const TableRowAdapter *
-  table_row_adapter(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual const TableCellAdapter *
-  table_cell_adapter(ElementIdentifier element_id) const = 0;
+  table_row_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
+  [[nodiscard]] virtual const TableCellAdapter *table_cell_adapter(
+      [[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const FrameAdapter *
-  frame_adapter(ElementIdentifier element_id) const = 0;
+  frame_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const RectAdapter *
-  rect_adapter(ElementIdentifier element_id) const = 0;
+  rect_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const LineAdapter *
-  line_adapter(ElementIdentifier element_id) const = 0;
+  line_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const CircleAdapter *
-  circle_adapter(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual const CustomShapeAdapter *
-  custom_shape_adapter(ElementIdentifier element_id) const = 0;
+  circle_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
+  [[nodiscard]] virtual const CustomShapeAdapter *custom_shape_adapter(
+      [[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
   [[nodiscard]] virtual const ImageAdapter *
-  image_adapter(ElementIdentifier element_id) const = 0;
+  image_adapter([[maybe_unused]] const ElementIdentifier element_id) const {
+    return nullptr;
+  }
 };
 
 class TextRootAdapter {
@@ -176,7 +225,7 @@ class TextRootAdapter {
   [[nodiscard]] virtual PageLayout
   text_root_page_layout(ElementIdentifier element_id) const = 0;
 
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   text_root_first_master_page(ElementIdentifier element_id) const = 0;
 };
 
@@ -221,10 +270,10 @@ class SheetAdapter {
   sheet_content(ElementIdentifier element_id,
                 std::optional<TableDimensions> range) const = 0;
 
-  [[nodiscard]] virtual ElementHandle sheet_cell(ElementIdentifier element_id,
-                                                 std::uint32_t column,
-                                                 std::uint32_t row) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
+  sheet_cell(ElementIdentifier element_id, std::uint32_t column,
+             std::uint32_t row) const = 0;
+  [[nodiscard]] virtual ElementIdentifier
   sheet_first_shape(ElementIdentifier element_id) const = 0;
 
   [[nodiscard]] virtual TableStyle
@@ -332,9 +381,9 @@ class TableAdapter {
   [[nodiscard]] virtual TableDimensions
   table_dimensions(ElementIdentifier element_id) const = 0;
 
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   table_first_column(ElementIdentifier element_id) const = 0;
-  [[nodiscard]] virtual ElementHandle
+  [[nodiscard]] virtual ElementIdentifier
   table_first_row(ElementIdentifier element_id) const = 0;
 
   [[nodiscard]] virtual TableStyle
diff --git a/src/odr/internal/abstract/file.hpp b/src/odr/internal/abstract/file.hpp
index 1720cd7e..82b9cb16 100644
--- a/src/odr/internal/abstract/file.hpp
+++ b/src/odr/internal/abstract/file.hpp
@@ -47,8 +47,7 @@ class DecodedFile {
     return EncryptionState::not_encrypted;
   }
   [[nodiscard]] virtual std::shared_ptr<DecodedFile>
-  decrypt(const std::string &password) const {
-    (void)password;
+  decrypt([[maybe_unused]] const std::string &password) const {
     return nullptr;
   }
 
diff --git a/src/odr/internal/cfb/cfb_archive.cpp b/src/odr/internal/cfb/cfb_archive.cpp
index 251294b1..42848a86 100644
--- a/src/odr/internal/cfb/cfb_archive.cpp
+++ b/src/odr/internal/cfb/cfb_archive.cpp
@@ -31,8 +31,7 @@ std::shared_ptr<abstract::Filesystem> CfbArchive::as_filesystem() const {
   return filesystem;
 }
 
-void CfbArchive::save(std::ostream &out) const {
-  (void)out;
+void CfbArchive::save([[maybe_unused]] std::ostream &out) const {
   throw UnsupportedOperation();
 }
 
diff --git a/src/odr/internal/common/document.cpp b/src/odr/internal/common/document.cpp
index 8641d024..5c34af2b 100644
--- a/src/odr/internal/common/document.cpp
+++ b/src/odr/internal/common/document.cpp
@@ -22,8 +22,10 @@ Document::as_filesystem() const noexcept {
   return m_files;
 }
 
-ElementHandle Document::root_element() const {
-  return {*m_element_adapter, m_root_element};
+ElementIdentifier Document::root_element() const { return m_root_element; }
+
+const abstract::ElementAdapter *Document::element_adapter() const {
+  return m_element_adapter.get();
 }
 
 } // namespace odr::internal
diff --git a/src/odr/internal/common/document.hpp b/src/odr/internal/common/document.hpp
index 89f649ba..78b9465c 100644
--- a/src/odr/internal/common/document.hpp
+++ b/src/odr/internal/common/document.hpp
@@ -2,6 +2,7 @@
 
 #include <odr/definitions.hpp>
 #include <odr/file.hpp>
+
 #include <odr/internal/abstract/document.hpp>
 
 #include <memory>
@@ -24,7 +25,10 @@ class Document : public abstract::Document {
   [[nodiscard]] std::shared_ptr<abstract::ReadableFilesystem>
   as_filesystem() const noexcept final;
 
-  [[nodiscard]] ElementHandle root_element() const override;
+  [[nodiscard]] ElementIdentifier root_element() const override;
+
+  [[nodiscard]] const abstract::ElementAdapter *
+  element_adapter() const override;
 
 protected:
   FileType m_file_type{FileType::unknown};
diff --git a/src/odr/internal/html/pdf2htmlex_wrapper.cpp b/src/odr/internal/html/pdf2htmlex_wrapper.cpp
index 6309cdeb..fc938bf3 100644
--- a/src/odr/internal/html/pdf2htmlex_wrapper.cpp
+++ b/src/odr/internal/html/pdf2htmlex_wrapper.cpp
@@ -23,8 +23,6 @@ namespace {
 
 pdf2htmlEX::Param create_params(PDFDoc &pdf_doc, const HtmlConfig &config,
                                 const std::string &cache_path) {
-  (void)config;
-
   pdf2htmlEX::Param param;
 
   // pages
@@ -299,9 +297,10 @@ class HtmlServiceImpl final : public HtmlService {
 
 namespace odr::internal {
 
-odr::HtmlService html::create_poppler_pdf_service(
-    const PopplerPdfFile &pdf_file, const std::string &cache_path,
-    HtmlConfig config, std::shared_ptr<Logger> logger) {
+HtmlService html::create_poppler_pdf_service(const PopplerPdfFile &pdf_file,
+                                             const std::string &cache_path,
+                                             HtmlConfig config,
+                                             std::shared_ptr<Logger> logger) {
   PDFDoc &pdf_doc = pdf_file.pdf_doc();
 
   auto html_renderer_param = std::make_shared<pdf2htmlEX::Param>(
diff --git a/src/odr/internal/html/pdf2htmlex_wrapper.hpp b/src/odr/internal/html/pdf2htmlex_wrapper.hpp
index 400611f3..038df272 100644
--- a/src/odr/internal/html/pdf2htmlex_wrapper.hpp
+++ b/src/odr/internal/html/pdf2htmlex_wrapper.hpp
@@ -16,9 +16,9 @@ class PopplerPdfFile;
 
 namespace odr::internal::html {
 
-odr::HtmlService create_poppler_pdf_service(const PopplerPdfFile &pdf_file,
-                                            const std::string &cache_path,
-                                            HtmlConfig config,
-                                            std::shared_ptr<Logger> logger);
+HtmlService create_poppler_pdf_service(const PopplerPdfFile &pdf_file,
+                                       const std::string &cache_path,
+                                       HtmlConfig config,
+                                       std::shared_ptr<Logger> logger);
 
 } // namespace odr::internal::html
diff --git a/src/odr/internal/html/text_file.cpp b/src/odr/internal/html/text_file.cpp
index c9c917ea..d1a4f460 100644
--- a/src/odr/internal/html/text_file.cpp
+++ b/src/odr/internal/html/text_file.cpp
@@ -130,12 +130,10 @@ class HtmlServiceImpl final : public HtmlService {
 
 namespace odr::internal {
 
-odr::HtmlService html::create_text_service(const TextFile &text_file,
-                                           const std::string &cache_path,
-                                           HtmlConfig config,
-                                           std::shared_ptr<Logger> logger) {
-  (void)cache_path;
-
+odr::HtmlService
+html::create_text_service(const TextFile &text_file,
+                          [[maybe_unused]] const std::string &cache_path,
+                          HtmlConfig config, std::shared_ptr<Logger> logger) {
   return odr::HtmlService(std::make_unique<HtmlServiceImpl>(
       text_file, std::move(config), std::move(logger)));
 }
diff --git a/src/odr/internal/json/json_util.cpp b/src/odr/internal/json/json_util.cpp
index 1ad2a9be..5d30ff7b 100644
--- a/src/odr/internal/json/json_util.cpp
+++ b/src/odr/internal/json/json_util.cpp
@@ -6,8 +6,7 @@ namespace odr::internal {
 
 void json::check_json_file(std::istream &in) {
   // TODO limit check size
-  const auto json = nlohmann::json::parse(in);
-  (void)json;
+  std::ignore = nlohmann::json::parse(in);
   // TODO check if that even works
 }
 
diff --git a/src/odr/internal/odf/odf_document.cpp b/src/odr/internal/odf/odf_document.cpp
index 3214a2a4..f3606d57 100644
--- a/src/odr/internal/odf/odf_document.cpp
+++ b/src/odr/internal/odf/odf_document.cpp
@@ -157,93 +157,58 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ElementType
   element_type(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->type;
-    }
-    return ElementType::none;
+    return m_registry->element_at(element_id).type;
   }
 
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_parent(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->parent_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).parent_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_first_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->first_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).first_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_last_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->last_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).last_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_previous_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->previous_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).previous_sibling_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_next_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->next_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).next_sibling_id;
   }
 
-  [[nodiscard]] bool
-  element_is_unique(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_unique(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_self_locatable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_self_locatable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
   [[nodiscard]] bool
   element_is_editable(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      if (element->parent_id != null_element_id) {
-        return element_is_editable(element->parent_id);
-      }
-      if (element->type == ElementType::sheet_cell) {
-        const ElementRegistry::SheetCell *sheet_cell =
-            m_registry->sheet_cell_element(element_id);
-        return sheet_cell != nullptr && !sheet_cell->is_repeated;
-      }
-      return true;
+    const ElementRegistry::Element &element =
+        m_registry->element_at(element_id);
+    if (element.parent_id != null_element_id) {
+      return element_is_editable(element.parent_id);
     }
-    return false;
+    if (element.type == ElementType::sheet_cell) {
+      const ElementRegistry::SheetCell &sheet_cell =
+          m_registry->sheet_cell_element_at(element_id);
+      return !sheet_cell.is_repeated;
+    }
+    return true;
   }
   [[nodiscard]]
   DocumentPath
   element_document_path(const ElementIdentifier element_id) const override {
     return util::document::extract_path(*this, element_id, null_element_id);
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_navigate_path(const ElementIdentifier element_id,
                         const DocumentPath &path) const override {
     return util::document::navigate_path(*this, element_id, path);
@@ -251,230 +216,112 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] const TextRootAdapter *
   text_root_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::root) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::root ? this : nullptr;
   }
   [[nodiscard]] const SlideAdapter *
   slide_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::slide) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::slide ? this : nullptr;
   }
   [[nodiscard]] const PageAdapter *
   page_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::page) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::page ? this : nullptr;
   }
   [[nodiscard]] const SheetAdapter *
   sheet_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::sheet) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::sheet ? this : nullptr;
   }
   [[nodiscard]] const SheetCellAdapter *
   sheet_cell_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::sheet_cell) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::sheet_cell ? this : nullptr;
   }
   [[nodiscard]] const MasterPageAdapter *
   master_page_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::page) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::master_page ? this
+                                                                : nullptr;
   }
   [[nodiscard]] const LineBreakAdapter *
   line_break_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::line_break) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::line_break ? this : nullptr;
   }
   [[nodiscard]] const ParagraphAdapter *
   paragraph_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::paragraph) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::paragraph ? this : nullptr;
   }
   [[nodiscard]] const SpanAdapter *
   span_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::span) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::span ? this : nullptr;
   }
   [[nodiscard]] const TextAdapter *
   text_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::text) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::text ? this : nullptr;
   }
   [[nodiscard]] const LinkAdapter *
   link_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::link) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::link ? this : nullptr;
   }
   [[nodiscard]] const BookmarkAdapter *
   bookmark_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::bookmark) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::bookmark ? this : nullptr;
   }
   [[nodiscard]] const ListItemAdapter *
   list_item_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::list_item) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::list_item ? this : nullptr;
   }
   [[nodiscard]] const TableAdapter *
   table_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table ? this : nullptr;
   }
   [[nodiscard]] const TableColumnAdapter *
   table_column_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_column) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_column ? this
+                                                                 : nullptr;
   }
   [[nodiscard]] const TableRowAdapter *
   table_row_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_row) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_row ? this : nullptr;
   }
   [[nodiscard]] const TableCellAdapter *
   table_cell_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_cell) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_cell ? this : nullptr;
   }
   [[nodiscard]] const FrameAdapter *
   frame_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::frame) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::frame ? this : nullptr;
   }
   [[nodiscard]] const RectAdapter *
   rect_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::rect) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::rect ? this : nullptr;
   }
   [[nodiscard]] const LineAdapter *
   line_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::line) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::line ? this : nullptr;
   }
   [[nodiscard]] const CircleAdapter *
   circle_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::circle) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::circle ? this : nullptr;
   }
   [[nodiscard]] const CustomShapeAdapter *
   custom_shape_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::custom_shape) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::custom_shape ? this
+                                                                 : nullptr;
   }
   [[nodiscard]] const ImageAdapter *
   image_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::image) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::image ? this : nullptr;
   }
 
   [[nodiscard]] PageLayout
   text_root_page_layout(const ElementIdentifier element_id) const override {
-    if (const auto [_, master_page_id] =
+    if (const ElementIdentifier master_page_id =
             text_root_first_master_page(element_id);
         master_page_id != null_element_id) {
       return master_page_page_layout(master_page_id);
     }
     return {};
   }
-  [[nodiscard]] ElementHandle text_root_first_master_page(
-      const ElementIdentifier element_id) const override {
-    (void)element_id;
-    if (const ElementIdentifier first_master_page_id =
-            m_document->style_registry().first_master_page();
-        first_master_page_id != null_element_id) {
-      return {this, first_master_page_id};
-    }
-    return {};
+  [[nodiscard]] ElementIdentifier text_root_first_master_page(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
+    return m_document->style_registry().first_master_page();
   }
 
   [[nodiscard]] PageLayout
@@ -523,23 +370,16 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   [[nodiscard]] std::string
   page_name(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("draw:name").value();
+    return get_node(element_id).attribute("draw:name").value();
   }
 
   [[nodiscard]] std::string
   sheet_name(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("table:name").value();
+    return get_node(element_id).attribute("table:name").value();
   }
   [[nodiscard]] TableDimensions
   sheet_dimensions(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Sheet *sheet_registry =
-            m_registry->sheet_element(element_id);
-        sheet_registry != nullptr) {
-      return sheet_registry->dimensions;
-    }
-    return {};
+    return m_registry->sheet_element_at(element_id).dimensions;
   }
   [[nodiscard]] TableDimensions
   sheet_content(const ElementIdentifier element_id,
@@ -576,28 +416,21 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
     return result;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   sheet_cell(const ElementIdentifier element_id, const std::uint32_t column,
              const std::uint32_t row) const override {
-    if (const ElementRegistry::Sheet *sheet_registry =
-            m_registry->sheet_element(element_id);
-        sheet_registry != nullptr) {
-      if (const ElementRegistry::Sheet::Cell *sheet_cell =
-              sheet_registry->cell(column, row);
-          sheet_cell != nullptr) {
-        return {this, sheet_cell->element_id};
-      }
+    const ElementRegistry::Sheet &sheet_registry =
+        m_registry->sheet_element_at(element_id);
+    if (const ElementRegistry::Sheet::Cell *sheet_cell =
+            sheet_registry.cell(column, row);
+        sheet_cell != nullptr) {
+      return sheet_cell->element_id;
     }
     return {};
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   sheet_first_shape(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Sheet *sheet_registry =
-            m_registry->sheet_element(element_id);
-        sheet_registry != nullptr) {
-      return {this, sheet_registry->first_shape_id};
-    }
-    return {};
+    return m_registry->sheet_element_at(element_id).first_shape_id;
   }
   [[nodiscard]] TableStyle
   sheet_style(const ElementIdentifier element_id) const override {
@@ -606,20 +439,15 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] TableColumnStyle
   sheet_column_style(const ElementIdentifier element_id,
                      const std::uint32_t column) const override {
-    if (const ElementRegistry::Sheet *sheet_registry =
-            m_registry->sheet_element(element_id);
-        sheet_registry != nullptr) {
-      if (const pugi::xml_node column_node =
-              sheet_registry->column_node(column);
-          column_node) {
-        if (const pugi::xml_attribute attr =
-                column_node.attribute("table:style-name")) {
-          if (const Style *style =
-                  m_document->style_registry().style(attr.value());
-              style != nullptr) {
-            return style->resolved().table_column_style;
-          }
-        }
+    const ElementRegistry::Sheet &sheet_registry =
+        m_registry->sheet_element_at(element_id);
+    const pugi::xml_node column_node = sheet_registry.column_node(column);
+    if (const pugi::xml_attribute attr =
+            column_node.attribute("table:style-name");
+        attr) {
+      if (const Style *style = m_document->style_registry().style(attr.value());
+          style != nullptr) {
+        return style->resolved().table_column_style;
       }
     }
     return {};
@@ -627,19 +455,14 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] TableRowStyle
   sheet_row_style(const ElementIdentifier element_id,
                   const std::uint32_t row) const override {
-    if (const ElementRegistry::Sheet *sheet_registry =
-            m_registry->sheet_element(element_id);
-        sheet_registry != nullptr) {
-      if (const pugi::xml_node column_node = sheet_registry->row_node(row);
-          column_node) {
-        if (const pugi::xml_attribute attr =
-                column_node.attribute("table:style-name")) {
-          if (const Style *style =
-                  m_document->style_registry().style(attr.value());
-              style != nullptr) {
-            return style->resolved().table_row_style;
-          }
-        }
+    const ElementRegistry::Sheet &sheet_registry =
+        m_registry->sheet_element_at(element_id);
+    const pugi::xml_node column_node = sheet_registry.row_node(row);
+    if (const pugi::xml_attribute attr =
+            column_node.attribute("table:style-name")) {
+      if (const Style *style = m_document->style_registry().style(attr.value());
+          style != nullptr) {
+        return style->resolved().table_row_style;
       }
     }
     return {};
@@ -648,24 +471,19 @@ class ElementAdapter final : public abstract::ElementAdapter,
   sheet_cell_style(const ElementIdentifier element_id,
                    const std::uint32_t column,
                    const std::uint32_t row) const override {
-    const auto [_, cell_id] = sheet_cell(element_id, column, row);
+    const ElementIdentifier cell_id = sheet_cell(element_id, column, row);
     return get_partial_cell_style(element_id, cell_id, {column, row})
         .table_cell_style;
   }
 
   [[nodiscard]] TablePosition
   sheet_cell_position(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::SheetCell *sheet_cell =
-            m_registry->sheet_cell_element(element_id);
-        sheet_cell != nullptr) {
-      return sheet_cell->position;
-    }
-    return {};
+    return m_registry->sheet_cell_element_at(element_id).position;
   }
   [[nodiscard]] bool
   sheet_cell_is_covered(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return std::strcmp(node.name(), "table:covered-table-cell") == 0;
+    return std::strcmp(get_node(element_id).name(),
+                       "table:covered-table-cell") == 0;
   }
   [[nodiscard]] TableDimensions
   sheet_cell_span(const ElementIdentifier element_id) const override {
@@ -687,7 +505,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   master_page_page_layout(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
     if (const pugi::xml_attribute attribute =
-            node.attribute("style:page-layout-name")) {
+            node.attribute("style:page-layout-name");
+        attribute) {
       return m_document->style_registry().page_layout(attribute.value());
     }
     return {};
@@ -714,14 +533,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   text_content(const ElementIdentifier element_id) const override {
-    const ElementRegistry::Text *text_element =
-        m_registry->text_element(element_id);
-    if (text_element == nullptr) {
-      return "";
-    }
+    const ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     std::string result;
     for (pugi::xml_node node = first; node != last.next_sibling();
@@ -732,14 +548,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   void text_set_content(const ElementIdentifier element_id,
                         const std::string &text) const override {
-    ElementRegistry::Element *element = m_registry->element(element_id);
-    ElementRegistry::Text *text_element = m_registry->text_element(element_id);
-    if (element == nullptr || text_element == nullptr) {
-      return;
-    }
+    ElementRegistry::Element &element = m_registry->element_at(element_id);
+    ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     pugi::xml_node parent = first.parent();
     const pugi::xml_node old_first = first;
@@ -786,8 +600,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
       }
     }
 
-    element->node = new_first;
-    text_element->last = new_last;
+    element.node = new_first;
+    text_element.last = new_last;
 
     for (pugi::xml_node node = old_first; node != old_last.next_sibling();) {
       const pugi::xml_node next = node.next_sibling();
@@ -802,14 +616,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   link_href(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("xlink:href").value();
+    return get_node(element_id).attribute("xlink:href").value();
   }
 
   [[nodiscard]] std::string
   bookmark_name(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("text:name").value();
+    return get_node(element_id).attribute("text:name").value();
   }
 
   [[nodiscard]] TextStyle
@@ -843,16 +655,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
     return result;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   table_first_column(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Table *table_registry =
-            m_registry->table_element(element_id);
-        table_registry != nullptr) {
-      return {this, table_registry->first_column_id};
-    }
-    return {};
+    return m_registry->table_element_at(element_id).first_column_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   table_first_row(const ElementIdentifier element_id) const override {
     return element_first_child(element_id);
   }
@@ -873,8 +680,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] bool
   table_cell_is_covered(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return std::strcmp(node.name(), "table:covered-table-cell") == 0;
+    return std::strcmp(get_node(element_id).name(),
+                       "table:covered-table-cell") == 0;
   }
   [[nodiscard]] TableDimensions
   table_cell_span(const ElementIdentifier element_id) const override {
@@ -918,7 +725,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   frame_x(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("svg:x")) {
+    if (const pugi::xml_attribute attribute = node.attribute("svg:x");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -926,7 +734,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   frame_y(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("svg:y")) {
+    if (const pugi::xml_attribute attribute = node.attribute("svg:y");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -934,7 +743,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   frame_width(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("svg:width")) {
+    if (const pugi::xml_attribute attribute = node.attribute("svg:width");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -942,7 +752,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   frame_height(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("svg:height")) {
+    if (const pugi::xml_attribute attribute = node.attribute("svg:height");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -950,7 +761,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   frame_z_index(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("draw:z-index")) {
+    if (const pugi::xml_attribute attribute = node.attribute("draw:z-index");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -962,23 +774,19 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   rect_x(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:x").value();
+    return get_node(element_id).attribute("svg:x").value();
   }
   [[nodiscard]] std::string
   rect_y(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:y").value();
+    return get_node(element_id).attribute("svg:y").value();
   }
   [[nodiscard]] std::string
   rect_width(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:width").value();
+    return get_node(element_id).attribute("svg:width").value();
   }
   [[nodiscard]] std::string
   rect_height(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:height").value();
+    return get_node(element_id).attribute("svg:height").value();
   }
   [[nodiscard]] GraphicStyle
   rect_style(const ElementIdentifier element_id) const override {
@@ -987,23 +795,19 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   line_x1(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:x1").value();
+    return get_node(element_id).attribute("svg:x1").value();
   }
   [[nodiscard]] std::string
   line_y1(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:y1").value();
+    return get_node(element_id).attribute("svg:y1").value();
   }
   [[nodiscard]] std::string
   line_x2(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:x2").value();
+    return get_node(element_id).attribute("svg:x2").value();
   }
   [[nodiscard]] std::string
   line_y2(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:y2").value();
+    return get_node(element_id).attribute("svg:y2").value();
   }
   [[nodiscard]] GraphicStyle
   line_style(const ElementIdentifier element_id) const override {
@@ -1012,23 +816,19 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   circle_x(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:x").value();
+    return get_node(element_id).attribute("svg:x").value();
   }
   [[nodiscard]] std::string
   circle_y(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:y").value();
+    return get_node(element_id).attribute("svg:y").value();
   }
   [[nodiscard]] std::string
   circle_width(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:width").value();
+    return get_node(element_id).attribute("svg:width").value();
   }
   [[nodiscard]] std::string
   circle_height(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("svg:height").value();
+    return get_node(element_id).attribute("svg:height").value();
   }
   [[nodiscard]] GraphicStyle
   circle_style(const ElementIdentifier element_id) const override {
@@ -1038,7 +838,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   custom_shape_x(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("svg:x")) {
+    if (const pugi::xml_attribute attribute = node.attribute("svg:x");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -1046,7 +847,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::optional<std::string>
   custom_shape_y(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute attribute = node.attribute("svg:y")) {
+    if (const pugi::xml_attribute attribute = node.attribute("svg:y");
+        attribute) {
       return attribute.value();
     }
     return std::nullopt;
@@ -1098,12 +900,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] pugi::xml_node
   get_node(const ElementIdentifier element_id) const {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->node;
-    }
-    return {};
+    return m_registry->element_at(element_id).node;
   }
 
   [[nodiscard]] static std::string get_text(const pugi::xml_node node) {
@@ -1125,7 +922,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] const char *
   get_style_name(const ElementIdentifier element_id) const {
     const pugi::xml_node node = get_node(element_id);
-    for (pugi::xml_attribute attribute : node.attributes()) {
+    for (const pugi::xml_attribute attribute : node.attributes()) {
       if (util::string::ends_with(attribute.name(), ":style-name")) {
         return attribute.value();
       }
@@ -1138,7 +935,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
     if (const ElementRegistry::SheetCell *cell_registry =
             m_registry->sheet_cell_element(element_id);
         cell_registry != nullptr) {
-      const auto [_, parent_id] = element_parent(element_id);
+      const ElementIdentifier parent_id = element_parent(element_id);
       return get_partial_cell_style(parent_id, element_id,
                                     cell_registry->position);
     }
@@ -1153,7 +950,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ResolvedStyle
   get_intermediate_style(const ElementIdentifier element_id) const {
-    const auto [_, parent_id] = element_parent(element_id);
+    const ElementIdentifier parent_id = element_parent(element_id);
     if (parent_id == null_element_id) {
       return get_partial_style(element_id);
     }
@@ -1168,38 +965,41 @@ class ElementAdapter final : public abstract::ElementAdapter,
                          const TablePosition &position) const {
     const char *style_name = nullptr;
 
-    if (const pugi::xml_attribute attr =
-            get_node(cell_id).attribute("table:style-name")) {
-      style_name = attr.value();
+    if (cell_id != null_element_id) {
+      if (const pugi::xml_attribute attribute =
+              get_node(cell_id).attribute("table:style-name");
+          attribute) {
+        style_name = attribute.value();
+      }
     }
 
     const auto [column, row] = position.pair();
-    const ElementRegistry::Sheet *sheet_registry =
-        m_registry->sheet_element(sheet_id);
-    if (sheet_registry == nullptr) {
-      return {};
-    }
+    const ElementRegistry::Sheet &sheet_registry =
+        m_registry->sheet_element_at(sheet_id);
 
     if (style_name == nullptr) {
-      const pugi::xml_node cell_node = sheet_registry->cell_node(column, row);
-      if (const pugi::xml_attribute attr =
-              cell_node.attribute("table:style-name")) {
-        style_name = attr.value();
+      const pugi::xml_node cell_node = sheet_registry.cell_node(column, row);
+      if (const pugi::xml_attribute attribute =
+              cell_node.attribute("table:style-name");
+          attribute) {
+        style_name = attribute.value();
       }
     }
 
     if (style_name == nullptr) {
-      const pugi::xml_node row_node = sheet_registry->row_node(row);
-      if (const pugi::xml_attribute attr =
-              row_node.attribute("table:default-cell-style-name")) {
-        style_name = attr.value();
+      const pugi::xml_node row_node = sheet_registry.row_node(row);
+      if (const pugi::xml_attribute attribute =
+              row_node.attribute("table:default-cell-style-name");
+          attribute) {
+        style_name = attribute.value();
       }
     }
     if (style_name == nullptr) {
-      const pugi::xml_node column_node = sheet_registry->column_node(column);
-      if (const pugi::xml_attribute attr =
-              column_node.attribute("table:default-cell-style-name")) {
-        style_name = attr.value();
+      const pugi::xml_node column_node = sheet_registry.column_node(column);
+      if (const pugi::xml_attribute attribute =
+              column_node.attribute("table:default-cell-style-name");
+          attribute) {
+        style_name = attribute.value();
       }
     }
 
diff --git a/src/odr/internal/odf/odf_element_registry.cpp b/src/odr/internal/odf/odf_element_registry.cpp
index 74d5b3b2..cb6f01e3 100644
--- a/src/odr/internal/odf/odf_element_registry.cpp
+++ b/src/odr/internal/odf/odf_element_registry.cpp
@@ -71,6 +71,12 @@ ElementRegistry::element_at(const ElementIdentifier id) {
   return m_elements.at(id - 1);
 }
 
+ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) {
+  check_text_id(id);
+  return m_texts.at(id);
+}
+
 ElementRegistry::Table &
 ElementRegistry::table_element_at(const ElementIdentifier id) {
   check_table_id(id);
@@ -89,6 +95,12 @@ ElementRegistry::element_at(const ElementIdentifier id) const {
   return m_elements.at(id - 1);
 }
 
+const ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) const {
+  check_text_id(id);
+  return m_texts.at(id);
+}
+
 const ElementRegistry::Table &
 ElementRegistry::table_element_at(const ElementIdentifier id) const {
   check_table_id(id);
@@ -101,51 +113,10 @@ ElementRegistry::sheet_element_at(const ElementIdentifier id) const {
   return m_sheets.at(id);
 }
 
-ElementRegistry::Element *ElementRegistry::element(const ElementIdentifier id) {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Element *
-ElementRegistry::element(const ElementIdentifier id) const {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-const ElementRegistry::Table *
-ElementRegistry::table_element(const ElementIdentifier id) const {
-  if (const auto it = m_tables.find(id); it != m_tables.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) const {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Sheet *
-ElementRegistry::sheet_element(const ElementIdentifier id) const {
-  if (const auto it = m_sheets.find(id); it != m_sheets.end()) {
-    return &it->second;
-  }
-  return nullptr;
+const ElementRegistry::SheetCell &
+ElementRegistry::sheet_cell_element_at(const ElementIdentifier id) const {
+  check_sheet_cell_id(id);
+  return m_sheet_cells.at(id);
 }
 
 const ElementRegistry::SheetCell *
diff --git a/src/odr/internal/odf/odf_element_registry.hpp b/src/odr/internal/odf/odf_element_registry.hpp
index a3e52940..60bbf466 100644
--- a/src/odr/internal/odf/odf_element_registry.hpp
+++ b/src/odr/internal/odf/odf_element_registry.hpp
@@ -99,20 +99,17 @@ class ElementRegistry final {
                             bool is_repeated);
 
   [[nodiscard]] Element &element_at(ElementIdentifier id);
+  [[nodiscard]] Text &text_element_at(ElementIdentifier id);
   [[nodiscard]] Table &table_element_at(ElementIdentifier id);
   [[nodiscard]] Sheet &sheet_element_at(ElementIdentifier id);
 
   [[nodiscard]] const Element &element_at(ElementIdentifier id) const;
+  [[nodiscard]] const Text &text_element_at(ElementIdentifier id) const;
   [[nodiscard]] const Table &table_element_at(ElementIdentifier id) const;
   [[nodiscard]] const Sheet &sheet_element_at(ElementIdentifier id) const;
+  [[nodiscard]] const SheetCell &
+  sheet_cell_element_at(ElementIdentifier id) const;
 
-  [[nodiscard]] Element *element(ElementIdentifier id);
-  [[nodiscard]] Text *text_element(ElementIdentifier id);
-
-  [[nodiscard]] const Element *element(ElementIdentifier id) const;
-  [[nodiscard]] const Text *text_element(ElementIdentifier id) const;
-  [[nodiscard]] const Table *table_element(ElementIdentifier id) const;
-  [[nodiscard]] const Sheet *sheet_element(ElementIdentifier id) const;
   [[nodiscard]] const SheetCell *sheet_cell_element(ElementIdentifier id) const;
 
   void append_child(ElementIdentifier parent_id, ElementIdentifier child_id);
diff --git a/src/odr/internal/oldms/oldms_file.cpp b/src/odr/internal/oldms/oldms_file.cpp
index ce11b0cf..d409b4e7 100644
--- a/src/odr/internal/oldms/oldms_file.cpp
+++ b/src/odr/internal/oldms/oldms_file.cpp
@@ -90,9 +90,8 @@ EncryptionState LegacyMicrosoftFile::encryption_state() const noexcept {
   return EncryptionState::unknown;
 }
 
-std::shared_ptr<abstract::DecodedFile>
-LegacyMicrosoftFile::decrypt(const std::string &password) const {
-  (void)password;
+std::shared_ptr<abstract::DecodedFile> LegacyMicrosoftFile::decrypt(
+    [[maybe_unused]] const std::string &password) const {
   throw UnsupportedOperation(
       "odrcore does not support decryption of legacy Microsoft files");
 }
diff --git a/src/odr/internal/ooxml/presentation/ooxml_presentation_document.cpp b/src/odr/internal/ooxml/presentation/ooxml_presentation_document.cpp
index 3abd782b..ceb1de3a 100644
--- a/src/odr/internal/ooxml/presentation/ooxml_presentation_document.cpp
+++ b/src/odr/internal/ooxml/presentation/ooxml_presentation_document.cpp
@@ -147,73 +147,40 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ElementType
   element_type(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->type;
-    }
-    return ElementType::none;
+    return m_registry->element_at(element_id).type;
   }
 
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_parent(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->parent_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).parent_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_first_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->first_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).first_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_last_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->last_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).last_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_previous_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->previous_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).previous_sibling_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_next_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->next_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).next_sibling_id;
   }
 
-  [[nodiscard]] bool
-  element_is_unique(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_unique(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_self_locatable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_self_locatable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_editable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_editable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
   [[nodiscard]]
@@ -221,178 +188,72 @@ class ElementAdapter final : public abstract::ElementAdapter,
   element_document_path(const ElementIdentifier element_id) const override {
     return util::document::extract_path(*this, element_id, null_element_id);
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_navigate_path(const ElementIdentifier element_id,
                         const DocumentPath &path) const override {
     return util::document::navigate_path(*this, element_id, path);
   }
 
-  [[nodiscard]] const abstract::TextRootAdapter *
-  text_root_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
   [[nodiscard]] const SlideAdapter *
   slide_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::slide) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::PageAdapter *
-  page_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::SheetAdapter *
-  sheet_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::SheetCellAdapter *
-  sheet_cell_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::MasterPageAdapter *
-  master_page_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::slide ? this : nullptr;
   }
   [[nodiscard]] const LineBreakAdapter *
   line_break_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::line_break) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::line_break ? this : nullptr;
   }
   [[nodiscard]] const ParagraphAdapter *
   paragraph_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::paragraph) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::paragraph ? this : nullptr;
   }
   [[nodiscard]] const SpanAdapter *
   span_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::span) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::span ? this : nullptr;
   }
   [[nodiscard]] const TextAdapter *
   text_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::text) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::text ? this : nullptr;
   }
   [[nodiscard]] const LinkAdapter *
   link_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::link) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::link ? this : nullptr;
   }
   [[nodiscard]] const BookmarkAdapter *
   bookmark_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::bookmark) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::bookmark ? this : nullptr;
   }
   [[nodiscard]] const ListItemAdapter *
   list_item_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::list_item) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::list_item ? this : nullptr;
   }
   [[nodiscard]] const TableAdapter *
   table_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table ? this : nullptr;
   }
   [[nodiscard]] const TableColumnAdapter *
   table_column_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_column) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_column ? this
+                                                                 : nullptr;
   }
   [[nodiscard]] const TableRowAdapter *
   table_row_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_row) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_row ? this : nullptr;
   }
   [[nodiscard]] const TableCellAdapter *
   table_cell_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_cell) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_cell ? this : nullptr;
   }
   [[nodiscard]] const FrameAdapter *
   frame_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::frame) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::RectAdapter *
-  rect_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::LineAdapter *
-  line_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::CircleAdapter *
-  circle_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::CustomShapeAdapter *
-  custom_shape_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::frame ? this : nullptr;
   }
   [[nodiscard]] const ImageAdapter *
   image_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::image) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::image ? this : nullptr;
   }
 
-  [[nodiscard]] PageLayout
-  slide_page_layout(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] PageLayout slide_page_layout(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     // TODO
     return {
         .width = Measure("11.02 in"),
@@ -401,14 +262,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
         .margin = {},
     };
   }
-  [[nodiscard]] ElementIdentifier
-  slide_master_page(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] ElementIdentifier slide_master_page(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {}; // TODO
   }
-  [[nodiscard]] std::string
-  slide_name(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] std::string slide_name(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {}; // TODO
   }
 
@@ -433,14 +292,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   text_content(const ElementIdentifier element_id) const override {
-    const ElementRegistry::Text *text_element =
-        m_registry->text_element(element_id);
-    if (text_element == nullptr) {
-      return "";
-    }
+    const ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     std::string result;
     for (pugi::xml_node node = first; node != last.next_sibling();
@@ -451,14 +307,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   void text_set_content(const ElementIdentifier element_id,
                         const std::string &text) const override {
-    ElementRegistry::Element *element = m_registry->element(element_id);
-    ElementRegistry::Text *text_element = m_registry->text_element(element_id);
-    if (element == nullptr || text_element == nullptr) {
-      return;
-    }
+    ElementRegistry::Element &element = m_registry->element_at(element_id);
+    ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     pugi::xml_node parent = first.parent();
     const pugi::xml_node old_first = first;
@@ -501,8 +355,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
       }
     }
 
-    element->node = new_first;
-    text_element->last = new_last;
+    element.node = new_first;
+    text_element.last = new_last;
 
     for (pugi::xml_node node = old_first; node != old_last.next_sibling();) {
       const pugi::xml_node next = node.next_sibling();
@@ -515,16 +369,14 @@ class ElementAdapter final : public abstract::ElementAdapter,
     return get_intermediate_style(element_id).text_style;
   }
 
-  [[nodiscard]] std::string
-  link_href(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] std::string link_href(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {}; // TODO
   }
 
   [[nodiscard]] std::string
   bookmark_name(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("text:name").value();
+    return get_node(element_id).attribute("text:name").value();
   }
 
   [[nodiscard]] TextStyle
@@ -558,16 +410,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
     return result;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   table_first_column(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Table *table_registry =
-            m_registry->table_element(element_id);
-        table_registry != nullptr) {
-      return {this, table_registry->first_column_id};
-    }
-    return {};
+    return m_registry->table_element_at(element_id).first_column_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   table_first_row(const ElementIdentifier element_id) const override {
     return element_first_child(element_id);
   }
@@ -586,19 +433,16 @@ class ElementAdapter final : public abstract::ElementAdapter,
     return get_partial_style(element_id).table_row_style;
   }
 
-  [[nodiscard]] bool
-  table_cell_is_covered(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool table_cell_is_covered(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return false;
   }
-  [[nodiscard]] TableDimensions
-  table_cell_span(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] TableDimensions table_cell_span(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {1, 1}; // TODO
   }
-  [[nodiscard]] ValueType
-  table_cell_value_type(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] ValueType table_cell_value_type(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return ValueType::string;
   }
   [[nodiscard]] TableCellStyle
@@ -606,9 +450,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
     return get_partial_style(element_id).table_cell_style;
   }
 
-  [[nodiscard]] AnchorType
-  frame_anchor_type(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] AnchorType frame_anchor_type(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return AnchorType::at_page;
   }
   [[nodiscard]] std::optional<std::string>
@@ -670,9 +513,6 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] bool
   image_is_internal(const ElementIdentifier element_id) const override {
-    if (m_document->as_filesystem() == nullptr) {
-      return false;
-    }
     try {
       const AbsPath path = Path(image_href(element_id)).make_absolute();
       return m_document->as_filesystem()->is_file(path);
@@ -682,16 +522,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   [[nodiscard]] std::optional<File>
   image_file(const ElementIdentifier element_id) const override {
-    if (m_document->as_filesystem() == nullptr) {
-      return std::nullopt;
-    }
     const AbsPath path = Path(image_href(element_id)).make_absolute();
     return File(m_document->as_filesystem()->open(path));
   }
   [[nodiscard]] std::string
   image_href(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("xlink:href").value();
+    return get_node(element_id).attribute("xlink:href").value();
   }
 
 private:
@@ -700,12 +536,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] pugi::xml_node
   get_node(const ElementIdentifier element_id) const {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->node;
-    }
-    return {};
+    return m_registry->element_at(element_id).node;
   }
 
   [[nodiscard]] static std::string get_text(const pugi::xml_node node) {
@@ -723,27 +554,25 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ResolvedStyle
   get_partial_style(const ElementIdentifier element_id) const {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      if (element->type == ElementType::paragraph) {
-        ResolvedStyle result;
-        resolve_text_style_(element->node, result.text_style);
-        resolve_paragraph_style_(element->node, result.paragraph_style);
-        return result;
-      }
-      if (element->type == ElementType::span) {
-        ResolvedStyle result;
-        resolve_text_style_(element->node, result.text_style);
-        return result;
-      }
+    const ElementRegistry::Element &element =
+        m_registry->element_at(element_id);
+    if (element.type == ElementType::paragraph) {
+      ResolvedStyle result;
+      resolve_text_style_(element.node, result.text_style);
+      resolve_paragraph_style_(element.node, result.paragraph_style);
+      return result;
+    }
+    if (element.type == ElementType::span) {
+      ResolvedStyle result;
+      resolve_text_style_(element.node, result.text_style);
+      return result;
     }
     return {};
   }
 
   [[nodiscard]] ResolvedStyle
   get_intermediate_style(const ElementIdentifier element_id) const {
-    const auto [_, parent_id] = element_parent(element_id);
+    const ElementIdentifier parent_id = element_parent(element_id);
     if (parent_id == null_element_id) {
       return get_partial_style(element_id);
     }
diff --git a/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.cpp b/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.cpp
index 942649ee..6407a2eb 100644
--- a/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.cpp
+++ b/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.cpp
@@ -54,6 +54,12 @@ ElementRegistry::table_element_at(const ElementIdentifier id) {
   return m_tables.at(id);
 }
 
+ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) {
+  check_text_id(id);
+  return m_texts.at(id);
+}
+
 const ElementRegistry::Element &
 ElementRegistry::element_at(const ElementIdentifier id) const {
   check_element_id(id);
@@ -66,51 +72,10 @@ ElementRegistry::table_element_at(const ElementIdentifier id) const {
   return m_tables.at(id);
 }
 
-ElementRegistry::Element *ElementRegistry::element(const ElementIdentifier id) {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-ElementRegistry::Table *
-ElementRegistry::table_element(const ElementIdentifier id) {
-  if (const auto it = m_tables.find(id); it != m_tables.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Element *
-ElementRegistry::element(const ElementIdentifier id) const {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-const ElementRegistry::Table *
-ElementRegistry::table_element(const ElementIdentifier id) const {
-  if (const auto it = m_tables.find(id); it != m_tables.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) const {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
+const ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) const {
+  check_text_id(id);
+  return m_texts.at(id);
 }
 
 void ElementRegistry::check_element_id(const ElementIdentifier id) const {
diff --git a/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.hpp b/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.hpp
index 60a8ada0..1530caa3 100644
--- a/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.hpp
+++ b/src/odr/internal/ooxml/presentation/ooxml_presentation_element_registry.hpp
@@ -45,17 +45,11 @@ class ElementRegistry final {
 
   [[nodiscard]] Element &element_at(ElementIdentifier id);
   [[nodiscard]] Table &table_element_at(ElementIdentifier id);
+  [[nodiscard]] Text &text_element_at(ElementIdentifier id);
 
   [[nodiscard]] const Element &element_at(ElementIdentifier id) const;
   [[nodiscard]] const Table &table_element_at(ElementIdentifier id) const;
-
-  [[nodiscard]] Element *element(ElementIdentifier id);
-  [[nodiscard]] Table *table_element(ElementIdentifier id);
-  [[nodiscard]] Text *text_element(ElementIdentifier id);
-
-  [[nodiscard]] const Element *element(ElementIdentifier id) const;
-  [[nodiscard]] const Table *table_element(ElementIdentifier id) const;
-  [[nodiscard]] const Text *text_element(ElementIdentifier id) const;
+  [[nodiscard]] const Text &text_element_at(ElementIdentifier id) const;
 
   void append_child(ElementIdentifier parent_id, ElementIdentifier child_id);
   void append_column(ElementIdentifier table_id, ElementIdentifier column_id);
diff --git a/src/odr/internal/ooxml/presentation/ooxml_presentation_parser.cpp b/src/odr/internal/ooxml/presentation/ooxml_presentation_parser.cpp
index 4391b8fa..7ba89ccf 100644
--- a/src/odr/internal/ooxml/presentation/ooxml_presentation_parser.cpp
+++ b/src/odr/internal/ooxml/presentation/ooxml_presentation_parser.cpp
@@ -70,10 +70,9 @@ bool is_text_node(const pugi::xml_node node) {
 }
 
 std::tuple<ElementIdentifier, pugi::xml_node>
-parse_text_element(ElementRegistry &registry, const ParseContext &context,
+parse_text_element(ElementRegistry &registry,
+                   [[maybe_unused]] const ParseContext &context,
                    const pugi::xml_node first) {
-  (void)context;
-
   if (!first) {
     return {null_element_id, pugi::xml_node()};
   }
diff --git a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_document.cpp b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_document.cpp
index 79310629..02b9030e 100644
--- a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_document.cpp
+++ b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_document.cpp
@@ -113,73 +113,40 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ElementType
   element_type(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->type;
-    }
-    return ElementType::none;
+    return m_registry->element_at(element_id).type;
   }
 
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_parent(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->parent_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).parent_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_first_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->first_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).first_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_last_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->last_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).last_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_previous_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->previous_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).previous_sibling_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_next_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->next_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).next_sibling_id;
   }
 
-  [[nodiscard]] bool
-  element_is_unique(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_unique(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_self_locatable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_self_locatable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_editable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_editable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return false;
   }
   [[nodiscard]]
@@ -187,148 +154,47 @@ class ElementAdapter final : public abstract::ElementAdapter,
   element_document_path(const ElementIdentifier element_id) const override {
     return util::document::extract_path(*this, element_id, null_element_id);
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_navigate_path(const ElementIdentifier element_id,
                         const DocumentPath &path) const override {
     return util::document::navigate_path(*this, element_id, path);
   }
 
-  [[nodiscard]] const abstract::TextRootAdapter *
-  text_root_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::SlideAdapter *
-  slide_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::PageAdapter *
-  page_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
   [[nodiscard]] const SheetAdapter *
   sheet_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::sheet) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::sheet ? this : nullptr;
   }
   [[nodiscard]] const SheetCellAdapter *
   sheet_cell_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::sheet_cell) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::MasterPageAdapter *
-  master_page_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::sheet_cell ? this : nullptr;
   }
   [[nodiscard]] const LineBreakAdapter *
   line_break_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::line_break) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::line_break ? this : nullptr;
   }
   [[nodiscard]] const ParagraphAdapter *
   paragraph_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::paragraph) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::paragraph ? this : nullptr;
   }
   [[nodiscard]] const SpanAdapter *
   span_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::span) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::span ? this : nullptr;
   }
   [[nodiscard]] const TextAdapter *
   text_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::text) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::text ? this : nullptr;
   }
   [[nodiscard]] const LinkAdapter *
   link_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::link) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::BookmarkAdapter *
-  bookmark_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::ListItemAdapter *
-  list_item_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::TableAdapter *
-  table_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::TableColumnAdapter *
-  table_column_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::TableRowAdapter *
-  table_row_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::TableCellAdapter *
-  table_cell_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::link ? this : nullptr;
   }
   [[nodiscard]] const FrameAdapter *
   frame_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::frame) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::RectAdapter *
-  rect_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::LineAdapter *
-  line_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::CircleAdapter *
-  circle_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::CustomShapeAdapter *
-  custom_shape_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::frame ? this : nullptr;
   }
   [[nodiscard]] const ImageAdapter *
   image_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::image) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::image ? this : nullptr;
   }
 
   [[nodiscard]] std::string
@@ -337,72 +203,57 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   [[nodiscard]] TableDimensions
   sheet_dimensions(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Sheet *element =
-            m_registry->sheet_element(element_id);
-        element != nullptr) {
-      return element->dimensions;
-    }
-    return {};
+    return m_registry->sheet_element_at(element_id).dimensions;
   }
   [[nodiscard]] TableDimensions
   sheet_content(const ElementIdentifier element_id,
-                const std::optional<TableDimensions> range) const override {
-    (void)range;
+                [[maybe_unused]] const std::optional<TableDimensions> range)
+      const override {
     return sheet_dimensions(element_id); // TODO
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   sheet_cell(const ElementIdentifier element_id, const std::uint32_t column,
              const std::uint32_t row) const override {
-    if (const ElementRegistry::Sheet *sheet_element =
-            m_registry->sheet_element(element_id);
-        sheet_element != nullptr) {
-      if (const ElementRegistry::Sheet::Cell *cell =
-              sheet_element->cell(column, row);
-          cell != nullptr) {
-        return {this, cell->element_id};
-      }
+    const ElementRegistry::Sheet &sheet_element =
+        m_registry->sheet_element_at(element_id);
+    if (const ElementRegistry::Sheet::Cell *cell =
+            sheet_element.cell(column, row);
+        cell != nullptr) {
+      return cell->element_id;
     }
     return {};
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   sheet_first_shape(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Sheet *sheet_element =
-            m_registry->sheet_element(element_id);
-        sheet_element != nullptr) {
-      return {this, sheet_element->first_shape_id};
-    }
-    return {};
+    return m_registry->sheet_element_at(element_id).first_shape_id;
   }
-  [[nodiscard]] TableStyle
-  sheet_style(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] TableStyle sheet_style(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {}; // TODO
   }
   [[nodiscard]] TableColumnStyle
   sheet_column_style(const ElementIdentifier element_id,
                      const std::uint32_t column) const override {
+    const ElementRegistry::Sheet &sheet_element =
+        m_registry->sheet_element_at(element_id);
+    const pugi::xml_node column_node = sheet_element.column_node(column);
+
     TableColumnStyle result;
-    if (const ElementRegistry::Sheet *sheet_element =
-            m_registry->sheet_element(element_id);
-        sheet_element != nullptr) {
-      const pugi::xml_node column_node = sheet_element->column_node(column);
-      if (const pugi::xml_attribute width = column_node.attribute("width")) {
-        result.width = Measure(width.as_float(), DynamicUnit("ch"));
-      }
+    if (const pugi::xml_attribute width = column_node.attribute("width")) {
+      result.width = Measure(width.as_float(), DynamicUnit("ch"));
     }
     return result;
   }
   [[nodiscard]] TableRowStyle
   sheet_row_style(const ElementIdentifier element_id,
                   const std::uint32_t row) const override {
+    const ElementRegistry::Sheet &sheet_element =
+        m_registry->sheet_element_at(element_id);
+    const pugi::xml_node row_node = sheet_element.row_node(row);
+
     TableRowStyle result;
-    if (const ElementRegistry::Sheet *sheet_element =
-            m_registry->sheet_element(element_id);
-        sheet_element != nullptr) {
-      const pugi::xml_node row_node = sheet_element->row_node(row);
-      if (const pugi::xml_attribute height = row_node.attribute("ht")) {
-        result.height = Measure(height.as_float(), DynamicUnit("pt"));
-      }
+    if (const pugi::xml_attribute height = row_node.attribute("ht")) {
+      result.height = Measure(height.as_float(), DynamicUnit("pt"));
     }
     return result;
   }
@@ -410,43 +261,34 @@ class ElementAdapter final : public abstract::ElementAdapter,
   sheet_cell_style(const ElementIdentifier element_id,
                    const std::uint32_t column,
                    const std::uint32_t row) const override {
+    const ElementRegistry::Sheet &sheet_element =
+        m_registry->sheet_element_at(element_id);
+    const pugi::xml_node cell_node = sheet_element.cell_node(column, row);
+
     TableCellStyle result;
-    if (const ElementRegistry::Sheet *sheet_element =
-            m_registry->sheet_element(element_id);
-        sheet_element != nullptr) {
-      if (const pugi::xml_attribute style_attr =
-              sheet_element->cell_node(column, row).attribute("s");
-          style_attr) {
-        const std::uint32_t style_id = style_attr.as_uint();
-        const ResolvedStyle style = m_style_registry->cell_style(style_id);
-        result.override(style.table_cell_style);
-      }
+    if (const pugi::xml_attribute style_attribute = cell_node.attribute("s");
+        style_attribute) {
+      const std::uint32_t style_id = style_attribute.as_uint();
+      const ResolvedStyle style = m_style_registry->cell_style(style_id);
+      result.override(style.table_cell_style);
     }
     return result;
   }
 
   [[nodiscard]] TablePosition
   sheet_cell_position(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::SheetCell *cell_element =
-            m_registry->sheet_cell_element(element_id);
-        cell_element != nullptr) {
-      return cell_element->position;
-    }
-    return {};
+    return m_registry->sheet_cell_element_at(element_id).position;
   }
-  [[nodiscard]] bool
-  sheet_cell_is_covered(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool sheet_cell_is_covered(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return false; // TODO
   }
-  [[nodiscard]] TableDimensions
-  sheet_cell_span(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] TableDimensions sheet_cell_span(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {1, 1}; // TODO
   }
-  [[nodiscard]] ValueType
-  sheet_cell_value_type(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] ValueType sheet_cell_value_type(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return ValueType::string; // TODO
   }
 
@@ -471,14 +313,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   text_content(const ElementIdentifier element_id) const override {
-    const ElementRegistry::Text *text_element =
-        m_registry->text_element(element_id);
-    if (text_element == nullptr) {
-      return "";
-    }
+    const ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     std::string result;
     for (pugi::xml_node node = first; node != last.next_sibling();
@@ -487,10 +326,9 @@ class ElementAdapter final : public abstract::ElementAdapter,
     }
     return result;
   }
-  void text_set_content(const ElementIdentifier element_id,
-                        const std::string &text) const override {
-    (void)element_id;
-    (void)text;
+  void
+  text_set_content([[maybe_unused]] const ElementIdentifier element_id,
+                   [[maybe_unused]] const std::string &text) const override {
     // TODO
   }
   [[nodiscard]] TextStyle
@@ -498,15 +336,13 @@ class ElementAdapter final : public abstract::ElementAdapter,
     return get_intermediate_style(element_id).text_style;
   }
 
-  [[nodiscard]] std::string
-  link_href(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] std::string link_href(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {}; // TODO
   }
 
-  [[nodiscard]] AnchorType
-  frame_anchor_type(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] AnchorType frame_anchor_type(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return AnchorType::at_page;
   }
   [[nodiscard]] std::optional<std::string>
@@ -561,22 +397,17 @@ class ElementAdapter final : public abstract::ElementAdapter,
     }
     return {};
   }
-  [[nodiscard]] std::optional<std::string>
-  frame_z_index(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] std::optional<std::string> frame_z_index(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return std::nullopt;
   }
-  [[nodiscard]] GraphicStyle
-  frame_style(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] GraphicStyle frame_style(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {};
   }
 
   [[nodiscard]] bool
   image_is_internal(const ElementIdentifier element_id) const override {
-    if (m_document->as_filesystem() == nullptr) {
-      return false;
-    }
     try {
       const AbsPath path = Path(image_href(element_id)).make_absolute();
       return m_document->as_filesystem()->is_file(path);
@@ -586,9 +417,6 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   [[nodiscard]] std::optional<File>
   image_file(const ElementIdentifier element_id) const override {
-    if (m_document->as_filesystem() == nullptr) {
-      return std::nullopt;
-    }
     const AbsPath path = Path(image_href(element_id)).make_absolute();
     return File(m_document->as_filesystem()->open(path));
   }
@@ -614,19 +442,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] pugi::xml_node
   get_node(const ElementIdentifier element_id) const {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->node;
-    }
-    return {};
+    return m_registry->element_at(element_id).node;
   }
 
   [[nodiscard]] std::pair<const Relations *, AbsPath>
   get_relations_and_origin(const ElementIdentifier element_id) const {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr) {
+    if (element_id == null_element_id) {
       return {nullptr, {}};
     }
     if (const ElementRegistry::ElementRelations *element_relations =
@@ -634,7 +455,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
         element_relations != nullptr) {
       return {element_relations->relations, element_relations->origin};
     }
-    const auto [_, parent_id] = element_parent(element_id);
+    const ElementIdentifier parent_id = element_parent(element_id);
     return get_relations_and_origin(parent_id);
   }
 
@@ -666,7 +487,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ResolvedStyle
   get_intermediate_style(const ElementIdentifier element_id) const {
-    const auto [_, parent_id] = element_parent(element_id);
+    const ElementIdentifier parent_id = element_parent(element_id);
     if (parent_id == null_element_id) {
       return get_partial_style(element_id);
     }
diff --git a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.cpp b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.cpp
index aeefe5cd..2a8cd223 100644
--- a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.cpp
+++ b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.cpp
@@ -88,33 +88,22 @@ ElementRegistry::element_at(const ElementIdentifier id) const {
   return m_elements.at(id - 1);
 }
 
+const ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) const {
+  check_text_id(id);
+  return m_texts.at(id);
+}
+
 const ElementRegistry::Sheet &
 ElementRegistry::sheet_element_at(const ElementIdentifier id) const {
   check_sheet_id(id);
   return m_sheets.at(id);
 }
 
-ElementRegistry::Element *ElementRegistry::element(const ElementIdentifier id) {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Element *
-ElementRegistry::element(const ElementIdentifier id) const {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
+const ElementRegistry::SheetCell &
+ElementRegistry::sheet_cell_element_at(const ElementIdentifier id) const {
+  check_sheet_cell_id(id);
+  return m_sheet_cells.at(id);
 }
 
 const ElementRegistry::ElementRelations *
@@ -126,30 +115,6 @@ ElementRegistry::element_relations(const ElementIdentifier id) const {
   return nullptr;
 }
 
-const ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) const {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Sheet *
-ElementRegistry::sheet_element(const ElementIdentifier id) const {
-  if (const auto it = m_sheets.find(id); it != m_sheets.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::SheetCell *
-ElementRegistry::sheet_cell_element(const ElementIdentifier id) const {
-  if (const auto it = m_sheet_cells.find(id); it != m_sheet_cells.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
 void ElementRegistry::check_element_id(const ElementIdentifier id) const {
   if (id == null_element_id) {
     throw std::out_of_range(
@@ -231,10 +196,9 @@ void ElementRegistry::append_sheet_cell(const ElementIdentifier sheet_id,
   element_at(cell_id).parent_id = sheet_id;
 }
 
-void ElementRegistry::Sheet::register_column(const std::uint32_t column_min,
-                                             const std::uint32_t column_max,
-                                             const pugi::xml_node element) {
-  (void)column_min;
+void ElementRegistry::Sheet::register_column(
+    [[maybe_unused]] const std::uint32_t column_min,
+    const std::uint32_t column_max, const pugi::xml_node element) {
   columns[column_max] = {.node = element};
 }
 
diff --git a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.hpp b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.hpp
index f25f3dbd..b9b6e6e0 100644
--- a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.hpp
+++ b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.hpp
@@ -103,17 +103,13 @@ class ElementRegistry final {
   [[nodiscard]] Sheet &sheet_element_at(ElementIdentifier id);
 
   [[nodiscard]] const Element &element_at(ElementIdentifier id) const;
+  [[nodiscard]] const Text &text_element_at(ElementIdentifier id) const;
   [[nodiscard]] const Sheet &sheet_element_at(ElementIdentifier id) const;
+  [[nodiscard]] const SheetCell &
+  sheet_cell_element_at(ElementIdentifier id) const;
 
-  [[nodiscard]] Element *element(ElementIdentifier id);
-  [[nodiscard]] Text *text_element(ElementIdentifier id);
-
-  [[nodiscard]] const Element *element(ElementIdentifier id) const;
   [[nodiscard]] const ElementRelations *
   element_relations(ElementIdentifier id) const;
-  [[nodiscard]] const Text *text_element(ElementIdentifier id) const;
-  [[nodiscard]] const Sheet *sheet_element(ElementIdentifier id) const;
-  [[nodiscard]] const SheetCell *sheet_cell_element(ElementIdentifier id) const;
 
   void append_child(ElementIdentifier parent_id, ElementIdentifier child_id);
   void append_shape(ElementIdentifier sheet_id, ElementIdentifier shape_id);
diff --git a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_parser.cpp b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_parser.cpp
index b9cdf32c..9dea058f 100644
--- a/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_parser.cpp
+++ b/src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_parser.cpp
@@ -180,10 +180,9 @@ bool is_text_node(const pugi::xml_node node) {
 }
 
 std::tuple<ElementIdentifier, pugi::xml_node>
-parse_text_element(ElementRegistry &registry, const ParseContext &context,
+parse_text_element(ElementRegistry &registry,
+                   [[maybe_unused]] const ParseContext &context,
                    const pugi::xml_node first) {
-  (void)context;
-
   if (!first) {
     return {null_element_id, pugi::xml_node()};
   }
diff --git a/src/odr/internal/ooxml/text/ooxml_text_document.cpp b/src/odr/internal/ooxml/text/ooxml_text_document.cpp
index 6fe9405a..462f3279 100644
--- a/src/odr/internal/ooxml/text/ooxml_text_document.cpp
+++ b/src/odr/internal/ooxml/text/ooxml_text_document.cpp
@@ -122,73 +122,40 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ElementType
   element_type(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->type;
-    }
-    return ElementType::none;
+    return m_registry->element_at(element_id).type;
   }
 
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_parent(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->parent_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).parent_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_first_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->first_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).first_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_last_child(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->last_child_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).last_child_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_previous_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->previous_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).previous_sibling_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_next_sibling(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return {this, element->next_sibling_id};
-    }
-    return {};
+    return m_registry->element_at(element_id).next_sibling_id;
   }
 
-  [[nodiscard]] bool
-  element_is_unique(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_unique(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_self_locatable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_self_locatable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
-  [[nodiscard]] bool
-  element_is_editable(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] bool element_is_editable(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return true;
   }
   [[nodiscard]]
@@ -196,7 +163,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
   element_document_path(const ElementIdentifier element_id) const override {
     return util::document::extract_path(*this, element_id, null_element_id);
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   element_navigate_path(const ElementIdentifier element_id,
                         const DocumentPath &path) const override {
     return util::document::navigate_path(*this, element_id, path);
@@ -204,175 +171,68 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] const TextRootAdapter *
   text_root_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::root) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::SlideAdapter *
-  slide_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::PageAdapter *
-  page_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::SheetAdapter *
-  sheet_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::SheetCellAdapter *
-  sheet_cell_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::MasterPageAdapter *
-  master_page_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::root ? this : nullptr;
   }
   [[nodiscard]] const LineBreakAdapter *
   line_break_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::line_break) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::line_break ? this : nullptr;
   }
   [[nodiscard]] const ParagraphAdapter *
   paragraph_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::paragraph) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::paragraph ? this : nullptr;
   }
   [[nodiscard]] const SpanAdapter *
   span_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::span) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::span ? this : nullptr;
   }
   [[nodiscard]] const TextAdapter *
   text_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::text) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::text ? this : nullptr;
   }
   [[nodiscard]] const LinkAdapter *
   link_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::link) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::link ? this : nullptr;
   }
   [[nodiscard]] const BookmarkAdapter *
   bookmark_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::bookmark) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::bookmark ? this : nullptr;
   }
   [[nodiscard]] const ListItemAdapter *
   list_item_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::list_item) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::list_item ? this : nullptr;
   }
   [[nodiscard]] const TableAdapter *
   table_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table ? this : nullptr;
   }
   [[nodiscard]] const TableColumnAdapter *
   table_column_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_column) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_column ? this
+                                                                 : nullptr;
   }
   [[nodiscard]] const TableRowAdapter *
   table_row_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_row) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_row ? this : nullptr;
   }
   [[nodiscard]] const TableCellAdapter *
   table_cell_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::table_cell) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::table_cell ? this : nullptr;
   }
   [[nodiscard]] const FrameAdapter *
   frame_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::frame) {
-      return nullptr;
-    }
-    return this;
-  }
-  [[nodiscard]] const abstract::RectAdapter *
-  rect_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::LineAdapter *
-  line_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::CircleAdapter *
-  circle_adapter(const ElementIdentifier) const override {
-    return nullptr;
-  }
-  [[nodiscard]] const abstract::CustomShapeAdapter *
-  custom_shape_adapter(const ElementIdentifier) const override {
-    return nullptr;
+    return element_type(element_id) == ElementType::frame ? this : nullptr;
   }
   [[nodiscard]] const ImageAdapter *
   image_adapter(const ElementIdentifier element_id) const override {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element == nullptr || element->type != ElementType::image) {
-      return nullptr;
-    }
-    return this;
+    return element_type(element_id) == ElementType::image ? this : nullptr;
   }
 
-  [[nodiscard]] PageLayout
-  text_root_page_layout(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] PageLayout text_root_page_layout(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {};
   }
-  [[nodiscard]] ElementHandle text_root_first_master_page(
-      const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] ElementIdentifier text_root_first_master_page(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {};
   }
 
@@ -397,14 +257,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   text_content(const ElementIdentifier element_id) const override {
-    const ElementRegistry::Text *text_element =
-        m_registry->text_element(element_id);
-    if (text_element == nullptr) {
-      return "";
-    }
+    const ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     std::string result;
     for (pugi::xml_node node = first; node != last.next_sibling();
@@ -415,14 +272,12 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   void text_set_content(const ElementIdentifier element_id,
                         const std::string &text) const override {
-    ElementRegistry::Element *element = m_registry->element(element_id);
-    ElementRegistry::Text *text_element = m_registry->text_element(element_id);
-    if (element == nullptr || text_element == nullptr) {
-      return;
-    }
+    ElementRegistry::Element &element = m_registry->element_at(element_id);
+    ElementRegistry::Text &text_element =
+        m_registry->text_element_at(element_id);
 
     const pugi::xml_node first = get_node(element_id);
-    const pugi::xml_node last = text_element->last;
+    const pugi::xml_node last = text_element.last;
 
     pugi::xml_node parent = first.parent();
     const pugi::xml_node old_first = first;
@@ -465,8 +320,8 @@ class ElementAdapter final : public abstract::ElementAdapter,
       }
     }
 
-    element->node = new_first;
-    text_element->last = new_last;
+    element.node = new_first;
+    text_element.last = new_last;
 
     for (pugi::xml_node node = old_first; node != old_last.next_sibling();) {
       const pugi::xml_node next = node.next_sibling();
@@ -482,10 +337,10 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::string
   link_href(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    if (const pugi::xml_attribute anchor = node.attribute("w:anchor")) {
+    if (const pugi::xml_attribute anchor = node.attribute("w:anchor"); anchor) {
       return std::string("#") + anchor.value();
     }
-    if (const pugi::xml_attribute ref = node.attribute("r:id")) {
+    if (const pugi::xml_attribute ref = node.attribute("r:id"); ref) {
       const auto relations = get_document_relations();
       if (const auto rel = relations.find(ref.value());
           rel != std::end(relations)) {
@@ -497,8 +352,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] std::string
   bookmark_name(const ElementIdentifier element_id) const override {
-    const pugi::xml_node node = get_node(element_id);
-    return node.attribute("text:name").value();
+    return get_node(element_id).attribute("text:name").value();
   }
 
   [[nodiscard]] TextStyle
@@ -532,11 +386,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
     return result;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   table_first_column(const ElementIdentifier element_id) const override {
-    return {this, m_registry->table_element_at(element_id).first_column_id};
+    return m_registry->table_element_at(element_id).first_column_id;
   }
-  [[nodiscard]] ElementHandle
+  [[nodiscard]] ElementIdentifier
   table_first_row(const ElementIdentifier element_id) const override {
     return element_first_child(element_id);
   }
@@ -602,13 +456,11 @@ class ElementAdapter final : public abstract::ElementAdapter,
     return AnchorType::as_char; // TODO default?
   }
   [[nodiscard]] std::optional<std::string>
-  frame_x(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  frame_x([[maybe_unused]] const ElementIdentifier element_id) const override {
     return std::nullopt;
   }
   [[nodiscard]] std::optional<std::string>
-  frame_y(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  frame_y([[maybe_unused]] const ElementIdentifier element_id) const override {
     return std::nullopt;
   }
   [[nodiscard]] std::optional<std::string>
@@ -629,22 +481,17 @@ class ElementAdapter final : public abstract::ElementAdapter,
     }
     return {};
   }
-  [[nodiscard]] std::optional<std::string>
-  frame_z_index(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] std::optional<std::string> frame_z_index(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return std::nullopt;
   }
-  [[nodiscard]] GraphicStyle
-  frame_style(const ElementIdentifier element_id) const override {
-    (void)element_id;
+  [[nodiscard]] GraphicStyle frame_style(
+      [[maybe_unused]] const ElementIdentifier element_id) const override {
     return {};
   }
 
   [[nodiscard]] bool
   image_is_internal(const ElementIdentifier element_id) const override {
-    if (m_document->as_filesystem() == nullptr) {
-      return false;
-    }
     try {
       const AbsPath path = Path(image_href(element_id)).make_absolute();
       return m_document->as_filesystem()->is_file(path);
@@ -654,9 +501,6 @@ class ElementAdapter final : public abstract::ElementAdapter,
   }
   [[nodiscard]] std::optional<File>
   image_file(const ElementIdentifier element_id) const override {
-    if (m_document->as_filesystem() == nullptr) {
-      return std::nullopt;
-    }
     const AbsPath path = Path(image_href(element_id)).make_absolute();
     return File(m_document->as_filesystem()->open(path));
   }
@@ -682,12 +526,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] pugi::xml_node
   get_node(const ElementIdentifier element_id) const {
-    if (const ElementRegistry::Element *element =
-            m_registry->element(element_id);
-        element != nullptr) {
-      return element->node;
-    }
-    return {};
+    return m_registry->element_at(element_id).node;
   }
 
   [[nodiscard]] pugi::xml_node
@@ -734,7 +573,7 @@ class ElementAdapter final : public abstract::ElementAdapter,
 
   [[nodiscard]] ResolvedStyle
   get_intermediate_style(const ElementIdentifier element_id) const {
-    const auto [_, parent_id] = element_parent(element_id);
+    const ElementIdentifier parent_id = element_parent(element_id);
     ResolvedStyle base;
     if (parent_id == null_element_id) {
       base = m_document->style_registry().default_style()->resolved();
diff --git a/src/odr/internal/ooxml/text/ooxml_text_element_registry.cpp b/src/odr/internal/ooxml/text/ooxml_text_element_registry.cpp
index a0e6da99..cb8c6f51 100644
--- a/src/odr/internal/ooxml/text/ooxml_text_element_registry.cpp
+++ b/src/odr/internal/ooxml/text/ooxml_text_element_registry.cpp
@@ -48,6 +48,12 @@ ElementRegistry::element_at(const ElementIdentifier id) {
   return m_elements.at(id - 1);
 }
 
+ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) {
+  check_text_id(id);
+  return m_texts.at(id);
+}
+
 ElementRegistry::Table &
 ElementRegistry::table_element_at(const ElementIdentifier id) {
   return m_tables.at(id);
@@ -59,42 +65,17 @@ ElementRegistry::element_at(const ElementIdentifier id) const {
   return m_elements.at(id - 1);
 }
 
+const ElementRegistry::Text &
+ElementRegistry::text_element_at(const ElementIdentifier id) const {
+  check_text_id(id);
+  return m_texts.at(id);
+}
+
 const ElementRegistry::Table &
 ElementRegistry::table_element_at(const ElementIdentifier id) const {
   return m_tables.at(id);
 }
 
-ElementRegistry::Element *ElementRegistry::element(const ElementIdentifier id) {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
-const ElementRegistry::Element *
-ElementRegistry::element(const ElementIdentifier id) const {
-  if (id == null_element_id || id - 1 >= m_elements.size()) {
-    return nullptr;
-  }
-  return &m_elements.at(id - 1);
-}
-
-const ElementRegistry::Text *
-ElementRegistry::text_element(const ElementIdentifier id) const {
-  if (const auto it = m_texts.find(id); it != m_texts.end()) {
-    return &it->second;
-  }
-  return nullptr;
-}
-
 void ElementRegistry::check_element_id(const ElementIdentifier id) const {
   if (id == null_element_id) {
     throw std::out_of_range(
diff --git a/src/odr/internal/ooxml/text/ooxml_text_element_registry.hpp b/src/odr/internal/ooxml/text/ooxml_text_element_registry.hpp
index d4115b30..0faf355d 100644
--- a/src/odr/internal/ooxml/text/ooxml_text_element_registry.hpp
+++ b/src/odr/internal/ooxml/text/ooxml_text_element_registry.hpp
@@ -44,17 +44,13 @@ class ElementRegistry final {
   create_text_element(pugi::xml_node first_node, pugi::xml_node last_node);
 
   [[nodiscard]] Element &element_at(ElementIdentifier id);
+  [[nodiscard]] Text &text_element_at(ElementIdentifier id);
   [[nodiscard]] Table &table_element_at(ElementIdentifier id);
 
   [[nodiscard]] const Element &element_at(ElementIdentifier id) const;
+  [[nodiscard]] const Text &text_element_at(ElementIdentifier id) const;
   [[nodiscard]] const Table &table_element_at(ElementIdentifier id) const;
 
-  [[nodiscard]] Element *element(ElementIdentifier id);
-  [[nodiscard]] Text *text_element(ElementIdentifier id);
-
-  [[nodiscard]] const Element *element(ElementIdentifier id) const;
-  [[nodiscard]] const Text *text_element(ElementIdentifier id) const;
-
   void append_child(ElementIdentifier parent_id, ElementIdentifier child_id);
   void append_column(ElementIdentifier table_id, ElementIdentifier column_id);
 
diff --git a/src/odr/internal/pdf/pdf_cmap_parser.cpp b/src/odr/internal/pdf/pdf_cmap_parser.cpp
index f6a2779f..c28934bc 100644
--- a/src/odr/internal/pdf/pdf_cmap_parser.cpp
+++ b/src/odr/internal/pdf/pdf_cmap_parser.cpp
@@ -51,9 +51,7 @@ std::variant<Object, std::string> CMapParser::read_token() const {
 }
 
 void CMapParser::read_codespacerange(const std::uint32_t n,
-                                     const CMap &cmap) const {
-  (void)cmap;
-
+                                     [[maybe_unused]] const CMap &cmap) const {
   m_parser.skip_whitespace();
   for (std::uint32_t i = 0; i < n; ++i) {
     auto from_glyph = m_parser.read_object();
@@ -89,9 +87,8 @@ void CMapParser::read_bfchar(const std::uint32_t n, CMap &cmap) const {
   }
 }
 
-void CMapParser::read_bfrange(const std::uint32_t n, const CMap &cmap) const {
-  (void)cmap;
-
+void CMapParser::read_bfrange(const std::uint32_t n,
+                              [[maybe_unused]] const CMap &cmap) const {
   m_parser.skip_whitespace();
   for (std::uint32_t i = 0; i < n; ++i) {
     auto from_glyph = m_parser.read_object();
diff --git a/src/odr/internal/pdf/pdf_file.cpp b/src/odr/internal/pdf/pdf_file.cpp
index b5a0ba9a..4c1ddb92 100644
--- a/src/odr/internal/pdf/pdf_file.cpp
+++ b/src/odr/internal/pdf/pdf_file.cpp
@@ -24,8 +24,7 @@ EncryptionState PdfFile::encryption_state() const noexcept {
 }
 
 std::shared_ptr<abstract::DecodedFile>
-PdfFile::decrypt(const std::string &password) const {
-  (void)password;
+PdfFile::decrypt([[maybe_unused]] const std::string &password) const {
   return nullptr;
 }
 
diff --git a/src/odr/internal/pdf/pdf_object_parser.cpp b/src/odr/internal/pdf/pdf_object_parser.cpp
index 82da2eeb..d7ba953e 100644
--- a/src/odr/internal/pdf/pdf_object_parser.cpp
+++ b/src/odr/internal/pdf/pdf_object_parser.cpp
@@ -230,9 +230,8 @@ bool ObjectParser::peek_null() const {
 }
 
 void ObjectParser::read_null() const {
-  const auto tmp = bumpnc<4>();
+  std::ignore = bumpnc<4>();
   // TODO check ignore case
-  (void)tmp;
 }
 
 bool ObjectParser::peek_boolean() const {
@@ -244,17 +243,15 @@ Boolean ObjectParser::read_boolean() const {
   const int_type c = geti();
 
   if (c == 't' || c == 'T') {
-    const auto tmp = bumpnc<4>();
+    std::ignore = bumpnc<4>();
     // TODO check ignore case
-    (void)tmp;
 
     return true;
   }
 
   if (c == 'f' || c == 'F') {
-    const auto tmp = bumpnc<5>();
+    std::ignore = bumpnc<5>();
     // TODO check ignore case
-    (void)tmp;
 
     return false;
   }
diff --git a/src/odr/internal/util/document_util.cpp b/src/odr/internal/util/document_util.cpp
index 48b6c704..b91413d2 100644
--- a/src/odr/internal/util/document_util.cpp
+++ b/src/odr/internal/util/document_util.cpp
@@ -27,33 +27,34 @@ extract_path_component(const abstract::ElementAdapter &element_adapter,
   }
 
   std::uint32_t distance = 0;
-  for (ElementHandle current =
+  for (ElementIdentifier current_id =
            element_adapter.element_previous_sibling(element_id);
-       !current.is_null(); current = current.adapter().element_previous_sibling(
-                               current.identifier)) {
+       current_id != null_element_id;
+       current_id = element_adapter.element_previous_sibling(current_id)) {
     ++distance;
   }
 
   return DocumentPath::Child(distance);
 }
 
-ElementHandle
+ElementIdentifier
 navigate_path_component(const abstract::ElementAdapter &element_adapter,
                         const ElementIdentifier element_id,
                         const DocumentPath::Component &component) {
   if (const auto *child = std::get_if<DocumentPath::Child>(&component);
       child != nullptr) {
-    ElementHandle result = element_adapter.element_first_child(element_id);
-    if (result.is_null()) {
+    ElementIdentifier result_id =
+        element_adapter.element_first_child(element_id);
+    if (result_id == null_element_id) {
       throw std::invalid_argument("child not found");
     }
     for (std::uint32_t i = 0; i < child->number(); ++i) {
-      result = result.adapter().element_next_sibling(result.identifier);
-      if (result.is_null()) {
+      result_id = element_adapter.element_next_sibling(result_id);
+      if (result_id == null_element_id) {
         throw std::invalid_argument("child not found");
       }
     }
-    return result;
+    return result_id;
   }
 
   if (const auto *cell = std::get_if<DocumentPath::Cell>(&component);
@@ -82,39 +83,39 @@ document::extract_path(const abstract::ElementAdapter &element_adapter,
 
   std::vector<DocumentPath::Component> reverse;
 
-  for (ElementHandle current = {&element_adapter, to_element_id};
-       current.identifier != from_element_id;) {
-    const ElementHandle parent =
-        current.adapter().element_parent(current.identifier);
-    if (parent.is_null()) {
+  for (ElementIdentifier current_id = to_element_id;
+       current_id != from_element_id;) {
+    const ElementIdentifier parent_id =
+        element_adapter.element_parent(current_id);
+    if (parent_id == null_element_id) {
       break;
     }
-    if (current.is_null()) {
+    if (current_id == null_element_id) {
       throw std::invalid_argument(
           "Element is not a descendant of the specified root.");
     }
 
     const DocumentPath::Component component =
-        extract_path_component(element_adapter, current.identifier);
+        extract_path_component(element_adapter, current_id);
     reverse.push_back(component);
 
-    current = parent;
+    current_id = parent_id;
   }
 
   std::ranges::reverse(reverse);
   return DocumentPath(std::move(reverse));
 }
 
-ElementHandle
+ElementIdentifier
 document::navigate_path(const abstract::ElementAdapter &element_adapter,
                         const ElementIdentifier from_element_id,
                         const DocumentPath &path) {
-  ElementHandle current{element_adapter, from_element_id};
+  ElementIdentifier current_id = from_element_id;
   for (const DocumentPath::Component &component : path) {
-    current = navigate_path_component(current.adapter(), current.identifier,
-                                      component);
+    current_id =
+        navigate_path_component(element_adapter, current_id, component);
   }
-  return current;
+  return current_id;
 }
 
 } // namespace odr::internal::util
diff --git a/src/odr/internal/util/document_util.hpp b/src/odr/internal/util/document_util.hpp
index 02a06c31..e4d6321b 100644
--- a/src/odr/internal/util/document_util.hpp
+++ b/src/odr/internal/util/document_util.hpp
@@ -16,8 +16,8 @@ DocumentPath extract_path(const abstract::ElementAdapter &element_adapter,
                           ElementIdentifier to_element_id,
                           ElementIdentifier from_element_id);
 
-ElementHandle navigate_path(const abstract::ElementAdapter &element_adapter,
-                            ElementIdentifier from_element_id,
-                            const DocumentPath &path);
+ElementIdentifier navigate_path(const abstract::ElementAdapter &element_adapter,
+                                ElementIdentifier from_element_id,
+                                const DocumentPath &path);
 
 } // namespace odr::internal::util::document