brakeman 7.0.1 → 7.1.0

data/bundle/ruby/{3.1.0/gems/haml-5.2.2 → 3.2.0/gems/haml-6.3.0}/lib/haml/util.rb

@@ -14,6 +14,24 @@ module Haml
   module Util
     extend self
 
+    begin # Ruby 3.2+ or ERB 4+
+      require 'erb/escape'
+
+      define_singleton_method(:escape_html, ERB::Escape.instance_method(:html_escape))
+    rescue LoadError
+      require 'cgi/escape'
+
+      def self.escape_html(html)
+        CGI.escapeHTML(html.to_s)
+      end
+    end
+
+    # TODO: Remove unescape_interpolation's workaround and get rid of `respond_to?`.
+    def self.escape_html_safe(html)
+      html = html.to_s
+      (html.respond_to?(:html_safe?) && html.html_safe?) ? html : escape_html(html)
+    end
+
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -35,20 +53,6 @@ module Haml
       false
     end
 
-    # Returns the given text, marked as being HTML-safe.
-    # With older versions of the Rails XSS-safety mechanism,
-    # this destructively modifies the HTML-safety of `text`.
-    #
-    # It only works if you are using ActiveSupport or the parameter `text`
-    # implements the #html_safe method.
-    #
-    # @param text [String, nil]
-    # @return [String, nil] `text`, marked as HTML-safe
-    def html_safe(text)
-      return unless text
-      text.html_safe
-    end
-
     # Checks that the encoding of a string is valid
     # and cleans up potential encoding gotchas like the UTF-8 BOM.
     # If it's not, yields an error string describing the invalid character
@@ -214,7 +218,7 @@ MSG
           end
           content = eval("\"#{interpolated}\"")
           content = "#{char}#{content}" if char == '@' || char == '$'
-          content = "Haml::Helpers.html_escape((#{content}))" if escape_html
+          content = "Haml::Util.escape_html_safe((#{content}).to_s)" if escape_html
 
           res << "\#{#{content}}"
         end

data/bundle/ruby/{3.1.0/gems/haml-5.2.2 → 3.2.0/gems/haml-6.3.0}/lib/haml/version.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module Haml
-  VERSION = "5.2.2"
+  VERSION = '6.3.0'
 end

data/bundle/ruby/3.2.0/gems/haml-6.3.0/lib/haml/whitespace.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Haml
+  class Whitespace < Temple::Filter
+    def on_whitespace
+      [:static, "\n"]
+    end
+  end
+end

data/bundle/ruby/3.2.0/gems/haml-6.3.0/lib/haml.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require 'haml/engine'
+require 'haml/error'
+require 'haml/version'
+require 'haml/template'
+
+if File.basename($0) != 'haml'
+  begin
+    require 'rails'
+    require 'haml/railtie'
+  rescue LoadError
+  end
+end

data/bundle/ruby/3.2.0/gems/parallel-1.27.0/lib/parallel/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Parallel
+  VERSION = Version = '1.27.0' # rubocop:disable Naming/ConstantName
+end

data/bundle/ruby/{3.1.0/gems/parallel-1.26.3 → 3.2.0/gems/parallel-1.27.0}/lib/parallel.rb

@@ -255,7 +255,7 @@ module Parallel
 
       if options[:in_processes] && options[:in_threads]
         raise ArgumentError, "Please specify only one of `in_processes` or `in_threads`."
-      elsif RUBY_PLATFORM =~ (/java/) && !(options[:in_processes])
+      elsif RUBY_PLATFORM =~ (/java/) && !options[:in_processes]
         method = :in_threads
         size = options[method] || processor_count
       elsif options[:in_threads]

data/bundle/ruby/{3.1.0/gems/reline-0.6.0 → 3.2.0/gems/reline-0.6.1}/lib/reline/io/ansi.rb

@@ -2,18 +2,6 @@ require 'io/console'
 require 'io/wait'
 
 class Reline::ANSI < Reline::IO
-  CAPNAME_KEY_BINDINGS = {
-    'khome' => :ed_move_to_beg,
-    'kend'  => :ed_move_to_end,
-    'kdch1' => :key_delete,
-    'kpp' => :ed_search_prev_history,
-    'knp' => :ed_search_next_history,
-    'kcuu1' => :ed_prev_history,
-    'kcud1' => :ed_next_history,
-    'kcuf1' => :ed_next_char,
-    'kcub1' => :ed_prev_char,
-  }
-
   ANSI_CURSOR_KEY_BINDINGS = {
     # Up
     'A' => [:ed_prev_history, {}],
@@ -217,9 +205,7 @@ class Reline::ANSI < Reline::IO
           break
         end
       end
-      buf.chars.reverse_each do |ch|
-        stdin.ungetc ch
-      end
+      @buf.concat buf.bytes
     end
     [match[:column].to_i - 1, match[:row].to_i - 1] if match
   end
@@ -309,6 +295,13 @@ class Reline::ANSI < Reline::IO
     # Signal.trap may raise an ArgumentError if the platform doesn't support the signal.
   end
 
+  def read_single_char(keyseq_timeout)
+    # Disable intr to read `C-c` `C-z` `C-\` for quoted insert
+    @input.raw(intr: false) do
+      super
+    end
+  end
+
   def prep
     # Enable bracketed paste
     write "\e[?2004h" if Reline.core.config.enable_bracketed_paste && both_tty?

data/bundle/ruby/{3.1.0/gems/reline-0.6.0 → 3.2.0/gems/reline-0.6.1}/lib/reline/key_stroke.rb

@@ -56,8 +56,8 @@ class Reline::KeyStroke
     if func.is_a?(Array)
       # Perform simple macro expansion for single byte key bindings.
       # Multibyte key bindings and recursive macro expansion are not supported yet.
-      marco = func.pack('c*').force_encoding(@encoding)
-      keys = marco.chars.map do |c|
+      macro = func.pack('c*').force_encoding(@encoding)
+      keys = macro.chars.map do |c|
         f = key_mapping.get(c.bytes)
         Reline::Key.new(c, f.is_a?(Symbol) ? f : :ed_insert, false)
       end

data/bundle/ruby/{3.1.0/gems/reline-0.6.0 → 3.2.0/gems/reline-0.6.1}/lib/reline/line_editor.rb

@@ -250,8 +250,8 @@ class Reline::LineEditor
     @resized = false
     @cache = {}
     @rendered_screen = RenderedScreen.new(base_y: 0, lines: [], cursor_y: 0)
-    @input_lines = [[[""], 0, 0]]
-    @input_lines_position = 0
+    @undo_redo_history = [[[""], 0, 0]]
+    @undo_redo_index = 0
     @restoring = false
     @prev_action_state = NullActionState
     @next_action_state = NullActionState
@@ -542,6 +542,7 @@ class Reline::LineEditor
       Reline::IOGate.show_cursor
     end
     Reline::IOGate.move_cursor_column new_cursor_x
+    new_cursor_y = new_cursor_y.clamp(0, screen_height - 1)
     Reline::IOGate.move_cursor_down new_cursor_y - cursor_y
     @rendered_screen.cursor_y = new_cursor_y
   ensure
@@ -911,28 +912,36 @@ class Reline::LineEditor
     )
   end
 
-  private def run_for_operators(key, method_symbol, &block)
+  private def run_for_operators(key, method_symbol)
+    # Reject multibyte input (converted to ed_insert) in vi_command mode
+    return if method_symbol == :ed_insert && @config.editing_mode_is?(:vi_command) && !@waiting_proc
+
+    if ARGUMENT_DIGIT_METHODS.include?(method_symbol) && !@waiting_proc
+      wrap_method_call(method_symbol, key, false)
+      return
+    end
+
     if @vi_waiting_operator
-      if VI_MOTIONS.include?(method_symbol)
+      if @waiting_proc || VI_MOTIONS.include?(method_symbol)
         old_byte_pointer = @byte_pointer
         @vi_arg = (@vi_arg || 1) * @vi_waiting_operator_arg
-        block.(true)
+        wrap_method_call(method_symbol, key, true)
         unless @waiting_proc
           byte_pointer_diff = @byte_pointer - old_byte_pointer
           @byte_pointer = old_byte_pointer
-          method_obj = method(@vi_waiting_operator)
-          wrap_method_call(@vi_waiting_operator, method_obj, byte_pointer_diff)
+          __send__(@vi_waiting_operator, byte_pointer_diff)
           cleanup_waiting
         end
       else
         # Ignores operator when not motion is given.
-        block.(false)
+        wrap_method_call(method_symbol, key, false)
         cleanup_waiting
       end
-      @vi_arg = nil
     else
-      block.(false)
+      wrap_method_call(method_symbol, key, false)
     end
+    @vi_arg = nil
+    @kill_ring.process
   end
 
   private def argumentable?(method_obj)
@@ -945,20 +954,23 @@ class Reline::LineEditor
     method_obj and method_obj.parameters.any? { |param| param[0] == :key and param[1] == :inclusive }
   end
 
-  def wrap_method_call(method_symbol, method_obj, key, with_operator = false)
-    if @config.editing_mode_is?(:emacs, :vi_insert) and @vi_waiting_operator.nil?
-      not_insertion = method_symbol != :ed_insert
-      process_insert(force: not_insertion)
+  def wrap_method_call(method_symbol, key, with_operator)
+    if @waiting_proc
+      @waiting_proc.call(key)
+      return
     end
+
+    return unless respond_to?(method_symbol, true)
+    method_obj = method(method_symbol)
     if @vi_arg and argumentable?(method_obj)
-      if with_operator and inclusive?(method_obj)
-        method_obj.(key, arg: @vi_arg, inclusive: true)
+      if inclusive?(method_obj)
+        method_obj.(key, arg: @vi_arg, inclusive: with_operator)
       else
         method_obj.(key, arg: @vi_arg)
       end
     else
-      if with_operator and inclusive?(method_obj)
-        method_obj.(key, inclusive: true)
+      if inclusive?(method_obj)
+        method_obj.(key, inclusive: with_operator)
       else
         method_obj.(key)
       end
@@ -984,50 +996,9 @@ class Reline::LineEditor
       cleanup_waiting unless VI_WAITING_ACCEPT_METHODS.include?(method_symbol) || VI_MOTIONS.include?(method_symbol)
     end
 
-    if @waiting_proc
-      old_byte_pointer = @byte_pointer
-      @waiting_proc.call(key)
-      if @vi_waiting_operator
-        byte_pointer_diff = @byte_pointer - old_byte_pointer
-        @byte_pointer = old_byte_pointer
-        method_obj = method(@vi_waiting_operator)
-        wrap_method_call(@vi_waiting_operator, method_obj, byte_pointer_diff)
-        cleanup_waiting
-      end
-      @kill_ring.process
-      return
-    end
-
-    # Reject multibyte input (converted to ed_insert) in vi_command mode
-    return if method_symbol == :ed_insert && @config.editing_mode_is?(:vi_command)
+    process_insert(force: method_symbol != :ed_insert)
 
-    if method_symbol and respond_to?(method_symbol, true)
-      method_obj = method(method_symbol)
-    end
-    if @vi_arg
-      if ARGUMENT_DIGIT_METHODS.include?(method_symbol)
-        ed_argument_digit(key)
-      else
-        if argumentable?(method_obj)
-          run_for_operators(key, method_symbol) do |with_operator|
-            wrap_method_call(method_symbol, method_obj, key, with_operator)
-          end
-        elsif method_obj
-          wrap_method_call(method_symbol, method_obj, key)
-        end
-        @kill_ring.process
-        @vi_arg = nil
-      end
-    elsif method_obj
-      if method_symbol == :ed_argument_digit
-        wrap_method_call(method_symbol, method_obj, key)
-      else
-        run_for_operators(key, method_symbol) do |with_operator|
-          wrap_method_call(method_symbol, method_obj, key, with_operator)
-        end
-      end
-      @kill_ring.process
-    end
+    run_for_operators(key, method_symbol)
   end
 
   def update(key)
@@ -1041,7 +1012,7 @@ class Reline::LineEditor
   end
 
   def input_key(key)
-    save_old_buffer
+    old_buffer_of_lines = @buffer_of_lines.dup
     @config.reset_oneshot_key_bindings
     if key.char.nil?
       process_insert(force: true)
@@ -1049,11 +1020,8 @@ class Reline::LineEditor
       finish
       return
     end
-    @dialogs.each do |dialog|
-      if key.method_symbol == dialog.name
-        return
-      end
-    end
+    return if @dialogs.any? { |dialog| dialog.name == key.method_symbol }
+
     @completion_occurs = false
 
     process_key(key.char, key.method_symbol)
@@ -1069,7 +1037,9 @@ class Reline::LineEditor
       @completion_journey_state = nil
     end
 
-    push_input_lines unless @restoring
+    modified = old_buffer_of_lines != @buffer_of_lines
+
+    push_undo_redo(modified) unless @restoring
     @restoring = false
 
     if @in_pasting
@@ -1077,7 +1047,6 @@ class Reline::LineEditor
       return
     end
 
-    modified = @old_buffer_of_lines != @buffer_of_lines
     if !@completion_occurs && modified && !@config.disable_completion && @config.autocompletion
       # Auto complete starts only when edited
       process_insert(force: true)
@@ -1086,26 +1055,17 @@ class Reline::LineEditor
     modified
   end
 
-  def save_old_buffer
-    @old_buffer_of_lines = @buffer_of_lines.dup
-  end
-
-  def push_input_lines
-    if @old_buffer_of_lines == @buffer_of_lines
-      @input_lines[@input_lines_position] = [@buffer_of_lines.dup, @byte_pointer, @line_index]
+  MAX_UNDO_REDO_HISTORY_SIZE = 100
+  def push_undo_redo(modified)
+    if modified
+      @undo_redo_history = @undo_redo_history[0..@undo_redo_index]
+      @undo_redo_history.push([@buffer_of_lines.dup, @byte_pointer, @line_index])
+      if @undo_redo_history.size > MAX_UNDO_REDO_HISTORY_SIZE
+        @undo_redo_history.shift
+      end
+      @undo_redo_index = @undo_redo_history.size - 1
     else
-      @input_lines = @input_lines[0..@input_lines_position]
-      @input_lines_position += 1
-      @input_lines.push([@buffer_of_lines.dup, @byte_pointer, @line_index])
-    end
-    trim_input_lines
-  end
-
-  MAX_INPUT_LINES = 100
-  def trim_input_lines
-    if @input_lines.size > MAX_INPUT_LINES
-      @input_lines.shift
-      @input_lines_position -= 1
+      @undo_redo_history[@undo_redo_index] = [@buffer_of_lines.dup, @byte_pointer, @line_index]
     end
   end
 
@@ -1188,7 +1148,7 @@ class Reline::LineEditor
     quote_characters = Reline.completer_quote_characters
     before = current_line.byteslice(0, @byte_pointer).grapheme_clusters
     quote = nil
-    # Calcualte closing quote when cursor is at the end of the line
+    # Calculate closing quote when cursor is at the end of the line
     if current_line.bytesize == @byte_pointer && !quote_characters.empty?
       escaped = false
       before.each do |c|
@@ -1413,9 +1373,16 @@ class Reline::LineEditor
 
     insert_text(str)
   end
-  alias_method :ed_digit, :ed_insert
   alias_method :self_insert, :ed_insert
 
+  private def ed_digit(key)
+    if @vi_arg
+      ed_argument_digit(key)
+    else
+      ed_insert(key)
+    end
+  end
+
   private def insert_raw_char(str, arg: 1)
     arg.times do
       if str == "\C-j" or str == "\C-m"
@@ -1461,7 +1428,14 @@ class Reline::LineEditor
     @byte_pointer = 0
   end
   alias_method :beginning_of_line, :ed_move_to_beg
-  alias_method :vi_zero, :ed_move_to_beg
+
+  private def vi_zero(key)
+    if @vi_arg
+      ed_argument_digit(key)
+    else
+      ed_move_to_beg(key)
+    end
+  end
 
   private def ed_move_to_end(key)
     @byte_pointer = current_line.bytesize
@@ -1691,17 +1665,10 @@ class Reline::LineEditor
           finish
         end
       else
-        if @line_index == (@buffer_of_lines.size - 1)
-          if confirm_multiline_termination
-            finish
-          else
-            key_newline(key)
-          end
-        else
-          # should check confirm_multiline_termination to finish?
-          @line_index = @buffer_of_lines.size - 1
-          @byte_pointer = current_line.bytesize
+        if @line_index == @buffer_of_lines.size - 1 && confirm_multiline_termination
           finish
+        else
+          key_newline(key)
         end
       end
     else
@@ -1709,6 +1676,11 @@ class Reline::LineEditor
     end
   end
 
+  private def ed_force_submit(_key)
+    process_insert(force: true)
+    finish
+  end
+
   private def em_delete_prev_char(key, arg: 1)
     arg.times do
       if @byte_pointer == 0 and @line_index > 0
@@ -2351,10 +2323,10 @@ class Reline::LineEditor
 
   private def move_undo_redo(direction)
     @restoring = true
-    return unless (0..@input_lines.size - 1).cover?(@input_lines_position + direction)
+    return unless (0..@undo_redo_history.size - 1).cover?(@undo_redo_index + direction)
 
-    @input_lines_position += direction
-    buffer_of_lines, byte_pointer, line_index = @input_lines[@input_lines_position]
+    @undo_redo_index += direction
+    buffer_of_lines, byte_pointer, line_index = @undo_redo_history[@undo_redo_index]
     @buffer_of_lines = buffer_of_lines.dup
     @line_index = line_index
     @byte_pointer = byte_pointer

data/bundle/ruby/{3.1.0/gems/reline-0.6.0 → 3.2.0/gems/reline-0.6.1}/lib/reline/unicode/east_asian_width.rb

@@ -1,6 +1,6 @@
 class Reline::Unicode::EastAsianWidth
   # This is based on EastAsianWidth.txt
-  # UNICODE_VERSION = '15.1.0'
+  # UNICODE_VERSION = '16.0.0'
 
   CHUNK_LAST, CHUNK_WIDTH = [
     [0x1f, 2],
@@ -174,7 +174,7 @@ class Reline::Unicode::EastAsianWidth
     [0x82d, 0],
     [0x858, 1],
     [0x85b, 0],
-    [0x897, 1],
+    [0x896, 1],
     [0x89f, 0],
     [0x8c9, 1],
     [0x8e1, 0],
@@ -646,6 +646,8 @@ class Reline::Unicode::EastAsianWidth
     [0x261c, -1],
     [0x261d, 1],
     [0x261e, -1],
+    [0x262f, 1],
+    [0x2637, 2],
     [0x263f, 1],
     [0x2640, -1],
     [0x2641, 1],
@@ -664,6 +666,8 @@ class Reline::Unicode::EastAsianWidth
     [0x266f, -1],
     [0x267e, 1],
     [0x267f, 2],
+    [0x2689, 1],
+    [0x268f, 2],
     [0x2692, 1],
     [0x2693, 2],
     [0x269d, 1],
@@ -753,14 +757,12 @@ class Reline::Unicode::EastAsianWidth
     [0x3130, 1],
     [0x318e, 2],
     [0x318f, 1],
-    [0x31e3, 2],
+    [0x31e5, 2],
     [0x31ee, 1],
     [0x321e, 2],
     [0x321f, 1],
     [0x3247, 2],
     [0x324f, -1],
-    [0x4dbf, 2],
-    [0x4dff, 1],
     [0xa48c, 2],
     [0xa48f, 1],
     [0xa4c6, 2],
@@ -879,9 +881,11 @@ class Reline::Unicode::EastAsianWidth
     [0x10ae6, 0],
     [0x10d23, 1],
     [0x10d27, 0],
+    [0x10d68, 1],
+    [0x10d6d, 0],
     [0x10eaa, 1],
     [0x10eac, 0],
-    [0x10efc, 1],
+    [0x10efb, 1],
     [0x10eff, 0],
     [0x10f45, 1],
     [0x10f50, 0],
@@ -943,6 +947,16 @@ class Reline::Unicode::EastAsianWidth
     [0x1136c, 0],
     [0x1136f, 1],
     [0x11374, 0],
+    [0x113ba, 1],
+    [0x113c0, 0],
+    [0x113cd, 1],
+    [0x113ce, 0],
+    [0x113cf, 1],
+    [0x113d0, 0],
+    [0x113d1, 1],
+    [0x113d2, 0],
+    [0x113e0, 1],
+    [0x113e2, 0],
     [0x11437, 1],
     [0x1143f, 0],
     [0x11441, 1],
@@ -982,6 +996,8 @@ class Reline::Unicode::EastAsianWidth
     [0x116b6, 1],
     [0x116b7, 0],
     [0x1171c, 1],
+    [0x1171d, 0],
+    [0x1171e, 1],
     [0x1171f, 0],
     [0x11721, 1],
     [0x11725, 0],
@@ -1059,10 +1075,16 @@ class Reline::Unicode::EastAsianWidth
     [0x11f40, 0],
     [0x11f41, 1],
     [0x11f42, 0],
+    [0x11f59, 1],
+    [0x11f5a, 0],
     [0x1343f, 1],
     [0x13440, 0],
     [0x13446, 1],
     [0x13455, 0],
+    [0x1611d, 1],
+    [0x16129, 0],
+    [0x1612c, 1],
+    [0x1612f, 0],
     [0x16aef, 1],
     [0x16af4, 0],
     [0x16b2f, 1],
@@ -1080,7 +1102,7 @@ class Reline::Unicode::EastAsianWidth
     [0x187f7, 2],
     [0x187ff, 1],
     [0x18cd5, 2],
-    [0x18cff, 1],
+    [0x18cfe, 1],
     [0x18d08, 2],
     [0x1afef, 1],
     [0x1aff3, 2],
@@ -1116,6 +1138,10 @@ class Reline::Unicode::EastAsianWidth
     [0x1d1ad, 0],
     [0x1d241, 1],
     [0x1d244, 0],
+    [0x1d2ff, 1],
+    [0x1d356, 2],
+    [0x1d35f, 1],
+    [0x1d376, 2],
     [0x1d9ff, 1],
     [0x1da36, 0],
     [0x1da3a, 1],
@@ -1148,6 +1174,8 @@ class Reline::Unicode::EastAsianWidth
     [0x1e2ef, 0],
     [0x1e4eb, 1],
     [0x1e4ef, 0],
+    [0x1e5ed, 1],
+    [0x1e5ef, 0],
     [0x1e8cf, 1],
     [0x1e8d6, 0],
     [0x1e943, 1],
@@ -1241,15 +1269,13 @@ class Reline::Unicode::EastAsianWidth
     [0x1fa6f, 1],
     [0x1fa7c, 2],
     [0x1fa7f, 1],
-    [0x1fa88, 2],
-    [0x1fa8f, 1],
-    [0x1fabd, 2],
-    [0x1fabe, 1],
-    [0x1fac5, 2],
+    [0x1fa89, 2],
+    [0x1fa8e, 1],
+    [0x1fac6, 2],
     [0x1facd, 1],
-    [0x1fadb, 2],
-    [0x1fadf, 1],
-    [0x1fae8, 2],
+    [0x1fadc, 2],
+    [0x1fade, 1],
+    [0x1fae9, 2],
     [0x1faef, 1],
     [0x1faf8, 2],
     [0x1ffff, 1],

data/bundle/ruby/{3.1.0/gems/reline-0.6.0 → 3.2.0/gems/reline-0.6.1}/lib/reline/unicode.rb

@@ -28,12 +28,12 @@ class Reline::Unicode
     0x19 => '^Y',
     0x1A => '^Z', # C-z
     0x1B => '^[', # C-[ C-3
+    0x1C => '^\\', # C-\
     0x1D => '^]', # C-]
     0x1E => '^^', # C-~ C-6
     0x1F => '^_', # C-_ C-7
     0x7F => '^?', # C-? C-8
   }
-  EscapedChars = EscapedPairs.keys.map(&:chr)
 
   NON_PRINTING_START = "\1"
   NON_PRINTING_END = "\2"
@@ -61,7 +61,7 @@ class Reline::Unicode
 
     # This code is essentially doing the same thing as
     # `str.encode(utf8, **replace_options).encode(encoding, **replace_options)`
-    # but also avoids unneccesary irreversible encoding conversion.
+    # but also avoids unnecessary irreversible encoding conversion.
     converted.gsub(/\X/) do |c|
       c.encode(Encoding::UTF_8)
       c

data/bundle/ruby/3.2.0/gems/reline-0.6.1/lib/reline/version.rb

@@ -0,0 +1,3 @@
+module Reline
+  VERSION = '0.6.1'
+end