cybrid_api_id_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/sig/settings.rbs

@@ -0,0 +1,71 @@
+module HTTP2
+  MAX_HEADER_LIST_SIZE: Integer
+
+  SPEC_DEFAULT_CONNECTION_SETTINGS: Hash[Symbol, Integer]
+
+  ENCODING_CONTEXT_SETTINGS: Array[Symbol]
+
+  type huffman_type = :always | :never | :shorter
+
+  type index_type = :all | :static | :never
+
+  # Container for all settings required for the management of an HTTP/2 connection. This
+  # includes the managemenet of the settings negotiated via the SETTINGS frame, as well as
+  # user-level configuration related with header compression.
+  class Settings # this is actually a Struct, but RBS does not support it yet
+    # connection settings (send and received in the SETTINGS frame)
+
+    # maximum size of the header compression table used to decode header blocks, in bytes.
+    attr_reader settings_header_table_size: Integer
+
+    # can be used to disable server push (set to 0)
+    attr_reader settings_enable_push: Integer
+
+    # maximum number of concurrent streams that the sender will allow.
+    attr_reader settings_max_concurrent_streams: Integer
+
+    # initial window size (in bytes) for stream-level flow control.
+    attr_reader settings_initial_window_size: Integer
+
+    # max size of for payload that the sender is willing to receive, in bytes.
+    attr_reader settings_max_frame_size: Integer
+    attr_reader settings_max_header_list_size: Integer
+
+    # encoding context settings
+
+    # controls how to use huffman encoding to encode strings. can be one of the following values:
+    #
+    # * `:always` - Always use Huffman encoding
+    # * `:never` - Do not use Huffman encoding
+    # * `:shorter` - Use Huffman when the result is strictly shorter
+    attr_reader huffman: huffman_type
+
+    # controls the configuration of the HPACK indexing tables:
+    #
+    # * `:static` - use the static table only
+    # * `:all` - use the static table and the dynamic table
+    # * `:never` - do not use any of the tables.
+    attr_reader index: index_type
+
+    # maximum dynamic table size in bytes
+    attr_reader table_size: Integer
+
+    def initialize: (
+      # connection settings
+      ?settings_header_table_size: Integer,
+      ?settings_enable_push: Integer,
+      ?settings_max_concurrent_streams: Integer,
+      ?settings_initial_window_size: Integer,
+      ?settings_max_frame_size: Integer,
+      ?settings_max_header_list_size: Integer,
+      # encoding context settings
+      ?huffman: huffman_type,
+      ?index: index_type,
+      ?table_size: Integer
+    ) -> void
+
+    # yields connection-level settings only.
+    def connection_settings: () { (Symbol, Integer) -> void } -> self
+                           | () -> Enumerable[[Symbol, Integer]]
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/sig/stream.rbs

@@ -0,0 +1,93 @@
+module HTTP2
+  class Stream
+    include FlowBuffer
+    include Emitter
+
+    STREAM_OPEN_STATES: Array[Symbol]
+
+    attr_reader id: Integer
+    attr_reader state: Symbol
+    attr_reader parent: Stream?
+    attr_reader weight: Integer
+    attr_reader dependency: Integer
+    attr_reader remote_window: Integer
+    attr_reader local_window: Integer
+    attr_reader closed: Symbol?
+
+    @connection: Connection
+    @local_window_max_size: Integer
+    @error: bool
+    @_method: String?
+    @_content_length: Integer?
+    @_status_code: Integer?
+    @_waiting_on_trailers: bool
+    @_trailers: Array[String]?
+    @received_data: bool
+    @activated: bool
+
+    alias window local_window
+
+    def closed?: () -> bool
+
+    def receive: (frame frame) -> void
+
+    alias << receive
+
+    def verify_trailers: (headers_frame frame) -> void
+
+    def calculate_content_length: (Integer?) -> void
+
+    def send: (stream_frame_props frame) -> void
+
+    def headers: (Enumerable[header_pair] headers, ?end_headers: bool, ?end_stream: bool) -> void
+
+    def promise: (Enumerable[header_pair] headers, ?end_headers: bool) { (Stream) -> void } -> void
+
+    def reprioritize: (?weight: Integer, ?dependency: Integer, ?exclusive: bool) -> void
+
+    def data: (String payload, ?end_stream: bool) -> void
+
+    def chunk_data: (String payload, Integer max_size) { (String) -> void } -> String
+
+    def close: (Symbol error) -> void
+             | () -> void
+
+    def cancel: () -> void
+
+    def refuse: () -> void
+
+    def window_update: (Integer increment) -> void
+
+    private
+
+    def initialize: (
+      connection: Connection,
+      id: Integer,
+      ?weight: Integer,
+      ?dependency: Integer,
+      ?exclusive: bool,
+      ?parent: Stream?,
+      ?state: Symbol
+    ) -> untyped
+
+    def transition: (stream_frame_props frame, bool sending) -> void
+
+    def event: (Symbol newstate) -> void
+
+    def activate_stream_in_conn: () -> void
+
+    def close_stream_in_conn: (*untyped) -> void
+
+    def complete_transition: (frame) -> void
+
+    def process_priority: (priority_frame_inner_props frame) -> void
+
+    def end_stream?: (stream_frame_props frame) -> boolish
+
+    def stream_error: (?Symbol error, ?msg: String?) -> void
+
+    alias error stream_error
+
+    def manage_state: (stream_frame_props frame) { () -> void } -> void
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/LICENSE.txt

@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2013-2017 Docker, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/README.md

@@ -0,0 +1,164 @@
+# HTTPX: A Ruby HTTP library for tomorrow... and beyond!
+
+[![Gem Version](https://badge.fury.io/rb/httpx.svg)](http://rubygems.org/gems/httpx)
+[![pipeline status](https://gitlab.com/os85/httpx/badges/master/pipeline.svg)](https://gitlab.com/os85/httpx/pipelines?page=1&scope=all&ref=master)
+[![coverage report](https://gitlab.com/os85/httpx/badges/master/coverage.svg?job=coverage)](https://os85.gitlab.io/httpx/coverage/#_AllFiles)
+
+HTTPX is an HTTP client library for the Ruby programming language.
+
+Among its features, it supports:
+
+* HTTP/2 and HTTP/1.x protocol versions
+* Concurrent requests by default
+* Simple and chainable API
+* Proxy Support (HTTP(S), Socks4/4a/5)
+* Simple Timeout System
+* Lightweight by default (require what you need)
+
+And also:
+
+* Compression (gzip, deflate, brotli)
+* Streaming Requests
+* Auth (Basic Auth, Digest Auth, NTLM)
+* Expect 100-continue
+* Multipart Requests
+* Advanced Cookie handling
+* HTTP/2 Server Push
+* HTTP/1.1 Upgrade (support for "h2c", "h2")
+* Automatic follow redirects
+* GRPC
+* WebDAV
+* Circuit Breaker
+* HTTP-based response cache
+* International Domain Names
+
+## How
+
+Here are some simple examples:
+
+```ruby
+HTTPX.get("https://nghttp2.org").to_s #=> "<!DOCT...."
+```
+
+And that's the simplest one there is. But you can also do:
+
+```ruby
+HTTPX.post("http://example.com", form: { user: "john", password: "pass" })
+
+http = HTTPX.with(headers: { "x-my-name" => "joe" })
+File.open("path/to/file") do |file|
+  http.patch("http://example.com/file", body: file) # request body is streamed
+end
+```
+
+If you want to do some more things with the response, you can get an `HTTPX::Response`:
+
+```ruby
+response = HTTPX.get("https://nghttp2.org")
+puts response.status #=> 200
+body = response.body
+puts body #=> #<HTTPX::Response ...
+```
+
+You can also send as many requests as you want simultaneously:
+
+```ruby
+page1, page2, page3 = HTTPX.get("https://news.ycombinator.com/news", "https://news.ycombinator.com/news?p=2", "https://news.ycombinator.com/news?p=3")
+```
+
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem "httpx"
+```
+
+or install it in your system:
+
+```
+> gem install httpx
+```
+
+and then just require it in your program:
+
+```ruby
+require "httpx"
+```
+
+## What makes it the best ruby HTTP client
+
+
+### Concurrency, HTTP/2 support
+
+`httpx` supports HTTP/2 (for "https" requests, it'll automatically do ALPN negotiation). However if the server supports HTTP/1.1, it will use HTTP pipelining, falling back to 1 request at a time if the server doesn't support it either (and it'll use Keep-Alive connections, unless the server does not support).
+
+If you passed multiple URIs, it'll perform all of the requests concurrently, by mulitplexing on the necessary sockets (and it'll batch requests to the same socket when the origin is the same):
+
+```ruby
+HTTPX.get(
+  "https://news.ycombinator.com/news",
+  "https://news.ycombinator.com/news?p=2",
+  "https://google.com/q=me"
+) # first two requests will be multiplexed on the same socket.
+```
+
+### Clean API
+
+`httpx` builds all functions around the `HTTPX` module, so that all calls can compose of each other. Here are a few examples:
+
+```ruby
+response = HTTPX.get("https://www.google.com", params: { q: "me" })
+response = HTTPX.post("https://www.nghttp2.org/httpbin/post", form: { name: "John", age: "22" })
+response = HTTPX.plugin(:basic_auth)
+                .basic_auth("user", "pass")
+                .get("https://www.google.com")
+
+# more complex client objects can be cached, and are thread-safe
+http = HTTPX.plugin(:expect).with(headers: { "x-pvt-token" => "TOKEN" })
+http.get("https://example.com") # the above options will apply
+http.post("https://example2.com", form: { name: "John", age: "22" }) # same, plus the form POST body
+```
+
+### Lightweight
+
+It ships with most features published as a plugin, making vanilla `httpx` lightweight and dependency-free, while allowing you to "pay for what you use"
+
+The plugin system is similar to the ones used by [sequel](https://github.com/jeremyevans/sequel), [roda](https://github.com/jeremyevans/roda) or [shrine](https://github.com/shrinerb/shrine).
+
+### Advanced DNS features
+
+`HTTPX` ships with custom DNS resolver implementations, including a native Happy Eyeballs resolver implementation, and a DNS-over-HTTPS resolver.
+
+## User-driven test suite
+
+The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so actual requests are performed during tests.
+
+## Supported Rubies
+
+All Rubies greater or equal to 2.7, and always latest JRuby and Truffleruby.
+
+**Note**: This gem is tested against all latest patch versions, i.e. if you're using 3.3.0 and you experience some issue, please test it against 3.3.$latest before creating an issue.
+
+## Resources
+|               |                                                        |
+| ------------- | ------------------------------------------------------ |
+| Website       | https://honeyryderchuck.gitlab.io/httpx/               |
+| Documentation | https://honeyryderchuck.gitlab.io/httpx/rdoc/          |
+| Wiki          | https://honeyryderchuck.gitlab.io/httpx/wiki/home.html |
+| CI            | https://gitlab.com/os85/httpx/pipelines                |
+| Rubygems      | https://rubygems.org/gems/httpx                        |
+
+## Caveats
+
+## Versioning Policy
+
+`httpx` follows Semantic Versioning.
+
+## Contributing
+
+* Discuss your contribution in an issue
+* Fork it
+* Make your changes, add some tests (follow the instructions from [here](test/README.md))
+* Open a Merge Request (that's Pull Request in Github-ish)
+* Wait for feedback

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_0_1.md

@@ -0,0 +1,7 @@
+# Genesis Release
+
+This is the first release of `httpx`.
+
+It accomplishes all the API and feature goals necessary to its first use, which is testing server implementations.
+
+From here on, the sky is the limit. 

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_0_2.md

@@ -0,0 +1,9 @@
+# 0.0.2
+
+* Hot-Fixed a flaw from the first version which was breaking https calls (SNI was broken).
+
+* Added a few test hackernews scraping scripts, which will be used for trouble-shooting/benchmarking.
+
+* Refactored/Fixed closing connections (HTTP/2 connections were buffering but not sending the GOAWAY frame)
+
+

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_0_3.md

@@ -0,0 +1,9 @@
+# 0.0.3
+
+* Added `HTTPX::Response#raise_for_status`. If there was an error response, it will raise it's exception. If the HTTP response has a 4xx or 5xx error, it will raise an `HTTPX::HTTPError` exception (this feature was inspired by a similar feature in python requests library).
+
+* Added `HTTPX::Client#wrap`, which allows to use the client inside a block and keep connections open, without resorting to the initializer only.
+
+* TCP connection establishment errors are now wrapped in error responses, like other possible errors.
+
+* SSL non-blocking connection API is now in use (it was previously using the blocking connect API, and was breaking the hackernews script from time to time. Now I'm looking at you, DNS).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_0_4.md

@@ -0,0 +1,7 @@
+# 0.0.4
+
+* Added ANSI coloring to the debugging output (when in TTY mode).
+
+* `HTTPX::HTTPError` exceptions now carry the full response object, instead of just the status (so the user can inspect the body and headers if it so desires).
+
+* Fixed a bug related with HTTP/1 multiple requests on a domain which closed connections not being able to open a new socket to the domain.

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_0_5.md

@@ -0,0 +1,5 @@
+# 0.0.5
+
+* Fixed HTTP/1 pipelining (it's working again).
+
+* Fixed multiple requests to the same domain over https (SSL sockets weren't being properly reopened).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_10_0.md

@@ -0,0 +1,66 @@
+# 0.10.0
+
+## Features
+
+### Streaming Requests
+
+The `stream` plugin adds functionality to handle long-lived stream responses, such as the Twitter Streaming API:
+
+```ruby
+http = HTTPX.plugin(:stream)
+
+http.get(stream_api_endpoint, stream: true).each_line do |line|
+  payload = JSON.parse(line)
+  # do smth with this
+end
+```
+
+https://gitlab.com/os85/httpx/-/wikis/Stream
+
+### Rate Limiter
+
+The `rate_limiter` plugin adds functionality for automatically hooking into rate-limiting responses coming from the server, and waits-and-retries them according to what the server advertises.
+
+```ruby
+HTTPX.plugin(:rate_limiter).get(rate_limited_api_endpoint)
+# => 429 Too Many Requests .... Retry-After: 3
+# waits 3 seconds before retrying
+```
+
+https://gitlab.com/os85/httpx/-/wikis/Rate-Limiter
+
+### Ruby 3
+
+This release is the first testing against and targeting Ruby 3 and some of the new features.
+
+It ships with RBS signatures for all of the client-facing APIs. There's non 100% typinng coverage yet, but I'm gradually (pun intended) working on it.
+
+
+## Improvements
+
+### IDN support
+
+Requests where the domains are formed by non-ASCII characters, are now supported (if you're using ruby 2.3 or more recent).
+
+```ruby
+HTTPX.get("http://bücher.ch") # it works!
+```
+
+### cookies plugin full implementation
+
+
+The `cookies` plugin is now independent of 3rd-party gems. The motivation for this was that `http-cookie` was dependent of both `domain_name` and `unf` gems, which are currently unusable in ruby 3, and haven't received any update in the last 3 years.
+
+The implementation is still compliant with RFC6265, and all of the features provided in earlier versions were ported, exceptwhen loading the cookie jar stored in a Netscape-format file or Mozilla sqlite database, which were not documented for `httpx` anyway, and I considered too niche to backport. If you feel `httpx` should support those, do let me know.
+
+Some code from these gems, including the ruby punycode implementation, is now part of the source tree, along with its licenses and attribution mentions.
+
+## Bugfixes
+
+
+Several edge-case bugs have been fixed solely by the integration of RBS runtime type checking, including some bugs around closing a connection pool that can cause loops.
+
+
+## Regressions
+
+`HTTPX::ErrorResponse`'s methods `#headers` and `#reason` were removed, as they didn't provide much value. Consider calling `#raise_for_status` or checking the API (`is_a?(HTTPX::ErrorResponse)` or `respond_to?(:error)` are strategies for this).

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_10_1.md

@@ -0,0 +1,37 @@
+# 0.10.1
+
+## Improvements
+
+### URL-encoded nested params
+
+url encoder now supports nested params, which is a standard of rack-based frameworks:
+
+```ruby
+HTTPX.post("https://httpbin.org/post", form: { a: { b: 1 }, c: [2, 3] })
+# a[b]=1&c[]=2&c[]=3
+```
+
+This encoding scheme is now the standard for URL-encoded request bodies, query params, and `:multipart` plugin requests.
+
+### Socks4 IPv6 addresses
+
+HTTPX supports IPv6 Socks4 proxies now. This support is restricted to rubies where `IPAddr#hton` is implemented though, so you are encouraged to upgrade.
+
+## More verbose HTTP Errors
+
+`HTTPX::Response#raise_for_status` was raising exceptions for client/server HTTP errors codes (4xx/5xx). However, only the status code was part of the message.
+
+From now on, both headers and the responnse payload will also appear, so expected more verbosity, but also more meaningful information.
+
+## Bugfixes
+
+* HTTP/2 and HTTP/1.1 exhausted connections now get properly migrated into a new connection;
+* HTTP/2 421 responses will now correctly migrate the connection and pending requests to HTTP/1.1 (a hanging loop was being caused);
+* HTTP/2 connection failed with a GOAWAY settings timeout will now return error responses (instead of hanging indefinitely);
+* Non-IP proxy name-resolving errors will now move on to the next available proxy in the list (instead of hanging indefinitely);
+* Non-IP DNS resolve errors for `native` and `https` variants will now return the appropriate error response (instead of hanging indefinitely);
+
+## Chore
+
+* `HTTPX.plugins` is now officially deprecated (use `HTTPX.plugin` instead);
+

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/doc/release_notes/0_10_2.md

@@ -0,0 +1,5 @@
+# 0.10.2
+
+## Bugfixes
+
+Support for nested params in multipart forms introduced a bug where top-level params weren't being spread out correctly in the request body.