--- a/ThirdParty/scn/vtkscn/include/vtkscn/scan.h	2026-05-16 04:34:56.000000000 +0800
+++ b/ThirdParty/scn/vtkscn/include/vtkscn/scan.h	2026-06-03 13:36:49.000000000 +0800
@@ -6161,23 +6161,23 @@
     }
 
     /**
-     * \return `basic_scan_arg` at index `id`. Empty `basic_scan_arg` if
-     * there's no argument at index `id`.
+     * \return `basic_scan_arg` at index `arg_id`. Empty `basic_scan_arg` if
+     * there's no argument at index `arg_id`.
      */
-    SCN_NODISCARD constexpr basic_scan_arg<Context> get(std::size_t id) const
+    SCN_NODISCARD constexpr basic_scan_arg<Context> get(std::size_t arg_id) const
     {
         if (SCN_UNLIKELY(!is_packed())) {
-            if (SCN_LIKELY(id < max_size())) {
-                return m_args[id];
+            if (SCN_LIKELY(arg_id < max_size())) {
+                return m_args[arg_id];
             }
             return {};
         }
 
-        if (SCN_UNLIKELY(id >= detail::max_packed_args)) {
+        if (SCN_UNLIKELY(arg_id >= detail::max_packed_args)) {
             return {};
         }
 
-        const auto t = type(id);
+        const auto t = type(arg_id);
         if (SCN_UNLIKELY(t == detail::arg_type::none_type)) {
             return {};
         }
@@ -6185,10 +6185,10 @@
         basic_scan_arg<Context> arg;
         arg.m_type = t;
         if (is_only_builtin()) {
-            arg.m_value.ref_value = m_builtin_values[id];
+            arg.m_value.ref_value = m_builtin_values[arg_id];
         }
         else {
-            arg.m_value = m_values[id];
+            arg.m_value = m_values[arg_id];
         }
         return arg;
     }
@@ -6313,12 +6313,12 @@
             return 0;
         }
 
-        auto id = static_cast<size_t>(m_next_arg_id++);
-        do_check_arg_id(id);
-        return id;
+        auto arg_id = static_cast<size_t>(m_next_arg_id++);
+        do_check_arg_id(arg_id);
+        return arg_id;
     }
 
-    constexpr void check_arg_id(std::size_t id)
+    constexpr void check_arg_id(std::size_t arg_id)
     {
         if (SCN_UNLIKELY(m_next_arg_id > 0)) {
             on_error(
@@ -6326,7 +6326,7 @@
             return;
         }
         m_next_arg_id = -1;
-        do_check_arg_id(id);
+        do_check_arg_id(arg_id);
     }
 
     /**
@@ -6348,7 +6348,7 @@
     }
 
 protected:
-    constexpr void do_check_arg_id(size_t id);
+    constexpr void do_check_arg_id(size_t arg_id);
 
     std::basic_string_view<CharT> m_format;
     scan_expected<void> m_error{};
@@ -6748,9 +6748,9 @@
     {
         return m_num_args;
     }
-    SCN_NODISCARD constexpr arg_type get_arg_type(std::size_t id) const
+    SCN_NODISCARD constexpr arg_type get_arg_type(std::size_t arg_id) const
     {
-        return m_types[id];
+        return m_types[arg_id];
     }
 
     SCN_GCC_PUSH
@@ -6758,25 +6758,25 @@
 
     constexpr std::size_t next_arg_id()
     {
-        auto id = base::next_arg_id();
-        if (SCN_UNLIKELY(id >= static_cast<size_t>(m_num_args))) {
+        auto arg_id = base::next_arg_id();
+        if (SCN_UNLIKELY(arg_id >= static_cast<size_t>(m_num_args))) {
             this->on_error("Argument not found");
         }
-        return id;
+        return arg_id;
     }
 
-    constexpr void check_arg_id(std::size_t id)
+    constexpr void check_arg_id(std::size_t arg_id)
     {
-        base::check_arg_id(id);
-        if (SCN_UNLIKELY(id >= static_cast<size_t>(m_num_args))) {
+        base::check_arg_id(arg_id);
+        if (SCN_UNLIKELY(arg_id >= static_cast<size_t>(m_num_args))) {
             this->on_error("Argument not found");
         }
     }
     using base::check_arg_id;
 
-    constexpr void check_arg_can_be_read(std::size_t id)
+    constexpr void check_arg_can_be_read(std::size_t arg_id)
     {
-        auto type = get_arg_type(id);
+        auto type = get_arg_type(arg_id);
 
         if ((type == arg_type::narrow_string_view_type ||
              type == arg_type::wide_string_view_type) &&
@@ -6825,13 +6825,13 @@
 }  // namespace detail
 
 template <typename CharT>
-constexpr void basic_scan_parse_context<CharT>::do_check_arg_id(size_t id)
+constexpr void basic_scan_parse_context<CharT>::do_check_arg_id(size_t arg_id)
 {
     if (detail::is_constant_evaluated() &&
         (!SCN_GCC || SCN_GCC >= SCN_COMPILER(12, 0, 0))) {
         // The cast below will cause an error on gcc pre-12
         using parse_context_type = detail::compile_parse_context<CharT>;
-        if (static_cast<int>(id) >=
+        if (static_cast<int>(arg_id) >=
             static_cast<parse_context_type*>(this)->get_num_args()) {
             SCN_UNLIKELY_ATTR
             on_error("Argument not found");
@@ -7726,9 +7726,9 @@
         {
             arg_id = handler.on_arg_id();
         }
-        constexpr void operator()(std::size_t id)
+        constexpr void operator()(std::size_t idx)
         {
-            arg_id = handler.on_arg_id(id);
+            arg_id = handler.on_arg_id(idx);
         }
 
         constexpr void on_error(const char* msg)
@@ -8618,33 +8618,33 @@
     {
         return m_parse_context.next_arg_id();
     }
-    constexpr auto on_arg_id(std::size_t id)
+    constexpr auto on_arg_id(std::size_t arg_id)
     {
-        m_parse_context.check_arg_id(id);
-        return id;
+        m_parse_context.check_arg_id(arg_id);
+        return arg_id;
     }
 
-    constexpr void on_replacement_field(size_t id, const CharT*)
+    constexpr void on_replacement_field(size_t arg_id, const CharT*)
     {
-        m_parse_context.check_arg_can_be_read(id);
-        set_arg_as_read(id);
+        m_parse_context.check_arg_can_be_read(arg_id);
+        set_arg_as_read(arg_id);
 
-        if (m_types[id] == arg_type::narrow_regex_matches_type ||
-            m_types[id] == arg_type::wide_regex_matches_type) {
+        if (m_types[arg_id] == arg_type::narrow_regex_matches_type ||
+            m_types[arg_id] == arg_type::wide_regex_matches_type) {
             // clang-format off
             return on_error("Regular expression needs to be specified when reading regex_matches");
             // clang-format on
         }
     }
 
-    constexpr const CharT* on_format_specs(std::size_t id,
+    constexpr const CharT* on_format_specs(std::size_t arg_id,
                                            const CharT* begin,
                                            const CharT*)
     {
-        m_parse_context.check_arg_can_be_read(id);
-        set_arg_as_read(id);
+        m_parse_context.check_arg_can_be_read(arg_id);
+        set_arg_as_read(arg_id);
         m_parse_context.advance_to(begin);
-        return id < num_args ? m_parse_funcs[id](m_parse_context) : begin;
+        return arg_id < num_args ? m_parse_funcs[arg_id](m_parse_context) : begin;
     }
 
     constexpr void check_args_exhausted()
@@ -8674,15 +8674,15 @@
     }
 
 private:
-    constexpr void set_arg_as_read(size_t id)
+    constexpr void set_arg_as_read(size_t arg_id)
     {
-        if (id >= num_args) {
+        if (arg_id >= num_args) {
             return on_error("Invalid out-of-range argument ID");
         }
-        if (m_visited_args[id]) {
+        if (m_visited_args[arg_id]) {
             return on_error("Argument with this ID already scanned");
         }
-        m_visited_args[id] = true;
+        m_visited_args[arg_id] = true;
     }
 
     using parse_func = const CharT* (*)(parse_context_type&);
@@ -8860,10 +8860,10 @@
 template <typename Args>
 class scan_context_base {
 public:
-    /// Get argument at index `id`
-    constexpr auto arg(size_t id) const noexcept
+    /// Get argument at index `arg_id`
+    constexpr auto arg(size_t arg_id) const noexcept
     {
-        return m_args.get(id);
+        return m_args.get(arg_id);
     }
 
     constexpr const Args& args() const
