tdiary 5.2.1 → 5.2.2

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http-1.0.1/lib/faraday/adapter/net_http.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'net/https'
-rescue LoadError
-  warn 'Warning: no such file to load -- net/https. ' \
-    'Make sure openssl is installed if you want ssl support'
-  require 'net/http'
-end
-require 'zlib'
-
-module Faraday
-  class Adapter
-    class NetHttp < Faraday::Adapter
-      exceptions = [
-        IOError,
-        Errno::EADDRNOTAVAIL,
-        Errno::ECONNABORTED,
-        Errno::ECONNREFUSED,
-        Errno::ECONNRESET,
-        Errno::EHOSTUNREACH,
-        Errno::EINVAL,
-        Errno::ENETUNREACH,
-        Errno::EPIPE,
-        Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError,
-        SocketError,
-        Zlib::GzipFile::Error
-      ]
-
-      exceptions << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
-      exceptions << ::Net::OpenTimeout if defined?(::Net::OpenTimeout)
-
-      NET_HTTP_EXCEPTIONS = exceptions.freeze
-
-      def initialize(app = nil, opts = {}, &block)
-        @ssl_cert_store = nil
-        super(app, opts, &block)
-      end
-
-      def build_connection(env)
-        net_http_connection(env).tap do |http|
-          http.use_ssl = env[:url].scheme == 'https' if http.respond_to?(:use_ssl=)
-          configure_ssl(http, env[:ssl])
-          configure_request(http, env[:request])
-        end
-      end
-
-      def net_http_connection(env)
-        proxy = env[:request][:proxy]
-        port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
-        if proxy
-          Net::HTTP.new(env[:url].hostname, port,
-                        proxy[:uri].hostname, proxy[:uri].port,
-                        proxy[:user], proxy[:password])
-        else
-          Net::HTTP.new(env[:url].hostname, port, nil)
-        end
-      end
-
-      def call(env)
-        super
-        http_response = connection(env) do |http|
-          begin
-            perform_request(http, env)
-          rescue *NET_HTTP_EXCEPTIONS => e
-            raise Faraday::SSLError, e if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
-
-            raise Faraday::ConnectionFailed, e
-          end
-        end
-
-        save_response(env, http_response.code.to_i,
-                      http_response.body || +'', nil,
-                      http_response.message) do |response_headers|
-          http_response.each_header do |key, value|
-            response_headers[key] = value
-          end
-        end
-
-        @app.call env
-      rescue Timeout::Error, Errno::ETIMEDOUT => e
-        raise Faraday::TimeoutError, e
-      end
-
-      private
-
-      def create_request(env)
-        request = Net::HTTPGenericRequest.new \
-          env[:method].to_s.upcase, # request method
-          !!env[:body], # is there request body
-          env[:method] != :head, # is there response body
-          env[:url].request_uri, # request uri path
-          env[:request_headers] # request headers
-
-        if env[:body].respond_to?(:read)
-          request.body_stream = env[:body]
-        else
-          request.body = env[:body]
-        end
-        request
-      end
-
-      def perform_request(http, env)
-        if env[:request].stream_response?
-          size = 0
-          yielded = false
-          http_response = request_with_wrapped_block(http, env) do |chunk|
-            if chunk.bytesize.positive? || size.positive?
-              yielded = true
-              size += chunk.bytesize
-              env[:request].on_data.call(chunk, size)
-            end
-          end
-          env[:request].on_data.call(+'', 0) unless yielded
-          # Net::HTTP returns something,
-          # but it's not meaningful according to the docs.
-          http_response.body = nil
-          http_response
-        else
-          request_with_wrapped_block(http, env)
-        end
-      end
-
-      def request_with_wrapped_block(http, env, &block)
-        if (env[:method] == :get) && !env[:body]
-          # prefer `get` to `request` because the former handles gzip (ruby 1.9)
-          request_via_get_method(http, env, &block)
-        else
-          request_via_request_method(http, env, &block)
-        end
-      end
-
-      def request_via_get_method(http, env, &block)
-        # Must use Net::HTTP#start and pass it a block otherwise the server's
-        # TCP socket does not close correctly.
-        http.start do |opened_http|
-          opened_http.get env[:url].request_uri, env[:request_headers], &block
-        end
-      end
-
-      def request_via_request_method(http, env, &block)
-        # Must use Net::HTTP#start and pass it a block otherwise the server's
-        # TCP socket does not close correctly.
-        http.start do |opened_http|
-          if block_given?
-            opened_http.request create_request(env) do |response|
-              response.read_body(&block)
-            end
-          else
-            opened_http.request create_request(env)
-          end
-        end
-      end
-
-      def configure_ssl(http, ssl)
-        return unless ssl
-
-        http.verify_mode = ssl_verify_mode(ssl)
-        http.cert_store = ssl_cert_store(ssl)
-
-        http.cert = ssl[:client_cert] if ssl[:client_cert]
-        http.key = ssl[:client_key] if ssl[:client_key]
-        http.ca_file = ssl[:ca_file] if ssl[:ca_file]
-        http.ca_path = ssl[:ca_path] if ssl[:ca_path]
-        http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        http.ssl_version = ssl[:version] if ssl[:version]
-        http.min_version = ssl[:min_version] if ssl[:min_version]
-        http.max_version = ssl[:max_version] if ssl[:max_version]
-      end
-
-      def configure_request(http, req)
-        if (sec = request_timeout(:read, req))
-          http.read_timeout = sec
-        end
-
-        if (sec = http.respond_to?(:write_timeout=) &&
-          request_timeout(:write, req))
-          http.write_timeout = sec
-        end
-
-        if (sec = request_timeout(:open, req))
-          http.open_timeout = sec
-        end
-
-        # Only set if Net::Http supports it, since Ruby 2.5.
-        http.max_retries = 0 if http.respond_to?(:max_retries=)
-
-        @config_block&.call(http)
-      end
-
-      def ssl_cert_store(ssl)
-        return ssl[:cert_store] if ssl[:cert_store]
-
-        @ssl_cert_store ||= begin
-                              # Use the default cert store by default, i.e. system ca certs
-                              OpenSSL::X509::Store.new.tap(&:set_default_paths)
-                            end
-      end
-
-      def ssl_verify_mode(ssl)
-        ssl[:verify_mode] || begin
-                               if ssl.fetch(:verify, true)
-                                 OpenSSL::SSL::VERIFY_PEER
-                               else
-                                 OpenSSL::SSL::VERIFY_NONE
-                               end
-                             end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http-1.0.1/lib/faraday/net_http/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  module NetHttp
-    VERSION = '1.0.1'
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http-1.0.1/lib/faraday/net_http.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'adapter/net_http'
-require_relative 'net_http/version'
-
-module Faraday
-  module NetHttp
-    Faraday::Adapter.register_middleware(net_http: Faraday::Adapter::NetHttp)
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http_persistent-1.2.0/LICENSE.md

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2020 Jan van der Pas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http_persistent-1.2.0/README.md

@@ -1,73 +0,0 @@
-# Faraday::NetHttpPersistent
-
-[![Gem Version](https://badge.fury.io/rb/faraday-net_http_persistent.svg)](https://rubygems.org/gems/faraday-net_http_persistent)
-[![GitHub Actions CI](https://github.com/lostisland/faraday-net_http_persistent/workflows/CI/badge.svg)](https://github.com/lostisland/faraday-net_http_persistent/actions?query=workflow%3ACI)
-
-This gem is a [Faraday][faraday] adapter for the [Net::HTTP::Persistent gem][net-http-persistent].
-
-## Installation
-
-Add these lines to your application's Gemfile:
-
-```ruby
-gem 'faraday-net_http_persistent'
-gem 'net-http-persistent', '>= 3.1'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install them yourself as:
-
-    $ gem install net_http_persistent -v '>= 3.1'
-    $ gem install faraday-net_http_persistent
-
-## Usage
-
-Configure your Faraday connection to use this adapter instead of the default one:
-
-```ruby
-connection = Faraday.new(url, conn_options) do |conn|
-  # Your other middleware goes here...
-  conn.adapter :net_http_persistent
-end
-```
-
-For more information on how to setup your Faraday connection and adapters usage,
-please refer to the [Faraday Website][faraday-website].
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies.
-Then, run `rake spec` to run the tests. You can also run `bin/console`
-for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`.
-To release a new version, update the version number in `version.rb`,
-and then run `bundle exec rake release`, which will create a git tag for the version,
-push git commits and tags, and push the `.gem` file to [rubygems.org].
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/lostisland/faraday-net_http_persistent.
-This project is intended to be a safe, welcoming space for collaboration,
-and contributors are expected to adhere to the [Contributor Covenant][covenant] code of conduct.
-
-## License
-
-The gem is available as open source under the terms of the [MIT License][mit-license].
-
-## Code of Conduct
-
-This project is intended to be a safe, welcoming space for collaboration.
-Everyone interacting in the Faraday::Http project’s codebases, issue trackers,
-chat rooms and mailing lists is expected to follow the [code of conduct][code-of-conduct].
-
-[code-of-conduct]:     https://github.com/lostisland/faraday-http/blob/main/CODE_OF_CONDUCT.md
-[covenant]:            http://contributor-covenant.org
-[faraday]:             https://github.com/lostisland/faraday
-[faraday-website]:     https://lostisland.github.io/faraday
-[net-http-persistent]: https://github.com/drbrain/net-http-persistent
-[mit-license]:         https://opensource.org/licenses/MIT
-[rubygems.org]:        https://rubygems.org

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http_persistent-1.2.0/lib/faraday/adapter/net_http_persistent.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Net::HTTP::Persistent adapter.
-    class NetHttpPersistent < NetHttp
-      dependency "net/http/persistent"
-
-      private
-
-      def net_http_connection(env)
-        @cached_connection ||=
-          if Net::HTTP::Persistent.instance_method(:initialize)
-              .parameters.first == %i[key name]
-            options = {name: "Faraday"}
-            if @connection_options.key?(:pool_size)
-              options[:pool_size] = @connection_options[:pool_size]
-            end
-            Net::HTTP::Persistent.new(**options)
-          else
-            Net::HTTP::Persistent.new("Faraday")
-          end
-
-        proxy_uri = proxy_uri(env)
-        if @cached_connection.proxy_uri != proxy_uri
-          @cached_connection.proxy = proxy_uri
-        end
-        @cached_connection
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        if (proxy = env[:request][:proxy])
-          proxy_uri = if proxy[:uri].is_a?(::URI::HTTP)
-            proxy[:uri].dup
-          else
-            ::URI.parse(proxy[:uri].to_s)
-          end
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8
-          # not unescaping user/password
-          if proxy[:user]
-            (class << proxy_uri; self; end).class_eval do
-              define_method(:user) { proxy[:user] }
-              define_method(:password) { proxy[:password] }
-            end
-          end
-        end
-        proxy_uri
-      end
-
-      def perform_request(http, env)
-        if env[:request].stream_response?
-          size = 0
-          yielded = false
-
-          http_response = http.request(env[:url], create_request(env)) do |response|
-            response.read_body do |chunk|
-              if chunk.bytesize.positive? || size.positive?
-                yielded = true
-                size += chunk.bytesize
-                env[:request].on_data.call(chunk, size)
-              end
-            end
-          end
-
-          env[:request].on_data.call(+"", 0) unless yielded
-          http_response.body = nil
-          http_response
-        else
-          http.request(env[:url], create_request(env))
-        end
-      rescue Errno::ETIMEDOUT, Net::OpenTimeout => e
-        raise Faraday::TimeoutError, e
-      rescue Net::HTTP::Persistent::Error => e
-        raise Faraday::TimeoutError, e if e.message.include? "Timeout"
-
-        if e.message.include? "connection refused"
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise
-      end
-
-      SSL_CONFIGURATIONS = {
-        certificate: :client_cert,
-        private_key: :client_key,
-        ca_file: :ca_file,
-        ssl_version: :version,
-        min_version: :min_version,
-        max_version: :max_version
-      }.freeze
-
-      def configure_ssl(http, ssl)
-        return unless ssl
-
-        http_set(http, :verify_mode, ssl_verify_mode(ssl))
-        http_set(http, :cert_store, ssl_cert_store(ssl))
-
-        SSL_CONFIGURATIONS
-          .select { |_, key| ssl[key] }
-          .each { |target, key| http_set(http, target, ssl[key]) }
-      end
-
-      def http_set(http, attr, value)
-        http.send("#{attr}=", value) if http.send(attr) != value
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http_persistent-1.2.0/lib/faraday/net_http_persistent/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  module NetHttpPersistent
-    VERSION = "1.2.0"
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-net_http_persistent-1.2.0/lib/faraday/net_http_persistent.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "adapter/net_http_persistent"
-require_relative "net_http_persistent/version"
-
-module Faraday
-  module NetHttpPersistent
-    # Faraday allows you to register your middleware for easier configuration.
-    # This step is totally optional, but it basically allows users to use a custom symbol (in this case, `:net_http_persistent`),
-    # to use your adapter in their connections.
-    # After calling this line, the following are both valid ways to set the adapter in a connection:
-    # * conn.adapter Faraday::Adapter::NetNttpPersistent
-    # * conn.adapter :net_http_persistent
-    # Without this line, only the former method is valid.
-    Faraday::Adapter.register_middleware(net_http_persistent: Faraday::Adapter::NetHttpPersistent)
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-patron-1.0.0/LICENSE.md

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2020 Jan van der Pas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/vendor/bundle/ruby/3.1.0/gems/faraday-patron-1.0.0/README.md

@@ -1,62 +0,0 @@
-# Faraday Patron adapter
-
-This gem is a [Faraday][faraday] adapter for the [Patron][patron] library.
-Faraday is an HTTP client library that provides a common interface over many adapters.
-Every adapter is defined into its own gem. This gem defines the adapter for Patron.
-
-## Installation
-
-Add these lines to your application's Gemfile:
-
-```ruby
-gem 'patron', '>= 2.2'
-gem 'faraday'
-gem 'faraday-patron'
-```
-
-And then execute:
-
-    $ bundle install
-
-Or install them yourself as:
-
-    $ gem install patron -v '>= 2.2'
-    $ gem install faraday faraday-patron
-
-## Usage
-
-Configure your Faraday connection to use this adapter like this:
-
-```ruby
-connection = Faraday.new(url, conn_options) do |conn|
-  conn.adapter(:patron)
-end
-```
-
-For more information on how to setup your Faraday connection and adapters usage, please refer to the [Faraday Website][faraday-website].
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](rubygems).
-
-## Contributing
-
-Bug reports and pull requests are welcome on [GitHub][repo].
-
-## License
-
-The gem is available as open source under the terms of the [license][license].
-
-## Code of Conduct
-
-Everyone interacting in the Faraday Patron adapter project's codebase, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct][code-of-conduct].
-
-[faraday]: https://github.com/lostisland/faraday
-[faraday-website]: https://lostisland.github.io/faraday
-[patron]: https://github.com/toland/patron
-[rubygems]: https://rubygems.org
-[repo]: https://github.com/lostisland/faraday-patron
-[license]: https://github.com/lostisland/faraday-patron/blob/main/LICENSE.md
-[code-of-conduct]: https://github.com/lostisland/faraday-patron/blob/main/CODE_OF_CONDUCT.md

data/vendor/bundle/ruby/3.1.0/gems/faraday-patron-1.0.0/lib/faraday/adapter/patron.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Patron adapter
-    class Patron < Faraday::Adapter
-      dependency 'patron'
-
-      def build_connection(env)
-        session = ::Patron::Session.new
-        @config_block&.call(session)
-        if (env[:url].scheme == 'https') && env[:ssl]
-          configure_ssl(session, env[:ssl])
-        end
-
-        if (req = env[:request])
-          configure_timeouts(session, req)
-          configure_proxy(session, req[:proxy])
-        end
-
-        session
-      end
-
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        response = connection(env) do |session|
-          begin
-            data = env[:body] ? env[:body].to_s : nil
-            session.request(env[:method], env[:url].to_s,
-                            env[:request_headers], data: data)
-          rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-            raise Faraday::ConnectionFailed, $ERROR_INFO
-          end
-        end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        end
-        # Remove the "HTTP/1.1 200", leaving just the reason phrase
-        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
-
-        save_response(env, response.status, response.body,
-                      response.headers, reason_phrase)
-
-        @app.call env
-      rescue ::Patron::TimeoutError => e
-        if connection_timed_out_message?(e.message)
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise Faraday::TimeoutError, e
-      rescue ::Patron::Error => e
-        if e.message.include?('code 407')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required ")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      end
-
-      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
-        # HAX: helps but doesn't work completely
-        # https://github.com/toland/patron/issues/34
-        ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          if actions[0].is_a?(Symbol)
-            actions << :patch unless actions.include? :patch
-            actions << :options unless actions.include? :options
-          else
-            # Patron 0.4.20 and up
-            actions << 'PATCH' unless actions.include? 'PATCH'
-            actions << 'OPTIONS' unless actions.include? 'OPTIONS'
-          end
-        end
-      end
-
-      def configure_ssl(session, ssl)
-        if ssl.fetch(:verify, true)
-          session.cacert = ssl[:ca_file]
-        else
-          session.insecure = true
-        end
-      end
-
-      def configure_timeouts(session, req)
-        return unless req
-
-        if (sec = request_timeout(:read, req))
-          session.timeout = sec
-        end
-
-        return unless (sec = request_timeout(:open, req))
-
-        session.connect_timeout = sec
-      end
-
-      def configure_proxy(session, proxy)
-        return unless proxy
-
-        proxy_uri = proxy[:uri].dup
-        proxy_uri.user = proxy[:user] &&
-                         Utils.escape(proxy[:user]).gsub('+', '%20')
-        proxy_uri.password = proxy[:password] &&
-                             Utils.escape(proxy[:password]).gsub('+', '%20')
-        session.proxy = proxy_uri.to_s
-      end
-
-      private
-
-      CURL_TIMEOUT_MESSAGES = [
-        'Connection time-out',
-        'Connection timed out',
-        'Timed out before name resolve',
-        'server connect has timed out',
-        'Resolving timed out',
-        'name lookup timed out',
-        'timed out before SSL',
-        'connect() timed out'
-      ].freeze
-
-      def connection_timed_out_message?(message)
-        CURL_TIMEOUT_MESSAGES.any? do |curl_message|
-          message.include?(curl_message)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-patron-1.0.0/lib/faraday/patron/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  module Patron
-    VERSION = '1.0.0'
-  end
-end