meta: ran format command.v0.0.3-release

Signed-off-by: Amlal <amlal@nekernel.org>

1 files changed, 374 insertions, 448 deletions

diff --git a/vendor/toml++/impl/path.inl b/vendor/toml++/impl/path.inl
index 999d651..c33632f 100644
--- a/vendor/toml++/impl/path.inl
+++ b/vendor/toml++/impl/path.inl
@@ -1,18 +1,18 @@
-//# This file is a part of toml++ and is subject to the the terms of the MIT license.
-//# Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
-//# See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
-// SPDX-License-Identifier: MIT
+// # This file is a part of toml++ and is subject to the the terms of the MIT license.
+// # Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
+// # See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
+//  SPDX-License-Identifier: MIT
 #pragma once
 
-//# {{
+// # {{
 #include "preprocessor.hpp"
 #if !TOML_IMPLEMENTATION
 #error This is an implementation-only header.
 #endif
-//# }}
+// # }}
 
-#include "path.hpp"
 #include "at_path.hpp"
+#include "path.hpp"
 #include "print_to_stream.hpp"
 TOML_DISABLE_WARNINGS;
 #if TOML_INT_CHARCONV
@@ -22,501 +22,427 @@ TOML_DISABLE_WARNINGS;
 TOML_ENABLE_WARNINGS;
 #include "header_start.hpp"
 
-//#=====================================================================================================================
-//# toml::path_component
-//#=====================================================================================================================
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component() //
-		: type_{ path_component_type::key }
-	{
-		store_key("", value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(size_t index) noexcept //
-		: type_(path_component_type::array_index)
-	{
-		store_index(index, value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(std::string_view key) //
-		: type_(path_component_type::key)
-	{
-		store_key(key, value_storage_);
-	}
+// #=====================================================================================================================
+// # toml::path_component
+// #=====================================================================================================================
+
+TOML_NAMESPACE_START {
+  TOML_EXTERNAL_LINKAGE
+  path_component::path_component()  //
+      : type_{path_component_type::key} {
+    store_key("", value_storage_);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component::path_component(size_t index) noexcept  //
+      : type_(path_component_type::array_index) {
+    store_index(index, value_storage_);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component::path_component(std::string_view key)  //
+      : type_(path_component_type::key) {
+    store_key(key, value_storage_);
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(std::wstring_view key) //
-		: path_component(impl::narrow(key))
-	{}
+  TOML_EXTERNAL_LINKAGE
+  path_component::path_component(std::wstring_view key)  //
+      : path_component(impl::narrow(key)) {}
 
 #endif
 
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(const path_component& pc) //
-		: type_{ pc.type_ }
-	{
-		if (type_ == path_component_type::array_index)
-			store_index(pc.index(), value_storage_);
-		else
-			store_key(pc.key(), value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(path_component && pc) noexcept //
-		: type_{ pc.type_ }
-	{
-		if (type_ == path_component_type::array_index)
-			store_index(pc.index_ref(), value_storage_);
-		else
-			store_key(std::move(pc.key_ref()), value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(const path_component& rhs)
-	{
-		if (type_ != rhs.type_)
-		{
-			destroy();
-
-			type_ = rhs.type_;
-			if (type_ == path_component_type::array_index)
-				store_index(rhs.index(), value_storage_);
-			else
-				store_key(rhs.key(), value_storage_);
-		}
-		else
-		{
-			if (type_ == path_component_type::array_index)
-				index_ref() = rhs.index();
-			else
-				key_ref() = rhs.key();
-		}
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(path_component&& rhs) noexcept
-	{
-		if (type_ != rhs.type_)
-		{
-			destroy();
-
-			type_ = rhs.type_;
-			if (type_ == path_component_type::array_index)
-				store_index(rhs.index(), value_storage_);
-			else
-				store_key(std::move(rhs.key_ref()), value_storage_);
-		}
-		else
-		{
-			if (type_ == path_component_type::array_index)
-				index_ref() = rhs.index();
-			else
-				key_ref() = std::move(rhs.key_ref());
-		}
-		return *this;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV path_component::equal(const path_component& lhs, const path_component& rhs) noexcept
-	{
-		// Different comparison depending on contents
-		if (lhs.type_ != rhs.type_)
-			return false;
-
-		if (lhs.type_ == path_component_type::array_index)
-			return lhs.index() == rhs.index();
-		else // path_component_type::key
-			return lhs.key() == rhs.key();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(size_t new_index) noexcept
-	{
-		// If currently a key, string will need to be destroyed regardless
-		destroy();
-
-		type_ = path_component_type::array_index;
-		store_index(new_index, value_storage_);
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(std::string_view new_key)
-	{
-		if (type_ == path_component_type::key)
-			key_ref() = new_key;
-		else
-		{
-			type_ = path_component_type::key;
-			store_key(new_key, value_storage_);
-		}
-
-		return *this;
-	}
+  TOML_EXTERNAL_LINKAGE
+  path_component::path_component(const path_component& pc)  //
+      : type_{pc.type_} {
+    if (type_ == path_component_type::array_index)
+      store_index(pc.index(), value_storage_);
+    else
+      store_key(pc.key(), value_storage_);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component::path_component(path_component && pc) noexcept  //
+      : type_{pc.type_} {
+    if (type_ == path_component_type::array_index)
+      store_index(pc.index_ref(), value_storage_);
+    else
+      store_key(std::move(pc.key_ref()), value_storage_);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component& path_component::operator=(const path_component& rhs) {
+    if (type_ != rhs.type_) {
+      destroy();
+
+      type_ = rhs.type_;
+      if (type_ == path_component_type::array_index)
+        store_index(rhs.index(), value_storage_);
+      else
+        store_key(rhs.key(), value_storage_);
+    } else {
+      if (type_ == path_component_type::array_index)
+        index_ref() = rhs.index();
+      else
+        key_ref() = rhs.key();
+    }
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component& path_component::operator=(path_component&& rhs) noexcept {
+    if (type_ != rhs.type_) {
+      destroy();
+
+      type_ = rhs.type_;
+      if (type_ == path_component_type::array_index)
+        store_index(rhs.index(), value_storage_);
+      else
+        store_key(std::move(rhs.key_ref()), value_storage_);
+    } else {
+      if (type_ == path_component_type::array_index)
+        index_ref() = rhs.index();
+      else
+        key_ref() = std::move(rhs.key_ref());
+    }
+    return *this;
+  }
+
+  TOML_PURE_GETTER
+  TOML_EXTERNAL_LINKAGE
+  bool TOML_CALLCONV path_component::equal(const path_component& lhs,
+                                           const path_component& rhs) noexcept {
+    // Different comparison depending on contents
+    if (lhs.type_ != rhs.type_) return false;
+
+    if (lhs.type_ == path_component_type::array_index)
+      return lhs.index() == rhs.index();
+    else  // path_component_type::key
+      return lhs.key() == rhs.key();
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component& path_component::operator=(size_t new_index) noexcept {
+    // If currently a key, string will need to be destroyed regardless
+    destroy();
+
+    type_ = path_component_type::array_index;
+    store_index(new_index, value_storage_);
+
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path_component& path_component::operator=(std::string_view new_key) {
+    if (type_ == path_component_type::key)
+      key_ref() = new_key;
+    else {
+      type_ = path_component_type::key;
+      store_key(new_key, value_storage_);
+    }
+
+    return *this;
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(std::wstring_view new_key)
-	{
-		if (type_ == path_component_type::key)
-			key_ref() = impl::narrow(new_key);
-		else
-		{
-			type_ = path_component_type::key;
-			store_key(impl::narrow(new_key), value_storage_);
-		}
+  TOML_EXTERNAL_LINKAGE
+  path_component& path_component::operator=(std::wstring_view new_key) {
+    if (type_ == path_component_type::key)
+      key_ref() = impl::narrow(new_key);
+    else {
+      type_ = path_component_type::key;
+      store_key(impl::narrow(new_key), value_storage_);
+    }
 
-		return *this;
-	}
+    return *this;
+  }
 
 #endif
 }
 TOML_NAMESPACE_END;
 
-//#=====================================================================================================================
-//# toml::path
-//#=====================================================================================================================
-
-TOML_ANON_NAMESPACE_START
-{
-	TOML_INTERNAL_LINKAGE
-	bool parse_path_into(std::string_view path_str, std::vector<path_component> & components)
-	{
-		using components_type = std::remove_reference_t<decltype(components)>;
-
-		const auto original_size = components.size();
-
-		static constexpr auto on_key = [](void* data, std::string_view key) -> bool
-		{
-			auto& comps = *static_cast<components_type*>(data);
-			comps.emplace_back(key);
-			return true;
-		};
-
-		static constexpr auto on_index = [](void* data, size_t index) -> bool
-		{
-			auto& comps = *static_cast<components_type*>(data);
-			comps.emplace_back(index);
-			return true;
-		};
-
-		if (!impl::parse_path(path_str, &components, on_key, on_index))
-		{
-			components.resize(original_size);
-			return false;
-		}
-
-		return true;
-	}
+// #=====================================================================================================================
+// # toml::path
+// #=====================================================================================================================
+
+TOML_ANON_NAMESPACE_START {
+  TOML_INTERNAL_LINKAGE
+  bool parse_path_into(std::string_view path_str, std::vector<path_component> & components) {
+    using components_type = std::remove_reference_t<decltype(components)>;
+
+    const auto original_size = components.size();
+
+    static constexpr auto on_key = [](void* data, std::string_view key) -> bool {
+      auto& comps = *static_cast<components_type*>(data);
+      comps.emplace_back(key);
+      return true;
+    };
+
+    static constexpr auto on_index = [](void* data, size_t index) -> bool {
+      auto& comps = *static_cast<components_type*>(data);
+      comps.emplace_back(index);
+      return true;
+    };
+
+    if (!impl::parse_path(path_str, &components, on_key, on_index)) {
+      components.resize(original_size);
+      return false;
+    }
+
+    return true;
+  }
 }
 TOML_ANON_NAMESPACE_END;
 
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	void path::print_to(std::ostream & os) const
-	{
-		bool root = true;
-		for (const auto& component : components_)
-		{
-			if (component.type() == path_component_type::key) // key
-			{
-				if (!root)
-					impl::print_to_stream(os, '.');
-				impl::print_to_stream(os, component.key());
-			}
-			else if (component.type() == path_component_type::array_index) // array
-			{
-				impl::print_to_stream(os, '[');
-				impl::print_to_stream(os, component.index());
-				impl::print_to_stream(os, ']');
-			}
-			root = false;
-		}
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV path::equal(const path& lhs, const path& rhs) noexcept
-	{
-		return lhs.components_ == rhs.components_;
-	}
-
-	//#=== constructors =================================================
-
-	TOML_EXTERNAL_LINKAGE
-	path::path(std::string_view str) //
-	{
-		TOML_ANON_NAMESPACE::parse_path_into(str, components_);
-	}
+TOML_NAMESPACE_START {
+  TOML_EXTERNAL_LINKAGE
+  void path::print_to(std::ostream & os) const {
+    bool root = true;
+    for (const auto& component : components_) {
+      if (component.type() == path_component_type::key)  // key
+      {
+        if (!root) impl::print_to_stream(os, '.');
+        impl::print_to_stream(os, component.key());
+      } else if (component.type() == path_component_type::array_index)  // array
+      {
+        impl::print_to_stream(os, '[');
+        impl::print_to_stream(os, component.index());
+        impl::print_to_stream(os, ']');
+      }
+      root = false;
+    }
+  }
+
+  TOML_PURE_GETTER
+  TOML_EXTERNAL_LINKAGE
+  bool TOML_CALLCONV path::equal(const path& lhs, const path& rhs) noexcept {
+    return lhs.components_ == rhs.components_;
+  }
+
+  // #=== constructors =================================================
+
+  TOML_EXTERNAL_LINKAGE
+  path::path(std::string_view str)  //
+  {
+    TOML_ANON_NAMESPACE::parse_path_into(str, components_);
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	path::path(std::wstring_view str) //
-		: path(impl::narrow(str))
-	{}
+  TOML_EXTERNAL_LINKAGE
+  path::path(std::wstring_view str)  //
+      : path(impl::narrow(str)) {}
 
 #endif
 
-	//#=== assignment =================================================
+  // #=== assignment =================================================
 
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator=(std::string_view rhs)
-	{
-		components_.clear();
-		TOML_ANON_NAMESPACE::parse_path_into(rhs, components_);
-		return *this;
-	}
+  TOML_EXTERNAL_LINKAGE
+  path& path::operator=(std::string_view rhs) {
+    components_.clear();
+    TOML_ANON_NAMESPACE::parse_path_into(rhs, components_);
+    return *this;
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator=(std::wstring_view rhs)
-	{
-		return assign(impl::narrow(rhs));
-	}
+  TOML_EXTERNAL_LINKAGE
+  path& path::operator=(std::wstring_view rhs) {
+    return assign(impl::narrow(rhs));
+  }
 
 #endif
 
-	//#=== appending =================================================
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(const path& rhs)
-	{
-		components_.insert(components_.cend(), rhs.begin(), rhs.end());
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(path&& rhs)
-	{
-		components_.insert(components_.end(),
-						   std::make_move_iterator(rhs.components_.begin()),
-						   std::make_move_iterator(rhs.components_.end()));
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(std::string_view str)
-	{
-		TOML_ANON_NAMESPACE::parse_path_into(str, components_);
-		return *this;
-	}
+  // #=== appending =================================================
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::operator+=(const path& rhs) {
+    components_.insert(components_.cend(), rhs.begin(), rhs.end());
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::operator+=(path&& rhs) {
+    components_.insert(components_.end(), std::make_move_iterator(rhs.components_.begin()),
+                       std::make_move_iterator(rhs.components_.end()));
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::operator+=(std::string_view str) {
+    TOML_ANON_NAMESPACE::parse_path_into(str, components_);
+    return *this;
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(std::wstring_view str)
-	{
-		return *this += impl::narrow(str);
-	}
+  TOML_EXTERNAL_LINKAGE
+  path& path::operator+=(std::wstring_view str) {
+    return *this += impl::narrow(str);
+  }
 
 #endif
 
-	//#=== prepending =================================================
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(const path& source)
-	{
-		components_.insert(components_.begin(), source.components_.begin(), source.components_.end());
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(path && source)
-	{
-		components_.insert(components_.begin(),
-						   std::make_move_iterator(source.components_.begin()),
-						   std::make_move_iterator(source.components_.end()));
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(std::string_view source)
-	{
-		return prepend(path{ source });
-	}
+  // #=== prepending =================================================
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::prepend(const path& source) {
+    components_.insert(components_.begin(), source.components_.begin(), source.components_.end());
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::prepend(path && source) {
+    components_.insert(components_.begin(), std::make_move_iterator(source.components_.begin()),
+                       std::make_move_iterator(source.components_.end()));
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::prepend(std::string_view source) {
+    return prepend(path{source});
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(std::wstring_view source)
-	{
-		return prepend(impl::narrow(source));
-	}
+  TOML_EXTERNAL_LINKAGE
+  path& path::prepend(std::wstring_view source) {
+    return prepend(impl::narrow(source));
+  }
 
 #endif
 
-	//#=== string conversion =================================================
+  // #=== string conversion =================================================
 
-	TOML_EXTERNAL_LINKAGE
-	std::string path::str() const
-	{
-		if (empty())
-			return "";
+  TOML_EXTERNAL_LINKAGE
+  std::string path::str() const {
+    if (empty()) return "";
 
-		std::ostringstream ss;
-		print_to(ss);
-		return std::move(ss).str();
-	}
+    std::ostringstream ss;
+    print_to(ss);
+    return std::move(ss).str();
+  }
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-	TOML_EXTERNAL_LINKAGE
-	std::wstring path::wide_str() const
-	{
-		return impl::widen(str());
-	}
+  TOML_EXTERNAL_LINKAGE
+  std::wstring path::wide_str() const {
+    return impl::widen(str());
+  }
 
 #endif
 
-	//#=== equality and comparison =================================================
-
-	TOML_EXTERNAL_LINKAGE
-	void path::clear() noexcept
-	{
-		components_.clear();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::truncate(size_t n)
-	{
-		n = n > components_.size() ? components_.size() : n;
-
-		auto it_end = components_.end();
-		components_.erase(it_end - static_cast<int>(n), it_end);
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::truncated(size_t n) const
-	{
-		path truncated_path{};
-
-		n = n > components_.size() ? components_.size() : n;
-
-		// Copy all components except one
-		// Need at least two path components to have a parent, since if there is
-		// only one path component, the parent is the root/null path ""
-		truncated_path.components_.insert(truncated_path.components_.begin(),
-										  components_.begin(),
-										  components_.end() - static_cast<int>(n));
-
-		return truncated_path;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::parent() const
-	{
-		return truncated(1);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::leaf(size_t n) const
-	{
-		path leaf_path{};
-
-		n = n > components_.size() ? components_.size() : n;
-
-		if (n > 0)
-		{
-			leaf_path.components_.insert(leaf_path.components_.begin(),
-										 components_.end() - static_cast<int>(n),
-										 components_.end());
-		}
-
-		return leaf_path;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::subpath(std::vector<path_component>::const_iterator start,
-					   std::vector<path_component>::const_iterator end) const
-	{
-		if (start >= end)
-			return {};
-
-		path subpath;
-		subpath.components_.insert(subpath.components_.begin(), start, end);
-		return subpath;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::subpath(size_t start, size_t length) const
-	{
-		return subpath(begin() + static_cast<int>(start), begin() + static_cast<int>(start + length));
-	}
+  // #=== equality and comparison =================================================
+
+  TOML_EXTERNAL_LINKAGE
+  void path::clear() noexcept {
+    components_.clear();
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path& path::truncate(size_t n) {
+    n = n > components_.size() ? components_.size() : n;
+
+    auto it_end = components_.end();
+    components_.erase(it_end - static_cast<int>(n), it_end);
+
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path path::truncated(size_t n) const {
+    path truncated_path{};
+
+    n = n > components_.size() ? components_.size() : n;
+
+    // Copy all components except one
+    // Need at least two path components to have a parent, since if there is
+    // only one path component, the parent is the root/null path ""
+    truncated_path.components_.insert(truncated_path.components_.begin(), components_.begin(),
+                                      components_.end() - static_cast<int>(n));
+
+    return truncated_path;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path path::parent() const {
+    return truncated(1);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path path::leaf(size_t n) const {
+    path leaf_path{};
+
+    n = n > components_.size() ? components_.size() : n;
+
+    if (n > 0) {
+      leaf_path.components_.insert(leaf_path.components_.begin(),
+                                   components_.end() - static_cast<int>(n), components_.end());
+    }
+
+    return leaf_path;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path path::subpath(std::vector<path_component>::const_iterator start,
+                     std::vector<path_component>::const_iterator end) const {
+    if (start >= end) return {};
+
+    path subpath;
+    subpath.components_.insert(subpath.components_.begin(), start, end);
+    return subpath;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  path path::subpath(size_t start, size_t length) const {
+    return subpath(begin() + static_cast<int>(start), begin() + static_cast<int>(start + length));
+  }
 }
 TOML_NAMESPACE_END;
 
-//#=====================================================================================================================
-//# at_path() overloads for toml::path
-//#=====================================================================================================================
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept
-	{
-		// early-exit sanity-checks
-		if (root.is_value())
-			return {};
-		if (auto tbl = root.as_table(); tbl && tbl->empty())
-			return {};
-		if (auto arr = root.as_array(); arr && arr->empty())
-			return {};
-
-		node* current = &root;
-
-		for (const auto& component : path)
-		{
-			auto type = component.type();
-			if (type == path_component_type::array_index)
-			{
-				const auto current_array = current->as<array>();
-				if (!current_array)
-					return {}; // not an array, using array index doesn't work
-
-				current = current_array->get(component.index());
-			}
-			else if (type == path_component_type::key)
-			{
-				const auto current_table = current->as<table>();
-				if (!current_table)
-					return {};
-
-				current = current_table->get(component.key());
-			}
-			else
-			{
-				// Error: invalid component
-				return {};
-			}
-
-			if (!current)
-				return {}; // not found
-		}
-
-		return node_view{ current };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept
-	{
-		return node_view<const node>{ at_path(const_cast<node&>(root), path).node() };
-	}
+// #=====================================================================================================================
+// # at_path() overloads for toml::path
+// #=====================================================================================================================
+
+TOML_NAMESPACE_START {
+  TOML_EXTERNAL_LINKAGE
+  node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept {
+    // early-exit sanity-checks
+    if (root.is_value()) return {};
+    if (auto tbl = root.as_table(); tbl && tbl->empty()) return {};
+    if (auto arr = root.as_array(); arr && arr->empty()) return {};
+
+    node* current = &root;
+
+    for (const auto& component : path) {
+      auto type = component.type();
+      if (type == path_component_type::array_index) {
+        const auto current_array = current->as<array>();
+        if (!current_array) return {};  // not an array, using array index doesn't work
+
+        current = current_array->get(component.index());
+      } else if (type == path_component_type::key) {
+        const auto current_table = current->as<table>();
+        if (!current_table) return {};
+
+        current = current_table->get(component.key());
+      } else {
+        // Error: invalid component
+        return {};
+      }
+
+      if (!current) return {};  // not found
+    }
+
+    return node_view{current};
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept {
+    return node_view<const node>{at_path(const_cast<node&>(root), path).node()};
+  }
 }
 TOML_NAMESPACE_END;