brakeman 7.0.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/{haml-5.2.2 → haml-6.4.0}/REFERENCE.md

@@ -30,7 +30,7 @@ The first step for all of these is to install the Haml gem:
 
 To run Haml from the command line, just use
 
-    haml input.haml output.html
+    haml render input.haml > output.html
 
 Use `haml --help` for full documentation.
 
@@ -68,24 +68,6 @@ may be compiled to:
       </div>
     </div>
 
-### Rails XSS Protection
-
-Haml supports Rails' XSS protection scheme, which was introduced in Rails 2.3.5+
-and is enabled by default in 3.0.0+. If it's enabled, Haml's
-{Haml::Options#escape_html `:escape_html`} option is set to `true` by default -
-like in ERB, all strings printed to a Haml template are escaped by default. Also
-like ERB, strings marked as HTML safe are not escaped. Haml also has [its own
-syntax for printing a raw string to the template](#unescaping_html).
-
-If the `:escape_html` option is set to false when XSS protection is enabled,
-Haml doesn't escape Ruby strings by default. However, if a string marked
-HTML-safe is passed to [Haml's escaping syntax](#escaping_html), it won't be
-escaped.
-
-Finally, all the {Haml::Helpers Haml helpers} that return strings that are known
-to be HTML safe are marked as such. In addition, string input is escaped unless
-it's HTML safe.
-
 ### Ruby Module
 
 Haml can also be used completely separately from Rails and ActionView. To do
@@ -93,10 +75,10 @@ this, install the gem with RubyGems:
 
     gem install haml
 
-You can then use it by including the "haml" gem in Ruby code, and using
-{Haml::Engine} like so:
+You can then use it by including the `haml` gem in Ruby code, and using
+{Haml::Template} like so:
 
-    engine = Haml::Engine.new("%p Haml code!")
+    engine = Haml::Template.new { "%p Haml code!" }
     engine.render #=> "<p>Haml code!</p>\n"
 
 ### Options
@@ -104,50 +86,26 @@ You can then use it by including the "haml" gem in Ruby code, and using
 Haml understands various configuration options that affect its performance and
 output.
 
-In Rails, options can be set by setting the {Haml::Template#options Haml::Template.options}
-hash in an initializer:
+In Rails, options can be set by using `Haml::RailsTemplate.set_options` in an initializer:
 
 ```ruby
 # config/initializers/haml.rb
-Haml::Template.options[:format] = :html5
-
-# Avoid escaping attributes which are already escaped
-Haml::Template.options[:escape_attrs] = :once
+Haml::RailsTemplate.set_options(escape_html: false)
 ```
 
-Outside Rails, you can set them by configuring them globally in
-Haml::Options.defaults:
+Outside Rails, you can set them by configuring them globally in `Haml::Template.options`:
 
 ```ruby
-Haml::Options.defaults[:format] = :html5
+Haml::Template.options[:escape_html] = false
 ```
 
 In sinatra specifically, you can set them in global config with:
 ```ruby
-set :haml, { escape_html: true }
+set :haml, { escape_html: false }
 ```
 
-Finally, you can also set them by passing an options hash to
-{Haml::Engine#initialize}. For the complete list of available options, please
-see {Haml::Options}.
-
-### Encodings
-
-Haml supports the same sorts of
-encoding-declaration comments that Ruby does. Although both Ruby and Haml
-support several different styles, the easiest it just to add `-# coding:
-encoding-name` at the beginning of the Haml template (it must come before all
-other lines). This will tell Haml that the template is encoded using the named
-encoding.
-
-By default, the HTML generated by Haml has the same encoding as the Haml
-template. However, if `Encoding.default_internal` is set, Haml will attempt to
-use that instead. In addition, the {Haml::Options#encoding `:encoding` option}
-can be used to specify an output encoding manually.
-
-Note that, like Ruby, Haml does not support templates encoded in UTF-16 or
-UTF-32, since these encodings are not compatible with ASCII. It is possible to
-use these as the output encoding, though.
+Finally, you can also set them by passing an options hash to `Haml::Engine.new` or `Haml::Template.new`.
+For the complete list of available options, please see [`Haml::Engine`](https://github.com/haml/haml/blob/main/lib/haml/engine.rb).
 
 ## Plain Text
 
@@ -222,10 +180,10 @@ closing tags for any element.
 
 ### Attributes: `{}` or `()` {#attributes}
 
-Brackets represent a Ruby hash that is used for specifying the attributes of an
+Braces represent a Ruby hash that is used for specifying the attributes of an
 element. It is literally evaluated as a Ruby hash, so logic will work in it and
 local variables may be used. Quote characters within the attribute will be
-replaced by appropriate escape sequences. The hash is placed after the tag is
+replaced with appropriate escape sequences. The hash is placed after the tag is
 defined. For example:
 
     %html{:xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en"}
@@ -289,7 +247,7 @@ could render as either of:
 #### HTML-style Attributes: `()`
 
 Haml also supports a terser, less Ruby-specific attribute syntax based on HTML's
-attributes. These are used with parentheses instead of brackets, like so:
+attributes. These are used with parentheses instead of braces, like so:
 
     %html(xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en")
 
@@ -325,49 +283,6 @@ Haml also supports Ruby's new hash syntax:
 
     %a{title: @title, href: href} Stuff
 
-#### Attribute Methods
-
-A Ruby method call that returns a hash can be substituted for the hash contents.
-For example, {Haml::Helpers} defines the following method:
-
-    def html_attrs(lang = 'en-US')
-      {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
-    end
-
-This can then be used in Haml, like so:
-
-    %html{html_attrs('fr-fr')}
-
-This is compiled to:
-
-    <html lang='fr-fr' xml:lang='fr-fr' xmlns='http://www.w3.org/1999/xhtml'>
-    </html>
-
-You can use as many such attribute methods as you want by separating them with
-commas, like a Ruby argument list. All the hashes will be merged together, from
-left to right. For example, if you defined
-
-    def hash1
-      {:bread => 'white', :filling => 'peanut butter and jelly'}
-    end
-
-    def hash2
-      {:bread => 'whole wheat'}
-    end
-
-then
-
-    %sandwich{hash1, hash2, :delicious => 'true'}/
-
-would compile to:
-
-    <sandwich bread='whole wheat' delicious='true' filling='peanut butter and jelly' />
-
-Note that the Haml attributes list has the same syntax as a Ruby method call.
-This means that any attribute methods must come before the hash literal.
-
-Attribute methods aren't supported for HTML-style attributes.
-
 #### Boolean Attributes
 
 Some attributes, such as "checked" for `input` tags or "selected" for `option`
@@ -404,24 +319,38 @@ or using `true` and `false`:
 
     %input(selected=true)
 
+This feature works only for attributes that are included in
+[`Haml::BOOLEAN_ATTRIBUTES`](https://github.com/haml/haml/blob/main/lib/haml/attribute_compiler.rb#L8),
+as well as `data-` and `aria-` attributes.
+
+    %input{'data-hidden' => false}
+    %input{'aria-hidden' => false}
+    %input{'xyz-hidden' => false}
+
+will render as:
+
+    <input>
+    <input>
+    <input xyz-hidden='false'>
+
+
 <!-- The title to the next section (Prefixed Attributes) has changed. This
 <a> tag is so old links to here still work. -->
 <a id="html5_custom_data_attributes" style="border:0;"></a>
 
-#### Prefixed Attributes
+#### Data Attributes
 
 HTML5 allows for adding
 [custom non-visible data attributes](http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
 to elements using attribute names beginning with `data-`. The
 [Accessible Rich Internet Applications](http://www.w3.org/WAI/intro/aria)
-specification makes use of attributes beginning with `aria-`. There are also
-frameworks that use non-standard attributes with a common prefix.
+specification makes use of attributes beginning with `aria-`.
 
 Haml can help generate collections of attributes that share a prefix like
-these. Any entry in an attribute hash that has a Hash as its value is expanded
-into a series of attributes, one for each key/value pair in the hash, with the
-attribute name formed by joining the “parent” key name to the key name with a
-hyphen.
+these. Any entry in an `data` or `aria` attribute hash that has a Hash as its
+value is expanded into a series of attributes, one for each key/value pair in
+the hash, with the attribute name formed by joining the “parent” key name to
+the key name with a hyphen. This works only for `data` or `aria`.
 
 For example:
 
@@ -431,13 +360,6 @@ will render as:
 
     <a data-author-id='123' data-category='7' href='/posts'>Posts By Author</a>
 
-Notice that the underscore in `author_id` was replaced by a hyphen. If you wish
-to suppress this behavior, you can set Haml's
-{Haml::Options#hyphenate_data_attrs `:hyphenate_data_attrs` option} to `false`,
-and the output will be rendered as:
-
-    <a data-author_id='123' data-category='7' href='/posts'>Posts By Author</a>
-
 This expansion of hashes is recursive – any value of the child hash that is
 itself a hash will create an attribute for each entry, with the attribute name
 prefixed with all ancestor keys. For example:
@@ -639,7 +561,7 @@ prefix for both the id and class attributes. For example:
     # file: app/controllers/users_controller.rb
 
     def show
-      @user = CrazyUser.find(15)
+      @user = FriendlyUser.find(15)
     end
 
     -# file: app/views/users/show.haml
@@ -650,7 +572,7 @@ prefix for both the id and class attributes. For example:
 
 is compiled to:
 
-    <div class='greeting_crazy_user' id='greeting_crazy_user_15'>
+    <div class='greeting_friendly_user' id='greeting_friendly_user_15'>
       <bar class='fixnum' id='fixnum_581' />
       Hello!
     </div>
@@ -658,11 +580,11 @@ is compiled to:
 If you require that the class be something other than the underscored object's
 class, you can implement the `haml_object_ref` method on the object.
 
-    # file: app/models/crazy_user.rb
+    # file: app/models/friendly_user.rb
 
-    class CrazyUser < ActiveRecord::Base
+    class FriendlyUser < ActiveRecord::Base
       def haml_object_ref
-        "a_crazy_user"
+        "a_friendly_user"
       end
     end
 
@@ -673,7 +595,7 @@ class, you can implement the `haml_object_ref` method on the object.
 
 is compiled to:
 
-    <div class='a_crazy_user' id='a_crazy_user_15'>
+    <div class='a_friendly_user' id='a_friendly_user_15'>
       Hello!
     </div>
 
@@ -993,7 +915,7 @@ is compiled to:
 
 ### Whitespace Preservation: `~` {#tilde}
 
-`~` works just like `=`, except that it runs {Haml::Helpers#find\_and\_preserve}
+`~` works just like `=`, except that it runs {Haml::Helpers.preserve}
 on its input. For example,
 
     ~ "Foo\n<pre>Bar\nBaz</pre>"
@@ -1063,7 +985,7 @@ most code but you may have errors with code like the following:
 
     %span #{'{'}
 
-This code will generate a syntax error, complaining about unbalanced brackets.
+This code will generate a syntax error, complaining about unbalanced braces.
 In cases like this, the recommended workaround is output the code as a Ruby
 string to force Haml to parse the code with Ruby.
 
@@ -1154,9 +1076,6 @@ is compiled to
       <p>I <strong>really</strong> prefer <em>raspberry</em> jam.</p>
     </div>
 
-Note that `#{}` interpolation within filters is HTML-escaped if you specify true to
-{Haml::Options#escape_filter_interpolations `:escape_filter_interpolations`} option.
-
 The functionality of some filters such as Markdown can be provided by many
 different libraries. Usually you don't have to worry about this - you can just
 load the gem of your choice and Haml will automatically use it.
@@ -1167,7 +1086,7 @@ uses to implement many of its filters:
 
     Tilt.prefer Tilt::RedCarpetTemplate
 
-See the [Tilt documentation](https://github.com/rtomayko/tilt#fallback-mode) for
+See the [Tilt documentation](https://github.com/rtomayko/tilt) for
 more info.
 
 Haml comes with the following filters defined:
@@ -1219,7 +1138,7 @@ implemented using Tilt.
 
 ### `:maruku` {#maruku-filter}
 
-Parses the filtered text with [Maruku](https://github.com/nex3/maruku), which
+Parses the filtered text with [Maruku](https://github.com/bhollis/maruku), which
 has some non-standard extensions to Markdown.
 
 As of Haml 4.0, this filter is defined in [Haml
@@ -1242,11 +1161,8 @@ HTML escape code for newlines, to preserve nice-looking output. See also
 
 ### `:ruby` {#ruby-filter}
 
-Parses the filtered text with the normal Ruby interpreter. Creates an `IO`
-object named `haml_io`, anything written to it is output into the Haml document.
-Not available if the {Haml::Options#suppress_eval `:suppress_eval`} option is
-set to true. The Ruby code is evaluated in the same context as the Haml
-template.
+Parses the filtered text with the normal Ruby interpreter.
+The Ruby code is evaluated in the same context as the Haml template.
 
 ### `:sass` {#sass-filter}
 
@@ -1271,43 +1187,44 @@ default. This filter is implemented using Tilt.
 
 ### Custom Filters
 
-You can also define your own filters. See {Haml::Filters} for details.
-
-## Helper Methods {#helper-methods}
-
-Sometimes you need to manipulate whitespace in a more precise fashion than what
-the whitespace removal methods allow. There are a few helper methods that are
-useful when dealing with inline content. All these methods take a Haml block to
-modify.
-
-### surround {#surround}
+You can also define your own filters.
+`Haml::Filters::YourCustomFilter#compile` should return
+[a Temple expression](https://github.com/judofyr/temple/blob/master/EXPRESSIONS.md).
 
-Surrounds a Haml block with text. Expects 1 or 2 string arguments used to
-surround the Haml block. If a second argument is not provided, the first
-argument is used as the second.
+The simplest example of a filter might be something like:
 
-    = surround "(", ")" do
-      = link_to "learn more", "#"
-
-### precede {#precede}
-
-Prepends a Haml block with text. Expects 1 argument.
-
-    = precede "*" do
-      %span Required
-
-### succeed {#succeed}
+    class HelloFilter < Haml::Filters::Base
+      def compile(_node)
+        [:static, "hello world"]
+      end
+    end
+    
+    Haml::Filters.registered[:hello] ||= HelloFilter
+
+A more complex example:
+
+    class BetterFilter < Haml::Filters::Base
+      def compile(node)
+        temple = [:multi]
+        temple << [:static, "hello "]
+        temple << compile_text(node.value[:text])
+        temple << [:static, " world"]
+        temple
+      end
+    
+      private
+      def compile_text(text)
+        if ::Haml::Util.contains_interpolation?(text)
+          [:dynamic, ::Haml::Util.unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
 
-Appends a Haml block with text. Expects 1 argument.
+    Haml::Filters.registered[:better] ||= BetterFilter
 
-    Begin by
-    = succeed "," do
-      = link_to "filling out your profile", "#"
-    = succeed "," do
-      = link_to "adding a bio", "#"
-    and
-    = succeed "." do
-      = link_to "inviting friends", "#"
+See {Haml::Filters} for examples.
 
 ## Multiline: `|` {#multiline}
 
@@ -1354,7 +1271,7 @@ can be wrapped over multiple lines,
 as long as each line but the last ends in a comma
 (see [Inserting Ruby](#inserting_ruby)).
 
-## Whitespace Preservation
+## Whitespace Preservation {#whitespace_preservation}
 
 Sometimes you don't want Haml to indent all your text.
 For example, tags like `pre` and `textarea` are whitespace-sensitive;
@@ -1367,14 +1284,26 @@ Haml won't try to re-format the indentation.
 Literal `textarea` and `pre` tags automatically preserve content given through
 `=`. Dynamically-generated `textarea`s and `pre`s can't be preserved
 automatically, and so should be passed through
-{Haml::Helpers#find\_and\_preserve} or the [`~` command](#tilde), which has the
+{Haml::Helpers.preserve} or the [`~` command](#tilde), which has the
 same effect.
 
 Blocks of literal text can be preserved using the [`:preserve` filter](#preserve-filter).
 
-## Helpers
+## Turbo
 
-Haml offers a bunch of helpers that are useful for doing stuff like preserving
-whitespace, creating nicely indented output for user-defined helpers, and other
-useful things. The helpers are all documented in the {Haml::Helpers} and
-{Haml::Helpers::ActionViewExtensions} modules.
+For people using Turbo-rails need to either:
+*  follow the naming convention with the html format (ie. ensure any `.haml` files end `.html.haml`), or
+*  add a monkey patch as follows:
+
+```rb
+# config/initializers/haml.rb
+require "haml/rails_template"
+
+module Haml
+  class RailsTemplate
+    def default_format
+      :html
+    end
+  end
+end
+```

data/bundle/ruby/3.1.0/gems/haml-6.4.0/exe/haml

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../lib', __dir__)
+require 'haml/cli'
+
+Haml::CLI.start(ARGV)

data/bundle/ruby/3.1.0/gems/haml-6.4.0/haml.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'haml'
+  spec.version       = Haml::VERSION
+  spec.authors       = ['Natalie Weizenbaum', 'Hampton Catlin', 'Norman Clarke', 'Akira Matsuda', 'Takashi Kokubun']
+  spec.email         = ['haml@googlegroups.com', 'ronnie@dio.jp']
+
+  spec.summary       = %q{An elegant, structured (X)HTML/XML templating engine.}
+  spec.description   = %q{An elegant, structured (X)HTML/XML templating engine.}
+  spec.homepage      = 'https://haml.info'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sample|benchmark)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.metadata      = { 'rubygems_mfa_required' => 'true' }
+
+  spec.metadata["changelog_uri"] = spec.homepage + "/blob/main/CHANGELOG.md"
+
+  spec.required_ruby_version = '>= 2.1.0'
+
+  spec.add_dependency 'temple', '>= 0.8.2'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'tilt'
+
+  spec.add_development_dependency 'benchmark_driver'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coffee-script'
+  spec.add_development_dependency 'erubi'
+  spec.add_development_dependency 'haml', '>= 5'
+  spec.add_development_dependency 'less'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'rails', '>= 4.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'sass'
+  spec.add_development_dependency 'slim'
+  spec.add_development_dependency 'string_template'
+  spec.add_development_dependency 'unindent'
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/ambles.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Haml
+  class Ambles < Temple::Filter
+    define_options :preamble, :postamble
+
+    def initialize(*)
+      super
+      @preamble = options[:preamble]
+      @postamble = options[:postamble]
+    end
+
+    def call(ast)
+      ret = [:multi]
+      ret << [:static, @preamble] if @preamble
+      ret << ast
+      ret << [:static, @postamble] if @postamble
+      ret
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/attribute_builder.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+require 'haml/object_ref'
+
+module Haml::AttributeBuilder
+  class << self
+    def build(escape_attrs, quote, format, object_ref, *hashes)
+      hashes << Haml::ObjectRef.parse(object_ref) if object_ref
+      buf  = []
+      hash = merge_all_attrs(hashes)
+
+      keys = hash.keys.sort!
+      keys.each do |key|
+        case key
+        when 'id'
+          buf << " id=#{quote}#{build_id(escape_attrs, *hash[key])}#{quote}"
+        when 'class'
+          buf << " class=#{quote}#{build_class(escape_attrs, *hash[key])}#{quote}"
+        when 'data'
+          buf << build_data(escape_attrs, quote, *hash[key])
+        when 'aria'
+          buf << build_aria(escape_attrs, quote, *hash[key])
+        when *Haml::BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
+          build_boolean!(escape_attrs, quote, format, buf, key, hash[key])
+        else
+          buf << " #{key}=#{quote}#{escape_html(escape_attrs, hash[key].to_s)}#{quote}"
+        end
+      end
+      buf.join
+    end
+
+    def build_id(escape_attrs, *values)
+      escape_html(escape_attrs, values.flatten.select { |v| v }.join('_'))
+    end
+
+    def build_class(escape_attrs, *values)
+      if values.size == 1
+        value = values.first
+        case
+        when value.is_a?(String)
+          # noop
+        when value.is_a?(Array)
+          value = value.flatten.select { |v| v }.map(&:to_s).uniq.join(' ')
+        when value
+          value = value.to_s
+        else
+          return ''
+        end
+        return escape_html(escape_attrs, value)
+      end
+
+      classes = []
+      values.each do |value|
+        case
+        when value.is_a?(String)
+          classes += value.split(' ')
+        when value.is_a?(Array)
+          classes += value.flatten.select { |v| v }
+        when value
+          classes << value.to_s
+        end
+      end
+      escape_html(escape_attrs, classes.map(&:to_s).uniq.join(' '))
+    end
+
+    def build_data(escape_attrs, quote, *hashes)
+      build_data_attribute(:data, escape_attrs, quote, *hashes)
+    end
+
+    def build_aria(escape_attrs, quote, *hashes)
+      build_data_attribute(:aria, escape_attrs, quote, *hashes)
+    end
+
+    private
+
+    def build_data_attribute(key, escape_attrs, quote, *hashes)
+      attrs = []
+      if hashes.size > 1 && hashes.all? { |h| h.is_a?(Hash) }
+        data_value = merge_all_attrs(hashes)
+      else
+        data_value = hashes.last
+      end
+      hash = flatten_attributes(key => data_value)
+
+      hash.sort_by(&:first).each do |key, value|
+        case value
+        when true
+          attrs << " #{key}"
+        when nil, false
+          # noop
+        else
+          attrs << " #{key}=#{quote}#{escape_html(escape_attrs, value.to_s)}#{quote}"
+        end
+      end
+      attrs.join
+    end
+
+    def flatten_attributes(attributes)
+      flattened = {}
+
+      attributes.each do |key, value|
+        case value
+        when attributes
+        when Hash
+          flatten_attributes(value).each do |k, v|
+            if k.nil?
+              flattened[key] = v
+            else
+              flattened["#{key}-#{k.to_s.tr('_', '-')}"] = v
+            end
+          end
+        else
+          flattened[key] = value if value
+        end
+      end
+      flattened
+    end
+
+    def merge_all_attrs(hashes)
+      merged = {}
+      hashes.each do |hash|
+        unless hash.is_a?(Hash)
+          raise ArgumentError, "Non-hash object is given to attributes!"
+        end
+        hash.each do |key, value|
+          key = key.to_s
+          case key
+          when 'id', 'class', 'data', 'aria'
+            merged[key] ||= []
+            merged[key] << value
+          else
+            merged[key] = value
+          end
+        end
+      end
+      merged
+    end
+
+    def build_boolean!(escape_attrs, quote, format, buf, key, value)
+      case value
+      when true
+        case format
+        when :xhtml
+          buf << " #{key}=#{quote}#{key}#{quote}"
+        else
+          buf << " #{key}"
+        end
+      when false, nil
+        # omitted
+      else
+        buf << " #{key}=#{quote}#{escape_html(escape_attrs, value)}#{quote}"
+      end
+    end
+
+    def escape_html(escape_attrs, str)
+      if escape_attrs
+        Haml::Util.escape_html(str)
+      else
+        str
+      end
+    end
+  end
+end