diff --git a/NEWS.md b/NEWS.md
index 0e1ecf093f4381..08c75c1a679085 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -119,7 +119,7 @@ releases.
   * 4.0.3 to [v4.0.4][RubyGems-v4.0.4], [v4.0.5][RubyGems-v4.0.5], [v4.0.6][RubyGems-v4.0.6], [v4.0.7][RubyGems-v4.0.7], [v4.0.8][RubyGems-v4.0.8], [v4.0.9][RubyGems-v4.0.9], [v4.0.10][RubyGems-v4.0.10], [v4.0.11][RubyGems-v4.0.11], [v4.0.12][RubyGems-v4.0.12], [v4.0.13][RubyGems-v4.0.13], [v4.0.14][RubyGems-v4.0.14], [v4.0.15][RubyGems-v4.0.15], [v4.0.16][RubyGems-v4.0.16]
 * bundler 4.1.0.dev
   * 4.0.3 to [v4.0.4][bundler-v4.0.4], [v4.0.5][bundler-v4.0.5], [v4.0.6][bundler-v4.0.6], [v4.0.7][bundler-v4.0.7], [v4.0.8][bundler-v4.0.8], [v4.0.9][bundler-v4.0.9], [v4.0.10][bundler-v4.0.10], [v4.0.11][bundler-v4.0.11], [v4.0.12][bundler-v4.0.12], [v4.0.13][bundler-v4.0.13], [v4.0.14][bundler-v4.0.14], [v4.0.15][bundler-v4.0.15], [v4.0.16][bundler-v4.0.16]
-* erb 6.0.5
+* erb 6.0.6
   * 6.0.1 to [v6.0.1.1][erb-v6.0.1.1], [v6.0.2][erb-v6.0.2], [v6.0.3][erb-v6.0.3], [v6.0.4][erb-v6.0.4], [v6.0.5][erb-v6.0.5]
 * error_highlight 0.7.2
 * ipaddr 1.2.9
diff --git a/lib/erb.rb b/lib/erb.rb
index a4b481a860eaec..0c4653d291f28d 100644
--- a/lib/erb.rb
+++ b/lib/erb.rb
@@ -53,7 +53,7 @@
 #
 # Here's how \ERB works:
 #
-# - You can create a *template*: a plain-text string that includes specially formatted *tags*..
+# - You can create a *template*: a plain-text string that includes specially formatted *tags*.
 # - You can create an \ERB object to store the template.
 # - You can call instance method ERB#result to get the *result*.
 #
@@ -63,10 +63,12 @@
 #   each begins with `'<%='`, ends with `'%>'`; contains a Ruby expression;
 #   in the result, the value of the expression replaces the entire tag:
 #
-#         template = 'The magic word is <%= magic_word %>.'
-#         erb = ERB.new(template)
-#         magic_word = 'xyzzy'
-#         erb.result(binding) # => "The magic word is xyzzy."
+#     ```
+#     template = 'The magic word is <%= magic_word %>.'
+#     erb = ERB.new(template)
+#     magic_word = 'xyzzy'
+#     erb.result(binding) # => "The magic word is xyzzy."
+#     ```
 #
 #     The above call to #result passes argument `binding`,
 #     which contains the binding of variable `magic_word` to its string value `'xyzzy'`.
@@ -74,21 +76,27 @@
 #     The below call to #result need not pass a binding,
 #     because its expression `Date::DAYNAMES` is globally defined.
 #
-#         ERB.new('Today is <%= Date::DAYNAMES[Date.today.wday] %>.').result # => "Today is Monday."
+#     ```
+#     ERB.new('Today is <%= Date::DAYNAMES[Date.today.wday] %>.').result # => "Today is Monday."
+#     ```
 #
 # - [Execution tags][execution tags]:
 #   each begins with `'<%'`, ends with `'%>'`; contains Ruby code to be executed:
 #
-#          template = '<% File.write("t.txt", "Some stuff.") %>'
-#          ERB.new(template).result
-#          File.read('t.txt') # => "Some stuff."
+#     ```
+#     template = '<% File.write("t.txt", "Some stuff.") %>'
+#     ERB.new(template).result
+#     File.read('t.txt') # => "Some stuff."
+#     ```
 #
 # - [Comment tags][comment tags]:
 #   each begins with `'<%#'`, ends with `'%>'`; contains comment text;
 #   in the result, the entire tag is omitted.
 #
-#          template = 'Some stuff;<%# Note to self: figure out what the stuff is. %> more stuff.'
-#          ERB.new(template).result # => "Some stuff; more stuff."
+#     ```
+#     template = 'Some stuff;<%# Note to self: figure out what the stuff is. %> more stuff.'
+#     ERB.new(template).result # => "Some stuff; more stuff."
+#     ```
 #
 # ## Some Simple Examples
 #
@@ -106,11 +114,10 @@
 # 1. A plain-text string is assigned to variable `template`.
 #    Its embedded [expression tag][expression tags] `'<%= Time.now %>'` includes a Ruby expression, `Time.now`.
 # 2. The string is put into a new \ERB object, and stored in variable `erb`.
-# 4. Method call `erb.result` generates a string that contains the run-time value of `Time.now`,
+# 3. Method call `erb.result` generates a string that contains the run-time value of `Time.now`,
 #    as computed at the time of the call.
 #
-# The
-# \ERB object may be re-used:
+# The \ERB object may be re-used:
 #
 # ```
 # erb.result
@@ -148,14 +155,14 @@
 # ## Bindings
 #
 # A call to method #result, which produces the formatted result string,
-# requires a [Binding object][binding object] as its argument.
+# requires a [`Binding` object][binding object] as its argument.
 #
 # The binding object provides the bindings for expressions in [expression tags][expression tags].
 #
 # There are three ways to provide the required binding:
 #
-# - [Default binding][default binding].
-# - [Local binding][local binding].
+# - [Default binding][default binding]
+# - [Local binding][local binding]
 # - [Augmented binding][augmented binding]
 #
 # ### Default Binding
@@ -174,6 +181,9 @@
 # The current process is <%= $0 %>.
 # TEMPLATE
 # puts ERB.new(template).result
+# ```
+#
+# ```
 # The Ruby copyright is "ruby - Copyright (C) 1993-2025 Yukihiro Matsumoto".
 # The current process is irb.
 # ```
@@ -183,7 +193,7 @@
 # ### Local Binding
 #
 # The default binding is *not* sufficient for an expression
-# that refers to a a constant or variable that is not defined there:
+# that refers to a constant or variable that is not defined there:
 #
 # ```
 # Foo = 1 # Defines local constant Foo.
@@ -209,6 +219,9 @@
 #
 # ```
 # puts erb.result(binding)
+# ```
+#
+# ```
 # The current value of constant Foo is 1.
 # The current value of variable foo is 2.
 # The Ruby copyright is "ruby - Copyright (C) 1993-2025 Yukihiro Matsumoto".
@@ -246,6 +259,9 @@
 # ```
 # hash = {bar: 3, baz: 4}
 # puts erb.result_with_hash(hash)
+# ```
+#
+# ```
 # The current value of variable bar is 3.
 # The current value of variable baz is 4.
 # The Ruby copyright is "ruby - Copyright (C) 1993-2025 Yukihiro Matsumoto".
@@ -268,7 +284,7 @@
 #
 # You can embed a Ruby expression in a template using an *expression tag*.
 #
-# Its syntax is `<%= _expression_ %>`,
+# Its syntax is `<%= expression %>`,
 # where *expression* is any valid Ruby expression.
 #
 # When you call method #result,
@@ -298,7 +314,7 @@
 #
 # You can embed Ruby executable code in template using an *execution tag*.
 #
-# Its syntax is `<% _code_ %>`,
+# Its syntax is `<% code %>`,
 # where *code* is any valid Ruby code.
 #
 # When you call method #result,
@@ -306,17 +322,17 @@
 # (generating no text in the result):
 #
 # ```
-# ERB.new('foo <% Dir.chdir("C:/") %> bar').result # => "foo  bar"
+# ERB.new('foo <% Dir.chdir(Dir.pwd) %> bar').result # => "foo  bar"
 # ```
 #
 # Whitespace before and after the embedded code is optional:
 #
 # ```
-# ERB.new('foo <%Dir.chdir("C:/")%> bar').result   # => "foo  bar"
+# ERB.new('foo <%Dir.chdir(Dir.pwd)%> bar').result   # => "foo  bar"
 # ```
 #
 # You can interleave text with execution tags to form a control structure
-# such as a conditional, a loop, or a `case` statements.
+# such as a conditional, a loop, or a `case` statement.
 #
 # Conditional:
 #
@@ -386,7 +402,7 @@
 # #### Shorthand Format for Execution Tags
 #
 # You can use keyword argument `trim_mode: '%'` to enable a shorthand format for execution tags;
-# this example uses the shorthand format `% _code_` instead of `<% _code_ %>`:
+# this example uses the shorthand format `% code` instead of `<% code %>`:
 #
 # ```
 # template = <<TEMPLATE
@@ -399,6 +415,9 @@
 #                'Document Modules',
 #                'Answer Questions on Ruby Talk' ]
 # puts erb.result(binding)
+# ```
+#
+# ```
 #   * Run Ruby Quiz
 #   * Document Modules
 #   * Answer Questions on Ruby Talk
@@ -419,12 +438,15 @@
 # <% end %>
 # TEMPLATE
 # ERB.new(template).result.lines.each {|line| puts line.inspect }
+# ```
+#
+# ```
 # "\n"
 # "3.4.5\n"
 # "\n"
 # ```
 #
-# You can give `trim_mode: '-'`, you can suppress each blank line
+# If you give `trim_mode: '-'`, you can suppress each blank line
 # whose source line ends with `-%>` (instead of `%>`):
 #
 # ```
@@ -434,6 +456,9 @@
 # <% end -%>
 # TEMPLATE
 # ERB.new(template, trim_mode: '-').result.lines.each {|line| puts line.inspect }
+# ```
+#
+# ```
 # "3.4.5\n"
 # ```
 #
@@ -460,6 +485,9 @@
 #
 # ```
 # ERB.new(template).result.lines.each {|line| puts line.inspect }
+# ```
+#
+# ```
 # "\n"
 # "3.4.5\n"
 # "foo \n"
@@ -471,6 +499,9 @@
 #
 # ```
 # ERB.new(template, trim_mode: '>').result.lines.each {|line| puts line.inspect }
+# ```
+#
+# ```
 # "3.4.5foo foo 3.4.5"
 # ```
 #
@@ -479,6 +510,9 @@
 #
 # ```
 # ERB.new(template, trim_mode: '<>').result.lines.each {|line| puts line.inspect }
+# ```
+#
+# ```
 # "3.4.5foo \n"
 # "foo 3.4.5\n"
 # ```
@@ -494,7 +528,7 @@
 # ### Comment Tags
 #
 # You can embed a comment in a template using a *comment tag*;
-# its syntax is `<%# _text_ %>`,
+# its syntax is `<%# text %>`,
 # where *text* is the text of the comment.
 #
 # When you call method #result,
@@ -570,7 +604,7 @@
 # erb.filename # => nil
 # erb.lineno   # => 0
 # erb.result
-# (erb):1:in '<main>': undefined local variable or method 'nosuch' for main (NameError)
+# # => (erb):1:in '<main>': undefined local variable or method 'nosuch' for main (NameError)
 # ```
 #
 # You can use methods #filename= and #lineno= to assign values
@@ -580,7 +614,7 @@
 # erb.filename = 't.txt'
 # erb.lineno = 555
 # erb.result
-# t.txt:556:in '<main>': undefined local variable or method 'nosuch' for main (NameError)
+# # => t.txt:556:in '<main>': undefined local variable or method 'nosuch' for main (NameError)
 # ```
 #
 # You can use method #location= to set both values:
@@ -588,7 +622,7 @@
 # ```
 # erb.location = ['u.txt', 999]
 # erb.result
-# u.txt:1000:in '<main>': undefined local variable or method 'nosuch' for main (NameError)
+# # => u.txt:1000:in '<main>': undefined local variable or method 'nosuch' for main (NameError)
 # ```
 #
 # ## Plain Text with Embedded Ruby
@@ -632,12 +666,14 @@
 #                'Answer Questions on Ruby Talk' ]
 # ```
 #
-# Finally, create the \ERB object and get the result
+# Finally, create the \ERB object and get the result:
 #
 # ```
 # erb = ERB.new(template, trim_mode: '%<>')
 # puts erb.result(binding)
+# ```
 #
+# ```
 # From:  James Edward Gray II <james@grayproductions.net>
 # To:  Community Spokesman <spokesman@ruby_community.org>
 # Subject:  Addressing Needs
@@ -683,7 +719,6 @@
 #   def get_binding
 #     binding
 #   end
-#
 # end
 # ```
 #
@@ -693,8 +728,7 @@
 # toy = Product.new('TZ-1002',
 #                   'Rubysapien',
 #                   "Geek's Best Friend!  Responds to Ruby commands...",
-#                   999.95
-#                   )
+#                   999.95)
 # toy.add_feature('Listens for verbal commands in the Ruby language!')
 # toy.add_feature('Ignores Perl, Java, and all C variants.')
 # toy.add_feature('Karate-Chop Action!!!')
@@ -733,6 +767,9 @@
 # ```
 # erb = ERB.new(template)
 # puts erb.result(toy.get_binding)
+# ```
+#
+# ```html
 # <html>
 #   <head><title>Ruby Toys -- Rubysapien</title></head>
 #   <body>
@@ -758,7 +795,7 @@
 # Various Ruby projects have their own template processors.
 # The Ruby Processing System [RDoc][rdoc], for example, has one that can be used elsewhere.
 #
-# Other popular template processors may found in the [Template Engines][template engines] page
+# Other popular template processors may be found in the [Template Engines][template engines] page
 # of the Ruby Toolbox.
 #
 # [%q literals]: https://docs.ruby-lang.org/en/master/syntax/literals_rdoc.html#label-25q-3A+Non-Interpolable+String+Literals
@@ -796,7 +833,7 @@ def self.version
   # :call-seq:
   #   ERB.new(template, trim_mode: nil, eoutvar: '_erbout')
   #
-  # Returns a new \ERB object containing the given string +template+.
+  # Returns a new \ERB object containing the given string `template`.
   #
   # For details about `template`, its embedded tags, and generated results, see ERB.
   #
@@ -877,13 +914,16 @@ def make_compiler(trim_mode)
   # In a more readable format:
   #
   # ```
-  #   # puts erb.src.split('; ')
-  #   # #coding:UTF-8
-  #   # _erbout = +''
-  #   # _erbout.<< "The time is ".freeze
-  #   # _erbout.<<(( Time.now ).to_s)
-  #   # _erbout.<< ".".freeze
-  #   # _erbout
+  # puts erb.src.split('; ')
+  # ```
+  #
+  # ```
+  # #coding:UTF-8
+  # _erbout = +''
+  # _erbout.<< "The time is ".freeze
+  # _erbout.<<(( Time.now ).to_s)
+  # _erbout.<< ".".freeze
+  # _erbout
   # ```
   #
   # Variable `_erbout` is used to store the intermediate results in the code;
@@ -893,6 +933,9 @@ def make_compiler(trim_mode)
   # ```
   # erb = ERB.new(template, eoutvar: '_foo')
   # puts erb.src.split('; ')
+  # ```
+  #
+  # ```
   # #coding:UTF-8
   # _foo = +''
   # _foo.<< "The time is ".freeze
@@ -955,6 +998,9 @@ def location=((filename, lineno))
   # template = ERB.new('')
   # compiler = template.make_compiler(nil)
   # pp compiler
+  # ```
+  #
+  # ```
   # #<ERB::Compiler:0x000001cff8a9aa00
   #  @insert_cmd="print",
   #  @percent=false,
@@ -962,8 +1008,14 @@ def location=((filename, lineno))
   #  @pre_cmd=[],
   #  @put_cmd="print",
   #  @trim_mode=nil>
+  # ```
+  #
+  # ```
   # template.set_eoutvar(compiler, '_foo') # => ["_foo"]
   # pp compiler
+  # ```
+  #
+  # ```
   # #<ERB::Compiler:0x000001cff8a9aa00
   #  @insert_cmd="_foo.<<",
   #  @percent=false,
@@ -1091,7 +1143,8 @@ def initialized_by_new? # :nodoc:
   # MyModule = Module.new
   # erb.def_method(MyModule, 'render(arg1, arg2)') # => :render
   # class MyClass; include MyModule; end
-  # MyClass.new.render('foo', 123)                      # => "foo 123"
+  # MyClass.new.render('foo', 123)
+  # # => "foo 123"
   # ```
   #
   def def_method(mod, methodname, fname='(ERB)')
@@ -1114,7 +1167,7 @@ def def_method(mod, methodname, fname='(ERB)')
   # ```
   # template = '<%= arg1 %> <%= arg2 %>'
   # erb = ERB.new(template)
-  # MyModule = template.def_module('render(arg1, arg2)')
+  # MyModule = erb.def_module('render(arg1, arg2)')
   # class MyClass
   #   include MyModule
   # end
@@ -1171,6 +1224,9 @@ def def_module(methodname='erb')
   #
   # ```
   # puts MySubClass.new('foo', 123).render
+  # ```
+  #
+  # ```html
   # <html>
   # <body>
   #   <p>foo</p>
diff --git a/lib/erb/version.rb b/lib/erb/version.rb
index ce233ab7434b2f..04908528c99d69 100644
--- a/lib/erb/version.rb
+++ b/lib/erb/version.rb
@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 class ERB
   # The string \ERB version.
-  VERSION = '6.0.5'
+  VERSION = '6.0.6'
 end
diff --git a/lib/prism/deprecated.rb b/lib/prism/deprecated.rb
new file mode 100644
index 00000000000000..332aed76dfacdf
--- /dev/null
+++ b/lib/prism/deprecated.rb
@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+# :markup: markdown
+#--
+# rbs_inline: enabled
+
+module Prism
+  class InNode < Node
+    #: () -> String
+    def in # :nodoc
+      in_keyword
+    end
+
+    #: () -> Location
+    def in_loc # :nodoc
+      in_keyword_loc
+    end
+
+    #: () -> String?
+    def then # :nodoc
+      then_keyword
+    end
+
+    #: () -> Location?
+    def then_loc # :nodoc
+      then_keyword_loc
+    end
+  end
+
+  class MatchPredicateNode < Node
+    #: () -> String
+    def operator # :nodoc
+      keyword
+    end
+
+    #: () -> Location
+    def operator_loc # :nodoc
+      keyword_loc
+    end
+  end
+
+  class UnlessNode < Node
+    #: () -> String
+    def keyword # :nodoc
+      unless_keyword
+    end
+
+    #: () -> Location
+    def keyword_loc # :nodoc
+      unless_keyword_loc
+    end
+  end
+
+  class UntilNode < Node
+    #: () -> String
+    def keyword # :nodoc
+      until_keyword
+    end
+
+    #: () -> Location
+    def keyword_loc # :nodoc
+      until_keyword_loc
+    end
+
+    #: () -> String?
+    def closing # :nodoc
+      end_keyword
+    end
+
+    #: () -> Location?
+    def closing_loc # :nodoc
+      end_keyword_loc
+    end
+  end
+
+  class WhenNode < Node
+    #: () -> String
+    def keyword # :nodoc
+      when_keyword
+    end
+
+    #: () -> Location
+    def keyword_loc # :nodoc
+      when_keyword_loc
+    end
+  end
+
+  class WhileNode < Node
+    #: () -> String
+    def keyword # :nodoc
+      while_keyword
+    end
+
+    #: () -> Location
+    def keyword_loc # :nodoc
+      while_keyword_loc
+    end
+
+    #: () -> String?
+    def closing # :nodoc
+      end_keyword
+    end
+
+    #: () -> Location?
+    def closing_loc # :nodoc
+      end_keyword_loc
+    end
+  end
+end
diff --git a/lib/prism/prism.gemspec b/lib/prism/prism.gemspec
index c18d68f4d8a5f9..709eb83a82ad39 100644
--- a/lib/prism/prism.gemspec
+++ b/lib/prism/prism.gemspec
@@ -109,6 +109,7 @@ Gem::Specification.new do |spec|
     "include/prism/version.h",
     "lib/prism.rb",
     "lib/prism/compiler.rb",
+    "lib/prism/deprecated.rb",
     "lib/prism/desugar_compiler.rb",
     "lib/prism/dispatcher.rb",
     "lib/prism/dot_visitor.rb",
@@ -178,6 +179,7 @@ Gem::Specification.new do |spec|
     "rbi/rubyvm/node_find.rbi",
     "sig/generated/prism.rbs",
     "sig/generated/prism/compiler.rbs",
+    "sig/generated/prism/deprecated.rbs",
     "sig/generated/prism/desugar_compiler.rbs",
     "sig/generated/prism/dispatcher.rbs",
     "sig/generated/prism/dot_visitor.rbs",
diff --git a/lib/prism/translation/parser/compiler.rb b/lib/prism/translation/parser/compiler.rb
index d11db12ae6a9a4..8e17b5b61e951f 100644
--- a/lib/prism/translation/parser/compiler.rb
+++ b/lib/prism/translation/parser/compiler.rb
@@ -970,17 +970,17 @@ def visit_in_node(node)
             guard = builder.if_guard(token(node.pattern.if_keyword_loc), visit(node.pattern.predicate))
           when UnlessNode
             pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
-            guard = builder.unless_guard(token(node.pattern.keyword_loc), visit(node.pattern.predicate))
+            guard = builder.unless_guard(token(node.pattern.unless_keyword_loc), visit(node.pattern.predicate))
           else
             pattern = within_pattern { |compiler| node.pattern.accept(compiler) }
           end
 
           builder.in_pattern(
-            token(node.in_loc),
+            token(node.in_keyword_loc),
             pattern,
             guard,
-            if (then_loc = node.then_loc)
-              token(then_loc)
+            if (then_keyword_loc = node.then_keyword_loc)
+              token(then_keyword_loc)
             else
               srange_semicolon(node.pattern.location.end_offset, node.statements&.location&.start_offset)
             end,
@@ -1291,7 +1291,7 @@ def visit_local_variable_target_node(node)
         def visit_match_predicate_node(node)
           builder.match_pattern_p(
             visit(node.value),
-            token(node.operator_loc),
+            token(node.keyword_loc),
             within_pattern { |compiler| node.pattern.accept(compiler) }
           )
         end
@@ -1802,9 +1802,9 @@ def visit_undef_node(node)
         # bar unless foo
         # ^^^^^^^^^^^^^^
         def visit_unless_node(node)
-          if node.keyword_loc.start_offset == node.location.start_offset
+          if node.unless_keyword_loc.start_offset == node.location.start_offset
             builder.condition(
-              token(node.keyword_loc),
+              token(node.unless_keyword_loc),
               visit(node.predicate),
               if (then_keyword_loc = node.then_keyword_loc)
                 token(then_keyword_loc)
@@ -1820,7 +1820,7 @@ def visit_unless_node(node)
             builder.condition_mod(
               visit(node.else_clause),
               visit(node.statements),
-              token(node.keyword_loc),
+              token(node.unless_keyword_loc),
               visit(node.predicate)
             )
           end
@@ -1832,24 +1832,24 @@ def visit_unless_node(node)
         # bar until foo
         # ^^^^^^^^^^^^^
         def visit_until_node(node)
-          if node.location.start_offset == node.keyword_loc.start_offset
+          if node.location.start_offset == node.until_keyword_loc.start_offset
             builder.loop(
               :until,
-              token(node.keyword_loc),
+              token(node.until_keyword_loc),
               visit(node.predicate),
               if (do_keyword_loc = node.do_keyword_loc)
                 token(do_keyword_loc)
               else
-                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset)
+                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset)
               end,
               visit(node.statements),
-              token(node.closing_loc)
+              token(node.end_keyword_loc)
             )
           else
             builder.loop_mod(
               :until,
               visit(node.statements),
-              token(node.keyword_loc),
+              token(node.until_keyword_loc),
               visit(node.predicate)
             )
           end
@@ -1859,7 +1859,7 @@ def visit_until_node(node)
         #           ^^^^^^^^^^^^^
         def visit_when_node(node)
           builder.when(
-            token(node.keyword_loc),
+            token(node.when_keyword_loc),
             visit_all(node.conditions),
             if (then_keyword_loc = node.then_keyword_loc)
               token(then_keyword_loc)
@@ -1876,24 +1876,24 @@ def visit_when_node(node)
         # bar while foo
         # ^^^^^^^^^^^^^
         def visit_while_node(node)
-          if node.location.start_offset == node.keyword_loc.start_offset
+          if node.location.start_offset == node.while_keyword_loc.start_offset
             builder.loop(
               :while,
-              token(node.keyword_loc),
+              token(node.while_keyword_loc),
               visit(node.predicate),
               if (do_keyword_loc = node.do_keyword_loc)
                 token(do_keyword_loc)
               else
-                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset)
+                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset)
               end,
               visit(node.statements),
-              token(node.closing_loc)
+              token(node.end_keyword_loc)
             )
           else
             builder.loop_mod(
               :while,
               visit(node.statements),
-              token(node.keyword_loc),
+              token(node.while_keyword_loc),
               visit(node.predicate)
             )
           end
diff --git a/lib/prism/translation/ripper.rb b/lib/prism/translation/ripper.rb
index 826a4e3f87c728..d9c1e69f920d48 100644
--- a/lib/prism/translation/ripper.rb
+++ b/lib/prism/translation/ripper.rb
@@ -2472,12 +2472,12 @@ def visit_in_node(node)
         # This is a special case where we're not going to call on_in directly
         # because we don't have access to the subsequent. Instead, we'll return
         # the component parts and let the parent node handle it.
-        bounds(node.in_loc)
+        bounds(node.in_keyword_loc)
         on_kw("in")
 
         pattern = visit_pattern_node(node.pattern)
-        if node.then_loc
-          bounds(node.then_loc)
+        if node.then_keyword_loc
+          bounds(node.then_keyword_loc)
           on_kw("then")
         end
         statements =
@@ -2984,7 +2984,7 @@ def visit_match_last_line_node(node)
       # ^^^^^^^^^^
       def visit_match_predicate_node(node)
         value = visit(node.value)
-        bounds(node.operator_loc)
+        bounds(node.keyword_loc)
         on_kw("in")
         pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
 
@@ -3887,7 +3887,7 @@ def visit_undef_node(node)
       # ^^^^^^^^^^^^^^
       def visit_unless_node(node)
         if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
-          bounds(node.keyword_loc)
+          bounds(node.unless_keyword_loc)
           on_kw("unless")
           predicate = visit(node.predicate)
           if node.then_keyword_loc
@@ -3912,7 +3912,7 @@ def visit_unless_node(node)
           on_unless(predicate, statements, else_clause)
         else
           statements = visit(node.statements.body.first)
-          bounds(node.keyword_loc)
+          bounds(node.unless_keyword_loc)
           on_kw("unless")
           predicate = visit(node.predicate)
 
@@ -3927,7 +3927,7 @@ def visit_unless_node(node)
       # bar until foo
       # ^^^^^^^^^^^^^
       def visit_until_node(node)
-        bounds(node.keyword_loc)
+        bounds(node.until_keyword_loc)
         on_kw("until")
 
         if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
@@ -3944,8 +3944,8 @@ def visit_until_node(node)
               visit(node.statements)
             end
 
-          if node.closing_loc
-            bounds(node.closing_loc)
+          if node.end_keyword_loc
+            bounds(node.end_keyword_loc)
             on_kw("end")
           end
 
@@ -3966,7 +3966,7 @@ def visit_when_node(node)
         # This is a special case where we're not going to call on_when directly
         # because we don't have access to the subsequent. Instead, we'll return
         # the component parts and let the parent node handle it.
-        bounds(node.keyword_loc)
+        bounds(node.when_keyword_loc)
         on_kw("when")
 
         conditions = visit_arguments(node.conditions)
@@ -3992,15 +3992,15 @@ def visit_when_node(node)
       # ^^^^^^^^^^^^^
       def visit_while_node(node)
         if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
-          bounds(node.keyword_loc)
+          bounds(node.while_keyword_loc)
           on_kw("while")
           if node.do_keyword_loc
             bounds(node.do_keyword_loc)
             on_kw("do")
           end
           predicate = visit(node.predicate)
-          if node.closing_loc
-            bounds(node.closing_loc)
+          if node.end_keyword_loc
+            bounds(node.end_keyword_loc)
             on_kw("end")
           end
           statements =
@@ -4015,7 +4015,7 @@ def visit_while_node(node)
           on_while(predicate, statements)
         else
           statements = visit(node.statements.body.first)
-          bounds(node.keyword_loc)
+          bounds(node.while_keyword_loc)
           on_kw("while")
           predicate = visit(node.predicate)
 
diff --git a/lib/time.rb b/lib/time.rb
index eaf98364d6710f..40f954ab274d5c 100644
--- a/lib/time.rb
+++ b/lib/time.rb
@@ -670,7 +670,7 @@ def rfc3339(time)
     if RUBY_VERSION >= "3.2"
       def _xmlschema(pattern, time) # :nodoc:
         if pattern.match?(time)
-          new(time)
+          new(time.strip)
         else
           raise ArgumentError.new("invalid xmlschema format: #{time.inspect}")
         end
diff --git a/libexec/erb b/libexec/erb
index de7d5888c346e8..76635be61d9236 100755
--- a/libexec/erb
+++ b/libexec/erb
@@ -89,7 +89,7 @@ class ERB
             set_encoding(Encoding::UTF_8, Encoding::UTF_8)
           when '-P'
             disable_percent = true
-          when '--help'
+          when '-h', '--help'
             raise ''
           when /\A-/
             raise "Unknown switch: #{switch.dump}"
diff --git a/prism/config.yml b/prism/config.yml
index a27cc829b9e7fb..21502ea8ca9e91 100644
--- a/prism/config.yml
+++ b/prism/config.yml
@@ -3018,9 +3018,9 @@ nodes:
       - name: statements
         type: node?
         kind: StatementsNode
-      - name: in_loc
+      - name: in_keyword_loc
         type: location
-      - name: then_loc
+      - name: then_keyword_loc
         type: location?
     comment: |
       Represents the use of the `in` keyword in a case statement.
@@ -3605,7 +3605,7 @@ nodes:
       - name: pattern
         type: node
         kind: pattern expression
-      - name: operator_loc
+      - name: keyword_loc
         type: location
     comment: |
       Represents the use of the modifier `in` operator.
@@ -4578,7 +4578,7 @@ nodes:
           ^^^^^^^^^^^^^^^^^^^^^^
   - name: UnlessNode
     fields:
-      - name: keyword_loc
+      - name: unless_keyword_loc
         type: location
         comment: |
           The Location of the `unless` keyword.
@@ -4642,11 +4642,11 @@ nodes:
   - name: UntilNode
     flags: LoopFlags
     fields:
-      - name: keyword_loc
+      - name: until_keyword_loc
         type: location
       - name: do_keyword_loc
         type: location?
-      - name: closing_loc
+      - name: end_keyword_loc
         type: location?
       - name: predicate
         type: node
@@ -4665,7 +4665,7 @@ nodes:
           ^^^^^^^^^^^^^^^^^^^^
   - name: WhenNode
     fields:
-      - name: keyword_loc
+      - name: when_keyword_loc
         type: location
       - name: conditions
         type: node[]
@@ -4685,11 +4685,11 @@ nodes:
   - name: WhileNode
     flags: LoopFlags
     fields:
-      - name: keyword_loc
+      - name: while_keyword_loc
         type: location
       - name: do_keyword_loc
         type: location?
-      - name: closing_loc
+      - name: end_keyword_loc
         type: location?
       - name: predicate
         type: node
diff --git a/test/test_time.rb b/test/test_time.rb
index a4df0b9ef4d9a1..200adc9a0b0428 100644
--- a/test/test_time.rb
+++ b/test/test_time.rb
@@ -245,6 +245,16 @@ def subtest_xmlschema_encode(method)
     assert_equal("-10000-01-01T00:00:00Z", Time.utc(-10000).__send__(method))
   end
 
+  def subtest_xmlschema_whitespaces(method)
+    t = Time.utc(1985, 4, 12, 23, 20, 50, 520000)
+    s = "  \t  1985-04-12T23:20:50.52Z"
+    assert_equal(t, Time.__send__(method, s))
+
+    t = Time.utc(1985, 4, 12, 23, 20, 50, 520000)
+    s = "1985-04-12T23:20:50.52Z  \t "
+    assert_equal(t, Time.__send__(method, s))
+  end
+
   def test_completion
     now = Time.local(2001,11,29,21,26,35)
     assert_equal(Time.local( 2001,11,29,21,12),