diff --git a/Gemfile b/Gemfile
index 87c56a70..68f2952c 100644
--- a/Gemfile
+++ b/Gemfile
@@ -4,19 +4,21 @@ source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
-gem 'html2rss'
+gem 'html2rss', '~> 0.14'
 gem 'html2rss-configs', github: 'html2rss/html2rss-configs'
 
 # Use these instead of the two above (uncomment them) when developing locally:
 # gem 'html2rss', path: '../html2rss'
 # gem 'html2rss-configs', path: '../html2rss-configs'
 
+gem 'base64'
 gem 'erubi'
 gem 'parallel'
 gem 'rack-cache'
 gem 'rack-timeout'
 gem 'rack-unreloader'
 gem 'roda'
+gem 'ssrf_filter'
 gem 'tilt'
 
 gem 'puma', require: false
@@ -33,7 +35,10 @@ group :development do
 end
 
 group :test do
+  gem 'climate_control'
+  gem 'rack-test'
   gem 'rspec'
   gem 'simplecov', require: false
   gem 'vcr'
+  gem 'webmock'
 end
diff --git a/Gemfile.lock b/Gemfile.lock
index 46bfddc5..87cc5f17 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -11,8 +11,14 @@ GEM
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.8)
     byebug (11.1.3)
+    climate_control (1.2.0)
     concurrent-ruby (1.3.4)
+    crack (1.0.0)
+      bigdecimal
+      rexml
     crass (1.0.6)
     diff-lcs (1.5.1)
     docile (1.4.1)
@@ -25,6 +31,7 @@ GEM
       faraday (>= 1, < 3)
     faraday-net_http (3.3.0)
       net-http
+    hashdiff (1.1.1)
     html2rss (0.14.0)
       addressable (~> 2.7)
       faraday (> 2.0.1, < 3.0)
@@ -75,6 +82,8 @@ GEM
     rack (3.1.7)
     rack-cache (1.17.0)
       rack (>= 0.4)
+    rack-test (2.1.0)
+      rack (>= 1.3)
     rack-timeout (0.7.0)
     rack-unreloader (2.1.0)
     rainbow (3.1.1)
@@ -132,6 +141,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    ssrf_filter (1.1.2)
     thor (1.3.2)
     tilt (2.4.0)
     tzinfo (2.0.6)
@@ -139,6 +149,10 @@ GEM
     unicode-display_width (2.5.0)
     uri (0.13.1)
     vcr (6.2.0)
+    webmock (3.24.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
     yard (0.9.36)
     zeitwerk (2.6.18)
 
@@ -151,13 +165,16 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  base64
   byebug
+  climate_control
   erubi
-  html2rss
+  html2rss (~> 0.14)
   html2rss-configs!
   parallel
   puma
   rack-cache
+  rack-test
   rack-timeout
   rack-unreloader
   rake
@@ -169,8 +186,10 @@ DEPENDENCIES
   rubocop-rspec
   rubocop-thread_safety
   simplecov
+  ssrf_filter
   tilt
   vcr
+  webmock
   yard
 
 BUNDLED WITH
diff --git a/README.md b/README.md
index d30ae229..9cc1fb84 100644
--- a/README.md
+++ b/README.md
@@ -45,9 +45,16 @@ services:
         target: /app/config/feeds.yml
         read_only: true
     environment:
-      - RACK_ENV=production
-      - HEALTH_CHECK_USERNAME=health
-      - HEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!
+      RACK_ENV: production
+      HEALTH_CHECK_USERNAME: health
+      HEALTH_CHECK_PASSWORD: please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!
+      # AUTO_SOURCE_ENABLED: true
+      # AUTO_SOURCE_USERNAME: foobar
+      # AUTO_SOURCE_PASSWORD: A-Unique-And-Long-Password-For-Your-Own-Instance
+      ## to allow just requests originating from the local host
+      # AUTO_SOURCE_ALLOWED_ORIGINS: 127.0.0.1:3000
+      ## to allow multiple origins, seperate those via comma:
+      # AUTO_SOURCE_ALLOWED_ORIGINS: example.com,h2r.host.tld
   watchtower:
     image: containrrr/watchtower
     volumes:
@@ -66,6 +73,31 @@ The [watchtower](https://containrrr.dev/watchtower/) service automatically pulls
 
 The `docker-compose.yml` above contains a service description for watchtower.
 
+## How to use automatic feed generation
+
+> [!NOTE]
+> This feature is disabled by default.
+
+To enable the `auto_source` feature, comment in the env variables in the `docker-compose.yml` file from above and change the values accordingly:
+
+```yaml
+environment:
+  ## … snip ✁
+  AUTO_SOURCE_ENABLED: true
+  AUTO_SOURCE_USERNAME: foobar
+  AUTO_SOURCE_PASSWORD: A-Unique-And-Long-Password-For-Your-Own-Instance
+  ## to allow just requests originating from the local host
+  AUTO_SOURCE_ALLOWED_ORIGINS: 127.0.0.1:3000
+  ## to allow multiple origins, seperate those via comma:
+  # AUTO_SOURCE_ALLOWED_ORIGINS: example.com,h2r.host.tld
+  ## … snap ✃
+```
+
+Restart the container and open <http://127.0.0.1:3000/auto_source>.
+When asked, enter your username and password.
+
+Then enter the URL of a website and click on the _Generate_ button.
+
 ## How to use the included configs
 
 html2rss-web comes with many feed configs out of the box. [See the file list of all configs.](https://github.com/html2rss/html2rss-configs/tree/master/lib/html2rss/configs)
@@ -85,7 +117,7 @@ To build your own RSS feed, you need to create a _feed config_.\
 That _feed config_ goes into the file `feeds.yml`.\
 Check out the [`example` feed config](https://github.com/html2rss/html2rss-web/blob/master/config/feeds.yml#L9).
 
-Please refer to [html2rss' README for a description of _the feed config and its options_](https://github.com/html2rss/html2rss#the-feed-config-and-its-options). html2rss-web is just a small web application that depends on html2rss.
+Please refer to [html2rss' README for a description of _the feed config and its options_](https://github.com/html2rss/html2rss#the-feed-config-and-its-options). html2rss-web is just a small web application that builds on html2rss.
 
 ## Versioning and releases
 
@@ -112,15 +144,23 @@ If you're going to host a public instance, _please, please, please_:
 
 ### Supported ENV variables
 
-| Name                           | Description                      |
-| ------------------------------ | -------------------------------- |
-| `PORT`                         | default: 3000                    |
-| `RACK_ENV`                     | default: 'development'           |
-| `RACK_TIMEOUT_SERVICE_TIMEOUT` | default: 15                      |
-| `WEB_CONCURRENCY`              | default: 2                       |
-| `WEB_MAX_THREADS`              | default: 5                       |
-| `HEALTH_CHECK_USERNAME`        | default: auto-generated on start |
-| `HEALTH_CHECK_PASSWORD`        | default: auto-generated on start |
+| Name                           | Description                        |
+| ------------------------------ | ---------------------------------- |
+| `BASE_URL`                     | default: '<http://localhost:3000>' |
+| `LOG_LEVEL`                    | default: 'warn'                    |
+| `HEALTH_CHECK_USERNAME`        | default: auto-generated on start   |
+| `HEALTH_CHECK_PASSWORD`        | default: auto-generated on start   |
+|                                |                                    |
+| `AUTO_SOURCE_ENABLED`          | default: false                     |
+| `AUTO_SOURCE_USERNAME          | no default                         |
+| `AUTO_SOURCE_PASSWORD          | no default                         |
+| `AUTO_SOURCE_ALLOWED_ORIGINS`  | no default.                        |
+|                                |                                    |
+| `PORT`                         | default: 3000                      |
+| `RACK_ENV`                     | default: 'development'             |
+| `RACK_TIMEOUT_SERVICE_TIMEOUT` | default: 15                        |
+| `WEB_CONCURRENCY`              | default: 2                         |
+| `WEB_MAX_THREADS`              | default: 5                         |
 
 ### Runtime monitoring via `GET /health_check.txt`
 
diff --git a/app.rb b/app.rb
index 37976e93..a75142cd 100644
--- a/app.rb
+++ b/app.rb
@@ -2,7 +2,6 @@
 
 require 'roda'
 require 'rack/cache'
-
 require_relative 'roda/roda_plugins/basic_auth'
 
 module Html2rss
@@ -12,12 +11,9 @@ module Web
     #
     # It is built with [Roda](https://roda.jeremyevans.net/).
     class App < Roda
-      # TODO: move to helper
-      def self.development?
-        ENV['RACK_ENV'] == 'development'
-      end
+      CONTENT_TYPE_RSS = 'application/xml'
 
-      def development? = self.class.development?
+      def self.development? = ENV['RACK_ENV'] == 'development'
 
       opts[:check_dynamic_arity] = false
       opts[:check_arity] = :warn
@@ -33,16 +29,16 @@ def development? = self.class.development?
         csp.script_src :self
         csp.connect_src :self
         csp.img_src :self
-        csp.font_src :self
+        csp.font_src :self, 'data:'
         csp.form_action :self
         csp.base_uri :none
-        csp.frame_ancestors :none
+        csp.frame_ancestors :self
+        csp.frame_src :self
         csp.block_all_mixed_content
       end
 
       plugin :default_headers,
              'Content-Type' => 'text/html',
-             'X-Frame-Options' => 'deny',
              'X-Content-Type-Options' => 'nosniff',
              'X-XSS-Protection' => '1; mode=block'
 
@@ -53,8 +49,9 @@ def development? = self.class.development?
         handle_error(error)
       end
 
-      plugin :hash_branches
+      plugin :hash_branch_view_subdir
       plugin :public
+      plugin :content_for
       plugin :render, escape: true, layout: 'layout'
       plugin :typecast_params
       plugin :basic_auth
@@ -69,7 +66,6 @@ def development? = self.class.development?
 
       route do |r|
         r.public
-
         r.hash_branches('')
 
         r.root { view 'index' }
diff --git a/config.ru b/config.ru
index 270d545e..cf3e5368 100644
--- a/config.ru
+++ b/config.ru
@@ -4,8 +4,6 @@ require 'rubygems'
 require 'bundler/setup'
 require 'rack-timeout'
 
-use Rack::Timeout
-
 dev = ENV.fetch('RACK_ENV', nil) == 'development'
 
 requires = Dir['app/**/*.rb']
@@ -26,6 +24,8 @@ if dev
 
   run Unreloader
 else
+  use Rack::Timeout
+
   require_relative 'app'
   requires.each { |f| require_relative f }
 
diff --git a/helpers/auto_source.rb b/helpers/auto_source.rb
new file mode 100644
index 00000000..fbf8e1a5
--- /dev/null
+++ b/helpers/auto_source.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'base64'
+require 'html2rss'
+require 'ssrf_filter'
+
+module Html2rss
+  module Web
+    ##
+    # Helper methods for handling auto source feature.
+    class AutoSource
+      def self.enabled?        = ENV['AUTO_SOURCE_ENABLED'].to_s == 'true'
+      def self.username        = ENV.fetch('AUTO_SOURCE_USERNAME')
+      def self.password        = ENV.fetch('AUTO_SOURCE_PASSWORD')
+
+      def self.allowed_origins = ENV.fetch('AUTO_SOURCE_ALLOWED_ORIGINS', '')
+                                    .split(',')
+                                    .map(&:strip)
+                                    .reject(&:empty?)
+                                    .to_set
+
+      # @param encoded_url [String] Base64 encoded URL
+      # @return [RSS::Rss]
+      def self.build_auto_source_from_encoded_url(encoded_url)
+        url = Addressable::URI.parse Base64.urlsafe_decode64(encoded_url)
+        request = SsrfFilter.get(url)
+        headers = request.to_hash.transform_values(&:first)
+
+        auto_source = Html2rss::AutoSource.new(url, body: request.body, headers:)
+
+        auto_source.channel.stylesheets << Html2rss::RssBuilder::Stylesheet.new(href: '/rss.xsl', type: 'text/xsl')
+
+        auto_source.build
+      end
+
+      # @param rss [RSS::Rss]
+      # @param default_in_minutes [Integer]
+      # @return [Integer]
+      def self.ttl_in_seconds(rss, default_in_minutes: 60)
+        (rss&.channel&.ttl || default_in_minutes) * 60
+      end
+
+      # @param request [Roda::RodaRequest]
+      # @param response [Roda::RodaResponse]
+      # @param allowed_origins [Set<String>]
+      def self.check_request_origin!(request, response, allowed_origins = AutoSource.allowed_origins)
+        if allowed_origins.empty?
+          response.write 'No allowed origins are configured. Please set AUTO_SOURCE_ALLOWED_ORIGINS.'
+        else
+          origin = Set[request.env['HTTP_HOST'], request.env['HTTP_X_FORWARDED_HOST']].delete(nil)
+          return if allowed_origins.intersect?(origin)
+
+          response.write 'Origin is not allowed.'
+        end
+
+        response.status = 403
+        request.halt
+      end
+    end
+  end
+end
diff --git a/helpers/error_handlers.rb b/helpers/handle_error.rb
similarity index 80%
rename from helpers/error_handlers.rb
rename to helpers/handle_error.rb
index e5f93236..b3245c0e 100644
--- a/helpers/error_handlers.rb
+++ b/helpers/handle_error.rb
@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'html2rss/configs'
+require_relative '../app/local_config'
+
 module Html2rss
   module Web
     class App
@@ -15,15 +18,21 @@ def handle_error(error) # rubocop:disable Metrics/MethodLength
         when LocalConfig::NotFound,
              Html2rss::Configs::ConfigNotFound
           set_error_response('Feed config not found', 404)
+        when Html2rss::Error
+          set_error_response('Html2rss error', 422)
         else
           set_error_response('Internal Server Error', 500)
         end
 
-        @show_backtrace = ENV.fetch('RACK_ENV', nil) == 'development'
+        @show_backtrace = self.class.development?
         @error = error
+
+        set_view_subdir nil
         view 'error'
       end
 
+      private
+
       def set_error_response(page_title, status)
         @page_title = page_title
         response.status = status
diff --git a/helpers/handle_html2rss_configs.rb b/helpers/handle_html2rss_configs.rb
index e3103cce..de616276 100644
--- a/helpers/handle_html2rss_configs.rb
+++ b/helpers/handle_html2rss_configs.rb
@@ -7,7 +7,7 @@ def handle_html2rss_configs(request, _folder_name, _config_name_with_ext)
         path = RequestPath.new(request)
 
         Html2rssFacade.from_config(path.full_config_name, typecast_params) do |config|
-          response['Content-Type'] = 'text/xml'
+          response['Content-Type'] = CONTENT_TYPE_RSS
           HttpCache.expires(response, config.ttl * 60, cache_control: 'public')
         end
       end
diff --git a/helpers/handle_local_config_feeds.rb b/helpers/handle_local_config_feeds.rb
index 03662af6..533fabf1 100644
--- a/helpers/handle_local_config_feeds.rb
+++ b/helpers/handle_local_config_feeds.rb
@@ -7,7 +7,7 @@ def handle_local_config_feeds(request, _config_name_with_ext)
         path = RequestPath.new(request)
 
         Html2rssFacade.from_local_config(path.full_config_name, typecast_params) do |config|
-          response['Content-Type'] = 'text/xml'
+          response['Content-Type'] = CONTENT_TYPE_RSS
           HttpCache.expires(response, config.ttl * 60, cache_control: 'public')
         end
       end
diff --git a/public/auto_source.css b/public/auto_source.css
new file mode 100644
index 00000000..00e6ae2a
--- /dev/null
+++ b/public/auto_source.css
@@ -0,0 +1,64 @@
+/* Auto Source Form */
+.auto_source {
+  display: flex;
+  flex-direction: column;
+}
+
+.auto_source input,
+.auto_source button {
+  width: 100%;
+}
+
+.auto_source > form {
+  display: flex;
+  flex-direction: column;
+}
+
+.auto_source > form input[type="submit"] {
+  flex: 1 1;
+  margin-right: 0;
+}
+
+.auto_source > nav {
+  display: flex;
+  flex-direction: column;
+}
+
+@media screen and (min-width: 768px) {
+  .auto_source > nav {
+    justify-content: space-between;
+    flex-direction: row;
+  }
+}
+
+.auto_source > nav button {
+  margin-left: 0.25em;
+  margin-right: 0;
+  flex: 1;
+}
+
+.auto_source__bookmarklet {
+  background-color: var(--background);
+  padding: 0.25em;
+  border-radius: 0.25em;
+}
+
+.auto_source button.muted {
+  color: var(--text-muted);
+  border: 1px solid var(--background-alt);
+}
+
+.auto_source iframe {
+  margin-top: 2em;
+  border: 2px groove transparent;
+  border-radius: 0.5em;
+  display: none; /* Hide by default */
+  transition: border-color 0.2s;
+}
+
+.auto_source iframe[src] {
+  display: block;
+  min-height: 50em;
+  max-height: 80vh;
+  border-color: var(--highlight);
+}
diff --git a/public/auto_source.js b/public/auto_source.js
new file mode 100644
index 00000000..d4c1c06d
--- /dev/null
+++ b/public/auto_source.js
@@ -0,0 +1,297 @@
+const autoSource = (function () {
+  const BASE_PATH = "auto_source";
+
+  class Bookmarklet {
+    constructor() {
+      const $bookmarklet = document.querySelector("a#bookmarklet");
+
+      if (!$bookmarklet) {
+        console.error("Bookmarklet element not found in the DOM.");
+        return;
+      }
+
+      $bookmarklet.href = this.generateBookmarkletHref();
+    }
+
+    generateBookmarkletHref() {
+      const h2rUrl = new URL(window.location.origin);
+      h2rUrl.pathname = `${BASE_PATH}/`;
+      h2rUrl.search = "?url=";
+      h2rUrl.hash = "";
+
+      return `javascript:window.location.href='${h2rUrl.toString()}'+window.location.href;`;
+    }
+  }
+
+  class FormHandler {
+    constructor() {
+      // Initialize DOM elements
+      this.form = document.querySelector("form");
+      this.urlInput = document.querySelector("#url");
+      this.iframe = document.querySelector("iframe");
+      this.rssUrlInput = document.querySelector("#rss_url");
+
+      if (!this.form || !this.urlInput || !this.iframe || !this.rssUrlInput) {
+        console.error("One or more necessary form elements were not found in the DOM.");
+        return;
+      }
+
+      // Bind event handlers
+      this.initEventListeners();
+      this.setInitialUrl();
+    }
+
+    /**
+     * Initializes event listeners for form elements.
+     */
+    initEventListeners() {
+      // Event listener for URL input change
+      this.urlInput.addEventListener("change", () => this.clearRssUrl());
+
+      // Event listener for form submit
+      this.form.addEventListener("submit", (event) => this.handleFormSubmit(event));
+
+      // Event listener for RSS URL input focus
+      this.rssUrlInput.addEventListener("focus", () => {
+        const strippedIframeSrc = this.iframe.src.replace("#items", "").trim();
+        if (this.rssUrlInput.value.trim() !== strippedIframeSrc) {
+          this.updateIframeSrc(this.rssUrlInput.value.trim());
+        }
+      });
+    }
+
+    /**
+     * Sets the initial URL from query parameter if it exists.
+     */
+    setInitialUrl() {
+      const params = new URLSearchParams(window.location.search);
+      const initialUrl = params.get("url");
+      if (initialUrl) {
+        this.urlInput.value = initialUrl;
+        this.form.dispatchEvent(new Event("submit"));
+      }
+    }
+
+    /**
+     * Clears the RSS URL input value.
+     */
+    clearRssUrl() {
+      this.rssUrlInput.value = "";
+    }
+
+    /**
+     * Handles form submission.
+     * @param {Event} event - The form submit event.
+     */
+    handleFormSubmit(event) {
+      event.preventDefault();
+
+      this.rssUrlInput.value = "";
+      this.iframe.src = "";
+
+      const url = this.urlInput.value;
+
+      if (this.isValidUrl(url)) {
+        const encodedUrl = this.encodeUrl(url);
+        const autoSourceUrl = this.generateAutoSourceUrl(encodedUrl);
+
+        this.rssUrlInput.value = autoSourceUrl;
+        this.rssUrlInput.select();
+
+        if (window.location.search !== `?url=${url}`) {
+          window.history.pushState({}, "", `?url=${url}`);
+        }
+      }
+    }
+
+    /**
+     * Checks if the URL is valid and starts with "http".
+     * @param {string} url - The URL to validate.
+     * @returns {boolean} True if the URL is valid, false otherwise.
+     */
+    isValidUrl(url) {
+      try {
+        new URL(url);
+        return url.trim() !== "" && url.startsWith("http");
+      } catch (_) {
+        return false;
+      }
+    }
+
+    /**
+     * Encodes the URL using base64 encoding.
+     * @param {string} url - The URL to encode.
+     * @returns {string} The base64 encoded URL.
+     */
+    encodeUrl(url) {
+      return btoa(url).replace(/=/g, "");
+    }
+
+    /**
+     * Generates an auto-source URL.
+     * @param {string} encodedUrl - The base64 encoded URL.
+     * @returns {string} The generated auto-source URL.
+     */
+    generateAutoSourceUrl(encodedUrl) {
+      const baseUrl = new URL(window.location.origin);
+      return `${baseUrl}${BASE_PATH}/${encodedUrl}`;
+    }
+
+    /**
+     * Updates the iframe source.
+     * @param {string} rssUrlValue - The RSS URL value.
+     */
+    updateIframeSrc(rssUrlValue) {
+      this.iframe.src = rssUrlValue === "" ? "" : `${rssUrlValue}#items`;
+    }
+  }
+
+  class ButtonHandler {
+    constructor() {
+      // Cache necessary DOM elements
+      const copyButton = document.querySelector("#copy");
+      const gotoButton = document.querySelector("#goto");
+      const openInFeedButton = document.querySelector("#openInFeed");
+      const rssUrlField = document.querySelector("#rss_url");
+      const resetCredentialsButton = document.querySelector("#resetCredentials");
+
+      if (!copyButton || !gotoButton || !openInFeedButton || !rssUrlField || !resetCredentialsButton) {
+        console.error("One or more necessary button elements were not found in the DOM.");
+        return;
+      }
+
+      // Assign elements to instance variables
+      this.copyButton = copyButton;
+      this.gotoButton = gotoButton;
+      this.openInFeedButton = openInFeedButton;
+      this.rssUrlField = rssUrlField;
+      this.resetCredentialsButton = resetCredentialsButton;
+
+      // Initialize event listeners
+      this.initEventListeners();
+    }
+
+    /**
+     * Initializes event listeners for buttons.
+     */
+    initEventListeners() {
+      // Bind event handlers to the context of the class instance
+      this.copyButton.addEventListener("click", this.copyText.bind(this));
+      this.gotoButton.addEventListener("click", this.openLink.bind(this));
+      this.openInFeedButton.addEventListener("click", this.subscribeToFeed.bind(this));
+      this.resetCredentialsButton.addEventListener("click", this.resetCredentials.bind(this));
+    }
+
+    /**
+     * Copies the text from the text field to the clipboard.
+     */
+    async copyText() {
+      try {
+        const textToCopy = this.rssUrlField.value;
+        await navigator.clipboard.writeText(textToCopy);
+      } catch (error) {
+        console.error("Failed to copy text to clipboard:", error);
+      }
+    }
+
+    /**
+     * Opens the link specified in the text field.
+     */
+    openLink() {
+      const linkToOpen = this.rssUrlField?.value;
+
+      if (typeof linkToOpen === "string" && linkToOpen.trim() !== "") {
+        window.open(linkToOpen, "_blank", "noopener,noreferrer");
+      }
+    }
+
+    /**
+     * Subscribes to the feed specified in the text field.
+     */
+    async subscribeToFeed() {
+      const feedUrl = this.rssUrlField.value;
+      const storedUser = LocalStorageFacade.getOrAsk("username");
+      const storedPassword = LocalStorageFacade.getOrAsk("password");
+
+      const url = new URL(feedUrl);
+      url.username = storedUser;
+      url.password = storedPassword;
+
+      const feedUrlWithAuth = `feed:${url.toString()}`;
+
+      window.open(feedUrlWithAuth);
+    }
+
+    resetCredentials() {
+      ["username", "password"].forEach((key) => {
+        LocalStorageFacade.remove(key);
+      });
+
+      alert("Credentials have been reset. Click 'Subscribe' to re-enter credentials.");
+    }
+  }
+
+  class LocalStorageFacade {
+    static get prefix() {
+      return "html2rss-web/auto_source/";
+    }
+
+    static get(key) {
+      key = LocalStorageFacade.encode(`${LocalStorageFacade.prefix}${key}`);
+
+      return LocalStorageFacade.decode(localStorage.getItem(key));
+    }
+
+    static set(key, value) {
+      key = LocalStorageFacade.encode(`${LocalStorageFacade.prefix}${key}`);
+
+      return localStorage.setItem(key, LocalStorageFacade.encode(value));
+    }
+
+    static remove(key) {
+      key = LocalStorageFacade.encode(`${LocalStorageFacade.prefix}${key}`);
+
+      return localStorage.removeItem(key);
+    }
+
+    static getOrAsk(key) {
+      let value = LocalStorageFacade.get(key);
+
+      while (typeof value !== "string" || value === "") {
+        value = window.prompt(`Please enter your ${key}:`);
+
+        if (!value || value.trim() === "") {
+          alert(`Blank ${key} submitted. Try again!`);
+        } else {
+          LocalStorageFacade.set(key, value);
+        }
+      }
+
+      return value;
+    }
+
+    static encode(value) {
+      return btoa(value.trim()).replace(/=/g, "");
+    }
+
+    static decode(value) {
+      if (typeof value !== "string") {
+        return null;
+      }
+
+      return atob(value);
+    }
+  }
+
+  function init() {
+    new Bookmarklet();
+    new FormHandler();
+    new ButtonHandler();
+  }
+
+  return { init: init };
+})();
+
+document.readyState === "complete"
+  ? autoSource.init()
+  : document.addEventListener("DOMContentLoaded", autoSource.init());
diff --git a/public/rss.xsl b/public/rss.xsl
index ab38a3e3..1d5258e9 100644
--- a/public/rss.xsl
+++ b/public/rss.xsl
@@ -42,11 +42,11 @@
     </p>
 
     <h2>Feed content preview</h2>
-    <ol class="items">
+    <ol class="items" id="items">
       <xsl:for-each select="rss/channel/item">
         <li>
           <h3>
-            <a rel="noopener">
+            <a rel="noopener" target="_blank">
               <xsl:attribute name="href"><xsl:value-of select="link"/></xsl:attribute>
               <xsl:value-of select="title"/>
             </a>
diff --git a/public/styles.css b/public/styles.css
index 553bbb1e..d62d7f0b 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -3,10 +3,28 @@
   --highlight: #ff9300;
 }
 
+::selection {
+  background-color: var(--highlight);
+}
+
+html {
+  box-sizing: border-box;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: inherit;
+}
+
+body {
+  scroll-behavior: smooth;
+}
+
+/* General Styles */
 label {
   font-weight: bold;
   cursor: pointer;
-  margin-top: 0.5em;
 }
 
 input[type="text"] {
@@ -18,10 +36,10 @@ body > h2 {
   margin-top: 2em;
 }
 
+/* List Items */
 .items {
   list-style: none;
-  padding-left: 0;
-  margin-top: 2em;
+  padding: 2em 0 0 0;
 }
 
 .items > li {
@@ -39,11 +57,12 @@ body > h2 {
   margin-top: 0;
 }
 
-.item > li > div {
+.items > li > div {
   font-size: 0.9em;
   padding: 0.25em;
 }
 
+/* Aside Icon */
 .aside-icon {
   position: fixed;
   top: 0.5em;
@@ -57,11 +76,13 @@ body > h2 {
   box-shadow: 0 0 0.25em;
   border-radius: 0.25em;
   border: 1px solid transparent;
-  transition: border-color 0.2s, opacity 0.2s;
+  transition:
+    border-color 0.2s,
+    opacity 0.2s;
 }
 
 .aside-icon > a:hover > img,
 .aside-icon > a:focus > img {
-  border-color: currentColor;
+  border-color: var(--highlight);
   opacity: 0.9;
 }
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
new file mode 100644
index 00000000..12969c98
--- /dev/null
+++ b/routes/auto_source.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../app/http_cache'
+require_relative '../helpers/auto_source'
+
+module Html2rss
+  module Web
+    class App
+      hash_branch 'auto_source' do |r|
+        with_basic_auth(realm: 'Auto Source',
+                        username: AutoSource.username,
+                        password: AutoSource.password) do
+          AutoSource.check_request_origin!(request, response)
+
+          if AutoSource.enabled?
+            r.root do
+              view 'index', layout: '/layout'
+            end
+
+            r.on String, method: :get do |encoded_url|
+              rss = AutoSource.build_auto_source_from_encoded_url(encoded_url)
+
+              HttpCache.expires response,
+                                AutoSource.ttl_in_seconds(rss),
+                                cache_control: 'private, must-revalidate'
+
+              response['Content-Type'] = CONTENT_TYPE_RSS
+
+              rss.to_s
+            end
+          else
+            # auto_source feature is disabled
+            r.on do
+              response.status = 400
+              'The auto source feature is disabled.'
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml b/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml
new file mode 100644
index 00000000..cccb4119
--- /dev/null
+++ b/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml
@@ -0,0 +1,102 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://140.82.121.3/html2rss/html2rss-web/commits/master
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+      Host:
+      - github.com
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Server:
+      - GitHub.com
+      Date:
+      - Sun, 20 Oct 2024 16:33:57 GMT
+      Content-Type:
+      - text/html; charset=utf-8
+      Vary:
+      - X-PJAX, X-PJAX-Container, Turbo-Visit, Turbo-Frame, Accept-Encoding, Accept,
+        X-Requested-With
+      Etag:
+      - W/"05a7012808772ba0e0bd352531fa0e7a"
+      Cache-Control:
+      - max-age=0, private, must-revalidate
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubdomains; preload
+      X-Frame-Options:
+      - deny
+      X-Content-Type-Options:
+      - nosniff
+      X-Xss-Protection:
+      - '0'
+      Referrer-Policy:
+      - no-referrer-when-downgrade
+      Content-Security-Policy:
+      - 'default-src ''none''; base-uri ''self''; child-src github.com/assets-cdn/worker/
+        github.com/webpack/ github.com/assets/ gist.github.com/assets-cdn/worker/;
+        connect-src ''self'' uploads.github.com www.githubstatus.com collector.github.com
+        raw.githubusercontent.com api.github.com github-cloud.s3.amazonaws.com github-production-repository-file-5c1aeb.s3.amazonaws.com
+        github-production-upload-manifest-file-7fdce7.s3.amazonaws.com github-production-user-asset-6210df.s3.amazonaws.com
+        *.rel.tunnels.api.visualstudio.com wss://*.rel.tunnels.api.visualstudio.com
+        objects-origin.githubusercontent.com copilot-proxy.githubusercontent.com proxy.individual.githubcopilot.com
+        proxy.business.githubcopilot.com proxy.enterprise.githubcopilot.com *.actions.githubusercontent.com
+        wss://*.actions.githubusercontent.com productionresultssa0.blob.core.windows.net/
+        productionresultssa1.blob.core.windows.net/ productionresultssa2.blob.core.windows.net/
+        productionresultssa3.blob.core.windows.net/ productionresultssa4.blob.core.windows.net/
+        productionresultssa5.blob.core.windows.net/ productionresultssa6.blob.core.windows.net/
+        productionresultssa7.blob.core.windows.net/ productionresultssa8.blob.core.windows.net/
+        productionresultssa9.blob.core.windows.net/ productionresultssa10.blob.core.windows.net/
+        productionresultssa11.blob.core.windows.net/ productionresultssa12.blob.core.windows.net/
+        productionresultssa13.blob.core.windows.net/ productionresultssa14.blob.core.windows.net/
+        productionresultssa15.blob.core.windows.net/ productionresultssa16.blob.core.windows.net/
+        productionresultssa17.blob.core.windows.net/ productionresultssa18.blob.core.windows.net/
+        productionresultssa19.blob.core.windows.net/ github-production-repository-image-32fea6.s3.amazonaws.com
+        github-production-release-asset-2e65be.s3.amazonaws.com insights.github.com
+        wss://alive.github.com api.githubcopilot.com api.individual.githubcopilot.com
+        api.business.githubcopilot.com api.enterprise.githubcopilot.com; font-src
+        github.githubassets.com; form-action ''self'' github.com gist.github.com copilot-workspace.githubnext.com
+        objects-origin.githubusercontent.com; frame-ancestors ''none''; frame-src
+        viewscreen.githubusercontent.com notebooks.githubusercontent.com; img-src
+        ''self'' data: blob: github.githubassets.com media.githubusercontent.com camo.githubusercontent.com
+        identicons.github.com avatars.githubusercontent.com private-avatars.githubusercontent.com
+        github-cloud.s3.amazonaws.com objects.githubusercontent.com secured-user-images.githubusercontent.com/
+        user-images.githubusercontent.com/ private-user-images.githubusercontent.com
+        opengraph.githubassets.com github-production-user-asset-6210df.s3.amazonaws.com
+        customer-stories-feed.github.com spotlights-feed.github.com objects-origin.githubusercontent.com
+        *.githubusercontent.com; manifest-src ''self''; media-src github.com user-images.githubusercontent.com/
+        secured-user-images.githubusercontent.com/ private-user-images.githubusercontent.com
+        github-production-user-asset-6210df.s3.amazonaws.com gist.github.com; script-src
+        github.githubassets.com; style-src ''unsafe-inline'' github.githubassets.com;
+        upgrade-insecure-requests; worker-src github.com/assets-cdn/worker/ github.com/webpack/
+        github.com/assets/ gist.github.com/assets-cdn/worker/'
+      Set-Cookie:
+      - _gh_sess=LeE%2BK48vEzjPkQtKqpuOwp8JGpYpIwL9xNwNlN4fRWJvuXeHMss3vP0r1vsBX1vXh6W8UVjvP29JNF%2BL2zUwczz%2FbiV1fdlLCmckJgfQUUQwTM5W%2FCrM2OOm91L%2FMY%2Fins0F8u6JTomT7zRvJlYns%2F9ghggsSqig6cyepiQHdY%2Bz%2BZgbvInoZm%2F9Y3JuJnnRNY1Xe5Wwyk4uZXx9ETqrQckia%2Bm1LiElw%2BgWnKE2yX0LAbfbM9R%2F2eDKAod2JxHVMY5Mk%2F%2F4PbtD%2BKpwZfW%2BJQ%3D%3D--wxBMY2hRrjUNiWWV--DRAFBTBsKbj5OkdSOlWdpg%3D%3D;
+        Path=/; HttpOnly; Secure; SameSite=Lax
+      - _octo=GH1.1.1506430827.1729442036; Path=/; Domain=github.com; Expires=Mon,
+        20 Oct 2025 16:33:56 GMT; Secure; SameSite=Lax
+      - logged_in=no; Path=/; Domain=github.com; Expires=Mon, 20 Oct 2025 16:33:56
+        GMT; HttpOnly; Secure; SameSite=Lax
+      Accept-Ranges:
+      - bytes
+      Transfer-Encoding:
+      - chunked
+      X-Github-Request-Id:
+      - D9BC:2C9A0F:144395:14B03F:671530F4
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        





<!DOCTYPE html>
<html
  lang="en"
  
  data-color-mode="auto" data-light-theme="light" data-dark-theme="dark"
  data-a11y-animated-images="system" data-a11y-link-underlines="true"
  
  >



  <head>
    <meta charset="utf-8">
  <link rel="dns-prefetch" href="https://github.githubassets.com">
  <link rel="dns-prefetch" href="https://avatars.githubusercontent.com">
  <link rel="dns-prefetch" href="https://github-cloud.s3.amazonaws.com">
  <link rel="dns-prefetch" href="https://user-images.githubusercontent.com/">
  <link rel="preconnect" href="https://github.githubassets.com" crossorigin>
  <link rel="preconnect" href="https://avatars.githubusercontent.com">

  


  <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/light-3e154969b9f9.css" /><link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/dark-9c5b7a476542.css" /><link data-color-theme="dark_dimmed" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_dimmed-afda8eb0fb33.css" /><link data-color-theme="dark_high_contrast" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_high_contrast-2494e44ccdc5.css" /><link data-color-theme="dark_colorblind" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_colorblind-56fff47acadc.css" /><link data-color-theme="light_colorblind" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/light_colorblind-71cd4cc132ec.css" /><link data-color-theme="light_high_contrast" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/light_high_contrast-fd5499848985.css" /><link data-color-theme="light_tritanopia" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/light_tritanopia-31d17ba3e139.css" /><link data-color-theme="dark_tritanopia" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_tritanopia-68d6b2c79663.css" />

    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-primitives-4cf0d59ab51a.css" />
    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-fefb1a332c28.css" />
    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/global-dfacc4e45ec5.css" />
    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/github-73db358cd913.css" />
  <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/repository-0f7cf89e325a.css" />
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/code-59de543ca292.css" />

  


  <script type="application/json" id="client-env">{"locale":"en","featureFlags":["code_vulnerability_scanning","copilot_beta_features_opt_in","copilot_chat_conversation_intent_knowledge_search_skill","copilot_chat_static_thread_suggestions","copilot_conversational_ux_history_refs","copilot_copy_message","copilot_implicit_context","copilot_smell_icebreaker_ux","experimentation_azure_variant_endpoint","failbot_handle_non_errors","geojson_azure_maps","ghost_pilot_confidence_truncation_25","ghost_pilot_confidence_truncation_40","hovercard_accessibility","hovercard_longer_activate_timeout","marketing_pages_search_explore_provider","remove_child_patch","sample_network_conn_type","site_metered_billing_update","issues_react_first_time_contribution_banner","jk_navigation_in_list_view","ui_commands_respect_modals","overview_branch_and_tag_count","overview_spoofed_commit_banner_react"]}</script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/wp-runtime-e711cecaa174.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_dompurify_dist_purify_js-b73fdff77a4e.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_oddbird_popover-polyfill_dist_popover_js-aff936e590ed.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_arianotify-polyfill_ariaNotify-polyfill_js-node_modules_github_mi-247092-76666ec8c39f.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_failbot_failbot_ts-314bc7883729.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/environment-b7c8196d9516.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_primer_behaviors_dist_esm_index_mjs-4aa4b0e95669.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_selector-observer_dist_index_esm_js-f690fd9ae3d5.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_relative-time-element_dist_index_js-6d3967acd51c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_combobox-nav_dist_index_js-node_modules_github_g-emoji-element_di-6ce195-53781cbc550f.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_text-expander-element_dist_index_js-f5498b8d4e5d.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_auto-complete-element_dist_index_js-a164c5ea9f62.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_filter-input-element_dist_index_js-node_modules_github_remote-inp-d1a841-8f251a0656e7.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_delegated-events_dist_index_js-node_modules_github_catalyst_lib_index_js-f4b251-f7c3b6081b19.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_mini-throttle_dist_index_js-node_modules_stacktrace-parser_dist_s-1f651a-0cff18664748.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_file-attachment-element_dist_index_js-node_modules_primer_view-co-21f158-7d460d5f7704.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/github-elements-aeb1b578f60b.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/element-registry-35c81adeb5a5.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_catalyst_lib_index_js-node_modules_primer_live-region-element_dis-037ad60-8582b70cd5a9.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_braintree_browser-detection_dist_browser-detection_js-node_modules_githu-bb80ec-634de60bacfa.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_lit-html_lit-html_js-ce7225a304c5.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_hydro-analytics-client_dist_analytics-client_js-node_modules_gith-f3aee1-e6893db9c19e.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_mini-throttle_dist_index_js-node_modules_morphdom_dist_morphdom-e-7c534c-f8a5485c982a.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_turbo_dist_turbo_es2017-esm_js-858e043fcf76.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_remote-form_dist_index_js-node_modules_delegated-events_dist_inde-893f9f-6cf3320416b8.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_scroll-anchoring_dist_scroll-anchoring_esm_js-node_modules_stacktrace-pa-a71630-67856ad29bae.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_color-convert_index_js-0e07cc183eed.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_quote-selection_dist_index_js-node_modules_github_session-resume_-9a8cd2-373766bf71f1.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_updatable-content_updatable-content_ts-69467ce2cf45.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/app_assets_modules_github_behaviors_task-list_ts-app_assets_modules_github_sso_ts-ui_packages-900dde-18d1c91a7872.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/app_assets_modules_github_sticky-scroll-into-view_ts-7cbef09a422c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/app_assets_modules_github_behaviors_ajax-error_ts-app_assets_modules_github_behaviors_include-d0d0a6-aa0f176b5b12.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/app_assets_modules_github_behaviors_commenting_edit_ts-app_assets_modules_github_behaviors_ht-83c235-c89801ebbe15.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/behaviors-93a5d7e13186.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_delegated-events_dist_index_js-node_modules_github_catalyst_lib_index_js-06ff531-bf7e5a3732fd.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/notifications-global-54f34167118d.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_virtualized-list_es_index_js-node_modules_github_template-parts_lib_index_js-96453a51f920.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_filter-input-element_dist_index_js-node_modules_github_remote-inp-cdab1b-03eba6ef6933.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_mini-throttle_dist_decorators_js-node_modules_delegated-events_di-e161aa-a6774a3bb897.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_file-attachment-element_dist_index_js-node_modules_github_remote--b0e14d-a57a4c842e6f.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/app_assets_modules_github_ref-selector_ts-a14af0a18402.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/repositories-e391e0092c62.js"></script>
  
  <script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/primer-react-65b92279806c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-core-0819e0281150.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-lib-7b7b5264f6c1.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/octicons-react-45c3a19dd792.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_emotion_is-prop-valid_dist_emotion-is-prop-valid_esm_js-node_modules_emo-41da55-1851acd376ff.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_oddbird_popover-polyfill_dist_popover-fn_js-4896ddd4b7bb.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_react-relay_index_js-ec159195f800.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_date-fns_format_mjs-486d100272bc.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_date-fns_addWeeks_mjs-node_modules_date-fns_addYears_mjs-node_modules_da-827f4f-cf37cd06c24f.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_focus-visible_dist_focus-visible_js-node_modules_fzy_js_index_js-node_mo-c4d1d6-a05a17a9cf03.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_hotkey_dist_index_js-node_modules_date-fns_getDaysInMonth_mjs-nod-70c11b-ab75dac7796a.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_react-relay_hooks_js-node_modules_github_paste-markdown_dist_index_js-no-da0d56-637b731b17ac.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_quote-selection_dist_index_js-node_modules_react-intersection-obs-075542-0ccda89eba42.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_hydro-analytics-client_dist_analytics-client_js-node_modules_gith-59dd96-25b7dbffe96d.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_aria-live_aria-live_ts-ui_packages_promise-with-resolvers-polyfill_promise-with-r-014121-ce989b6c1293.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_paths_index_ts-dce6cc95a312.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_ui-commands_ui-commands_ts-d25fac54a6bc.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_list-view_src_ListItem_ListItem_tsx-ui_packages_list-view_src_ListItem_Title_tsx--68e5b9-2e1957450c6d.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_date-picker_date-picker_ts-ui_packages_github-avatar_GitHubAvatar_tsx-408a62f07e62.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_item-picker_constants_labels_ts-ui_packages_item-picker_constants_values_ts-ui_pa-163a9a-fb8a70c9ab56.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_item-picker_components_RepositoryPicker_tsx-e6d08164eb66.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_issue-create_dialog_CreateIssueDialogEntry_tsx-83121a581e70.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_hydro-analytics_hydro-analytics_ts-ui_packages_ref-selector_RefSelector_tsx-a26f6bcc1e3a.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_commenting_hooks_use-markdown-body_ts-ui_packages_commenting_utils_blocked-commen-3a8adc-58eda7dae79c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_code-view-shared_hooks_shortcuts_ts-ui_packages_code-view-shared_utilities_web-wo-4a6509-1064a2d07db4.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/commits-808a73d44a0c.js"></script>
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-react.ed72bee494c072c5b54c.module.css" />
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/commits.824d6909bff76ee56c2f.module.css" />

  <script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/primer-react-65b92279806c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-core-0819e0281150.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-lib-7b7b5264f6c1.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/octicons-react-45c3a19dd792.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_emotion_is-prop-valid_dist_emotion-is-prop-valid_esm_js-node_modules_emo-41da55-1851acd376ff.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_oddbird_popover-polyfill_dist_popover-fn_js-4896ddd4b7bb.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/notifications-subscriptions-menu-5d446132baea.js"></script>
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-react.ed72bee494c072c5b54c.module.css" />
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/notifications-subscriptions-menu.1bcff9205c241e99cff2.module.css" />


  <title>Commits · html2rss/html2rss-web · GitHub</title>



  <meta name="route-pattern" content="/:user_id/:repository/commits(/*name)" data-turbo-transient>
  <meta name="route-controller" content="commits" data-turbo-transient>
  <meta name="route-action" content="show" data-turbo-transient>

    
  <meta name="current-catalog-service-hash" content="f3abb0cc802f3d7b95fc8762b94bdcb13bf39634c40c357301c4aa1d67a256fb">


  <meta name="request-id" content="D9BC:2C9A0F:144395:14B03F:671530F4" data-pjax-transient="true"/><meta name="html-safe-nonce" content="4a3657124ccafe73c8390f79dd8c921666dad2568cadfdcccbb8763b084d92e3" data-pjax-transient="true"/><meta name="visitor-payload" content="eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJEOUJDOjJDOUEwRjoxNDQzOTU6MTRCMDNGOjY3MTUzMEY0IiwidmlzaXRvcl9pZCI6IjY0NzAwNzExMzczODA2NzU4MjgiLCJyZWdpb25fZWRnZSI6ImZyYSIsInJlZ2lvbl9yZW5kZXIiOiJmcmEifQ==" data-pjax-transient="true"/><meta name="visitor-hmac" content="67fe1706caf66f28f435a2560f5751d08a2c6e0d905c6476daa21813b5fa658e" data-pjax-transient="true"/>


    <meta name="hovercard-subject-tag" content="repository:135929870" data-turbo-transient>


  <meta name="github-keyboard-shortcuts" content="repository,commit-list,copilot" data-turbo-transient="true" />
  

  <meta name="selected-link" value="/html2rss/html2rss-web/commits/master" data-turbo-transient>
  <link rel="assets" href="https://github.githubassets.com/">

    <meta name="google-site-verification" content="Apib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I">

<meta name="octolytics-url" content="https://collector.github.com/github/collect" />

  <meta name="analytics-location" content="/&lt;user-name&gt;/&lt;repo-name&gt;/commits/show" data-turbo-transient="true" />

  




    <meta name="user-login" content="">

  

    <meta name="viewport" content="width=device-width">

    

      <meta name="description" content="🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly. - Commits · html2rss/html2rss-web">

      <link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="GitHub">

    <link rel="fluid-icon" href="https://github.com/fluidicon.png" title="GitHub">
    <meta property="fb:app_id" content="1401488693436528">
    <meta name="apple-itunes-app" content="app-id=1477376905, app-argument=https://github.com/html2rss/html2rss-web/commits/master" />

      <meta name="twitter:image" content="https://repository-images.githubusercontent.com/135929870/81f1f732-1238-49b0-a66f-2e9987b4db58" /><meta name="twitter:site" content="@github" /><meta name="twitter:card" content="summary_large_image" /><meta name="twitter:title" content="Commits · html2rss/html2rss-web" /><meta name="twitter:description" content="🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly. - Commits · html2rss/html2rss-web" />
  <meta property="og:image" content="https://repository-images.githubusercontent.com/135929870/81f1f732-1238-49b0-a66f-2e9987b4db58" /><meta property="og:image:alt" content="🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly. - Commits · html2rss/html2rss-web" /><meta property="og:site_name" content="GitHub" /><meta property="og:type" content="object" /><meta property="og:title" content="Commits · html2rss/html2rss-web" /><meta property="og:url" content="https://github.com/html2rss/html2rss-web" /><meta property="og:description" content="🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly. - Commits · html2rss/html2rss-web" />
  




      <meta name="hostname" content="github.com">



        <meta name="expected-hostname" content="github.com">


  <meta http-equiv="x-pjax-version" content="49a0d34ddee86f2adbdf4cd17ab5a8ea0d524b7fe1c18248ab1376cf4570601f" data-turbo-track="reload">
  <meta http-equiv="x-pjax-csp-version" content="ace39c3b6632770952207593607e6e0be0db363435a8b877b1f96abe6430f345" data-turbo-track="reload">
  <meta http-equiv="x-pjax-css-version" content="6799ca7c5d90d335a555cb049e18e95092201b013b9dc658bb3fa3b68c57bc90" data-turbo-track="reload">
  <meta http-equiv="x-pjax-js-version" content="5c0a4ec477d61b3d1a9027a3bba77075e0e6027c512de21348fa78cf2ed18c6c" data-turbo-track="reload">

    <meta name="turbo-cache-control" content="no-preview" data-turbo-transient="">

      <meta name="turbo-cache-control" content="no-cache" data-turbo-transient>


  <meta name="go-import" content="github.com/html2rss/html2rss-web git https://github.com/html2rss/html2rss-web.git">

  <meta name="octolytics-dimension-user_id" content="67504668" /><meta name="octolytics-dimension-user_login" content="html2rss" /><meta name="octolytics-dimension-repository_id" content="135929870" /><meta name="octolytics-dimension-repository_nwo" content="html2rss/html2rss-web" /><meta name="octolytics-dimension-repository_public" content="true" /><meta name="octolytics-dimension-repository_is_fork" content="false" /><meta name="octolytics-dimension-repository_network_root_id" content="135929870" /><meta name="octolytics-dimension-repository_network_root_nwo" content="html2rss/html2rss-web" />



    

    <meta name="turbo-body-classes" content="logged-out env-production page-responsive">


  <meta name="browser-stats-url" content="https://api.github.com/_private/browser/stats">

  <meta name="browser-errors-url" content="https://api.github.com/_private/browser/errors">

  <link rel="mask-icon" href="https://github.githubassets.com/assets/pinned-octocat-093da3e6fa40.svg" color="#000000">
  <link rel="alternate icon" class="js-site-favicon" type="image/png" href="https://github.githubassets.com/favicons/favicon.png">
  <link rel="icon" class="js-site-favicon" type="image/svg+xml" href="https://github.githubassets.com/favicons/favicon.svg">

<meta name="theme-color" content="#1e2327">
<meta name="color-scheme" content="light dark" />


  <link rel="manifest" href="/manifest.json" crossOrigin="use-credentials">

  </head>

  <body class="logged-out env-production page-responsive" style="word-wrap: break-word;">
    <div data-turbo-body class="logged-out env-production page-responsive" style="word-wrap: break-word;">
      


    <div class="position-relative js-header-wrapper ">
      <a href="#start-of-content" data-skip-target-assigned="false" class="px-2 py-4 color-bg-accent-emphasis color-fg-on-emphasis show-on-focus js-skip-to-content">Skip to content</a>

      <span data-view-component="true" class="progress-pjax-loader Progress position-fixed width-full">
    <span style="width: 0%;" data-view-component="true" class="Progress-item progress-pjax-loader-bar left-0 top-0 color-bg-accent-emphasis"></span>
</span>      
      
      <script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_catalyst_lib_index_js-node_modules_github_hotkey_dist_index_js-no-d67c7f-bd7d077cdcb1.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/keyboard-shortcuts-dialog-a549d5821edb.js"></script>

<react-partial
  partial-name="keyboard-shortcuts-dialog"
  data-ssr="false"
  data-attempted-ssr="false"
>
  
  <script type="application/json" data-target="react-partial.embeddedData">{"props":{"docsUrl":"https://docs.github.com/get-started/accessibility/keyboard-shortcuts"}}</script>
  <div data-target="react-partial.reactRoot"></div>
</react-partial>




      

          

              
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_remote-form_dist_index_js-node_modules_delegated-events_dist_inde-94fd67-9a621ecbf672.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/sessions-b61003c45c5a.js"></script>
<header class="HeaderMktg header-logged-out js-details-container js-header Details position-relative f4 py-3" role="banner" data-color-mode=light data-light-theme=light data-dark-theme=dark>
  <h2 class="sr-only">Navigation Menu</h2>

  <button type="button" class="HeaderMktg-backdrop d-lg-none border-0 position-fixed top-0 left-0 width-full height-full js-details-target" aria-label="Toggle navigation">
    <span class="d-none">Toggle navigation</span>
  </button>

  <div class="d-flex flex-column flex-lg-row flex-items-center px-3 px-md-4 px-lg-5 height-full position-relative z-1">
    <div class="d-flex flex-justify-between flex-items-center width-full width-lg-auto">
      <div class="flex-1">
        <button aria-label="Toggle navigation" aria-expanded="false" type="button" data-view-component="true" class="js-details-target js-nav-padding-recalculate js-header-menu-toggle Button--link Button--medium Button d-lg-none color-fg-inherit p-1">  <span class="Button-content">
    <span class="Button-label"><div class="HeaderMenu-toggle-bar rounded my-1"></div>
            <div class="HeaderMenu-toggle-bar rounded my-1"></div>
            <div class="HeaderMenu-toggle-bar rounded my-1"></div></span>
  </span>
</button>
      </div>

      <a class="mr-lg-3 color-fg-inherit flex-order-2 js-prevent-focus-on-mobile-nav"
        href="/"
        aria-label="Homepage"
        data-analytics-event="{&quot;category&quot;:&quot;Marketing nav&quot;,&quot;action&quot;:&quot;click to go to homepage&quot;,&quot;label&quot;:&quot;ref_page:Marketing;ref_cta:Logomark;ref_loc:Header&quot;}">
        <svg height="32" aria-hidden="true" viewBox="0 0 24 24" version="1.1" width="32" data-view-component="true" class="octicon octicon-mark-github">
    <path d="M12.5.75C6.146.75 1 5.896 1 12.25c0 5.089 3.292 9.387 7.863 10.91.575.101.79-.244.79-.546 0-.273-.014-1.178-.014-2.142-2.889.532-3.636-.704-3.866-1.35-.13-.331-.69-1.352-1.18-1.625-.402-.216-.977-.748-.014-.762.906-.014 1.553.834 1.769 1.179 1.035 1.74 2.688 1.25 3.349.948.1-.747.402-1.25.733-1.538-2.559-.287-5.232-1.279-5.232-5.678 0-1.25.445-2.285 1.178-3.09-.115-.288-.517-1.467.115-3.048 0 0 .963-.302 3.163 1.179.92-.259 1.897-.388 2.875-.388.977 0 1.955.13 2.875.388 2.2-1.495 3.162-1.179 3.162-1.179.633 1.581.23 2.76.115 3.048.733.805 1.179 1.825 1.179 3.09 0 4.413-2.688 5.39-5.247 5.678.417.36.776 1.05.776 2.128 0 1.538-.014 2.774-.014 3.162 0 .302.216.662.79.547C20.709 21.637 24 17.324 24 12.25 24 5.896 18.854.75 12.5.75Z"></path>
</svg>
      </a>

      <div class="flex-1 flex-order-2 text-right">
          <a
            href="/login?return_to=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web%2Fcommits%2Fmaster"
            class="HeaderMenu-link HeaderMenu-button d-inline-flex d-lg-none flex-order-1 f5 no-underline border color-border-default rounded-2 px-2 py-1 color-fg-inherit js-prevent-focus-on-mobile-nav"
            data-hydro-click="{&quot;event_type&quot;:&quot;authentication.click&quot;,&quot;payload&quot;:{&quot;location_in_page&quot;:&quot;site header menu&quot;,&quot;repository_id&quot;:null,&quot;auth_type&quot;:&quot;SIGN_UP&quot;,&quot;originating_url&quot;:&quot;https://github.com/html2rss/html2rss-web/commits/master&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="2fcdd233dc323ade3f85d44cbbf9d702b72aba7ec4b698cb5998fa55147c31a8"
            data-analytics-event="{&quot;category&quot;:&quot;Marketing nav&quot;,&quot;action&quot;:&quot;click to Sign in&quot;,&quot;label&quot;:&quot;ref_page:Marketing;ref_cta:Sign in;ref_loc:Header&quot;}"
          >
            Sign in
          </a>
      </div>
    </div>


    <div class="HeaderMenu js-header-menu height-fit position-lg-relative d-lg-flex flex-column flex-auto top-0">
      <div class="HeaderMenu-wrapper d-flex flex-column flex-self-start flex-lg-row flex-auto rounded rounded-lg-0">
          <nav class="HeaderMenu-nav" aria-label="Global">
            <ul class="d-lg-flex list-style-none">
                <li class="HeaderMenu-item position-relative flex-wrap flex-justify-between flex-items-center d-block d-lg-flex flex-lg-nowrap flex-lg-items-center js-details-container js-header-menu-item">
      <button type="button" class="HeaderMenu-link border-0 width-full width-lg-auto px-0 px-lg-2 py-lg-2 no-wrap d-flex flex-items-center flex-justify-between js-details-target" aria-expanded="false">
        Product
        <svg opacity="0.5" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-chevron-down HeaderMenu-icon ml-1">
    <path d="M12.78 5.22a.749.749 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.06 0L3.22 6.28a.749.749 0 1 1 1.06-1.06L8 8.939l3.72-3.719a.749.749 0 0 1 1.06 0Z"></path>
</svg>
      </button>
      <div class="HeaderMenu-dropdown dropdown-menu rounded m-0 p-0 pt-2 pt-lg-4 position-relative position-lg-absolute left-0 left-lg-n3 pb-2 pb-lg-4 d-lg-flex flex-wrap dropdown-menu-wide">
          <div class="HeaderMenu-column px-lg-4 border-lg-right mb-4 mb-lg-0 pr-lg-7">
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0">
                <ul class="list-style-none f5" >
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;github_copilot&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;github_copilot_link_product_navbar&quot;}" href="https://github.com/features/copilot">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-copilot color-fg-subtle mr-3">
    <path d="M23.922 16.992c-.861 1.495-5.859 5.023-11.922 5.023-6.063 0-11.061-3.528-11.922-5.023A.641.641 0 0 1 0 16.736v-2.869a.841.841 0 0 1 .053-.22c.372-.935 1.347-2.292 2.605-2.656.167-.429.414-1.055.644-1.517a10.195 10.195 0 0 1-.052-1.086c0-1.331.282-2.499 1.132-3.368.397-.406.89-.717 1.474-.952 1.399-1.136 3.392-2.093 6.122-2.093 2.731 0 4.767.957 6.166 2.093.584.235 1.077.546 1.474.952.85.869 1.132 2.037 1.132 3.368 0 .368-.014.733-.052 1.086.23.462.477 1.088.644 1.517 1.258.364 2.233 1.721 2.605 2.656a.832.832 0 0 1 .053.22v2.869a.641.641 0 0 1-.078.256ZM12.172 11h-.344a4.323 4.323 0 0 1-.355.508C10.703 12.455 9.555 13 7.965 13c-1.725 0-2.989-.359-3.782-1.259a2.005 2.005 0 0 1-.085-.104L4 11.741v6.585c1.435.779 4.514 2.179 8 2.179 3.486 0 6.565-1.4 8-2.179v-6.585l-.098-.104s-.033.045-.085.104c-.793.9-2.057 1.259-3.782 1.259-1.59 0-2.738-.545-3.508-1.492a4.323 4.323 0 0 1-.355-.508h-.016.016Zm.641-2.935c.136 1.057.403 1.913.878 2.497.442.544 1.134.938 2.344.938 1.573 0 2.292-.337 2.657-.751.384-.435.558-1.15.558-2.361 0-1.14-.243-1.847-.705-2.319-.477-.488-1.319-.862-2.824-1.025-1.487-.161-2.192.138-2.533.529-.269.307-.437.808-.438 1.578v.021c0 .265.021.562.063.893Zm-1.626 0c.042-.331.063-.628.063-.894v-.02c-.001-.77-.169-1.271-.438-1.578-.341-.391-1.046-.69-2.533-.529-1.505.163-2.347.537-2.824 1.025-.462.472-.705 1.179-.705 2.319 0 1.211.175 1.926.558 2.361.365.414 1.084.751 2.657.751 1.21 0 1.902-.394 2.344-.938.475-.584.742-1.44.878-2.497Z"></path><path d="M14.5 14.25a1 1 0 0 1 1 1v2a1 1 0 0 1-2 0v-2a1 1 0 0 1 1-1Zm-5 0a1 1 0 0 1 1 1v2a1 1 0 0 1-2 0v-2a1 1 0 0 1 1-1Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">GitHub Copilot</div>
        Write better code with AI
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;security&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;security_link_product_navbar&quot;}" href="https://github.com/features/security">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-shield-check color-fg-subtle mr-3">
    <path d="M16.53 9.78a.75.75 0 0 0-1.06-1.06L11 13.19l-1.97-1.97a.75.75 0 0 0-1.06 1.06l2.5 2.5a.75.75 0 0 0 1.06 0l5-5Z"></path><path d="m12.54.637 8.25 2.675A1.75 1.75 0 0 1 22 4.976V10c0 6.19-3.771 10.704-9.401 12.83a1.704 1.704 0 0 1-1.198 0C5.77 20.705 2 16.19 2 10V4.976c0-.758.489-1.43 1.21-1.664L11.46.637a1.748 1.748 0 0 1 1.08 0Zm-.617 1.426-8.25 2.676a.249.249 0 0 0-.173.237V10c0 5.46 3.28 9.483 8.43 11.426a.199.199 0 0 0 .14 0C17.22 19.483 20.5 15.461 20.5 10V4.976a.25.25 0 0 0-.173-.237l-8.25-2.676a.253.253 0 0 0-.154 0Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Security</div>
        Find and fix vulnerabilities
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;actions&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;actions_link_product_navbar&quot;}" href="https://github.com/features/actions">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-workflow color-fg-subtle mr-3">
    <path d="M1 3a2 2 0 0 1 2-2h6.5a2 2 0 0 1 2 2v6.5a2 2 0 0 1-2 2H7v4.063C7 16.355 7.644 17 8.438 17H12.5v-2.5a2 2 0 0 1 2-2H21a2 2 0 0 1 2 2V21a2 2 0 0 1-2 2h-6.5a2 2 0 0 1-2-2v-2.5H8.437A2.939 2.939 0 0 1 5.5 15.562V11.5H3a2 2 0 0 1-2-2Zm2-.5a.5.5 0 0 0-.5.5v6.5a.5.5 0 0 0 .5.5h6.5a.5.5 0 0 0 .5-.5V3a.5.5 0 0 0-.5-.5ZM14.5 14a.5.5 0 0 0-.5.5V21a.5.5 0 0 0 .5.5H21a.5.5 0 0 0 .5-.5v-6.5a.5.5 0 0 0-.5-.5Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Actions</div>
        Automate any workflow
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;codespaces&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;codespaces_link_product_navbar&quot;}" href="https://github.com/features/codespaces">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-codespaces color-fg-subtle mr-3">
    <path d="M3.5 3.75C3.5 2.784 4.284 2 5.25 2h13.5c.966 0 1.75.784 1.75 1.75v7.5A1.75 1.75 0 0 1 18.75 13H5.25a1.75 1.75 0 0 1-1.75-1.75Zm-2 12c0-.966.784-1.75 1.75-1.75h17.5c.966 0 1.75.784 1.75 1.75v4a1.75 1.75 0 0 1-1.75 1.75H3.25a1.75 1.75 0 0 1-1.75-1.75ZM5.25 3.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h13.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Zm-2 12a.25.25 0 0 0-.25.25v4c0 .138.112.25.25.25h17.5a.25.25 0 0 0 .25-.25v-4a.25.25 0 0 0-.25-.25Z"></path><path d="M10 17.75a.75.75 0 0 1 .75-.75h6.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1-.75-.75Zm-4 0a.75.75 0 0 1 .75-.75h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1-.75-.75Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Codespaces</div>
        Instant dev environments
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;issues&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;issues_link_product_navbar&quot;}" href="https://github.com/features/issues">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-issue-opened color-fg-subtle mr-3">
    <path d="M12 1c6.075 0 11 4.925 11 11s-4.925 11-11 11S1 18.075 1 12 5.925 1 12 1ZM2.5 12a9.5 9.5 0 0 0 9.5 9.5 9.5 9.5 0 0 0 9.5-9.5A9.5 9.5 0 0 0 12 2.5 9.5 9.5 0 0 0 2.5 12Zm9.5 2a2 2 0 1 1-.001-3.999A2 2 0 0 1 12 14Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Issues</div>
        Plan and track work
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;code_review&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;code_review_link_product_navbar&quot;}" href="https://github.com/features/code-review">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-code-review color-fg-subtle mr-3">
    <path d="M10.3 6.74a.75.75 0 0 1-.04 1.06l-2.908 2.7 2.908 2.7a.75.75 0 1 1-1.02 1.1l-3.5-3.25a.75.75 0 0 1 0-1.1l3.5-3.25a.75.75 0 0 1 1.06.04Zm3.44 1.06a.75.75 0 1 1 1.02-1.1l3.5 3.25a.75.75 0 0 1 0 1.1l-3.5 3.25a.75.75 0 1 1-1.02-1.1l2.908-2.7-2.908-2.7Z"></path><path d="M1.5 4.25c0-.966.784-1.75 1.75-1.75h17.5c.966 0 1.75.784 1.75 1.75v12.5a1.75 1.75 0 0 1-1.75 1.75h-9.69l-3.573 3.573A1.458 1.458 0 0 1 5 21.043V18.5H3.25a1.75 1.75 0 0 1-1.75-1.75ZM3.25 4a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h2.5a.75.75 0 0 1 .75.75v3.19l3.72-3.72a.749.749 0 0 1 .53-.22h10a.25.25 0 0 0 .25-.25V4.25a.25.25 0 0 0-.25-.25Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Code Review</div>
        Manage code changes
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;discussions&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;discussions_link_product_navbar&quot;}" href="https://github.com/features/discussions">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-comment-discussion color-fg-subtle mr-3">
    <path d="M1.75 1h12.5c.966 0 1.75.784 1.75 1.75v9.5A1.75 1.75 0 0 1 14.25 14H8.061l-2.574 2.573A1.458 1.458 0 0 1 3 15.543V14H1.75A1.75 1.75 0 0 1 0 12.25v-9.5C0 1.784.784 1 1.75 1ZM1.5 2.75v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25H1.75a.25.25 0 0 0-.25.25Z"></path><path d="M22.5 8.75a.25.25 0 0 0-.25-.25h-3.5a.75.75 0 0 1 0-1.5h3.5c.966 0 1.75.784 1.75 1.75v9.5A1.75 1.75 0 0 1 22.25 20H21v1.543a1.457 1.457 0 0 1-2.487 1.03L15.939 20H10.75A1.75 1.75 0 0 1 9 18.25v-1.465a.75.75 0 0 1 1.5 0v1.465c0 .138.112.25.25.25h5.5a.75.75 0 0 1 .53.22l2.72 2.72v-2.19a.75.75 0 0 1 .75-.75h2a.25.25 0 0 0 .25-.25v-9.5Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Discussions</div>
        Collaborate outside of code
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;code_search&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;code_search_link_product_navbar&quot;}" href="https://github.com/features/code-search">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-code-square color-fg-subtle mr-3">
    <path d="M10.3 8.24a.75.75 0 0 1-.04 1.06L7.352 12l2.908 2.7a.75.75 0 1 1-1.02 1.1l-3.5-3.25a.75.75 0 0 1 0-1.1l3.5-3.25a.75.75 0 0 1 1.06.04Zm3.44 1.06a.75.75 0 1 1 1.02-1.1l3.5 3.25a.75.75 0 0 1 0 1.1l-3.5 3.25a.75.75 0 1 1-1.02-1.1l2.908-2.7-2.908-2.7Z"></path><path d="M2 3.75C2 2.784 2.784 2 3.75 2h16.5c.966 0 1.75.784 1.75 1.75v16.5A1.75 1.75 0 0 1 20.25 22H3.75A1.75 1.75 0 0 1 2 20.25Zm1.75-.25a.25.25 0 0 0-.25.25v16.5c0 .138.112.25.25.25h16.5a.25.25 0 0 0 .25-.25V3.75a.25.25 0 0 0-.25-.25Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Code Search</div>
        Find more, search less
      </div>

    
</a></li>

                </ul>
              </div>
          </div>
          <div class="HeaderMenu-column px-lg-4">
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0 border-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="product-explore-heading">Explore</span>
                <ul class="list-style-none f5" aria-labelledby="product-explore-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;all_features&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;all_features_link_product_navbar&quot;}" href="https://github.com/features">
      All features

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary Link--external" target="_blank" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;documentation&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;documentation_link_product_navbar&quot;}" href="https://docs.github.com">
      Documentation

    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link-external HeaderMenu-external-icon color-fg-subtle">
    <path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path>
</svg>
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary Link--external" target="_blank" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;github_skills&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;github_skills_link_product_navbar&quot;}" href="https://skills.github.com">
      GitHub Skills

    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link-external HeaderMenu-external-icon color-fg-subtle">
    <path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path>
</svg>
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary Link--external" target="_blank" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;blog&quot;,&quot;context&quot;:&quot;product&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;blog_link_product_navbar&quot;}" href="https://github.blog">
      Blog

    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link-external HeaderMenu-external-icon color-fg-subtle">
    <path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path>
</svg>
</a></li>

                </ul>
              </div>
          </div>
      </div>
</li>

                  <li class="HeaderMenu-item position-relative flex-wrap flex-justify-between flex-items-center d-block d-lg-flex flex-lg-nowrap flex-lg-items-center js-details-container js-header-menu-item">
      <button type="button" class="HeaderMenu-link border-0 width-full width-lg-auto px-0 px-lg-2 py-lg-2 no-wrap d-flex flex-items-center flex-justify-between js-details-target" aria-expanded="false">
        Solutions
        <svg opacity="0.5" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-chevron-down HeaderMenu-icon ml-1">
    <path d="M12.78 5.22a.749.749 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.06 0L3.22 6.28a.749.749 0 1 1 1.06-1.06L8 8.939l3.72-3.719a.749.749 0 0 1 1.06 0Z"></path>
</svg>
      </button>
      <div class="HeaderMenu-dropdown dropdown-menu rounded m-0 p-0 pt-2 pt-lg-4 position-relative position-lg-absolute left-0 left-lg-n3 d-lg-flex flex-wrap dropdown-menu-wide">
          <div class="HeaderMenu-column px-lg-4 border-lg-right mb-4 mb-lg-0 pr-lg-7">
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0 pb-lg-3 mb-3 mb-lg-0">
                    <span class="d-block h4 color-fg-default my-1" id="solutions-by-company-size-heading">By company size</span>
                <ul class="list-style-none f5" aria-labelledby="solutions-by-company-size-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;enterprises&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;enterprises_link_solutions_navbar&quot;}" href="https://github.com/enterprise">
      Enterprises

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;small_and_medium_teams&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;small_and_medium_teams_link_solutions_navbar&quot;}" href="https://github.com/team">
      Small and medium teams

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;startups&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;startups_link_solutions_navbar&quot;}" href="https://github.com/enterprise/startups">
      Startups

    
</a></li>

                </ul>
              </div>
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="solutions-by-use-case-heading">By use case</span>
                <ul class="list-style-none f5" aria-labelledby="solutions-by-use-case-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;devsecops&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;devsecops_link_solutions_navbar&quot;}" href="/solutions/use-case/devsecops">
      DevSecOps

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;devops&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;devops_link_solutions_navbar&quot;}" href="/solutions/use-case/devops">
      DevOps

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;ci_cd&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;ci_cd_link_solutions_navbar&quot;}" href="/solutions/use-case/ci-cd">
      CI/CD

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;view_all_use_cases&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;view_all_use_cases_link_solutions_navbar&quot;}" href="/solutions/use-case">
      View all use cases

    
</a></li>

                </ul>
              </div>
          </div>
          <div class="HeaderMenu-column px-lg-4">
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="solutions-by-industry-heading">By industry</span>
                <ul class="list-style-none f5" aria-labelledby="solutions-by-industry-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;healthcare&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;healthcare_link_solutions_navbar&quot;}" href="/solutions/industry/healthcare">
      Healthcare

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;financial_services&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;financial_services_link_solutions_navbar&quot;}" href="/solutions/industry/financial-services">
      Financial services

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;manufacturing&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;manufacturing_link_solutions_navbar&quot;}" href="/solutions/industry/manufacturing">
      Manufacturing

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;government&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;government_link_solutions_navbar&quot;}" href="/solutions/industry/government">
      Government

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;view_all_industries&quot;,&quot;context&quot;:&quot;solutions&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;view_all_industries_link_solutions_navbar&quot;}" href="/solutions/industry">
      View all industries

    
</a></li>

                </ul>
              </div>
          </div>
         <div class="HeaderMenu-trailing-link rounded-bottom-2 flex-shrink-0 mt-lg-4 px-lg-4 py-4 py-lg-3 f5 text-semibold">
            <a href="/solutions">
              View all solutions
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-chevron-right HeaderMenu-trailing-link-icon">
    <path d="M6.22 3.22a.75.75 0 0 1 1.06 0l4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L9.94 8 6.22 4.28a.75.75 0 0 1 0-1.06Z"></path>
</svg>
</a>         </div>
      </div>
</li>

                  <li class="HeaderMenu-item position-relative flex-wrap flex-justify-between flex-items-center d-block d-lg-flex flex-lg-nowrap flex-lg-items-center js-details-container js-header-menu-item">
      <button type="button" class="HeaderMenu-link border-0 width-full width-lg-auto px-0 px-lg-2 py-lg-2 no-wrap d-flex flex-items-center flex-justify-between js-details-target" aria-expanded="false">
        Resources
        <svg opacity="0.5" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-chevron-down HeaderMenu-icon ml-1">
    <path d="M12.78 5.22a.749.749 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.06 0L3.22 6.28a.749.749 0 1 1 1.06-1.06L8 8.939l3.72-3.719a.749.749 0 0 1 1.06 0Z"></path>
</svg>
      </button>
      <div class="HeaderMenu-dropdown dropdown-menu rounded m-0 p-0 pt-2 pt-lg-4 position-relative position-lg-absolute left-0 left-lg-n3 pb-2 pb-lg-4 d-lg-flex flex-wrap dropdown-menu-wide">
          <div class="HeaderMenu-column px-lg-4 border-lg-right mb-4 mb-lg-0 pr-lg-7">
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="resources-topics-heading">Topics</span>
                <ul class="list-style-none f5" aria-labelledby="resources-topics-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;ai&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;ai_link_resources_navbar&quot;}" href="/resources/articles/ai">
      AI

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;devops&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;devops_link_resources_navbar&quot;}" href="/resources/articles/devops">
      DevOps

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;security&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;security_link_resources_navbar&quot;}" href="/resources/articles/security">
      Security

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;software_development&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;software_development_link_resources_navbar&quot;}" href="/resources/articles/software-development">
      Software Development

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;view_all&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;view_all_link_resources_navbar&quot;}" href="/resources/articles">
      View all

    
</a></li>

                </ul>
              </div>
          </div>
          <div class="HeaderMenu-column px-lg-4">
              <div class="border-bottom pb-3 pb-lg-0 border-lg-bottom-0 border-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="resources-explore-heading">Explore</span>
                <ul class="list-style-none f5" aria-labelledby="resources-explore-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary Link--external" target="_blank" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;learning_pathways&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;learning_pathways_link_resources_navbar&quot;}" href="https://resources.github.com/learn/pathways">
      Learning Pathways

    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link-external HeaderMenu-external-icon color-fg-subtle">
    <path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path>
</svg>
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary Link--external" target="_blank" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;white_papers_ebooks_webinars&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;white_papers_ebooks_webinars_link_resources_navbar&quot;}" href="https://resources.github.com">
      White papers, Ebooks, Webinars

    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link-external HeaderMenu-external-icon color-fg-subtle">
    <path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path>
</svg>
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;customer_stories&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;customer_stories_link_resources_navbar&quot;}" href="https://github.com/customer-stories">
      Customer Stories

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary Link--external" target="_blank" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;partners&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;partners_link_resources_navbar&quot;}" href="https://partner.github.com">
      Partners

    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link-external HeaderMenu-external-icon color-fg-subtle">
    <path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path>
</svg>
</a></li>

                </ul>
              </div>
          </div>
      </div>
</li>


                <li class="HeaderMenu-item position-relative flex-wrap flex-justify-between flex-items-center d-block d-lg-flex flex-lg-nowrap flex-lg-items-center js-details-container js-header-menu-item">
      <button type="button" class="HeaderMenu-link border-0 width-full width-lg-auto px-0 px-lg-2 py-lg-2 no-wrap d-flex flex-items-center flex-justify-between js-details-target" aria-expanded="false">
        Open Source
        <svg opacity="0.5" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-chevron-down HeaderMenu-icon ml-1">
    <path d="M12.78 5.22a.749.749 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.06 0L3.22 6.28a.749.749 0 1 1 1.06-1.06L8 8.939l3.72-3.719a.749.749 0 0 1 1.06 0Z"></path>
</svg>
      </button>
      <div class="HeaderMenu-dropdown dropdown-menu rounded m-0 p-0 pt-2 pt-lg-4 position-relative position-lg-absolute left-0 left-lg-n3 pb-2 pb-lg-4 px-lg-4">
          <div class="HeaderMenu-column">
              <div class="border-bottom pb-3 pb-lg-0 pb-lg-3 mb-3 mb-lg-0 mb-lg-3">
                <ul class="list-style-none f5" >
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;github_sponsors&quot;,&quot;context&quot;:&quot;open_source&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;github_sponsors_link_open_source_navbar&quot;}" href="/sponsors">
      
      <div>
        <div class="color-fg-default h4">GitHub Sponsors</div>
        Fund open source developers
      </div>

    
</a></li>

                </ul>
              </div>
              <div class="border-bottom pb-3 pb-lg-0 pb-lg-3 mb-3 mb-lg-0 mb-lg-3">
                <ul class="list-style-none f5" >
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;the_readme_project&quot;,&quot;context&quot;:&quot;open_source&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;the_readme_project_link_open_source_navbar&quot;}" href="https://github.com/readme">
      
      <div>
        <div class="color-fg-default h4">The ReadME Project</div>
        GitHub community articles
      </div>

    
</a></li>

                </ul>
              </div>
              <div class="border-bottom pb-3 pb-lg-0 border-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="open-source-repositories-heading">Repositories</span>
                <ul class="list-style-none f5" aria-labelledby="open-source-repositories-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;topics&quot;,&quot;context&quot;:&quot;open_source&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;topics_link_open_source_navbar&quot;}" href="https://github.com/topics">
      Topics

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;trending&quot;,&quot;context&quot;:&quot;open_source&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;trending_link_open_source_navbar&quot;}" href="https://github.com/trending">
      Trending

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;collections&quot;,&quot;context&quot;:&quot;open_source&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;collections_link_open_source_navbar&quot;}" href="https://github.com/collections">
      Collections

    
</a></li>

                </ul>
              </div>
          </div>
      </div>
</li>


                <li class="HeaderMenu-item position-relative flex-wrap flex-justify-between flex-items-center d-block d-lg-flex flex-lg-nowrap flex-lg-items-center js-details-container js-header-menu-item">
      <button type="button" class="HeaderMenu-link border-0 width-full width-lg-auto px-0 px-lg-2 py-lg-2 no-wrap d-flex flex-items-center flex-justify-between js-details-target" aria-expanded="false">
        Enterprise
        <svg opacity="0.5" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-chevron-down HeaderMenu-icon ml-1">
    <path d="M12.78 5.22a.749.749 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.06 0L3.22 6.28a.749.749 0 1 1 1.06-1.06L8 8.939l3.72-3.719a.749.749 0 0 1 1.06 0Z"></path>
</svg>
      </button>
      <div class="HeaderMenu-dropdown dropdown-menu rounded m-0 p-0 pt-2 pt-lg-4 position-relative position-lg-absolute left-0 left-lg-n3 pb-2 pb-lg-4 px-lg-4">
          <div class="HeaderMenu-column">
              <div class="border-bottom pb-3 pb-lg-0 pb-lg-3 mb-3 mb-lg-0 mb-lg-3">
                <ul class="list-style-none f5" >
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;enterprise_platform&quot;,&quot;context&quot;:&quot;enterprise&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;enterprise_platform_link_enterprise_navbar&quot;}" href="/enterprise">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-stack color-fg-subtle mr-3">
    <path d="M11.063 1.456a1.749 1.749 0 0 1 1.874 0l8.383 5.316a1.751 1.751 0 0 1 0 2.956l-8.383 5.316a1.749 1.749 0 0 1-1.874 0L2.68 9.728a1.751 1.751 0 0 1 0-2.956Zm1.071 1.267a.25.25 0 0 0-.268 0L3.483 8.039a.25.25 0 0 0 0 .422l8.383 5.316a.25.25 0 0 0 .268 0l8.383-5.316a.25.25 0 0 0 0-.422Z"></path><path d="M1.867 12.324a.75.75 0 0 1 1.035-.232l8.964 5.685a.25.25 0 0 0 .268 0l8.964-5.685a.75.75 0 0 1 .804 1.267l-8.965 5.685a1.749 1.749 0 0 1-1.874 0l-8.965-5.685a.75.75 0 0 1-.231-1.035Z"></path><path d="M1.867 16.324a.75.75 0 0 1 1.035-.232l8.964 5.685a.25.25 0 0 0 .268 0l8.964-5.685a.75.75 0 0 1 .804 1.267l-8.965 5.685a1.749 1.749 0 0 1-1.874 0l-8.965-5.685a.75.75 0 0 1-.231-1.035Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Enterprise platform</div>
        AI-powered developer platform
      </div>

    
</a></li>

                </ul>
              </div>
              <div class="border-bottom pb-3 pb-lg-0 border-bottom-0">
                    <span class="d-block h4 color-fg-default my-1" id="enterprise-available-add-ons-heading">Available add-ons</span>
                <ul class="list-style-none f5" aria-labelledby="enterprise-available-add-ons-heading">
                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;advanced_security&quot;,&quot;context&quot;:&quot;enterprise&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;advanced_security_link_enterprise_navbar&quot;}" href="https://github.com/enterprise/advanced-security">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-shield-check color-fg-subtle mr-3">
    <path d="M16.53 9.78a.75.75 0 0 0-1.06-1.06L11 13.19l-1.97-1.97a.75.75 0 0 0-1.06 1.06l2.5 2.5a.75.75 0 0 0 1.06 0l5-5Z"></path><path d="m12.54.637 8.25 2.675A1.75 1.75 0 0 1 22 4.976V10c0 6.19-3.771 10.704-9.401 12.83a1.704 1.704 0 0 1-1.198 0C5.77 20.705 2 16.19 2 10V4.976c0-.758.489-1.43 1.21-1.664L11.46.637a1.748 1.748 0 0 1 1.08 0Zm-.617 1.426-8.25 2.676a.249.249 0 0 0-.173.237V10c0 5.46 3.28 9.483 8.43 11.426a.199.199 0 0 0 .14 0C17.22 19.483 20.5 15.461 20.5 10V4.976a.25.25 0 0 0-.173-.237l-8.25-2.676a.253.253 0 0 0-.154 0Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Advanced Security</div>
        Enterprise-grade security features
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description pb-lg-3" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;github_copilot&quot;,&quot;context&quot;:&quot;enterprise&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;github_copilot_link_enterprise_navbar&quot;}" href="/features/copilot#enterprise">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-copilot color-fg-subtle mr-3">
    <path d="M23.922 16.992c-.861 1.495-5.859 5.023-11.922 5.023-6.063 0-11.061-3.528-11.922-5.023A.641.641 0 0 1 0 16.736v-2.869a.841.841 0 0 1 .053-.22c.372-.935 1.347-2.292 2.605-2.656.167-.429.414-1.055.644-1.517a10.195 10.195 0 0 1-.052-1.086c0-1.331.282-2.499 1.132-3.368.397-.406.89-.717 1.474-.952 1.399-1.136 3.392-2.093 6.122-2.093 2.731 0 4.767.957 6.166 2.093.584.235 1.077.546 1.474.952.85.869 1.132 2.037 1.132 3.368 0 .368-.014.733-.052 1.086.23.462.477 1.088.644 1.517 1.258.364 2.233 1.721 2.605 2.656a.832.832 0 0 1 .053.22v2.869a.641.641 0 0 1-.078.256ZM12.172 11h-.344a4.323 4.323 0 0 1-.355.508C10.703 12.455 9.555 13 7.965 13c-1.725 0-2.989-.359-3.782-1.259a2.005 2.005 0 0 1-.085-.104L4 11.741v6.585c1.435.779 4.514 2.179 8 2.179 3.486 0 6.565-1.4 8-2.179v-6.585l-.098-.104s-.033.045-.085.104c-.793.9-2.057 1.259-3.782 1.259-1.59 0-2.738-.545-3.508-1.492a4.323 4.323 0 0 1-.355-.508h-.016.016Zm.641-2.935c.136 1.057.403 1.913.878 2.497.442.544 1.134.938 2.344.938 1.573 0 2.292-.337 2.657-.751.384-.435.558-1.15.558-2.361 0-1.14-.243-1.847-.705-2.319-.477-.488-1.319-.862-2.824-1.025-1.487-.161-2.192.138-2.533.529-.269.307-.437.808-.438 1.578v.021c0 .265.021.562.063.893Zm-1.626 0c.042-.331.063-.628.063-.894v-.02c-.001-.77-.169-1.271-.438-1.578-.341-.391-1.046-.69-2.533-.529-1.505.163-2.347.537-2.824 1.025-.462.472-.705 1.179-.705 2.319 0 1.211.175 1.926.558 2.361.365.414 1.084.751 2.657.751 1.21 0 1.902-.394 2.344-.938.475-.584.742-1.44.878-2.497Z"></path><path d="M14.5 14.25a1 1 0 0 1 1 1v2a1 1 0 0 1-2 0v-2a1 1 0 0 1 1-1Zm-5 0a1 1 0 0 1 1 1v2a1 1 0 0 1-2 0v-2a1 1 0 0 1 1-1Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">GitHub Copilot</div>
        Enterprise-grade AI features
      </div>

    
</a></li>

                    <li>
  <a class="HeaderMenu-dropdown-link d-block no-underline position-relative py-2 Link--secondary d-flex flex-items-center Link--has-description" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;premium_support&quot;,&quot;context&quot;:&quot;enterprise&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;premium_support_link_enterprise_navbar&quot;}" href="/premium-support">
      <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-comment-discussion color-fg-subtle mr-3">
    <path d="M1.75 1h12.5c.966 0 1.75.784 1.75 1.75v9.5A1.75 1.75 0 0 1 14.25 14H8.061l-2.574 2.573A1.458 1.458 0 0 1 3 15.543V14H1.75A1.75 1.75 0 0 1 0 12.25v-9.5C0 1.784.784 1 1.75 1ZM1.5 2.75v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25H1.75a.25.25 0 0 0-.25.25Z"></path><path d="M22.5 8.75a.25.25 0 0 0-.25-.25h-3.5a.75.75 0 0 1 0-1.5h3.5c.966 0 1.75.784 1.75 1.75v9.5A1.75 1.75 0 0 1 22.25 20H21v1.543a1.457 1.457 0 0 1-2.487 1.03L15.939 20H10.75A1.75 1.75 0 0 1 9 18.25v-1.465a.75.75 0 0 1 1.5 0v1.465c0 .138.112.25.25.25h5.5a.75.75 0 0 1 .53.22l2.72 2.72v-2.19a.75.75 0 0 1 .75-.75h2a.25.25 0 0 0 .25-.25v-9.5Z"></path>
</svg>
      <div>
        <div class="color-fg-default h4">Premium Support</div>
        Enterprise-grade 24/7 support
      </div>

    
</a></li>

                </ul>
              </div>
          </div>
      </div>
</li>


                <li class="HeaderMenu-item position-relative flex-wrap flex-justify-between flex-items-center d-block d-lg-flex flex-lg-nowrap flex-lg-items-center js-details-container js-header-menu-item">
    <a class="HeaderMenu-link no-underline px-0 px-lg-2 py-3 py-lg-2 d-block d-lg-inline-block" data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;pricing&quot;,&quot;context&quot;:&quot;global&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;pricing_link_global_navbar&quot;}" href="https://github.com/pricing">Pricing</a>
</li>

            </ul>
          </nav>

        <div class="d-flex flex-column flex-lg-row width-full flex-justify-end flex-lg-items-center text-center mt-3 mt-lg-0 text-lg-left ml-lg-3">
                


<qbsearch-input class="search-input" data-scope="repo:html2rss/html2rss-web" data-custom-scopes-path="/search/custom_scopes" data-delete-custom-scopes-csrf="Yj8RCTc8uwD-p-hqzEC0mKsMdd8USfjnQMyoLFlYl3SYYWaBQNvPKtMEjJk_XeeZGfnM4Swm0SQay3X-zi4cKQ" data-max-custom-scopes="10" data-header-redesign-enabled="false" data-initial-value="" data-blackbird-suggestions-path="/search/suggestions" data-jump-to-suggestions-path="/_graphql/GetSuggestedNavigationDestinations" data-current-repository="html2rss/html2rss-web" data-current-org="html2rss" data-current-owner="" data-logged-in="false" data-copilot-chat-enabled="false" data-nl-search-enabled="false" data-retain-scroll-position="true">
  <div
    class="search-input-container search-with-dialog position-relative d-flex flex-row flex-items-center mr-4 rounded"
    data-action="click:qbsearch-input#searchInputContainerClicked"
  >
      <button
        type="button"
        class="header-search-button placeholder  input-button form-control d-flex flex-1 flex-self-stretch flex-items-center no-wrap width-full py-0 pl-2 pr-0 text-left border-0 box-shadow-none"
        data-target="qbsearch-input.inputButton"
        aria-label="Search or jump to…"
        aria-haspopup="dialog"
        placeholder="Search or jump to..."
        data-hotkey=s,/
        autocapitalize="off"
        data-analytics-event="{&quot;location&quot;:&quot;navbar&quot;,&quot;action&quot;:&quot;searchbar&quot;,&quot;context&quot;:&quot;global&quot;,&quot;tag&quot;:&quot;input&quot;,&quot;label&quot;:&quot;searchbar_input_global_navbar&quot;}"
        data-action="click:qbsearch-input#handleExpand"
      >
        <div class="mr-2 color-fg-muted">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-search">
    <path d="M10.68 11.74a6 6 0 0 1-7.922-8.982 6 6 0 0 1 8.982 7.922l3.04 3.04a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215ZM11.5 7a4.499 4.499 0 1 0-8.997 0A4.499 4.499 0 0 0 11.5 7Z"></path>
</svg>
        </div>
        <span class="flex-1" data-target="qbsearch-input.inputButtonText">Search or jump to...</span>
          <div class="d-flex" data-target="qbsearch-input.hotkeyIndicator">
            <svg xmlns="http://www.w3.org/2000/svg" width="22" height="20" aria-hidden="true" class="mr-1"><path fill="none" stroke="#979A9C" opacity=".4" d="M3.5.5h12c1.7 0 3 1.3 3 3v13c0 1.7-1.3 3-3 3h-12c-1.7 0-3-1.3-3-3v-13c0-1.7 1.3-3 3-3z"></path><path fill="#979A9C" d="M11.8 6L8 15.1h-.9L10.8 6h1z"></path></svg>

          </div>
      </button>

    <input type="hidden" name="type" class="js-site-search-type-field">

    
<div class="Overlay--hidden " data-modal-dialog-overlay>
  <modal-dialog data-action="close:qbsearch-input#handleClose cancel:qbsearch-input#handleClose" data-target="qbsearch-input.searchSuggestionsDialog" role="dialog" id="search-suggestions-dialog" aria-modal="true" aria-labelledby="search-suggestions-dialog-header" data-view-component="true" class="Overlay Overlay--width-large Overlay--height-auto">
      <h1 id="search-suggestions-dialog-header" class="sr-only">Search code, repositories, users, issues, pull requests...</h1>
    <div class="Overlay-body Overlay-body--paddingNone">
      
          <div data-view-component="true">        <div class="search-suggestions position-fixed width-full color-shadow-large border color-fg-default color-bg-default overflow-hidden d-flex flex-column query-builder-container"
          style="border-radius: 12px;"
          data-target="qbsearch-input.queryBuilderContainer"
          hidden
        >
          <!-- '"` --><!-- </textarea></xmp> --></option></form><form id="query-builder-test-form" action="" accept-charset="UTF-8" method="get">
  <query-builder data-target="qbsearch-input.queryBuilder" id="query-builder-query-builder-test" data-filter-key=":" data-view-component="true" class="QueryBuilder search-query-builder">
    <div class="FormControl FormControl--fullWidth">
      <label id="query-builder-test-label" for="query-builder-test" class="FormControl-label sr-only">
        Search
      </label>
      <div
        class="QueryBuilder-StyledInput width-fit "
        data-target="query-builder.styledInput"
      >
          <span id="query-builder-test-leadingvisual-wrap" class="FormControl-input-leadingVisualWrap QueryBuilder-leadingVisualWrap">
            <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-search FormControl-input-leadingVisual">
    <path d="M10.68 11.74a6 6 0 0 1-7.922-8.982 6 6 0 0 1 8.982 7.922l3.04 3.04a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215ZM11.5 7a4.499 4.499 0 1 0-8.997 0A4.499 4.499 0 0 0 11.5 7Z"></path>
</svg>
          </span>
        <div data-target="query-builder.styledInputContainer" class="QueryBuilder-StyledInputContainer">
          <div
            aria-hidden="true"
            class="QueryBuilder-StyledInputContent"
            data-target="query-builder.styledInputContent"
          ></div>
          <div class="QueryBuilder-InputWrapper">
            <div aria-hidden="true" class="QueryBuilder-Sizer" data-target="query-builder.sizer"></div>
            <input id="query-builder-test" name="query-builder-test" value="" autocomplete="off" type="text" role="combobox" spellcheck="false" aria-expanded="false" aria-describedby="validation-857613a5-bf92-41b8-ac19-7a16f77c7c8b" data-target="query-builder.input" data-action="
          input:query-builder#inputChange
          blur:query-builder#inputBlur
          keydown:query-builder#inputKeydown
          focus:query-builder#inputFocus
        " data-view-component="true" class="FormControl-input QueryBuilder-Input FormControl-medium" />
          </div>
        </div>
          <span class="sr-only" id="query-builder-test-clear">Clear</span>
          <button role="button" id="query-builder-test-clear-button" aria-labelledby="query-builder-test-clear query-builder-test-label" data-target="query-builder.clearButton" data-action="
                click:query-builder#clear
                focus:query-builder#clearButtonFocus
                blur:query-builder#clearButtonBlur
              " variant="small" hidden="hidden" type="button" data-view-component="true" class="Button Button--iconOnly Button--invisible Button--medium mr-1 px-2 py-0 d-flex flex-items-center rounded-1 color-fg-muted">  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x-circle-fill Button-visual">
    <path d="M2.343 13.657A8 8 0 1 1 13.658 2.343 8 8 0 0 1 2.343 13.657ZM6.03 4.97a.751.751 0 0 0-1.042.018.751.751 0 0 0-.018 1.042L6.94 8 4.97 9.97a.749.749 0 0 0 .326 1.275.749.749 0 0 0 .734-.215L8 9.06l1.97 1.97a.749.749 0 0 0 1.275-.326.749.749 0 0 0-.215-.734L9.06 8l1.97-1.97a.749.749 0 0 0-.326-1.275.749.749 0 0 0-.734.215L8 6.94Z"></path>
</svg>
</button>

      </div>
      <template id="search-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-search">
    <path d="M10.68 11.74a6 6 0 0 1-7.922-8.982 6 6 0 0 1 8.982 7.922l3.04 3.04a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215ZM11.5 7a4.499 4.499 0 1 0-8.997 0A4.499 4.499 0 0 0 11.5 7Z"></path>
</svg>
</template>

<template id="code-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code">
    <path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path>
</svg>
</template>

<template id="file-code-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-file-code">
    <path d="M4 1.75C4 .784 4.784 0 5.75 0h5.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v8.586A1.75 1.75 0 0 1 14.25 15h-9a.75.75 0 0 1 0-1.5h9a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 10 4.25V1.5H5.75a.25.25 0 0 0-.25.25v2.5a.75.75 0 0 1-1.5 0Zm1.72 4.97a.75.75 0 0 1 1.06 0l2 2a.75.75 0 0 1 0 1.06l-2 2a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734l1.47-1.47-1.47-1.47a.75.75 0 0 1 0-1.06ZM3.28 7.78 1.81 9.25l1.47 1.47a.751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018l-2-2a.75.75 0 0 1 0-1.06l2-2a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Zm8.22-6.218V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path>
</svg>
</template>

<template id="history-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-history">
    <path d="m.427 1.927 1.215 1.215a8.002 8.002 0 1 1-1.6 5.685.75.75 0 1 1 1.493-.154 6.5 6.5 0 1 0 1.18-4.458l1.358 1.358A.25.25 0 0 1 3.896 6H.25A.25.25 0 0 1 0 5.75V2.104a.25.25 0 0 1 .427-.177ZM7.75 4a.75.75 0 0 1 .75.75v2.992l2.028.812a.75.75 0 0 1-.557 1.392l-2.5-1A.751.751 0 0 1 7 8.25v-3.5A.75.75 0 0 1 7.75 4Z"></path>
</svg>
</template>

<template id="repo-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-repo">
    <path d="M2 2.5A2.5 2.5 0 0 1 4.5 0h8.75a.75.75 0 0 1 .75.75v12.5a.75.75 0 0 1-.75.75h-2.5a.75.75 0 0 1 0-1.5h1.75v-2h-8a1 1 0 0 0-.714 1.7.75.75 0 1 1-1.072 1.05A2.495 2.495 0 0 1 2 11.5Zm10.5-1h-8a1 1 0 0 0-1 1v6.708A2.486 2.486 0 0 1 4.5 9h8ZM5 12.25a.25.25 0 0 1 .25-.25h3.5a.25.25 0 0 1 .25.25v3.25a.25.25 0 0 1-.4.2l-1.45-1.087a.249.249 0 0 0-.3 0L5.4 15.7a.25.25 0 0 1-.4-.2Z"></path>
</svg>
</template>

<template id="bookmark-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-bookmark">
    <path d="M3 2.75C3 1.784 3.784 1 4.75 1h6.5c.966 0 1.75.784 1.75 1.75v11.5a.75.75 0 0 1-1.227.579L8 11.722l-3.773 3.107A.751.751 0 0 1 3 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.91l3.023-2.489a.75.75 0 0 1 .954 0l3.023 2.49V2.75a.25.25 0 0 0-.25-.25Z"></path>
</svg>
</template>

<template id="plus-circle-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-plus-circle">
    <path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm7.25-3.25v2.5h2.5a.75.75 0 0 1 0 1.5h-2.5v2.5a.75.75 0 0 1-1.5 0v-2.5h-2.5a.75.75 0 0 1 0-1.5h2.5v-2.5a.75.75 0 0 1 1.5 0Z"></path>
</svg>
</template>

<template id="circle-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
</template>

<template id="trash-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-trash">
    <path d="M11 1.75V3h2.25a.75.75 0 0 1 0 1.5H2.75a.75.75 0 0 1 0-1.5H5V1.75C5 .784 5.784 0 6.75 0h2.5C10.216 0 11 .784 11 1.75ZM4.496 6.675l.66 6.6a.25.25 0 0 0 .249.225h5.19a.25.25 0 0 0 .249-.225l.66-6.6a.75.75 0 0 1 1.492.149l-.66 6.6A1.748 1.748 0 0 1 10.595 15h-5.19a1.75 1.75 0 0 1-1.741-1.575l-.66-6.6a.75.75 0 1 1 1.492-.15ZM6.5 1.75V3h3V1.75a.25.25 0 0 0-.25-.25h-2.5a.25.25 0 0 0-.25.25Z"></path>
</svg>
</template>

<template id="team-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-people">
    <path d="M2 5.5a3.5 3.5 0 1 1 5.898 2.549 5.508 5.508 0 0 1 3.034 4.084.75.75 0 1 1-1.482.235 4 4 0 0 0-7.9 0 .75.75 0 0 1-1.482-.236A5.507 5.507 0 0 1 3.102 8.05 3.493 3.493 0 0 1 2 5.5ZM11 4a3.001 3.001 0 0 1 2.22 5.018 5.01 5.01 0 0 1 2.56 3.012.749.749 0 0 1-.885.954.752.752 0 0 1-.549-.514 3.507 3.507 0 0 0-2.522-2.372.75.75 0 0 1-.574-.73v-.352a.75.75 0 0 1 .416-.672A1.5 1.5 0 0 0 11 5.5.75.75 0 0 1 11 4Zm-5.5-.5a2 2 0 1 0-.001 3.999A2 2 0 0 0 5.5 3.5Z"></path>
</svg>
</template>

<template id="project-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-project">
    <path d="M1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25V1.75C0 .784.784 0 1.75 0ZM1.5 1.75v12.5c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25V1.75a.25.25 0 0 0-.25-.25H1.75a.25.25 0 0 0-.25.25ZM11.75 3a.75.75 0 0 1 .75.75v7.5a.75.75 0 0 1-1.5 0v-7.5a.75.75 0 0 1 .75-.75Zm-8.25.75a.75.75 0 0 1 1.5 0v5.5a.75.75 0 0 1-1.5 0ZM8 3a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 3Z"></path>
</svg>
</template>

<template id="pencil-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-pencil">
    <path d="M11.013 1.427a1.75 1.75 0 0 1 2.474 0l1.086 1.086a1.75 1.75 0 0 1 0 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 0 1-.927-.928l.929-3.25c.081-.286.235-.547.445-.758l8.61-8.61Zm.176 4.823L9.75 4.81l-6.286 6.287a.253.253 0 0 0-.064.108l-.558 1.953 1.953-.558a.253.253 0 0 0 .108-.064Zm1.238-3.763a.25.25 0 0 0-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 0 0 0-.354Z"></path>
</svg>
</template>

<template id="copilot-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copilot">
    <path d="M7.998 15.035c-4.562 0-7.873-2.914-7.998-3.749V9.338c.085-.628.677-1.686 1.588-2.065.013-.07.024-.143.036-.218.029-.183.06-.384.126-.612-.201-.508-.254-1.084-.254-1.656 0-.87.128-1.769.693-2.484.579-.733 1.494-1.124 2.724-1.261 1.206-.134 2.262.034 2.944.765.05.053.096.108.139.165.044-.057.094-.112.143-.165.682-.731 1.738-.899 2.944-.765 1.23.137 2.145.528 2.724 1.261.566.715.693 1.614.693 2.484 0 .572-.053 1.148-.254 1.656.066.228.098.429.126.612.012.076.024.148.037.218.924.385 1.522 1.471 1.591 2.095v1.872c0 .766-3.351 3.795-8.002 3.795Zm0-1.485c2.28 0 4.584-1.11 5.002-1.433V7.862l-.023-.116c-.49.21-1.075.291-1.727.291-1.146 0-2.059-.327-2.71-.991A3.222 3.222 0 0 1 8 6.303a3.24 3.24 0 0 1-.544.743c-.65.664-1.563.991-2.71.991-.652 0-1.236-.081-1.727-.291l-.023.116v4.255c.419.323 2.722 1.433 5.002 1.433ZM6.762 2.83c-.193-.206-.637-.413-1.682-.297-1.019.113-1.479.404-1.713.7-.247.312-.369.789-.369 1.554 0 .793.129 1.171.308 1.371.162.181.519.379 1.442.379.853 0 1.339-.235 1.638-.54.315-.322.527-.827.617-1.553.117-.935-.037-1.395-.241-1.614Zm4.155-.297c-1.044-.116-1.488.091-1.681.297-.204.219-.359.679-.242 1.614.091.726.303 1.231.618 1.553.299.305.784.54 1.638.54.922 0 1.28-.198 1.442-.379.179-.2.308-.578.308-1.371 0-.765-.123-1.242-.37-1.554-.233-.296-.693-.587-1.713-.7Z"></path><path d="M6.25 9.037a.75.75 0 0 1 .75.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 .75-.75Zm4.25.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 1.5 0Z"></path>
</svg>
</template>

<template id="copilot-error-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copilot-error">
    <path d="M16 11.24c0 .112-.072.274-.21.467L13 9.688V7.862l-.023-.116c-.49.21-1.075.291-1.727.291-.198 0-.388-.009-.571-.029L6.833 5.226a4.01 4.01 0 0 0 .17-.782c.117-.935-.037-1.395-.241-1.614-.193-.206-.637-.413-1.682-.297-.683.076-1.115.231-1.395.415l-1.257-.91c.579-.564 1.413-.877 2.485-.996 1.206-.134 2.262.034 2.944.765.05.053.096.108.139.165.044-.057.094-.112.143-.165.682-.731 1.738-.899 2.944-.765 1.23.137 2.145.528 2.724 1.261.566.715.693 1.614.693 2.484 0 .572-.053 1.148-.254 1.656.066.228.098.429.126.612.012.076.024.148.037.218.924.385 1.522 1.471 1.591 2.095Zm-5.083-8.707c-1.044-.116-1.488.091-1.681.297-.204.219-.359.679-.242 1.614.091.726.303 1.231.618 1.553.299.305.784.54 1.638.54.922 0 1.28-.198 1.442-.379.179-.2.308-.578.308-1.371 0-.765-.123-1.242-.37-1.554-.233-.296-.693-.587-1.713-.7Zm2.511 11.074c-1.393.776-3.272 1.428-5.43 1.428-4.562 0-7.873-2.914-7.998-3.749V9.338c.085-.628.677-1.686 1.588-2.065.013-.07.024-.143.036-.218.029-.183.06-.384.126-.612-.18-.455-.241-.963-.252-1.475L.31 4.107A.747.747 0 0 1 0 3.509V3.49a.748.748 0 0 1 .625-.73c.156-.026.306.047.435.139l14.667 10.578a.592.592 0 0 1 .227.264.752.752 0 0 1 .046.249v.022a.75.75 0 0 1-1.19.596Zm-1.367-.991L5.635 7.964a5.128 5.128 0 0 1-.889.073c-.652 0-1.236-.081-1.727-.291l-.023.116v4.255c.419.323 2.722 1.433 5.002 1.433 1.539 0 3.089-.505 4.063-.934Z"></path>
</svg>
</template>

<template id="workflow-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-workflow">
    <path d="M0 1.75C0 .784.784 0 1.75 0h3.5C6.216 0 7 .784 7 1.75v3.5A1.75 1.75 0 0 1 5.25 7H4v4a1 1 0 0 0 1 1h4v-1.25C9 9.784 9.784 9 10.75 9h3.5c.966 0 1.75.784 1.75 1.75v3.5A1.75 1.75 0 0 1 14.25 16h-3.5A1.75 1.75 0 0 1 9 14.25v-.75H5A2.5 2.5 0 0 1 2.5 11V7h-.75A1.75 1.75 0 0 1 0 5.25Zm1.75-.25a.25.25 0 0 0-.25.25v3.5c0 .138.112.25.25.25h3.5a.25.25 0 0 0 .25-.25v-3.5a.25.25 0 0 0-.25-.25Zm9 9a.25.25 0 0 0-.25.25v3.5c0 .138.112.25.25.25h3.5a.25.25 0 0 0 .25-.25v-3.5a.25.25 0 0 0-.25-.25Z"></path>
</svg>
</template>

<template id="book-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-book">
    <path d="M0 1.75A.75.75 0 0 1 .75 1h4.253c1.227 0 2.317.59 3 1.501A3.743 3.743 0 0 1 11.006 1h4.245a.75.75 0 0 1 .75.75v10.5a.75.75 0 0 1-.75.75h-4.507a2.25 2.25 0 0 0-1.591.659l-.622.621a.75.75 0 0 1-1.06 0l-.622-.621A2.25 2.25 0 0 0 5.258 13H.75a.75.75 0 0 1-.75-.75Zm7.251 10.324.004-5.073-.002-2.253A2.25 2.25 0 0 0 5.003 2.5H1.5v9h3.757a3.75 3.75 0 0 1 1.994.574ZM8.755 4.75l-.004 7.322a3.752 3.752 0 0 1 1.992-.572H14.5v-9h-3.495a2.25 2.25 0 0 0-2.25 2.25Z"></path>
</svg>
</template>

<template id="code-review-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code-review">
    <path d="M1.75 1h12.5c.966 0 1.75.784 1.75 1.75v8.5A1.75 1.75 0 0 1 14.25 13H8.061l-2.574 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25v-8.5C0 1.784.784 1 1.75 1ZM1.5 2.75v8.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-8.5a.25.25 0 0 0-.25-.25H1.75a.25.25 0 0 0-.25.25Zm5.28 1.72a.75.75 0 0 1 0 1.06L5.31 7l1.47 1.47a.751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018l-2-2a.75.75 0 0 1 0-1.06l2-2a.75.75 0 0 1 1.06 0Zm2.44 0a.75.75 0 0 1 1.06 0l2 2a.75.75 0 0 1 0 1.06l-2 2a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L10.69 7 9.22 5.53a.75.75 0 0 1 0-1.06Z"></path>
</svg>
</template>

<template id="codespaces-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-codespaces">
    <path d="M0 11.25c0-.966.784-1.75 1.75-1.75h12.5c.966 0 1.75.784 1.75 1.75v3A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25Zm2-9.5C2 .784 2.784 0 3.75 0h8.5C13.216 0 14 .784 14 1.75v5a1.75 1.75 0 0 1-1.75 1.75h-8.5A1.75 1.75 0 0 1 2 6.75Zm1.75-.25a.25.25 0 0 0-.25.25v5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-5a.25.25 0 0 0-.25-.25Zm-2 9.5a.25.25 0 0 0-.25.25v3c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-3a.25.25 0 0 0-.25-.25Z"></path><path d="M7 12.75a.75.75 0 0 1 .75-.75h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1-.75-.75Zm-4 0a.75.75 0 0 1 .75-.75h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1-.75-.75Z"></path>
</svg>
</template>

<template id="comment-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-comment">
    <path d="M1 2.75C1 1.784 1.784 1 2.75 1h10.5c.966 0 1.75.784 1.75 1.75v7.5A1.75 1.75 0 0 1 13.25 12H9.06l-2.573 2.573A1.458 1.458 0 0 1 4 13.543V12H2.75A1.75 1.75 0 0 1 1 10.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h4.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>
</svg>
</template>

<template id="comment-discussion-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-comment-discussion">
    <path d="M1.75 1h8.5c.966 0 1.75.784 1.75 1.75v5.5A1.75 1.75 0 0 1 10.25 10H7.061l-2.574 2.573A1.458 1.458 0 0 1 2 11.543V10h-.25A1.75 1.75 0 0 1 0 8.25v-5.5C0 1.784.784 1 1.75 1ZM1.5 2.75v5.5c0 .138.112.25.25.25h1a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h3.5a.25.25 0 0 0 .25-.25v-5.5a.25.25 0 0 0-.25-.25h-8.5a.25.25 0 0 0-.25.25Zm13 2a.25.25 0 0 0-.25-.25h-.5a.75.75 0 0 1 0-1.5h.5c.966 0 1.75.784 1.75 1.75v5.5A1.75 1.75 0 0 1 14.25 12H14v1.543a1.458 1.458 0 0 1-2.487 1.03L9.22 12.28a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215l2.22 2.22v-2.19a.75.75 0 0 1 .75-.75h1a.25.25 0 0 0 .25-.25Z"></path>
</svg>
</template>

<template id="organization-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-organization">
    <path d="M1.75 16A1.75 1.75 0 0 1 0 14.25V1.75C0 .784.784 0 1.75 0h8.5C11.216 0 12 .784 12 1.75v12.5c0 .085-.006.168-.018.25h2.268a.25.25 0 0 0 .25-.25V8.285a.25.25 0 0 0-.111-.208l-1.055-.703a.749.749 0 1 1 .832-1.248l1.055.703c.487.325.779.871.779 1.456v5.965A1.75 1.75 0 0 1 14.25 16h-3.5a.766.766 0 0 1-.197-.026c-.099.017-.2.026-.303.026h-3a.75.75 0 0 1-.75-.75V14h-1v1.25a.75.75 0 0 1-.75.75Zm-.25-1.75c0 .138.112.25.25.25H4v-1.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 .75.75v1.25h2.25a.25.25 0 0 0 .25-.25V1.75a.25.25 0 0 0-.25-.25h-8.5a.25.25 0 0 0-.25.25ZM3.75 6h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1 0-1.5ZM3 3.75A.75.75 0 0 1 3.75 3h.5a.75.75 0 0 1 0 1.5h-.5A.75.75 0 0 1 3 3.75Zm4 3A.75.75 0 0 1 7.75 6h.5a.75.75 0 0 1 0 1.5h-.5A.75.75 0 0 1 7 6.75ZM7.75 3h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1 0-1.5ZM3 9.75A.75.75 0 0 1 3.75 9h.5a.75.75 0 0 1 0 1.5h-.5A.75.75 0 0 1 3 9.75ZM7.75 9h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1 0-1.5Z"></path>
</svg>
</template>

<template id="rocket-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-rocket">
    <path d="M14.064 0h.186C15.216 0 16 .784 16 1.75v.186a8.752 8.752 0 0 1-2.564 6.186l-.458.459c-.314.314-.641.616-.979.904v3.207c0 .608-.315 1.172-.833 1.49l-2.774 1.707a.749.749 0 0 1-1.11-.418l-.954-3.102a1.214 1.214 0 0 1-.145-.125L3.754 9.816a1.218 1.218 0 0 1-.124-.145L.528 8.717a.749.749 0 0 1-.418-1.11l1.71-2.774A1.748 1.748 0 0 1 3.31 4h3.204c.288-.338.59-.665.904-.979l.459-.458A8.749 8.749 0 0 1 14.064 0ZM8.938 3.623h-.002l-.458.458c-.76.76-1.437 1.598-2.02 2.5l-1.5 2.317 2.143 2.143 2.317-1.5c.902-.583 1.74-1.26 2.499-2.02l.459-.458a7.25 7.25 0 0 0 2.123-5.127V1.75a.25.25 0 0 0-.25-.25h-.186a7.249 7.249 0 0 0-5.125 2.123ZM3.56 14.56c-.732.732-2.334 1.045-3.005 1.148a.234.234 0 0 1-.201-.064.234.234 0 0 1-.064-.201c.103-.671.416-2.273 1.15-3.003a1.502 1.502 0 1 1 2.12 2.12Zm6.94-3.935c-.088.06-.177.118-.266.175l-2.35 1.521.548 1.783 1.949-1.2a.25.25 0 0 0 .119-.213ZM3.678 8.116 5.2 5.766c.058-.09.117-.178.176-.266H3.309a.25.25 0 0 0-.213.119l-1.2 1.95ZM12 5a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path>
</svg>
</template>

<template id="shield-check-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-shield-check">
    <path d="m8.533.133 5.25 1.68A1.75 1.75 0 0 1 15 3.48V7c0 1.566-.32 3.182-1.303 4.682-.983 1.498-2.585 2.813-5.032 3.855a1.697 1.697 0 0 1-1.33 0c-2.447-1.042-4.049-2.357-5.032-3.855C1.32 10.182 1 8.566 1 7V3.48a1.75 1.75 0 0 1 1.217-1.667l5.25-1.68a1.748 1.748 0 0 1 1.066 0Zm-.61 1.429.001.001-5.25 1.68a.251.251 0 0 0-.174.237V7c0 1.36.275 2.666 1.057 3.859.784 1.194 2.121 2.342 4.366 3.298a.196.196 0 0 0 .154 0c2.245-.957 3.582-2.103 4.366-3.297C13.225 9.666 13.5 8.358 13.5 7V3.48a.25.25 0 0 0-.174-.238l-5.25-1.68a.25.25 0 0 0-.153 0ZM11.28 6.28l-3.5 3.5a.75.75 0 0 1-1.06 0l-1.5-1.5a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215l.97.97 2.97-2.97a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z"></path>
</svg>
</template>

<template id="heart-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-heart">
    <path d="m8 14.25.345.666a.75.75 0 0 1-.69 0l-.008-.004-.018-.01a7.152 7.152 0 0 1-.31-.17 22.055 22.055 0 0 1-3.434-2.414C2.045 10.731 0 8.35 0 5.5 0 2.836 2.086 1 4.25 1 5.797 1 7.153 1.802 8 3.02 8.847 1.802 10.203 1 11.75 1 13.914 1 16 2.836 16 5.5c0 2.85-2.045 5.231-3.885 6.818a22.066 22.066 0 0 1-3.744 2.584l-.018.01-.006.003h-.002ZM4.25 2.5c-1.336 0-2.75 1.164-2.75 3 0 2.15 1.58 4.144 3.365 5.682A20.58 20.58 0 0 0 8 13.393a20.58 20.58 0 0 0 3.135-2.211C12.92 9.644 14.5 7.65 14.5 5.5c0-1.836-1.414-3-2.75-3-1.373 0-2.609.986-3.029 2.456a.749.749 0 0 1-1.442 0C6.859 3.486 5.623 2.5 4.25 2.5Z"></path>
</svg>
</template>

<template id="server-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-server">
    <path d="M1.75 1h12.5c.966 0 1.75.784 1.75 1.75v4c0 .372-.116.717-.314 1 .198.283.314.628.314 1v4a1.75 1.75 0 0 1-1.75 1.75H1.75A1.75 1.75 0 0 1 0 12.75v-4c0-.358.109-.707.314-1a1.739 1.739 0 0 1-.314-1v-4C0 1.784.784 1 1.75 1ZM1.5 2.75v4c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-4a.25.25 0 0 0-.25-.25H1.75a.25.25 0 0 0-.25.25Zm.25 5.75a.25.25 0 0 0-.25.25v4c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-4a.25.25 0 0 0-.25-.25ZM7 4.75A.75.75 0 0 1 7.75 4h4.5a.75.75 0 0 1 0 1.5h-4.5A.75.75 0 0 1 7 4.75ZM7.75 10h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM3 4.75A.75.75 0 0 1 3.75 4h.5a.75.75 0 0 1 0 1.5h-.5A.75.75 0 0 1 3 4.75ZM3.75 10h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1 0-1.5Z"></path>
</svg>
</template>

<template id="globe-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-globe">
    <path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM5.78 8.75a9.64 9.64 0 0 0 1.363 4.177c.255.426.542.832.857 1.215.245-.296.551-.705.857-1.215A9.64 9.64 0 0 0 10.22 8.75Zm4.44-1.5a9.64 9.64 0 0 0-1.363-4.177c-.307-.51-.612-.919-.857-1.215a9.927 9.927 0 0 0-.857 1.215A9.64 9.64 0 0 0 5.78 7.25Zm-5.944 1.5H1.543a6.507 6.507 0 0 0 4.666 5.5c-.123-.181-.24-.365-.352-.552-.715-1.192-1.437-2.874-1.581-4.948Zm-2.733-1.5h2.733c.144-2.074.866-3.756 1.58-4.948.12-.197.237-.381.353-.552a6.507 6.507 0 0 0-4.666 5.5Zm10.181 1.5c-.144 2.074-.866 3.756-1.58 4.948-.12.197-.237.381-.353.552a6.507 6.507 0 0 0 4.666-5.5Zm2.733-1.5a6.507 6.507 0 0 0-4.666-5.5c.123.181.24.365.353.552.714 1.192 1.436 2.874 1.58 4.948Z"></path>
</svg>
</template>

<template id="issue-opened-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened">
    <path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"></path><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"></path>
</svg>
</template>

<template id="device-mobile-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-device-mobile">
    <path d="M3.75 0h8.5C13.216 0 14 .784 14 1.75v12.5A1.75 1.75 0 0 1 12.25 16h-8.5A1.75 1.75 0 0 1 2 14.25V1.75C2 .784 2.784 0 3.75 0ZM3.5 1.75v12.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25V1.75a.25.25 0 0 0-.25-.25h-8.5a.25.25 0 0 0-.25.25ZM8 13a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path>
</svg>
</template>

<template id="package-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-package">
    <path d="m8.878.392 5.25 3.045c.54.314.872.89.872 1.514v6.098a1.75 1.75 0 0 1-.872 1.514l-5.25 3.045a1.75 1.75 0 0 1-1.756 0l-5.25-3.045A1.75 1.75 0 0 1 1 11.049V4.951c0-.624.332-1.201.872-1.514L7.122.392a1.75 1.75 0 0 1 1.756 0ZM7.875 1.69l-4.63 2.685L8 7.133l4.755-2.758-4.63-2.685a.248.248 0 0 0-.25 0ZM2.5 5.677v5.372c0 .09.047.171.125.216l4.625 2.683V8.432Zm6.25 8.271 4.625-2.683a.25.25 0 0 0 .125-.216V5.677L8.75 8.432Z"></path>
</svg>
</template>

<template id="credit-card-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-credit-card">
    <path d="M10.75 9a.75.75 0 0 0 0 1.5h1.5a.75.75 0 0 0 0-1.5h-1.5Z"></path><path d="M0 3.75C0 2.784.784 2 1.75 2h12.5c.966 0 1.75.784 1.75 1.75v8.5A1.75 1.75 0 0 1 14.25 14H1.75A1.75 1.75 0 0 1 0 12.25ZM14.5 6.5h-13v5.75c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25Zm0-2.75a.25.25 0 0 0-.25-.25H1.75a.25.25 0 0 0-.25.25V5h13Z"></path>
</svg>
</template>

<template id="play-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-play">
    <path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path>
</svg>
</template>

<template id="gift-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-gift">
    <path d="M2 2.75A2.75 2.75 0 0 1 4.75 0c.983 0 1.873.42 2.57 1.232.268.318.497.668.68 1.042.183-.375.411-.725.68-1.044C9.376.42 10.266 0 11.25 0a2.75 2.75 0 0 1 2.45 4h.55c.966 0 1.75.784 1.75 1.75v2c0 .698-.409 1.301-1 1.582v4.918A1.75 1.75 0 0 1 13.25 16H2.75A1.75 1.75 0 0 1 1 14.25V9.332C.409 9.05 0 8.448 0 7.75v-2C0 4.784.784 4 1.75 4h.55c-.192-.375-.3-.8-.3-1.25ZM7.25 9.5H2.5v4.75c0 .138.112.25.25.25h4.5Zm1.5 0v5h4.5a.25.25 0 0 0 .25-.25V9.5Zm0-4V8h5.5a.25.25 0 0 0 .25-.25v-2a.25.25 0 0 0-.25-.25Zm-7 0a.25.25 0 0 0-.25.25v2c0 .138.112.25.25.25h5.5V5.5h-5.5Zm3-4a1.25 1.25 0 0 0 0 2.5h2.309c-.233-.818-.542-1.401-.878-1.793-.43-.502-.915-.707-1.431-.707ZM8.941 4h2.309a1.25 1.25 0 0 0 0-2.5c-.516 0-1 .205-1.43.707-.337.392-.646.975-.879 1.793Z"></path>
</svg>
</template>

<template id="code-square-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code-square">
    <path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25V1.75a.25.25 0 0 0-.25-.25Zm7.47 3.97a.75.75 0 0 1 1.06 0l2 2a.75.75 0 0 1 0 1.06l-2 2a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L10.69 8 9.22 6.53a.75.75 0 0 1 0-1.06ZM6.78 6.53 5.31 8l1.47 1.47a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215l-2-2a.75.75 0 0 1 0-1.06l2-2a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z"></path>
</svg>
</template>

<template id="device-desktop-icon">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-device-desktop">
    <path d="M14.25 1c.966 0 1.75.784 1.75 1.75v7.5A1.75 1.75 0 0 1 14.25 12h-3.727c.099 1.041.52 1.872 1.292 2.757A.752.752 0 0 1 11.25 16h-6.5a.75.75 0 0 1-.565-1.243c.772-.885 1.192-1.716 1.292-2.757H1.75A1.75 1.75 0 0 1 0 10.25v-7.5C0 1.784.784 1 1.75 1ZM1.75 2.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25ZM9.018 12H6.982a5.72 5.72 0 0 1-.765 2.5h3.566a5.72 5.72 0 0 1-.765-2.5Z"></path>
</svg>
</template>

        <div class="position-relative">
                <ul
                  role="listbox"
                  class="ActionListWrap QueryBuilder-ListWrap"
                  aria-label="Suggestions"
                  data-action="
                    combobox-commit:query-builder#comboboxCommit
                    mousedown:query-builder#resultsMousedown
                  "
                  data-target="query-builder.resultsList"
                  data-persist-list=false
                  id="query-builder-test-results"
                ></ul>
        </div>
      <div class="FormControl-inlineValidation" id="validation-857613a5-bf92-41b8-ac19-7a16f77c7c8b" hidden="hidden">
        <span class="FormControl-inlineValidation--visual">
          <svg aria-hidden="true" height="12" viewBox="0 0 12 12" version="1.1" width="12" data-view-component="true" class="octicon octicon-alert-fill">
    <path d="M4.855.708c.5-.896 1.79-.896 2.29 0l4.675 8.351a1.312 1.312 0 0 1-1.146 1.954H1.33A1.313 1.313 0 0 1 .183 9.058ZM7 7V3H5v4Zm-1 3a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z"></path>
</svg>
        </span>
        <span></span>
</div>    </div>
    <div data-target="query-builder.screenReaderFeedback" aria-live="polite" aria-atomic="true" class="sr-only"></div>
</query-builder></form>
          <div class="d-flex flex-row color-fg-muted px-3 text-small color-bg-default search-feedback-prompt">
            <a target="_blank" href="https://docs.github.com/search-github/github-code-search/understanding-github-code-search-syntax" data-view-component="true" class="Link color-fg-accent text-normal ml-2">
              Search syntax tips
</a>            <div class="d-flex flex-1"></div>
          </div>
        </div>
</div>

    </div>
</modal-dialog></div>
  </div>
  <div data-action="click:qbsearch-input#retract" class="dark-backdrop position-fixed" hidden data-target="qbsearch-input.darkBackdrop"></div>
  <div class="color-fg-default">
    
<dialog-helper>
  <dialog data-target="qbsearch-input.feedbackDialog" data-action="close:qbsearch-input#handleDialogClose cancel:qbsearch-input#handleDialogClose" id="feedback-dialog" aria-modal="true" aria-labelledby="feedback-dialog-title" aria-describedby="feedback-dialog-description" data-view-component="true" class="Overlay Overlay-whenNarrow Overlay--size-medium Overlay--motion-scaleFade">
    <div data-view-component="true" class="Overlay-header">
  <div class="Overlay-headerContentWrap">
    <div class="Overlay-titleWrap">
      <h1 class="Overlay-title " id="feedback-dialog-title">
        Provide feedback
      </h1>
        
    </div>
    <div class="Overlay-actionWrap">
      <button data-close-dialog-id="feedback-dialog" aria-label="Close" type="button" data-view-component="true" class="close-button Overlay-closeButton"><svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x">
    <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path>
</svg></button>
    </div>
  </div>
  
</div>
      <scrollable-region data-labelled-by="feedback-dialog-title">
        <div data-view-component="true" class="Overlay-body">        <!-- '"` --><!-- </textarea></xmp> --></option></form><form id="code-search-feedback-form" data-turbo="false" action="/search/feedback" accept-charset="UTF-8" method="post"><input type="hidden" data-csrf="true" name="authenticity_token" value="Uoh6TLWXN9PTs/x0DIpBc9BAIso0uc/wx6CtqKf66u0FmwsNsTVpJ5EbcL5zDhkMMbabXcUQSQGJO5ce1voFJQ==" />
          <p>We read every piece of feedback, and take your input very seriously.</p>
          <textarea name="feedback" class="form-control width-full mb-2" style="height: 120px" id="feedback"></textarea>
          <input name="include_email" id="include_email" aria-label="Include my email address so I can be contacted" class="form-control mr-2" type="checkbox">
          <label for="include_email" style="font-weight: normal">Include my email address so I can be contacted</label>
</form></div>
      </scrollable-region>
      <div data-view-component="true" class="Overlay-footer Overlay-footer--alignEnd">          <button data-close-dialog-id="feedback-dialog" type="button" data-view-component="true" class="btn">    Cancel
</button>
          <button form="code-search-feedback-form" data-action="click:qbsearch-input#submitFeedback" type="submit" data-view-component="true" class="btn-primary btn">    Submit feedback
</button>
</div>
</dialog></dialog-helper>

    <custom-scopes data-target="qbsearch-input.customScopesManager">
    
<dialog-helper>
  <dialog data-target="custom-scopes.customScopesModalDialog" data-action="close:qbsearch-input#handleDialogClose cancel:qbsearch-input#handleDialogClose" id="custom-scopes-dialog" aria-modal="true" aria-labelledby="custom-scopes-dialog-title" aria-describedby="custom-scopes-dialog-description" data-view-component="true" class="Overlay Overlay-whenNarrow Overlay--size-medium Overlay--motion-scaleFade">
    <div data-view-component="true" class="Overlay-header Overlay-header--divided">
  <div class="Overlay-headerContentWrap">
    <div class="Overlay-titleWrap">
      <h1 class="Overlay-title " id="custom-scopes-dialog-title">
        Saved searches
      </h1>
        <h2 id="custom-scopes-dialog-description" class="Overlay-description">Use saved searches to filter your results more quickly</h2>
    </div>
    <div class="Overlay-actionWrap">
      <button data-close-dialog-id="custom-scopes-dialog" aria-label="Close" type="button" data-view-component="true" class="close-button Overlay-closeButton"><svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x">
    <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path>
</svg></button>
    </div>
  </div>
  
</div>
      <scrollable-region data-labelled-by="custom-scopes-dialog-title">
        <div data-view-component="true" class="Overlay-body">        <div data-target="custom-scopes.customScopesModalDialogFlash"></div>

        <div hidden class="create-custom-scope-form" data-target="custom-scopes.createCustomScopeForm">
        <!-- '"` --><!-- </textarea></xmp> --></option></form><form id="custom-scopes-dialog-form" data-turbo="false" action="/search/custom_scopes" accept-charset="UTF-8" method="post"><input type="hidden" data-csrf="true" name="authenticity_token" value="q2pLIwo6r1Ejbgn3qZsuzcKdPZ0wZx4eP/CbK7jWXpdXVtj+o873GmG/8LiLvFFagSRaz+Pz/6aV9zstKeipJg==" />
          <div data-target="custom-scopes.customScopesModalDialogFlash"></div>

          <input type="hidden" id="custom_scope_id" name="custom_scope_id" data-target="custom-scopes.customScopesIdField">

          <div class="form-group">
            <label for="custom_scope_name">Name</label>
            <auto-check src="/search/custom_scopes/check_name" required>
              <input
                type="text"
                name="custom_scope_name"
                id="custom_scope_name"
                data-target="custom-scopes.customScopesNameField"
                class="form-control"
                autocomplete="off"
                placeholder="github-ruby"
                required
                maxlength="50">
              <input type="hidden" data-csrf="true" value="Hq2Tl1uXjyMNGxIk/cIPd0e/mjQl966UDAXx03uVQUB7DLup6ahFzET85TFpAxIaGWuxffeD08yECnT34FS11Q==" />
            </auto-check>
          </div>

          <div class="form-group">
            <label for="custom_scope_query">Query</label>
            <input
              type="text"
              name="custom_scope_query"
              id="custom_scope_query"
              data-target="custom-scopes.customScopesQueryField"
              class="form-control"
              autocomplete="off"
              placeholder="(repo:mona/a OR repo:mona/b) AND lang:python"
              required
              maxlength="500">
          </div>

          <p class="text-small color-fg-muted">
            To see all available qualifiers, see our <a class="Link--inTextBlock" href="https://docs.github.com/search-github/github-code-search/understanding-github-code-search-syntax">documentation</a>.
          </p>
</form>        </div>

        <div data-target="custom-scopes.manageCustomScopesForm">
          <div data-target="custom-scopes.list"></div>
        </div>

</div>
      </scrollable-region>
      <div data-view-component="true" class="Overlay-footer Overlay-footer--alignEnd Overlay-footer--divided">          <button data-action="click:custom-scopes#customScopesCancel" type="button" data-view-component="true" class="btn">    Cancel
</button>
          <button form="custom-scopes-dialog-form" data-action="click:custom-scopes#customScopesSubmit" data-target="custom-scopes.customScopesSubmitButton" type="submit" data-view-component="true" class="btn-primary btn">    Create saved search
</button>
</div>
</dialog></dialog-helper>
    </custom-scopes>
  </div>
</qbsearch-input>

            <div class="position-relative HeaderMenu-link-wrap d-lg-inline-block">
              <a
                href="/login?return_to=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web%2Fcommits%2Fmaster"
                class="HeaderMenu-link HeaderMenu-link--sign-in HeaderMenu-button flex-shrink-0 no-underline d-none d-lg-inline-flex border border-lg-0 rounded rounded-lg-0 px-2 py-1"
                style="margin-left: 12px;"
                data-hydro-click="{&quot;event_type&quot;:&quot;authentication.click&quot;,&quot;payload&quot;:{&quot;location_in_page&quot;:&quot;site header menu&quot;,&quot;repository_id&quot;:null,&quot;auth_type&quot;:&quot;SIGN_UP&quot;,&quot;originating_url&quot;:&quot;https://github.com/html2rss/html2rss-web/commits/master&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="2fcdd233dc323ade3f85d44cbbf9d702b72aba7ec4b698cb5998fa55147c31a8"
                data-analytics-event="{&quot;category&quot;:&quot;Marketing nav&quot;,&quot;action&quot;:&quot;click to go to homepage&quot;,&quot;label&quot;:&quot;ref_page:Marketing;ref_cta:Sign in;ref_loc:Header&quot;}"
              >
                Sign in
              </a>
            </div>

              <a href="/signup?ref_cta=Sign+up&amp;ref_loc=header+logged+out&amp;ref_page=%2F%3Cuser-name%3E%2F%3Crepo-name%3E%2Fcommits%2Fshow&amp;source=header-repo&amp;source_repo=html2rss%2Fhtml2rss-web"
                class="HeaderMenu-link HeaderMenu-link--sign-up HeaderMenu-button flex-shrink-0 d-flex d-lg-inline-flex no-underline border color-border-default rounded px-2 py-1"
                data-hydro-click="{&quot;event_type&quot;:&quot;authentication.click&quot;,&quot;payload&quot;:{&quot;location_in_page&quot;:&quot;site header menu&quot;,&quot;repository_id&quot;:null,&quot;auth_type&quot;:&quot;SIGN_UP&quot;,&quot;originating_url&quot;:&quot;https://github.com/html2rss/html2rss-web/commits/master&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="2fcdd233dc323ade3f85d44cbbf9d702b72aba7ec4b698cb5998fa55147c31a8"
                data-analytics-event="{&quot;category&quot;:&quot;Sign up&quot;,&quot;action&quot;:&quot;click to sign up for account&quot;,&quot;label&quot;:&quot;ref_page:/&lt;user-name&gt;/&lt;repo-name&gt;/commits/show;ref_cta:Sign up;ref_loc:header logged out&quot;}"
              >
                Sign up
              </a>
          <button type="button" class="sr-only js-header-menu-focus-trap d-block d-lg-none">Reseting focus</button>
        </div>
      </div>
    </div>
  </div>
</header>

      <div hidden="hidden" data-view-component="true" class="js-stale-session-flash stale-session-flash flash flash-warn flash-full">
  
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-alert">
    <path d="M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path>
</svg>
        <span class="js-stale-session-flash-signed-in" hidden>You signed in with another tab or window. <a class="Link--inTextBlock" href="">Reload</a> to refresh your session.</span>
        <span class="js-stale-session-flash-signed-out" hidden>You signed out in another tab or window. <a class="Link--inTextBlock" href="">Reload</a> to refresh your session.</span>
        <span class="js-stale-session-flash-switched" hidden>You switched accounts on another tab or window. <a class="Link--inTextBlock" href="">Reload</a> to refresh your session.</span>

    <button id="icon-button-82584713-5701-4684-b4fe-6704726fdbe2" aria-labelledby="tooltip-9f89b6fd-2a75-4044-b22b-8c207789282a" type="button" data-view-component="true" class="Button Button--iconOnly Button--invisible Button--medium flash-close js-flash-close">  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x Button-visual">
    <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path>
</svg>
</button><tool-tip id="tooltip-9f89b6fd-2a75-4044-b22b-8c207789282a" for="icon-button-82584713-5701-4684-b4fe-6704726fdbe2" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Dismiss alert</tool-tip>


  
</div>
    </div>

  <div id="start-of-content" class="show-on-focus"></div>








    <div id="js-flash-container" class="flash-container" data-turbo-replace>




  <template class="js-flash-template">
    
<div class="flash flash-full   {{ className }}">
  <div >
    <button autofocus class="flash-close js-flash-close" type="button" aria-label="Dismiss this message">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x">
    <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path>
</svg>
    </button>
    <div aria-atomic="true" role="alert" class="js-flash-alert">
      
      <div>{{ message }}</div>

    </div>
  </div>
</div>
  </template>
</div>


    
    <include-fragment class="js-notification-shelf-include-fragment" data-base-src="https://github.com/notifications/beta/shelf"></include-fragment>





  <div
    class="application-main "
    data-commit-hovercards-enabled
    data-discussion-hovercards-enabled
    data-issue-and-pr-hovercards-enabled
  >
        <div itemscope itemtype="http://schema.org/SoftwareSourceCode" class="">
    <main id="js-repo-pjax-container" >
      
      
    

    






  
  <div id="repository-container-header"  class="pt-3 hide-full-screen" style="background-color: var(--page-header-bgColor, var(--color-page-header-bg));" data-turbo-replace>


      <div class="d-flex flex-nowrap flex-justify-end mb-3  px-3 px-lg-5" style="gap: 1rem;">

        <div class="flex-auto min-width-0 width-fit">
            
  <div class=" d-flex flex-wrap flex-items-center wb-break-word f3 text-normal">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-repo color-fg-muted mr-2">
    <path d="M2 2.5A2.5 2.5 0 0 1 4.5 0h8.75a.75.75 0 0 1 .75.75v12.5a.75.75 0 0 1-.75.75h-2.5a.75.75 0 0 1 0-1.5h1.75v-2h-8a1 1 0 0 0-.714 1.7.75.75 0 1 1-1.072 1.05A2.495 2.495 0 0 1 2 11.5Zm10.5-1h-8a1 1 0 0 0-1 1v6.708A2.486 2.486 0 0 1 4.5 9h8ZM5 12.25a.25.25 0 0 1 .25-.25h3.5a.25.25 0 0 1 .25.25v3.25a.25.25 0 0 1-.4.2l-1.45-1.087a.249.249 0 0 0-.3 0L5.4 15.7a.25.25 0 0 1-.4-.2Z"></path>
</svg>
    
    <span class="author flex-self-stretch" itemprop="author">
      <a class="url fn" rel="author" data-hovercard-type="organization" data-hovercard-url="/orgs/html2rss/hovercard" data-octo-click="hovercard-link-click" data-octo-dimensions="link_type:self" href="/html2rss">
        html2rss
</a>    </span>
    <span class="mx-1 flex-self-stretch color-fg-muted">/</span>
    <strong itemprop="name" class="mr-2 flex-self-stretch">
      <a data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" href="/html2rss/html2rss-web">html2rss-web</a>
    </strong>

    <span></span><span class="Label Label--secondary v-align-middle mr-1">Public</span>
  </div>


        </div>

        <div id="repository-details-container" class="flex-shrink-0" data-turbo-replace style="max-width: 70%;">
            <ul class="pagehead-actions flex-shrink-0 d-none d-md-inline" style="padding: 2px 0;">
    
        <li>
          <include-fragment src="/html2rss/html2rss-web/sponsor_button"></include-fragment>
        </li>

      

  <li>
            <a href="/login?return_to=%2Fhtml2rss%2Fhtml2rss-web" rel="nofollow" id="repository-details-watch-button" data-hydro-click="{&quot;event_type&quot;:&quot;authentication.click&quot;,&quot;payload&quot;:{&quot;location_in_page&quot;:&quot;notification subscription menu watch&quot;,&quot;repository_id&quot;:null,&quot;auth_type&quot;:&quot;LOG_IN&quot;,&quot;originating_url&quot;:&quot;https://github.com/html2rss/html2rss-web/commits/master&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="da807749c1825acf48cb46f0882551b07123aa3b90665d098b305bf5640342c1" aria-label="You must be signed in to change notification settings" data-view-component="true" class="btn-sm btn">    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-bell mr-2">
    <path d="M8 16a2 2 0 0 0 1.985-1.75c.017-.137-.097-.25-.235-.25h-3.5c-.138 0-.252.113-.235.25A2 2 0 0 0 8 16ZM3 5a5 5 0 0 1 10 0v2.947c0 .05.015.098.042.139l1.703 2.555A1.519 1.519 0 0 1 13.482 13H2.518a1.516 1.516 0 0 1-1.263-2.36l1.703-2.554A.255.255 0 0 0 3 7.947Zm5-3.5A3.5 3.5 0 0 0 4.5 5v2.947c0 .346-.102.683-.294.97l-1.703 2.556a.017.017 0 0 0-.003.01l.001.006c0 .002.002.004.004.006l.006.004.007.001h10.964l.007-.001.006-.004.004-.006.001-.007a.017.017 0 0 0-.003-.01l-1.703-2.554a1.745 1.745 0 0 1-.294-.97V5A3.5 3.5 0 0 0 8 1.5Z"></path>
</svg>Notifications
</a>    <tool-tip id="tooltip-1c5e538f-99a1-4cad-bb36-9f52a57ef860" for="repository-details-watch-button" popover="manual" data-direction="s" data-type="description" data-view-component="true" class="sr-only position-absolute">You must be signed in to change notification settings</tool-tip>

  </li>

  <li>
          <a icon="repo-forked" id="fork-button" href="/login?return_to=%2Fhtml2rss%2Fhtml2rss-web" rel="nofollow" data-hydro-click="{&quot;event_type&quot;:&quot;authentication.click&quot;,&quot;payload&quot;:{&quot;location_in_page&quot;:&quot;repo details fork button&quot;,&quot;repository_id&quot;:135929870,&quot;auth_type&quot;:&quot;LOG_IN&quot;,&quot;originating_url&quot;:&quot;https://github.com/html2rss/html2rss-web/commits/master&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="99797b042301227fcad3e12e1307a55dc57a7ca165b0fbd241c4f8557ee8de15" data-view-component="true" class="btn-sm btn">    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-repo-forked mr-2">
    <path d="M5 5.372v.878c0 .414.336.75.75.75h4.5a.75.75 0 0 0 .75-.75v-.878a2.25 2.25 0 1 1 1.5 0v.878a2.25 2.25 0 0 1-2.25 2.25h-1.5v2.128a2.251 2.251 0 1 1-1.5 0V8.5h-1.5A2.25 2.25 0 0 1 3.5 6.25v-.878a2.25 2.25 0 1 1 1.5 0ZM5 3.25a.75.75 0 1 0-1.5 0 .75.75 0 0 0 1.5 0Zm6.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Zm-3 8.75a.75.75 0 1 0-1.5 0 .75.75 0 0 0 1.5 0Z"></path>
</svg>Fork
    <span id="repo-network-counter" data-pjax-replace="true" data-turbo-replace="true" title="11" data-view-component="true" class="Counter">11</span>
</a>
  </li>

  <li>
        <div data-view-component="true" class="BtnGroup d-flex">
        <a href="/login?return_to=%2Fhtml2rss%2Fhtml2rss-web" rel="nofollow" data-hydro-click="{&quot;event_type&quot;:&quot;authentication.click&quot;,&quot;payload&quot;:{&quot;location_in_page&quot;:&quot;star button&quot;,&quot;repository_id&quot;:135929870,&quot;auth_type&quot;:&quot;LOG_IN&quot;,&quot;originating_url&quot;:&quot;https://github.com/html2rss/html2rss-web/commits/master&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="d01f476a2196c890ee5dc6c94973885b77d1f36e0e560c70c4af577f07e0de75" aria-label="You must be signed in to star a repository" data-view-component="true" class="tooltipped tooltipped-sw btn-sm btn">    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-star v-align-text-bottom d-inline-block mr-2">
    <path d="M8 .25a.75.75 0 0 1 .673.418l1.882 3.815 4.21.612a.75.75 0 0 1 .416 1.279l-3.046 2.97.719 4.192a.751.751 0 0 1-1.088.791L8 12.347l-3.766 1.98a.75.75 0 0 1-1.088-.79l.72-4.194L.818 6.374a.75.75 0 0 1 .416-1.28l4.21-.611L7.327.668A.75.75 0 0 1 8 .25Zm0 2.445L6.615 5.5a.75.75 0 0 1-.564.41l-3.097.45 2.24 2.184a.75.75 0 0 1 .216.664l-.528 3.084 2.769-1.456a.75.75 0 0 1 .698 0l2.77 1.456-.53-3.084a.75.75 0 0 1 .216-.664l2.24-2.183-3.096-.45a.75.75 0 0 1-.564-.41L8 2.694Z"></path>
</svg><span data-view-component="true" class="d-inline">
          Star
</span>          <span id="repo-stars-counter-star" aria-label="86 users starred this repository" data-singular-suffix="user starred this repository" data-plural-suffix="users starred this repository" data-turbo-replace="true" title="86" data-view-component="true" class="Counter js-social-count">86</span>
</a></div>
  </li>

</ul>

        </div>
      </div>

        <div id="responsive-meta-container" data-turbo-replace>
</div>


          <nav data-pjax="#js-repo-pjax-container" aria-label="Repository" data-view-component="true" class="js-repo-nav js-sidenav-container-pjax js-responsive-underlinenav overflow-hidden UnderlineNav px-3 px-md-4 px-lg-5">

  <ul data-view-component="true" class="UnderlineNav-body list-style-none">
      <li data-view-component="true" class="d-inline-flex">
  <a id="code-tab" href="/html2rss/html2rss-web" data-tab-item="i0code-tab" data-selected-links="repo_source repo_downloads repo_commits repo_releases repo_tags repo_branches repo_packages repo_deployments repo_attestations /html2rss/html2rss-web" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g c" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Code&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code UnderlineNav-octicon d-none d-sm-inline">
    <path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path>
</svg>
        <span data-content="Code">Code</span>
          <span id="code-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>


    
</a></li>
      <li data-view-component="true" class="d-inline-flex">
  <a id="issues-tab" href="/html2rss/html2rss-web/issues" data-tab-item="i1issues-tab" data-selected-links="repo_issues repo_labels repo_milestones /html2rss/html2rss-web/issues" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g i" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Issues&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened UnderlineNav-octicon d-none d-sm-inline">
    <path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"></path><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"></path>
</svg>
        <span data-content="Issues">Issues</span>
          <span id="issues-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="5" data-view-component="true" class="Counter">5</span>


    
</a></li>
      <li data-view-component="true" class="d-inline-flex">
  <a id="pull-requests-tab" href="/html2rss/html2rss-web/pulls" data-tab-item="i2pull-requests-tab" data-selected-links="repo_pulls checks /html2rss/html2rss-web/pulls" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g p" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Pull requests&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-pull-request UnderlineNav-octicon d-none d-sm-inline">
    <path d="M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z"></path>
</svg>
        <span data-content="Pull requests">Pull requests</span>
          <span id="pull-requests-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="2" data-view-component="true" class="Counter">2</span>


    
</a></li>
      <li data-view-component="true" class="d-inline-flex">
  <a id="actions-tab" href="/html2rss/html2rss-web/actions" data-tab-item="i3actions-tab" data-selected-links="repo_actions /html2rss/html2rss-web/actions" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g a" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Actions&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-play UnderlineNav-octicon d-none d-sm-inline">
    <path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path>
</svg>
        <span data-content="Actions">Actions</span>
          <span id="actions-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>


    
</a></li>
      <li data-view-component="true" class="d-inline-flex">
  <a id="wiki-tab" href="/html2rss/html2rss-web/wiki" data-tab-item="i4wiki-tab" data-selected-links="repo_wiki /html2rss/html2rss-web/wiki" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g w" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Wiki&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-book UnderlineNav-octicon d-none d-sm-inline">
    <path d="M0 1.75A.75.75 0 0 1 .75 1h4.253c1.227 0 2.317.59 3 1.501A3.743 3.743 0 0 1 11.006 1h4.245a.75.75 0 0 1 .75.75v10.5a.75.75 0 0 1-.75.75h-4.507a2.25 2.25 0 0 0-1.591.659l-.622.621a.75.75 0 0 1-1.06 0l-.622-.621A2.25 2.25 0 0 0 5.258 13H.75a.75.75 0 0 1-.75-.75Zm7.251 10.324.004-5.073-.002-2.253A2.25 2.25 0 0 0 5.003 2.5H1.5v9h3.757a3.75 3.75 0 0 1 1.994.574ZM8.755 4.75l-.004 7.322a3.752 3.752 0 0 1 1.992-.572H14.5v-9h-3.495a2.25 2.25 0 0 0-2.25 2.25Z"></path>
</svg>
        <span data-content="Wiki">Wiki</span>
          <span id="wiki-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>


    
</a></li>
      <li data-view-component="true" class="d-inline-flex">
  <a id="security-tab" href="/html2rss/html2rss-web/security" data-tab-item="i5security-tab" data-selected-links="security overview alerts policy token_scanning code_scanning /html2rss/html2rss-web/security" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g s" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Security&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-shield UnderlineNav-octicon d-none d-sm-inline">
    <path d="M7.467.133a1.748 1.748 0 0 1 1.066 0l5.25 1.68A1.75 1.75 0 0 1 15 3.48V7c0 1.566-.32 3.182-1.303 4.682-.983 1.498-2.585 2.813-5.032 3.855a1.697 1.697 0 0 1-1.33 0c-2.447-1.042-4.049-2.357-5.032-3.855C1.32 10.182 1 8.566 1 7V3.48a1.75 1.75 0 0 1 1.217-1.667Zm.61 1.429a.25.25 0 0 0-.153 0l-5.25 1.68a.25.25 0 0 0-.174.238V7c0 1.358.275 2.666 1.057 3.86.784 1.194 2.121 2.34 4.366 3.297a.196.196 0 0 0 .154 0c2.245-.956 3.582-2.104 4.366-3.298C13.225 9.666 13.5 8.36 13.5 7V3.48a.251.251 0 0 0-.174-.237l-5.25-1.68ZM8.75 4.75v3a.75.75 0 0 1-1.5 0v-3a.75.75 0 0 1 1.5 0ZM9 10.5a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path>
</svg>
        <span data-content="Security">Security</span>
          <include-fragment src="/html2rss/html2rss-web/security/overall-count" accept="text/fragment+html"></include-fragment>

    
</a></li>
      <li data-view-component="true" class="d-inline-flex">
  <a id="insights-tab" href="/html2rss/html2rss-web/pulse" data-tab-item="i6insights-tab" data-selected-links="repo_graphs repo_contributors dependency_graph dependabot_updates pulse people community /html2rss/html2rss-web/pulse" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-analytics-event="{&quot;category&quot;:&quot;Underline navbar&quot;,&quot;action&quot;:&quot;Click tab&quot;,&quot;label&quot;:&quot;Insights&quot;,&quot;target&quot;:&quot;UNDERLINE_NAV.TAB&quot;}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">
    
              <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-graph UnderlineNav-octicon d-none d-sm-inline">
    <path d="M1.5 1.75V13.5h13.75a.75.75 0 0 1 0 1.5H.75a.75.75 0 0 1-.75-.75V1.75a.75.75 0 0 1 1.5 0Zm14.28 2.53-5.25 5.25a.75.75 0 0 1-1.06 0L7 7.06 4.28 9.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.25-3.25a.75.75 0 0 1 1.06 0L10 7.94l4.72-4.72a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z"></path>
</svg>
        <span data-content="Insights">Insights</span>
          <span id="insights-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>


    
</a></li>
</ul>
    <div style="visibility:hidden;" data-view-component="true" class="UnderlineNav-actions js-responsive-underlinenav-overflow position-absolute pr-3 pr-md-4 pr-lg-5 right-0">      <action-menu data-select-variant="none" data-view-component="true">
  <focus-group direction="vertical" mnemonics retain>
    <button id="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-button" popovertarget="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-overlay" aria-controls="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-list" aria-haspopup="true" aria-labelledby="tooltip-edb05a11-759a-4645-bc6c-614d99707bce" type="button" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium UnderlineNav-item">  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-kebab-horizontal Button-visual">
    <path d="M8 9a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3ZM1.5 9a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Zm13 0a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"></path>
</svg>
</button><tool-tip id="tooltip-edb05a11-759a-4645-bc6c-614d99707bce" for="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-button" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Additional navigation options</tool-tip>


<anchored-position id="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-overlay" anchor="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-button" align="start" side="outside-bottom" anchor-offset="normal" popover="auto" data-view-component="true">
  <div data-view-component="true" class="Overlay Overlay--size-auto">
    
      <div data-view-component="true" class="Overlay-body Overlay-body--paddingNone">          <action-list>
  <div data-view-component="true">
    <ul aria-labelledby="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-button" id="action-menu-9bb18d41-a9df-4b64-81f5-72e022fe45ef-list" role="menu" data-view-component="true" class="ActionListWrap--inset ActionListWrap">
        <li hidden="hidden" data-menu-item="i0code-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-017412c7-1b89-41fa-b569-2a57af91f196" href="/html2rss/html2rss-web" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code">
    <path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Code
</span>      
</a>
  
</li>
        <li hidden="hidden" data-menu-item="i1issues-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-14df0b8f-85ec-40f5-8883-89c5b409e702" href="/html2rss/html2rss-web/issues" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened">
    <path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"></path><path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Issues
</span>      
</a>
  
</li>
        <li hidden="hidden" data-menu-item="i2pull-requests-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-07f0fca8-2b52-42b1-bb57-8132790e046b" href="/html2rss/html2rss-web/pulls" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-pull-request">
    <path d="M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Pull requests
</span>      
</a>
  
</li>
        <li hidden="hidden" data-menu-item="i3actions-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-439e4aff-eec0-4d34-bdc2-3a0c434e2e3e" href="/html2rss/html2rss-web/actions" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-play">
    <path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Actions
</span>      
</a>
  
</li>
        <li hidden="hidden" data-menu-item="i4wiki-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-58d2a84c-9d15-4d97-8443-46c397a97663" href="/html2rss/html2rss-web/wiki" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-book">
    <path d="M0 1.75A.75.75 0 0 1 .75 1h4.253c1.227 0 2.317.59 3 1.501A3.743 3.743 0 0 1 11.006 1h4.245a.75.75 0 0 1 .75.75v10.5a.75.75 0 0 1-.75.75h-4.507a2.25 2.25 0 0 0-1.591.659l-.622.621a.75.75 0 0 1-1.06 0l-.622-.621A2.25 2.25 0 0 0 5.258 13H.75a.75.75 0 0 1-.75-.75Zm7.251 10.324.004-5.073-.002-2.253A2.25 2.25 0 0 0 5.003 2.5H1.5v9h3.757a3.75 3.75 0 0 1 1.994.574ZM8.755 4.75l-.004 7.322a3.752 3.752 0 0 1 1.992-.572H14.5v-9h-3.495a2.25 2.25 0 0 0-2.25 2.25Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Wiki
</span>      
</a>
  
</li>
        <li hidden="hidden" data-menu-item="i5security-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-9fb92df0-7a9e-43e4-8a0b-cf7e9f80e9ad" href="/html2rss/html2rss-web/security" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-shield">
    <path d="M7.467.133a1.748 1.748 0 0 1 1.066 0l5.25 1.68A1.75 1.75 0 0 1 15 3.48V7c0 1.566-.32 3.182-1.303 4.682-.983 1.498-2.585 2.813-5.032 3.855a1.697 1.697 0 0 1-1.33 0c-2.447-1.042-4.049-2.357-5.032-3.855C1.32 10.182 1 8.566 1 7V3.48a1.75 1.75 0 0 1 1.217-1.667Zm.61 1.429a.25.25 0 0 0-.153 0l-5.25 1.68a.25.25 0 0 0-.174.238V7c0 1.358.275 2.666 1.057 3.86.784 1.194 2.121 2.34 4.366 3.297a.196.196 0 0 0 .154 0c2.245-.956 3.582-2.104 4.366-3.298C13.225 9.666 13.5 8.36 13.5 7V3.48a.251.251 0 0 0-.174-.237l-5.25-1.68ZM8.75 4.75v3a.75.75 0 0 1-1.5 0v-3a.75.75 0 0 1 1.5 0ZM9 10.5a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Security
</span>      
</a>
  
</li>
        <li hidden="hidden" data-menu-item="i6insights-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">
    
    
    <a tabindex="-1" id="item-93dbe053-7ddd-4ea5-9748-e452522fc135" href="/html2rss/html2rss-web/pulse" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16">
        <span class="ActionListItem-visual ActionListItem-visual--leading">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-graph">
    <path d="M1.5 1.75V13.5h13.75a.75.75 0 0 1 0 1.5H.75a.75.75 0 0 1-.75-.75V1.75a.75.75 0 0 1 1.5 0Zm14.28 2.53-5.25 5.25a.75.75 0 0 1-1.06 0L7 7.06 4.28 9.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.25-3.25a.75.75 0 0 1 1.06 0L10 7.94l4.72-4.72a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z"></path>
</svg>
        </span>
      
        <span data-view-component="true" class="ActionListItem-label">
          Insights
</span>      
</a>
  
</li>
</ul>    
</div></action-list>


</div>
      
</div></anchored-position>  </focus-group>
</action-menu></div>
</nav>

  </div>

  



<turbo-frame id="repo-content-turbo-frame" target="_top" data-turbo-action="advance" class="">
    <div id="repo-content-pjax-container" class="repository-content " >
    



    
      
    








<react-app
  app-name="commits"
  initial-path="/html2rss/html2rss-web/commits/master"
    style="display: block; min-height: calc(100vh - 64px);"
  data-attempted-ssr="true"
  data-ssr="true"
  data-lazy="false"
  data-alternate="false"
>
  
  <script type="application/json" data-target="react-app.embeddedData">{"payload":{"commitGroups":[{"title":"Oct 11, 2024","commits":[{"oid":"8eeb9e69a1c57f3c61ca00469083604e25066859","url":"/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859","authoredDate":"2024-10-11T22:03:43.000Z","committedDate":"2024-10-11T22:03:43.000Z","shortMessage":"chore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (#689)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (#689)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.84.0 to 3.85.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.84.0...3.85.0)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859\"\u003echore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2582254361\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/689\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/689/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/689\"\u003e#689\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (#689)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.84.0 to 3.85.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.84.0...3.85.0)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [roda](\u003ca href=\"https://github.com/jeremyevans/roda\"\u003ehttps://github.com/jeremyevans/roda\u003c/a\u003e).\n\n\nUpdates `roda` from 3.84.0 to 3.85.0\n- [Changelog](\u003ca href=\"https://github.com/jeremyevans/roda/blob/master/CHANGELOG\"\u003ehttps://github.com/jeremyevans/roda/blob/master/CHANGELOG\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/jeremyevans/roda/compare/3.84.0...3.85.0\"\u003ejeremyevans/roda@\u003ctt\u003e3.84.0...3.85.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Oct 9, 2024","commits":[{"oid":"65964787b26ab6406ca1e9f1f64de67adb66b49e","url":"/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e","authoredDate":"2024-10-09T22:48:10.000Z","committedDate":"2024-10-09T22:48:10.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#688)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#688)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `560c66c` to `9673d2b`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/560c66c8fb08abdc2e485a9576b8b414480b377d...9673d2b091e5d10bb6fa3c161b1ba97070921fd4)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e\"\u003echore(deps): bump html2rss-configs in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2577103680\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/688\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/688/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/688\"\u003e#688\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#688)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `560c66c` to `9673d2b`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/560c66c8fb08abdc2e485a9576b8b414480b377d...9673d2b091e5d10bb6fa3c161b1ba97070921fd4)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `560c66c` to `9673d2b`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/560c66c8fb08abdc2e485a9576b8b414480b377d...9673d2b091e5d10bb6fa3c161b1ba97070921fd4\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e560c66c...9673d2b\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Oct 8, 2024","commits":[{"oid":"9ff3cc1a706ebdea7b75e560ea263caab79ce68f","url":"/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f","authoredDate":"2024-10-08T11:13:34.000Z","committedDate":"2024-10-08T11:13:34.000Z","shortMessage":"chore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (#687)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (#687)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.13.0 to 0.14.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.13.0...v0.14.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f\"\u003echore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2572881396\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/687\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/687/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/687\"\u003e#687\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (#687)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.13.0 to 0.14.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.13.0...v0.14.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss](\u003ca href=\"https://github.com/gildesmarais/html2rss\"\u003ehttps://github.com/gildesmarais/html2rss\u003c/a\u003e).\n\n\nUpdates `html2rss` from 0.13.0 to 0.14.0\n- [Release notes](\u003ca href=\"https://github.com/gildesmarais/html2rss/releases\"\u003ehttps://github.com/gildesmarais/html2rss/releases\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/v0.13.0...v0.14.0\"\u003ehtml2rss/html2rss@\u003ctt\u003ev0.13.0...v0.14.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Sep 19, 2024","commits":[{"oid":"9d81615cc9c178127b86c45fa108bc3bf92ba163","url":"/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163","authoredDate":"2024-09-19T22:24:40.000Z","committedDate":"2024-09-19T22:24:40.000Z","shortMessage":"chore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (#686)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (#686)\n\nBumps the rubygems group with 1 update: [puma](https://github.com/puma/puma).\n\n\nUpdates `puma` from 6.4.2 to 6.4.3\n- [Release notes](https://github.com/puma/puma/releases)\n- [Changelog](https://github.com/puma/puma/blob/master/History.md)\n- [Commits](https://github.com/puma/puma/compare/v6.4.2...v6.4.3)\n\n---\nupdated-dependencies:\n- dependency-name: puma\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163\"\u003echore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2537463374\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/686\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/686/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/686\"\u003e#686\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (#686)\n\nBumps the rubygems group with 1 update: [puma](https://github.com/puma/puma).\n\n\nUpdates `puma` from 6.4.2 to 6.4.3\n- [Release notes](https://github.com/puma/puma/releases)\n- [Changelog](https://github.com/puma/puma/blob/master/History.md)\n- [Commits](https://github.com/puma/puma/compare/v6.4.2...v6.4.3)\n\n---\nupdated-dependencies:\n- dependency-name: puma\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [puma](\u003ca href=\"https://github.com/puma/puma\"\u003ehttps://github.com/puma/puma\u003c/a\u003e).\n\n\nUpdates `puma` from 6.4.2 to 6.4.3\n- [Release notes](\u003ca href=\"https://github.com/puma/puma/releases\"\u003ehttps://github.com/puma/puma/releases\u003c/a\u003e)\n- [Changelog](\u003ca href=\"https://github.com/puma/puma/blob/master/History.md\"\u003ehttps://github.com/puma/puma/blob/master/History.md\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/puma/puma/compare/v6.4.2...v6.4.3\"\u003epuma/puma@\u003ctt\u003ev6.4.2...v6.4.3\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: puma\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Sep 12, 2024","commits":[{"oid":"2d1b2506699897694d47244748fd6ece6dedbd4e","url":"/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e","authoredDate":"2024-09-12T22:44:19.000Z","committedDate":"2024-09-12T22:44:19.000Z","shortMessage":"chore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (#685)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (#685)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.83.0 to 3.84.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.83.0...3.84.0)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e\"\u003echore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2523481129\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/685\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/685/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/685\"\u003e#685\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (#685)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.83.0 to 3.84.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.83.0...3.84.0)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [roda](\u003ca href=\"https://github.com/jeremyevans/roda\"\u003ehttps://github.com/jeremyevans/roda\u003c/a\u003e).\n\n\nUpdates `roda` from 3.83.0 to 3.84.0\n- [Changelog](\u003ca href=\"https://github.com/jeremyevans/roda/blob/master/CHANGELOG\"\u003ehttps://github.com/jeremyevans/roda/blob/master/CHANGELOG\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/jeremyevans/roda/compare/3.83.0...3.84.0\"\u003ejeremyevans/roda@\u003ctt\u003e3.83.0...3.84.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Sep 5, 2024","commits":[{"oid":"ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989","url":"/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989","authoredDate":"2024-09-05T09:09:42.000Z","committedDate":"2024-09-05T09:09:42.000Z","shortMessage":"chore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (#684)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (#684)\n\nBumps ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20.\n\n---\nupdated-dependencies:\n- dependency-name: ruby\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989\"\u003echore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2507217874\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/684\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/684/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/684\"\u003e#684\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (#684)\n\nBumps ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20.\n\n---\nupdated-dependencies:\n- dependency-name: ruby\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20.\n\n---\nupdated-dependencies:\n- dependency-name: ruby\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 22, 2024","commits":[{"oid":"b45763778438aa153e7cd3d18a8b84e521624874","url":"/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874","authoredDate":"2024-08-22T22:47:40.000Z","committedDate":"2024-08-22T22:47:40.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#683)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#683)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `86f7f48` to `560c66c`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/86f7f48f4ed613c53da36f21ed6fa0021b6afa6a...560c66c8fb08abdc2e485a9576b8b414480b377d)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874\"\u003echore(deps): bump html2rss-configs in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2481937369\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/683\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/683/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/683\"\u003e#683\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#683)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `86f7f48` to `560c66c`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/86f7f48f4ed613c53da36f21ed6fa0021b6afa6a...560c66c8fb08abdc2e485a9576b8b414480b377d)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `86f7f48` to `560c66c`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/86f7f48f4ed613c53da36f21ed6fa0021b6afa6a...560c66c8fb08abdc2e485a9576b8b414480b377d\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e86f7f48...560c66c\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"dca827891199a7a8b6979ccd4e36487d1798ed0d","url":"/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d","authoredDate":"2024-08-22T20:59:58.000Z","committedDate":"2024-08-22T20:59:58.000Z","shortMessage":"chore(deps): bump rexml from 3.3.5 to 3.3.6 (#682)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump rexml from 3.3.5 to 3.3.6 (#682)\n\nBumps [rexml](https://github.com/ruby/rexml) from 3.3.5 to 3.3.6.\n- [Release notes](https://github.com/ruby/rexml/releases)\n- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)\n- [Commits](https://github.com/ruby/rexml/compare/v3.3.5...v3.3.6)\n\n---\nupdated-dependencies:\n- dependency-name: rexml\n  dependency-type: indirect\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d\"\u003echore(deps): bump rexml from 3.3.5 to 3.3.6 (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2481717985\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/682\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/682/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/682\"\u003e#682\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump rexml from 3.3.5 to 3.3.6 (#682)\n\nBumps [rexml](https://github.com/ruby/rexml) from 3.3.5 to 3.3.6.\n- [Release notes](https://github.com/ruby/rexml/releases)\n- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)\n- [Commits](https://github.com/ruby/rexml/compare/v3.3.5...v3.3.6)\n\n---\nupdated-dependencies:\n- dependency-name: rexml\n  dependency-type: indirect\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps [rexml](\u003ca href=\"https://github.com/ruby/rexml\"\u003ehttps://github.com/ruby/rexml\u003c/a\u003e) from 3.3.5 to 3.3.6.\n- [Release notes](\u003ca href=\"https://github.com/ruby/rexml/releases\"\u003ehttps://github.com/ruby/rexml/releases\u003c/a\u003e)\n- [Changelog](\u003ca href=\"https://github.com/ruby/rexml/blob/master/NEWS.md\"\u003ehttps://github.com/ruby/rexml/blob/master/NEWS.md\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/ruby/rexml/compare/v3.3.5...v3.3.6\"\u003eruby/rexml@\u003ctt\u003ev3.3.5...v3.3.6\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: rexml\n  dependency-type: indirect\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 19, 2024","commits":[{"oid":"5ebc9ec5de9799d9da28b93275cfbdc775240f0c","url":"/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c","authoredDate":"2024-08-19T22:54:51.000Z","committedDate":"2024-08-19T22:54:51.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#677)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#677)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `27f9f9a` to `86f7f48`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/27f9f9adcd0a85310f5dfe1a61ed2f96b6638697...86f7f48f4ed613c53da36f21ed6fa0021b6afa6a)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c\"\u003echore(deps): bump html2rss-configs in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2474391321\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/677\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/677/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/677\"\u003e#677\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#677)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `27f9f9a` to `86f7f48`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/27f9f9adcd0a85310f5dfe1a61ed2f96b6638697...86f7f48f4ed613c53da36f21ed6fa0021b6afa6a)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `27f9f9a` to `86f7f48`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/27f9f9adcd0a85310f5dfe1a61ed2f96b6638697...86f7f48f4ed613c53da36f21ed6fa0021b6afa6a\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e27f9f9a...86f7f48\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 17, 2024","commits":[{"oid":"929ae671dade0457a5af781982d3db5a39c8676a","url":"/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a","authoredDate":"2024-08-17T14:47:32.000+02:00","committedDate":"2024-08-17T14:47:32.000+02:00","shortMessage":"refactor: improve structure to follow more Roda conventions (#675)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"refactor: improve structure to follow more Roda conventions (#675)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a\"\u003erefactor: improve structure to follow more Roda conventions (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2471098036\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/675\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/675/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/675\"\u003e#675\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"refactor: improve structure to follow more Roda conventions (#675)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a\"\u003e)\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 16, 2024","commits":[{"oid":"59831cddd1ed24f722ac60c388141a5b65d8e269","url":"/html2rss/html2rss-web/commit/59831cddd1ed24f722ac60c388141a5b65d8e269","authoredDate":"2024-08-16T15:44:36.000Z","committedDate":"2024-08-16T17:45:41.000+02:00","shortMessage":"chore(deps): bump the rubygems group with 2 updates","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates\n\nBumps the rubygems group with 2 updates: [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [parallel](https://github.com/grosser/parallel).\n\n\nUpdates `html2rss-configs` from `721dc23` to `27f9f9a`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/721dc23e3cc84e7d6fd1183ff453f71e55ba5ab1...27f9f9adcd0a85310f5dfe1a61ed2f96b6638697)\n\nUpdates `parallel` from 1.26.2 to 1.26.3\n- [Commits](https://github.com/grosser/parallel/compare/v1.26.2...v1.26.3)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/59831cddd1ed24f722ac60c388141a5b65d8e269\"\u003echore(deps): bump the rubygems group with 2 updates\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 2 updates: [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e) and [parallel](\u003ca href=\"https://github.com/grosser/parallel\"\u003ehttps://github.com/grosser/parallel\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `721dc23` to `27f9f9a`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/721dc23e3cc84e7d6fd1183ff453f71e55ba5ab1...27f9f9adcd0a85310f5dfe1a61ed2f96b6638697\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e721dc23...27f9f9a\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `parallel` from 1.26.2 to 1.26.3\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/grosser/parallel/compare/v1.26.2...v1.26.3\"\u003egrosser/parallel@\u003ctt\u003ev1.26.2...v1.26.3\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":true,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"83772a132ca489c0b58d8becc716710896d348e4","url":"/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4","authoredDate":"2024-08-16T14:34:40.000Z","committedDate":"2024-08-16T14:34:40.000Z","shortMessage":"chore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (#672)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (#672)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.12.0 to 0.13.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.12.0...v0.13.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4\"\u003echore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2470397038\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/672\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/672/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/672\"\u003e#672\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (#672)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.12.0 to 0.13.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.12.0...v0.13.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss](\u003ca href=\"https://github.com/gildesmarais/html2rss\"\u003ehttps://github.com/gildesmarais/html2rss\u003c/a\u003e).\n\n\nUpdates `html2rss` from 0.12.0 to 0.13.0\n- [Release notes](\u003ca href=\"https://github.com/gildesmarais/html2rss/releases\"\u003ehttps://github.com/gildesmarais/html2rss/releases\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/v0.12.0...v0.13.0\"\u003ehtml2rss/html2rss@\u003ctt\u003ev0.12.0...v0.13.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 12, 2024","commits":[{"oid":"1f466065612bd289933b28747e7e6f76a628bc31","url":"/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31","authoredDate":"2024-08-12T22:47:37.000Z","committedDate":"2024-08-12T22:47:37.000Z","shortMessage":"chore(deps): bump the rubygems group with 2 updates (#671)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#671)\n\nBumps the rubygems group with 2 updates: [parallel](https://github.com/grosser/parallel) and [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `parallel` from 1.26.1 to 1.26.2\n- [Commits](https://github.com/grosser/parallel/compare/v1.26.1...v1.26.2)\n\nUpdates `roda` from 3.82.0 to 3.83.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.82.0...3.83.0)\n\n---\nupdated-dependencies:\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31\"\u003echore(deps): bump the rubygems group with 2 updates (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2462016360\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/671\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/671/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/671\"\u003e#671\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#671)\n\nBumps the rubygems group with 2 updates: [parallel](https://github.com/grosser/parallel) and [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `parallel` from 1.26.1 to 1.26.2\n- [Commits](https://github.com/grosser/parallel/compare/v1.26.1...v1.26.2)\n\nUpdates `roda` from 3.82.0 to 3.83.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.82.0...3.83.0)\n\n---\nupdated-dependencies:\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 2 updates: [parallel](\u003ca href=\"https://github.com/grosser/parallel\"\u003ehttps://github.com/grosser/parallel\u003c/a\u003e) and [roda](\u003ca href=\"https://github.com/jeremyevans/roda\"\u003ehttps://github.com/jeremyevans/roda\u003c/a\u003e).\n\n\nUpdates `parallel` from 1.26.1 to 1.26.2\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/grosser/parallel/compare/v1.26.1...v1.26.2\"\u003egrosser/parallel@\u003ctt\u003ev1.26.1...v1.26.2\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `roda` from 3.82.0 to 3.83.0\n- [Changelog](\u003ca href=\"https://github.com/jeremyevans/roda/blob/master/CHANGELOG\"\u003ehttps://github.com/jeremyevans/roda/blob/master/CHANGELOG\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/jeremyevans/roda/compare/3.82.0...3.83.0\"\u003ejeremyevans/roda@\u003ctt\u003e3.82.0...3.83.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-patch\n  dependency-group: rubygems\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 10, 2024","commits":[{"oid":"6ae606229ae48d9c1cd3c7d0339172eb244ce8eb","url":"/html2rss/html2rss-web/commit/6ae606229ae48d9c1cd3c7d0339172eb244ce8eb","authoredDate":"2024-08-10T14:47:25.000Z","committedDate":"2024-08-10T16:48:33.000+02:00","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `fef08c6` to `721dc23`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/fef08c6fc2696e8936173e68403fa991846ff6c6...721dc23e3cc84e7d6fd1183ff453f71e55ba5ab1)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/6ae606229ae48d9c1cd3c7d0339172eb244ce8eb\"\u003echore(deps): bump html2rss-configs in the rubygems group\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `fef08c6` to `721dc23`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/fef08c6fc2696e8936173e68403fa991846ff6c6...721dc23e3cc84e7d6fd1183ff453f71e55ba5ab1\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003efef08c6...721dc23\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":true,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"36e06a98c472e78a89abb6c6979e0bb9a11f2e75","url":"/html2rss/html2rss-web/commit/36e06a98c472e78a89abb6c6979e0bb9a11f2e75","authoredDate":"2024-08-10T12:43:18.000Z","committedDate":"2024-08-10T12:43:18.000Z","shortMessage":"chore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (#669)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (#669)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.11.0 to 0.12.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.11.0...v0.12.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/36e06a98c472e78a89abb6c6979e0bb9a11f2e75\"\u003echore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2459068748\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/669\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/669/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/669\"\u003e#669\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (#669)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.11.0 to 0.12.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.11.0...v0.12.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/36e06a98c472e78a89abb6c6979e0bb9a11f2e75\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss](\u003ca href=\"https://github.com/gildesmarais/html2rss\"\u003ehttps://github.com/gildesmarais/html2rss\u003c/a\u003e).\n\n\nUpdates `html2rss` from 0.11.0 to 0.12.0\n- [Release notes](\u003ca href=\"https://github.com/gildesmarais/html2rss/releases\"\u003ehttps://github.com/gildesmarais/html2rss/releases\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/v0.11.0...v0.12.0\"\u003ehtml2rss/html2rss@\u003ctt\u003ev0.11.0...v0.12.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Aug 9, 2024","commits":[{"oid":"a207c788cbc147e3c8b28a597caa70adaf09374d","url":"/html2rss/html2rss-web/commit/a207c788cbc147e3c8b28a597caa70adaf09374d","authoredDate":"2024-08-10T00:45:11.000+02:00","committedDate":"2024-08-10T00:48:39.000+02:00","shortMessage":"chore(deps): update ruby deps","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): update ruby deps\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/a207c788cbc147e3c8b28a597caa70adaf09374d\"\u003echore(deps): update ruby deps\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"dca3bc3e42876c7681e05a3805f4c33af885d472","url":"/html2rss/html2rss-web/commit/dca3bc3e42876c7681e05a3805f4c33af885d472","authoredDate":"2024-08-10T00:44:24.000+02:00","committedDate":"2024-08-10T00:48:39.000+02:00","shortMessage":"style(rubocop): enable Layout/ClassStructure cop","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"style(rubocop): enable Layout/ClassStructure cop\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/dca3bc3e42876c7681e05a3805f4c33af885d472\"\u003estyle(rubocop): enable Layout/ClassStructure cop\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"164b22216df50a2cbd6e0a6715e7aa170d3ea99f","url":"/html2rss/html2rss-web/commit/164b22216df50a2cbd6e0a6715e7aa170d3ea99f","authoredDate":"2024-08-09T22:45:28.000Z","committedDate":"2024-08-09T22:45:28.000Z","shortMessage":"chore(deps): bump the rubygems group with 3 updates (#667)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 3 updates (#667)\n\nBumps the rubygems group with 3 updates: [html2rss](https://github.com/gildesmarais/html2rss), [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [parallel](https://github.com/grosser/parallel).\n\n\nUpdates `html2rss` from 0.10.0 to 0.11.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.10.0...v0.11.0)\n\nUpdates `html2rss-configs` from `07bbadc` to `fef08c6`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/07bbadcc2be501488a3772352ab0f8c7b05235a3...fef08c6fc2696e8936173e68403fa991846ff6c6)\n\nUpdates `parallel` from 1.24.0 to 1.26.1\n- [Commits](https://github.com/grosser/parallel/compare/v1.24.0...v1.26.1)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/164b22216df50a2cbd6e0a6715e7aa170d3ea99f\"\u003echore(deps): bump the rubygems group with 3 updates (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2458755473\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/667\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/667/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/667\"\u003e#667\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 3 updates (#667)\n\nBumps the rubygems group with 3 updates: [html2rss](https://github.com/gildesmarais/html2rss), [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [parallel](https://github.com/grosser/parallel).\n\n\nUpdates `html2rss` from 0.10.0 to 0.11.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.10.0...v0.11.0)\n\nUpdates `html2rss-configs` from `07bbadc` to `fef08c6`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/07bbadcc2be501488a3772352ab0f8c7b05235a3...fef08c6fc2696e8936173e68403fa991846ff6c6)\n\nUpdates `parallel` from 1.24.0 to 1.26.1\n- [Commits](https://github.com/grosser/parallel/compare/v1.24.0...v1.26.1)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/164b22216df50a2cbd6e0a6715e7aa170d3ea99f\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 3 updates: [html2rss](\u003ca href=\"https://github.com/gildesmarais/html2rss\"\u003ehttps://github.com/gildesmarais/html2rss\u003c/a\u003e), [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e) and [parallel](\u003ca href=\"https://github.com/grosser/parallel\"\u003ehttps://github.com/grosser/parallel\u003c/a\u003e).\n\n\nUpdates `html2rss` from 0.10.0 to 0.11.0\n- [Release notes](\u003ca href=\"https://github.com/gildesmarais/html2rss/releases\"\u003ehttps://github.com/gildesmarais/html2rss/releases\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/v0.10.0...v0.11.0\"\u003ehtml2rss/html2rss@\u003ctt\u003ev0.10.0...v0.11.0\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `html2rss-configs` from `07bbadc` to `fef08c6`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/07bbadcc2be501488a3772352ab0f8c7b05235a3...fef08c6fc2696e8936173e68403fa991846ff6c6\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e07bbadc...fef08c6\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `parallel` from 1.24.0 to 1.26.1\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/grosser/parallel/compare/v1.24.0...v1.26.1\"\u003egrosser/parallel@\u003ctt\u003ev1.24.0...v1.26.1\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: parallel\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"398388dd843c121cabff6ea7cc73cb6de7b3870a","url":"/html2rss/html2rss-web/commit/398388dd843c121cabff6ea7cc73cb6de7b3870a","authoredDate":"2024-08-09T20:08:56.000+02:00","committedDate":"2024-08-09T21:47:41.000+02:00","shortMessage":"refactor: improve readability of docs and code performance","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"refactor: improve readability of docs and code performance\n\nSigned-off-by: Gil Desmarais \u0026lt;git@desmarais.de\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/398388dd843c121cabff6ea7cc73cb6de7b3870a\"\u003erefactor: improve readability of docs and code performance\u003c/a\u003e","bodyMessageHtml":"Signed-off-by: Gil Desmarais \u0026lt;git@desmarais.de\u0026gt;","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7","url":"/html2rss/html2rss-web/commit/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7","authoredDate":"2024-08-09T19:58:50.000+02:00","committedDate":"2024-08-09T19:58:50.000+02:00","shortMessage":"feat: use parallel processing for feed retrieval in health_check.rb (#665)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"feat: use parallel processing for feed retrieval in health_check.rb (#665)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7\"\u003efeat: use parallel processing for feed retrieval in health_check.rb (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2458394104\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/665\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/665/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/665\"\u003e#665\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"feat: use parallel processing for feed retrieval in health_check.rb (#665)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7\"\u003e)\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"b9618974e7baea0fa24344b158f07dcec8175ed6","url":"/html2rss/html2rss-web/commit/b9618974e7baea0fa24344b158f07dcec8175ed6","authoredDate":"2024-08-09T19:37:21.000+02:00","committedDate":"2024-08-09T19:37:21.000+02:00","shortMessage":"fix: example feed in config/feeds.yml broken (#664)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"fix: example feed in config/feeds.yml broken (#664)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/b9618974e7baea0fa24344b158f07dcec8175ed6\"\u003efix: example feed in config/feeds.yml broken (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2458371254\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/664\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/664/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/664\"\u003e#664\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"fix: example feed in config/feeds.yml broken (#664)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/b9618974e7baea0fa24344b158f07dcec8175ed6\"\u003e)\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"55814d2239463a71af9849ad8951142572316bc4","url":"/html2rss/html2rss-web/commit/55814d2239463a71af9849ad8951142572316bc4","authoredDate":"2024-08-09T19:32:44.000+02:00","committedDate":"2024-08-09T19:32:44.000+02:00","shortMessage":"fix: tzdata package not installed but required for tz conversion (#663)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"fix: tzdata package not installed but required for tz conversion (#663)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/55814d2239463a71af9849ad8951142572316bc4\"\u003efix: tzdata package not installed but required for tz conversion (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2458364353\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/663\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/663/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/663\"\u003e#663\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"fix: tzdata package not installed but required for tz conversion (#663)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/55814d2239463a71af9849ad8951142572316bc4\"\u003e)\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"729f31f1b9160971a02a9ba855c880113534368e","url":"/html2rss/html2rss-web/commit/729f31f1b9160971a02a9ba855c880113534368e","authoredDate":"2024-08-09T19:01:08.000+02:00","committedDate":"2024-08-09T19:05:00.000+02:00","shortMessage":"perf: enable YJIT","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"perf: enable YJIT\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/729f31f1b9160971a02a9ba855c880113534368e\"\u003eperf: enable YJIT\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"870936d5fe150916674a9a63ce8cc4bda5c4d4fb","url":"/html2rss/html2rss-web/commit/870936d5fe150916674a9a63ce8cc4bda5c4d4fb","authoredDate":"2024-08-09T19:00:53.000+02:00","committedDate":"2024-08-09T19:05:00.000+02:00","shortMessage":"chore(docker): update image (and with it ruby) to `3.3.4-alpine3.20`","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(docker): update image (and with it ruby) to `3.3.4-alpine3.20`\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/870936d5fe150916674a9a63ce8cc4bda5c4d4fb\"\u003echore(docker): update image (and with it ruby) to \u003ccode\u003e3.3.4-alpine3.20\u003c/code\u003e\u003c/a\u003e","bodyMessageHtml":"","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}},{"oid":"2f6e322c94776ccd33180061468e6ceaf31a73b4","url":"/html2rss/html2rss-web/commit/2f6e322c94776ccd33180061468e6ceaf31a73b4","authoredDate":"2024-08-09T17:34:01.000+02:00","committedDate":"2024-08-09T19:05:00.000+02:00","shortMessage":"feat(docker): use multilayer build to cut image size in half","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"feat(docker): use multilayer build to cut image size in half\n\nSigned-off-by: Gil Desmarais \u0026lt;git@desmarais.de\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/2f6e322c94776ccd33180061468e6ceaf31a73b4\"\u003efeat(docker): use multilayer build to cut image size in half\u003c/a\u003e","bodyMessageHtml":"Signed-off-by: Gil Desmarais \u0026lt;git@desmarais.de\u0026gt;","authors":[{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}],"committerAttribution":false,"committer":{"login":"gildesmarais","displayName":"Gil Desmarais","avatarUrl":"https://avatars.githubusercontent.com/u/350021?v=4","path":"/gildesmarais","isGitHub":false}}]},{"title":"Aug 2, 2024","commits":[{"oid":"68dc0a48d6417ce034c5be3a69b52d75a8073ad1","url":"/html2rss/html2rss-web/commit/68dc0a48d6417ce034c5be3a69b52d75a8073ad1","authoredDate":"2024-08-02T22:34:34.000Z","committedDate":"2024-08-02T22:34:34.000Z","shortMessage":"chore(deps): bump the rubygems group with 2 updates (#661)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#661)\n\nBumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss` from `d0a51a0` to `97d602a`\n- [Release notes](https://github.com/html2rss/html2rss/releases)\n- [Commits](https://github.com/html2rss/html2rss/compare/d0a51a0ca60264b9179b6982ce93b5100a4c6b4e...97d602ad42f4a3c1b11d810fb8924c29d19aee55)\n\nUpdates `html2rss-configs` from `8b2deab` to `07bbadc`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/8b2deab891846a0ef1e008c6d49bc19c97006ed9...07bbadcc2be501488a3772352ab0f8c7b05235a3)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/68dc0a48d6417ce034c5be3a69b52d75a8073ad1\"\u003echore(deps): bump the rubygems group with 2 updates (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2445841262\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/661\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/661/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/661\"\u003e#661\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#661)\n\nBumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss` from `d0a51a0` to `97d602a`\n- [Release notes](https://github.com/html2rss/html2rss/releases)\n- [Commits](https://github.com/html2rss/html2rss/compare/d0a51a0ca60264b9179b6982ce93b5100a4c6b4e...97d602ad42f4a3c1b11d810fb8924c29d19aee55)\n\nUpdates `html2rss-configs` from `8b2deab` to `07bbadc`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/8b2deab891846a0ef1e008c6d49bc19c97006ed9...07bbadcc2be501488a3772352ab0f8c7b05235a3)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/68dc0a48d6417ce034c5be3a69b52d75a8073ad1\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 2 updates: [html2rss](\u003ca href=\"https://github.com/html2rss/html2rss\"\u003ehttps://github.com/html2rss/html2rss\u003c/a\u003e) and [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss` from `d0a51a0` to `97d602a`\n- [Release notes](\u003ca href=\"https://github.com/html2rss/html2rss/releases\"\u003ehttps://github.com/html2rss/html2rss/releases\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/d0a51a0ca60264b9179b6982ce93b5100a4c6b4e...97d602ad42f4a3c1b11d810fb8924c29d19aee55\"\u003ehtml2rss/html2rss@\u003ctt\u003ed0a51a0...97d602a\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `html2rss-configs` from `8b2deab` to `07bbadc`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/8b2deab891846a0ef1e008c6d49bc19c97006ed9...07bbadcc2be501488a3772352ab0f8c7b05235a3\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e8b2deab...07bbadc\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"727f7564cd86e9d5c60a3f5d04f496694cce3aae","url":"/html2rss/html2rss-web/commit/727f7564cd86e9d5c60a3f5d04f496694cce3aae","authoredDate":"2024-08-02T02:08:27.000Z","committedDate":"2024-08-02T02:08:27.000Z","shortMessage":"chore(deps): bump rexml from 3.3.2 to 3.3.3 (#660)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump rexml from 3.3.2 to 3.3.3 (#660)\n\nBumps [rexml](https://github.com/ruby/rexml) from 3.3.2 to 3.3.3.\n- [Release notes](https://github.com/ruby/rexml/releases)\n- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)\n- [Commits](https://github.com/ruby/rexml/compare/v3.3.2...v3.3.3)\n\n---\nupdated-dependencies:\n- dependency-name: rexml\n  dependency-type: indirect\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/727f7564cd86e9d5c60a3f5d04f496694cce3aae\"\u003echore(deps): bump rexml from 3.3.2 to 3.3.3 (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2443835056\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/660\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/660/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/660\"\u003e#660\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump rexml from 3.3.2 to 3.3.3 (#660)\n\nBumps [rexml](https://github.com/ruby/rexml) from 3.3.2 to 3.3.3.\n- [Release notes](https://github.com/ruby/rexml/releases)\n- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)\n- [Commits](https://github.com/ruby/rexml/compare/v3.3.2...v3.3.3)\n\n---\nupdated-dependencies:\n- dependency-name: rexml\n  dependency-type: indirect\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/727f7564cd86e9d5c60a3f5d04f496694cce3aae\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps [rexml](\u003ca href=\"https://github.com/ruby/rexml\"\u003ehttps://github.com/ruby/rexml\u003c/a\u003e) from 3.3.2 to 3.3.3.\n- [Release notes](\u003ca href=\"https://github.com/ruby/rexml/releases\"\u003ehttps://github.com/ruby/rexml/releases\u003c/a\u003e)\n- [Changelog](\u003ca href=\"https://github.com/ruby/rexml/blob/master/NEWS.md\"\u003ehttps://github.com/ruby/rexml/blob/master/NEWS.md\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/ruby/rexml/compare/v3.3.2...v3.3.3\"\u003eruby/rexml@\u003ctt\u003ev3.3.2...v3.3.3\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: rexml\n  dependency-type: indirect\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jul 30, 2024","commits":[{"oid":"4cad73b7d7ccaf826d1249f44586517131c97a64","url":"/html2rss/html2rss-web/commit/4cad73b7d7ccaf826d1249f44586517131c97a64","authoredDate":"2024-07-30T20:32:04.000Z","committedDate":"2024-07-30T20:32:04.000Z","shortMessage":"chore(deps): bump the rubygems group with 2 updates (#659)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#659)\n\nBumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss` from `2c458a7` to `d0a51a0`\n- [Release notes](https://github.com/html2rss/html2rss/releases)\n- [Commits](https://github.com/html2rss/html2rss/compare/2c458a7606c2519a5fc75b58b1acca0cb4f1ace3...d0a51a0ca60264b9179b6982ce93b5100a4c6b4e)\n\nUpdates `html2rss-configs` from `8759c60` to `8b2deab`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/8759c607cc4bbe469f4294a200ee424dfa82ac48...8b2deab891846a0ef1e008c6d49bc19c97006ed9)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/4cad73b7d7ccaf826d1249f44586517131c97a64\"\u003echore(deps): bump the rubygems group with 2 updates (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2438627568\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/659\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/659/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/659\"\u003e#659\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#659)\n\nBumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss` from `2c458a7` to `d0a51a0`\n- [Release notes](https://github.com/html2rss/html2rss/releases)\n- [Commits](https://github.com/html2rss/html2rss/compare/2c458a7606c2519a5fc75b58b1acca0cb4f1ace3...d0a51a0ca60264b9179b6982ce93b5100a4c6b4e)\n\nUpdates `html2rss-configs` from `8759c60` to `8b2deab`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/8759c607cc4bbe469f4294a200ee424dfa82ac48...8b2deab891846a0ef1e008c6d49bc19c97006ed9)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/4cad73b7d7ccaf826d1249f44586517131c97a64\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 2 updates: [html2rss](\u003ca href=\"https://github.com/html2rss/html2rss\"\u003ehttps://github.com/html2rss/html2rss\u003c/a\u003e) and [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss` from `2c458a7` to `d0a51a0`\n- [Release notes](\u003ca href=\"https://github.com/html2rss/html2rss/releases\"\u003ehttps://github.com/html2rss/html2rss/releases\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/2c458a7606c2519a5fc75b58b1acca0cb4f1ace3...d0a51a0ca60264b9179b6982ce93b5100a4c6b4e\"\u003ehtml2rss/html2rss@\u003ctt\u003e2c458a7...d0a51a0\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `html2rss-configs` from `8759c60` to `8b2deab`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/8759c607cc4bbe469f4294a200ee424dfa82ac48...8b2deab891846a0ef1e008c6d49bc19c97006ed9\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e8759c60...8b2deab\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jul 29, 2024","commits":[{"oid":"5bd9e435564d3765544c7000bd26944014031461","url":"/html2rss/html2rss-web/commit/5bd9e435564d3765544c7000bd26944014031461","authoredDate":"2024-07-29T22:34:55.000Z","committedDate":"2024-07-29T22:34:55.000Z","shortMessage":"chore(deps): bump the rubygems group with 2 updates (#658)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#658)\n\nBumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss` from `aa99bd6` to `2c458a7`\n- [Commits](https://github.com/html2rss/html2rss/compare/aa99bd68c7add7abd4f65d2e4b558ebe20227ee8...2c458a7606c2519a5fc75b58b1acca0cb4f1ace3)\n\nUpdates `html2rss-configs` from `f5da387` to `8759c60`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/f5da387390341a8bb5191e65740ad456c714b0b3...8759c607cc4bbe469f4294a200ee424dfa82ac48)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/5bd9e435564d3765544c7000bd26944014031461\"\u003echore(deps): bump the rubygems group with 2 updates (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2436506436\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/658\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/658/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/658\"\u003e#658\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#658)\n\nBumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss` from `aa99bd6` to `2c458a7`\n- [Commits](https://github.com/html2rss/html2rss/compare/aa99bd68c7add7abd4f65d2e4b558ebe20227ee8...2c458a7606c2519a5fc75b58b1acca0cb4f1ace3)\n\nUpdates `html2rss-configs` from `f5da387` to `8759c60`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/f5da387390341a8bb5191e65740ad456c714b0b3...8759c607cc4bbe469f4294a200ee424dfa82ac48)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/5bd9e435564d3765544c7000bd26944014031461\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 2 updates: [html2rss](\u003ca href=\"https://github.com/html2rss/html2rss\"\u003ehttps://github.com/html2rss/html2rss\u003c/a\u003e) and [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss` from `aa99bd6` to `2c458a7`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/aa99bd68c7add7abd4f65d2e4b558ebe20227ee8...2c458a7606c2519a5fc75b58b1acca0cb4f1ace3\"\u003ehtml2rss/html2rss@\u003ctt\u003eaa99bd6...2c458a7\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `html2rss-configs` from `f5da387` to `8759c60`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/f5da387390341a8bb5191e65740ad456c714b0b3...8759c607cc4bbe469f4294a200ee424dfa82ac48\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003ef5da387...8759c60\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jul 23, 2024","commits":[{"oid":"25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab","url":"/html2rss/html2rss-web/commit/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab","authoredDate":"2024-07-23T22:21:04.000Z","committedDate":"2024-07-23T22:21:04.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#657)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#657)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `2dc20ca` to `f5da387`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/2dc20caa69be420f6bb9f100271f10583b4f3c72...f5da387390341a8bb5191e65740ad456c714b0b3)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab\"\u003echore(deps): bump html2rss-configs in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2426217189\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/657\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/657/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/657\"\u003e#657\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#657)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `2dc20ca` to `f5da387`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/2dc20caa69be420f6bb9f100271f10583b4f3c72...f5da387390341a8bb5191e65740ad456c714b0b3)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss-configs](\u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003ehttps://github.com/html2rss/html2rss-configs\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `2dc20ca` to `f5da387`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/2dc20caa69be420f6bb9f100271f10583b4f3c72...f5da387390341a8bb5191e65740ad456c714b0b3\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e2dc20ca...f5da387\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jul 19, 2024","commits":[{"oid":"b4627fe9dd55c3d5099b9a4e682661098bf4dfb4","url":"/html2rss/html2rss-web/commit/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4","authoredDate":"2024-07-19T22:10:59.000Z","committedDate":"2024-07-19T22:10:59.000Z","shortMessage":"chore(deps): bump html2rss in the rubygems group (#656)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss in the rubygems group (#656)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).\n\n\nUpdates `html2rss` from `a21f089` to `aa99bd6`\n- [Commits](https://github.com/html2rss/html2rss/compare/a21f0898c4a9b8359293ffef0ed8cb4beebeafa8...aa99bd68c7add7abd4f65d2e4b558ebe20227ee8)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4\"\u003echore(deps): bump html2rss in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2420048120\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/656\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/656/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/656\"\u003e#656\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss in the rubygems group (#656)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).\n\n\nUpdates `html2rss` from `a21f089` to `aa99bd6`\n- [Commits](https://github.com/html2rss/html2rss/compare/a21f0898c4a9b8359293ffef0ed8cb4beebeafa8...aa99bd68c7add7abd4f65d2e4b558ebe20227ee8)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss](\u003ca href=\"https://github.com/html2rss/html2rss\"\u003ehttps://github.com/html2rss/html2rss\u003c/a\u003e).\n\n\nUpdates `html2rss` from `a21f089` to `aa99bd6`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/a21f0898c4a9b8359293ffef0ed8cb4beebeafa8...aa99bd68c7add7abd4f65d2e4b558ebe20227ee8\"\u003ehtml2rss/html2rss@\u003ctt\u003ea21f089...aa99bd6\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}},{"oid":"65df84038d36c01ccee385e73aa9659b23cbf756","url":"/html2rss/html2rss-web/commit/65df84038d36c01ccee385e73aa9659b23cbf756","authoredDate":"2024-07-19T16:29:19.000Z","committedDate":"2024-07-19T16:29:19.000Z","shortMessage":"chore(deps): bump html2rss in the rubygems group (#655)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss in the rubygems group (#655)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).\n\n\nUpdates `html2rss` from `d8f0e66` to `a21f089`\n- [Commits](https://github.com/html2rss/html2rss/compare/d8f0e66108d6c63718628ad35004744c512c9b04...a21f0898c4a9b8359293ffef0ed8cb4beebeafa8)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/65df84038d36c01ccee385e73aa9659b23cbf756\"\u003echore(deps): bump html2rss in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2419312136\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/655\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/655/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/655\"\u003e#655\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss in the rubygems group (#655)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).\n\n\nUpdates `html2rss` from `d8f0e66` to `a21f089`\n- [Commits](https://github.com/html2rss/html2rss/compare/d8f0e66108d6c63718628ad35004744c512c9b04...a21f0898c4a9b8359293ffef0ed8cb4beebeafa8)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/65df84038d36c01ccee385e73aa9659b23cbf756\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [html2rss](\u003ca href=\"https://github.com/html2rss/html2rss\"\u003ehttps://github.com/html2rss/html2rss\u003c/a\u003e).\n\n\nUpdates `html2rss` from `d8f0e66` to `a21f089`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss/compare/d8f0e66108d6c63718628ad35004744c512c9b04...a21f0898c4a9b8359293ffef0ed8cb4beebeafa8\"\u003ehtml2rss/html2rss@\u003ctt\u003ed8f0e66...a21f089\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss\n  dependency-type: direct:production\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jul 12, 2024","commits":[{"oid":"006ed07532c7ad88c7ee070b8cc1a7f458cc0990","url":"/html2rss/html2rss-web/commit/006ed07532c7ad88c7ee070b8cc1a7f458cc0990","authoredDate":"2024-07-12T22:08:00.000Z","committedDate":"2024-07-12T22:08:00.000Z","shortMessage":"chore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (#654)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (#654)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.81.0 to 3.82.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.81.0...3.82.0)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/006ed07532c7ad88c7ee070b8cc1a7f458cc0990\"\u003echore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2406407623\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/654\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/654/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/654\"\u003e#654\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (#654)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.81.0 to 3.82.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.81.0...3.82.0)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/006ed07532c7ad88c7ee070b8cc1a7f458cc0990\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [roda](\u003ca href=\"https://github.com/jeremyevans/roda\"\u003ehttps://github.com/jeremyevans/roda\u003c/a\u003e).\n\n\nUpdates `roda` from 3.81.0 to 3.82.0\n- [Changelog](\u003ca href=\"https://github.com/jeremyevans/roda/blob/master/CHANGELOG\"\u003ehttps://github.com/jeremyevans/roda/blob/master/CHANGELOG\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/jeremyevans/roda/compare/3.81.0...3.82.0\"\u003ejeremyevans/roda@\u003ctt\u003e3.81.0...3.82.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: roda\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jun 27, 2024","commits":[{"oid":"d11fda09d15f52eecb4108fe55e52202072617eb","url":"/html2rss/html2rss-web/commit/d11fda09d15f52eecb4108fe55e52202072617eb","authoredDate":"2024-06-27T22:10:38.000Z","committedDate":"2024-06-27T22:10:38.000Z","shortMessage":"chore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (#653)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (#653)\n\nBumps the rubygems group with 1 update: [tilt](https://github.com/jeremyevans/tilt).\n\n\nUpdates `tilt` from 2.3.0 to 2.4.0\n- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)\n- [Commits](https://github.com/jeremyevans/tilt/compare/v2.3.0...v2.4.0)\n\n---\nupdated-dependencies:\n- dependency-name: tilt\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/d11fda09d15f52eecb4108fe55e52202072617eb\"\u003echore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2379171054\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/653\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/653/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/653\"\u003e#653\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (#653)\n\nBumps the rubygems group with 1 update: [tilt](https://github.com/jeremyevans/tilt).\n\n\nUpdates `tilt` from 2.3.0 to 2.4.0\n- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)\n- [Commits](https://github.com/jeremyevans/tilt/compare/v2.3.0...v2.4.0)\n\n---\nupdated-dependencies:\n- dependency-name: tilt\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/d11fda09d15f52eecb4108fe55e52202072617eb\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [tilt](\u003ca href=\"https://github.com/jeremyevans/tilt\"\u003ehttps://github.com/jeremyevans/tilt\u003c/a\u003e).\n\n\nUpdates `tilt` from 2.3.0 to 2.4.0\n- [Changelog](\u003ca href=\"https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md\"\u003ehttps://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/jeremyevans/tilt/compare/v2.3.0...v2.4.0\"\u003ejeremyevans/tilt@\u003ctt\u003ev2.3.0...v2.4.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: tilt\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]},{"title":"Jun 13, 2024","commits":[{"oid":"36a9a59468a8f3db5ddee6c2c585609761754119","url":"/html2rss/html2rss-web/commit/36a9a59468a8f3db5ddee6c2c585609761754119","authoredDate":"2024-06-13T22:08:39.000Z","committedDate":"2024-06-13T22:08:39.000Z","shortMessage":"chore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (#652)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (#652)\n\nBumps the rubygems group with 1 update: [erubi](https://github.com/jeremyevans/erubi).\n\n\nUpdates `erubi` from 1.12.0 to 1.13.0\n- [Changelog](https://github.com/jeremyevans/erubi/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/erubi/compare/1.12.0...1.13.0)\n\n---\nupdated-dependencies:\n- dependency-name: erubi\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/36a9a59468a8f3db5ddee6c2c585609761754119\"\u003echore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2352141017\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/652\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/652/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/652\"\u003e#652\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (#652)\n\nBumps the rubygems group with 1 update: [erubi](https://github.com/jeremyevans/erubi).\n\n\nUpdates `erubi` from 1.12.0 to 1.13.0\n- [Changelog](https://github.com/jeremyevans/erubi/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/erubi/compare/1.12.0...1.13.0)\n\n---\nupdated-dependencies:\n- dependency-name: erubi\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/36a9a59468a8f3db5ddee6c2c585609761754119\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [erubi](\u003ca href=\"https://github.com/jeremyevans/erubi\"\u003ehttps://github.com/jeremyevans/erubi\u003c/a\u003e).\n\n\nUpdates `erubi` from 1.12.0 to 1.13.0\n- [Changelog](\u003ca href=\"https://github.com/jeremyevans/erubi/blob/master/CHANGELOG\"\u003ehttps://github.com/jeremyevans/erubi/blob/master/CHANGELOG\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/jeremyevans/erubi/compare/1.12.0...1.13.0\"\u003ejeremyevans/erubi@\u003ctt\u003e1.12.0...1.13.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: erubi\n  dependency-type: direct:production\n  update-type: version-update:semver-minor\n  dependency-group: rubygems\n...\n\nSigned-off-by: dependabot[bot] \u0026lt;support@github.com\u0026gt;\nCo-authored-by: dependabot[bot] \u0026lt;49699333+dependabot[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"dependabot[bot]","displayName":"dependabot[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/29110?v=4","path":"/apps/dependabot","isGitHub":false}],"committerAttribution":false,"committer":{"login":"web-flow","displayName":"GitHub","avatarUrl":"https://avatars.githubusercontent.com/u/19864447?v=4","path":"/web-flow","isGitHub":true}}]}],"currentCommit":{"oid":"8eeb9e69a1c57f3c61ca00469083604e25066859"},"filters":{"since":null,"until":null,"author":null,"newPath":null,"originalBranch":null,"currentBlobPath":null,"pagination":{"startCursor":"8eeb9e69a1c57f3c61ca00469083604e25066859 0","endCursor":"8eeb9e69a1c57f3c61ca00469083604e25066859 34","hasNextPage":true,"hasPreviousPage":false}},"metadata":{"browsingRenameHistory":null,"showProfileHelp":false,"deferredDataUrl":"/html2rss/html2rss-web/commits/deferred_commit_data/master?original_branch=master","deferredContributorUrl":"/html2rss/html2rss-web/commits/deferred_commit_contributors","softNavToCommit":false},"repo":{"id":135929870,"defaultBranch":"master","name":"html2rss-web","ownerLogin":"html2rss","currentUserCanPush":false,"isFork":false,"isEmpty":false,"createdAt":"2018-06-03T18:28:51.000Z","ownerAvatar":"https://avatars.githubusercontent.com/u/67504668?v=4","public":true,"private":false,"isOrgOwned":true},"refInfo":{"name":"master","listCacheKey":"v0:1728684225.0","refType":"branch","currentOid":"8eeb9e69a1c57f3c61ca00469083604e25066859"},"timedOutMessage":""},"title":"Commits · html2rss/html2rss-web","appPayload":{"helpUrl":"https://docs.github.com","enabled_features":{"commits_ux_refresh_compare":false}}}</script>
  <div data-target="react-app.reactRoot"><style data-styled="true" data-styled-version="5.3.11">.kkWQEA{padding:16px;}/*!sc*/
@media screen and (min-width:544px){}/*!sc*/
@media screen and (min-width:768px){}/*!sc*/
@media screen and (min-width:1012px){.kkWQEA{padding:24px;}}/*!sc*/
.bSJDXx{max-width:1280px;margin-left:auto;margin-right:auto;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}/*!sc*/
.jPRcNF{width:100%;margin-bottom:16px;}/*!sc*/
.hOfjFo{padding:0;}/*!sc*/
.gKBBxN{margin-left:-16px;margin-right:-16px;display:block;height:1px;background-color:var(--borderColor-default,var(--color-border-default,#d0d7de));margin-top:0;}/*!sc*/
@media screen and (min-width:544px){}/*!sc*/
@media screen and (min-width:768px){.gKBBxN{margin-left:0 !important;margin-right:0 !important;}}/*!sc*/
@media screen and (min-width:1012px){.gKBBxN{margin-left:-24px;margin-right:-24px;}}/*!sc*/
.kowOcT{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex:1 1 100%;-ms-flex:1 1 100%;flex:1 1 100%;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;max-width:100%;}/*!sc*/
.dQkwwl{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-order:2;-ms-flex-order:2;order:2;-webkit-flex-basis:0;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-flex-shrink:1;-ms-flex-negative:1;flex-shrink:1;min-width:1px;}/*!sc*/
.FxAyp{width:100%;max-width:100%;margin-left:auto;margin-right:auto;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;padding:0;}/*!sc*/
.gwHaUx{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;gap:8px;margin-bottom:16px;}/*!sc*/
.gUkoLg{-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
.bZBlpz{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;}/*!sc*/
.lhTYNA{margin-right:4px;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.dbrgmi{font-size:14px;min-width:0;max-width:125px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}/*!sc*/
.hzSPyu{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;pointer-events:none;}/*!sc*/
.cSURfY{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
.hjDqIa{margin-right:8px;}/*!sc*/
.dGVxWp{max-width:125px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}/*!sc*/
.izArLR{position:relative;z-index:1;}/*!sc*/
.bbNsBg{margin-right:8px;margin-left:-15px;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));background-color:var(--timelineBadge-bgColor,var(--color-timeline-badge-bg,#eaeef2));display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;overflow:hidden;width:32px;height:32px;-webkit-flex-shrink:0;-ms-flex-negative:0;flex-shrink:0;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:50%;border-width:2px;border-style:solid;border-color:var(--bgColor-default,var(--color-canvas-default,#ffffff));background-color:var(--bgColor-default,var(--color-canvas-default,#ffffff));}/*!sc*/
.cdHayA:first-child{border-top-left-radius:6px;border-top-right-radius:6px;}/*!sc*/
.cdHayA:last-child{border-bottom-left-radius:6px;border-bottom-right-radius:6px;}/*!sc*/
.jJRiHe{display:inline;}/*!sc*/
.dpBUfI{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
@media screen and (min-width:544px){.dpBUfI{-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}}/*!sc*/
@media screen and (min-width:768px){.dpBUfI{-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}}/*!sc*/
@media screen and (min-width:1012px){.dpBUfI{-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;}}/*!sc*/
.hKWjvQ{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
.fIQuDd{width:20px;}/*!sc*/
.EDqVA{min-width:62px;}/*!sc*/
.dNbsEP{width:62px;}/*!sc*/
.iCHGgS{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding-left:4px;}/*!sc*/
data-styled.g1[id="Box-sc-g0xbh4-0"]{content:"kkWQEA,bSJDXx,jPRcNF,hOfjFo,gKBBxN,kowOcT,dQkwwl,FxAyp,gwHaUx,gUkoLg,bZBlpz,lhTYNA,dbrgmi,hzSPyu,cSURfY,hjDqIa,dGVxWp,izArLR,bbNsBg,cdHayA,jJRiHe,dpBUfI,hKWjvQ,fIQuDd,EDqVA,dNbsEP,iCHGgS,"}/*!sc*/
.eMMFM{min-width:0;}/*!sc*/
.eMMFM:where([data-size='small']){font-size:var(--text-body-size-small,0.75rem);line-height:var(--text-body-lineHeight-small,1.6666);}/*!sc*/
.eMMFM:where([data-size='medium']){font-size:var(--text-body-size-medium,0.875rem);line-height:var(--text-body-lineHeight-medium,1.4285);}/*!sc*/
.eMMFM:where([data-size='large']){font-size:var(--text-body-size-large,1rem);line-height:var(--text-body-lineHeight-large,1.5);}/*!sc*/
.eMMFM:where([data-weight='light']){font-weight:var(--base-text-weight-light,300);}/*!sc*/
.eMMFM:where([data-weight='normal']){font-weight:var(--base-text-weight-normal,400);}/*!sc*/
.eMMFM:where([data-weight='medium']){font-weight:var(--base-text-weight-medium,500);}/*!sc*/
.eMMFM:where([data-weight='semibold']){font-weight:var(--base-text-weight-semibold,600);}/*!sc*/
.ljLSiW{display:inline;}/*!sc*/
.ljLSiW:where([data-size='small']){font-size:var(--text-body-size-small,0.75rem);line-height:var(--text-body-lineHeight-small,1.6666);}/*!sc*/
.ljLSiW:where([data-size='medium']){font-size:var(--text-body-size-medium,0.875rem);line-height:var(--text-body-lineHeight-medium,1.4285);}/*!sc*/
.ljLSiW:where([data-size='large']){font-size:var(--text-body-size-large,1rem);line-height:var(--text-body-lineHeight-large,1.5);}/*!sc*/
.ljLSiW:where([data-weight='light']){font-weight:var(--base-text-weight-light,300);}/*!sc*/
.ljLSiW:where([data-weight='normal']){font-weight:var(--base-text-weight-normal,400);}/*!sc*/
.ljLSiW:where([data-weight='medium']){font-weight:var(--base-text-weight-medium,500);}/*!sc*/
.ljLSiW:where([data-weight='semibold']){font-weight:var(--base-text-weight-semibold,600);}/*!sc*/
.hWqAbU:where([data-size='small']){font-size:var(--text-body-size-small,0.75rem);line-height:var(--text-body-lineHeight-small,1.6666);}/*!sc*/
.hWqAbU:where([data-size='medium']){font-size:var(--text-body-size-medium,0.875rem);line-height:var(--text-body-lineHeight-medium,1.4285);}/*!sc*/
.hWqAbU:where([data-size='large']){font-size:var(--text-body-size-large,1rem);line-height:var(--text-body-lineHeight-large,1.5);}/*!sc*/
.hWqAbU:where([data-weight='light']){font-weight:var(--base-text-weight-light,300);}/*!sc*/
.hWqAbU:where([data-weight='normal']){font-weight:var(--base-text-weight-normal,400);}/*!sc*/
.hWqAbU:where([data-weight='medium']){font-weight:var(--base-text-weight-medium,500);}/*!sc*/
.hWqAbU:where([data-weight='semibold']){font-weight:var(--base-text-weight-semibold,600);}/*!sc*/
data-styled.g4[id="Text__StyledText-sc-17v1xeu-0"]{content:"eMMFM,ljLSiW,hWqAbU,"}/*!sc*/
.knLhXt{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.WGJwj{margin-top:2px;margin-bottom:2px;}/*!sc*/
data-styled.g6[id="Octicon-sc-9kayk9-0"]{content:"knLhXt,WGJwj,"}/*!sc*/
.iQGjqs{border-radius:6px;border:1px solid;border-color:var(--button-default-borderColor-rest,var(--button-default-borderColor-rest,var(--color-btn-border,rgba(31,35,40,0.15))));font-family:inherit;font-weight:500;font-size:14px;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-text-decoration:none;text-decoration:none;text-align:center;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;height:32px;padding:0 12px;gap:8px;min-width:-webkit-max-content;min-width:-moz-max-content;min-width:max-content;-webkit-transition:80ms cubic-bezier(0.65,0,0.35,1);transition:80ms cubic-bezier(0.65,0,0.35,1);-webkit-transition-property:color,fill,background-color,border-color;transition-property:color,fill,background-color,border-color;color:var(--button-default-fgColor-rest,var(--color-btn-text,#24292f));background-color:var(--button-default-bgColor-rest,var(--color-btn-bg,#f6f8fa));box-shadow:var(--button-default-shadow-resting,var(--color-btn-shadow,0 1px 0 rgba(31,35,40,0.04))),var(--button-default-shadow-inset,var(--color-btn-inset-shadow,inset 0 1px 0 rgba(255,255,255,0.25)));}/*!sc*/
.iQGjqs:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.iQGjqs:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.iQGjqs:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.iQGjqs[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.iQGjqs[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.iQGjqs:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.iQGjqs:active{-webkit-transition:none;transition:none;}/*!sc*/
.iQGjqs[data-inactive]{cursor:auto;}/*!sc*/
.iQGjqs:disabled{cursor:not-allowed;box-shadow:none;color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));border-color:var(--button-default-borderColor-disabled,var(--button-default-borderColor-rest,var(--color-btn-border,rgba(31,35,40,0.15))));background-color:var(--button-default-bgColor-disabled,var(--control-bgColor-disabled,var(--color-input-disabled-bg,rgba(175,184,193,0.2))));}/*!sc*/
.iQGjqs:disabled [data-component=ButtonCounter]{color:inherit;}/*!sc*/
@media (forced-colors:active){.iQGjqs:focus{outline:solid 1px transparent;}}/*!sc*/
.iQGjqs [data-component=ButtonCounter]{font-size:12px;background-color:var(--buttonCounter-default-bgColor-rest,var(--color-btn-counter-bg,rgba(31,35,40,0.08)));}/*!sc*/
.iQGjqs[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.iQGjqs[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.iQGjqs[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.iQGjqs[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.iQGjqs[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.iQGjqs[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.iQGjqs[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.iQGjqs[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.iQGjqs[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.iQGjqs[data-block="block"]{width:100%;}/*!sc*/
.iQGjqs[data-label-wrap="true"]{min-width:-webkit-fit-content;min-width:-moz-fit-content;min-width:fit-content;height:unset;min-height:var(--control-medium-size,2rem);}/*!sc*/
.iQGjqs[data-label-wrap="true"] [data-component="buttonContent"]{-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;-webkit-align-self:stretch;-ms-flex-item-align:stretch;align-self:stretch;padding-block:calc(var(--control-medium-paddingBlock,0.375rem) - 2px);}/*!sc*/
.iQGjqs[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.iQGjqs[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.iQGjqs[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.iQGjqs[data-label-wrap="true"][data-size="large"]{height:unset;min-height:var(--control-large-size,2.5rem);padding-inline:var(--control-large-paddingInline-spacious,1rem);}/*!sc*/
.iQGjqs[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.iQGjqs[data-inactive]:not([disabled]){background-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));border-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));color:var(--button-inactive-fgColor,var(--button-inactive-fgColor-rest,var(--color-btn-inactive-text,#57606a)));}/*!sc*/
.iQGjqs[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.iQGjqs [data-component="leadingVisual"]{grid-area:leadingVisual;}/*!sc*/
.iQGjqs [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.iQGjqs [data-component="trailingVisual"]{grid-area:trailingVisual;}/*!sc*/
.iQGjqs [data-component="trailingAction"]{margin-right:-4px;}/*!sc*/
.iQGjqs [data-component="buttonContent"]{-webkit-flex:1 0 auto;-ms-flex:1 0 auto;flex:1 0 auto;display:grid;grid-template-areas:"leadingVisual text trailingVisual";grid-template-columns:min-content minmax(0,auto) min-content;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-align-content:center;-ms-flex-line-pack:center;align-content:center;}/*!sc*/
.iQGjqs [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.iQGjqs [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.iQGjqs [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.iQGjqs:hover:not([disabled]):not([data-inactive]){background-color:var(--button-default-bgColor-hover,var(--color-btn-hover-bg,#f3f4f6));border-color:var(--button-default-borderColor-hover,var(--button-default-borderColor-hover,var(--color-btn-hover-border,rgba(31,35,40,0.15))));}/*!sc*/
.iQGjqs:active:not([disabled]):not([data-inactive]){background-color:var(--button-default-bgColor-active,var(--color-btn-active-bg,hsla(220,14%,93%,1)));border-color:var(--button-default-borderColor-active,var(--button-default-borderColor-active,var(--color-btn-active-border,rgba(31,35,40,0.15))));}/*!sc*/
.iQGjqs[aria-expanded=true]{background-color:var(--button-default-bgColor-active,var(--color-btn-active-bg,hsla(220,14%,93%,1)));border-color:var(--button-default-borderColor-active,var(--button-default-borderColor-active,var(--color-btn-active-border,rgba(31,35,40,0.15))));}/*!sc*/
.iQGjqs [data-component="leadingVisual"],.iQGjqs [data-component="trailingVisual"],.iQGjqs [data-component="trailingAction"]{color:var(--button-color,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.iQGjqs[data-component="IconButton"][data-no-visuals]:not(:disabled){color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.iQGjqs[data-size="medium"]{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
.iQGjqs[data-size="medium"] svg{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.iQGjqs[data-size="medium"] > span{width:inherit;}/*!sc*/
.gGdPyq{border-radius:6px;border:1px solid;border-color:var(--button-default-borderColor-rest,var(--button-default-borderColor-rest,var(--color-btn-border,rgba(31,35,40,0.15))));font-family:inherit;font-weight:500;font-size:14px;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-text-decoration:none;text-decoration:none;text-align:center;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;height:32px;padding:0 12px;gap:8px;min-width:-webkit-max-content;min-width:-moz-max-content;min-width:max-content;-webkit-transition:80ms cubic-bezier(0.65,0,0.35,1);transition:80ms cubic-bezier(0.65,0,0.35,1);-webkit-transition-property:color,fill,background-color,border-color;transition-property:color,fill,background-color,border-color;color:var(--button-default-fgColor-rest,var(--color-btn-text,#24292f));background-color:var(--button-default-bgColor-rest,var(--color-btn-bg,#f6f8fa));box-shadow:var(--button-default-shadow-resting,var(--color-btn-shadow,0 1px 0 rgba(31,35,40,0.04))),var(--button-default-shadow-inset,var(--color-btn-inset-shadow,inset 0 1px 0 rgba(255,255,255,0.25)));}/*!sc*/
.gGdPyq:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gGdPyq:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.gGdPyq:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gGdPyq[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.gGdPyq[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.gGdPyq:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.gGdPyq:active{-webkit-transition:none;transition:none;}/*!sc*/
.gGdPyq[data-inactive]{cursor:auto;}/*!sc*/
.gGdPyq:disabled{cursor:not-allowed;box-shadow:none;color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));border-color:var(--button-default-borderColor-disabled,var(--button-default-borderColor-rest,var(--color-btn-border,rgba(31,35,40,0.15))));background-color:var(--button-default-bgColor-disabled,var(--control-bgColor-disabled,var(--color-input-disabled-bg,rgba(175,184,193,0.2))));}/*!sc*/
.gGdPyq:disabled [data-component=ButtonCounter]{color:inherit;}/*!sc*/
@media (forced-colors:active){.gGdPyq:focus{outline:solid 1px transparent;}}/*!sc*/
.gGdPyq [data-component=ButtonCounter]{font-size:12px;background-color:var(--buttonCounter-default-bgColor-rest,var(--color-btn-counter-bg,rgba(31,35,40,0.08)));}/*!sc*/
.gGdPyq[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.gGdPyq[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.gGdPyq[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.gGdPyq[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gGdPyq[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.gGdPyq[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.gGdPyq[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.gGdPyq[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gGdPyq[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.gGdPyq[data-block="block"]{width:100%;}/*!sc*/
.gGdPyq[data-label-wrap="true"]{min-width:-webkit-fit-content;min-width:-moz-fit-content;min-width:fit-content;height:unset;min-height:var(--control-medium-size,2rem);}/*!sc*/
.gGdPyq[data-label-wrap="true"] [data-component="buttonContent"]{-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;-webkit-align-self:stretch;-ms-flex-item-align:stretch;align-self:stretch;padding-block:calc(var(--control-medium-paddingBlock,0.375rem) - 2px);}/*!sc*/
.gGdPyq[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.gGdPyq[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.gGdPyq[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.gGdPyq[data-label-wrap="true"][data-size="large"]{height:unset;min-height:var(--control-large-size,2.5rem);padding-inline:var(--control-large-paddingInline-spacious,1rem);}/*!sc*/
.gGdPyq[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.gGdPyq[data-inactive]:not([disabled]){background-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));border-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));color:var(--button-inactive-fgColor,var(--button-inactive-fgColor-rest,var(--color-btn-inactive-text,#57606a)));}/*!sc*/
.gGdPyq[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.gGdPyq [data-component="leadingVisual"]{grid-area:leadingVisual;}/*!sc*/
.gGdPyq [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.gGdPyq [data-component="trailingVisual"]{grid-area:trailingVisual;}/*!sc*/
.gGdPyq [data-component="trailingAction"]{margin-right:-4px;}/*!sc*/
.gGdPyq [data-component="buttonContent"]{-webkit-flex:1 0 auto;-ms-flex:1 0 auto;flex:1 0 auto;display:grid;grid-template-areas:"leadingVisual text trailingVisual";grid-template-columns:min-content minmax(0,auto) min-content;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-align-content:center;-ms-flex-line-pack:center;align-content:center;}/*!sc*/
.gGdPyq [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gGdPyq [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gGdPyq [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.gGdPyq:hover:not([disabled]):not([data-inactive]){background-color:var(--button-default-bgColor-hover,var(--color-btn-hover-bg,#f3f4f6));border-color:var(--button-default-borderColor-hover,var(--button-default-borderColor-hover,var(--color-btn-hover-border,rgba(31,35,40,0.15))));}/*!sc*/
.gGdPyq:active:not([disabled]):not([data-inactive]){background-color:var(--button-default-bgColor-active,var(--color-btn-active-bg,hsla(220,14%,93%,1)));border-color:var(--button-default-borderColor-active,var(--button-default-borderColor-active,var(--color-btn-active-border,rgba(31,35,40,0.15))));}/*!sc*/
.gGdPyq[aria-expanded=true]{background-color:var(--button-default-bgColor-active,var(--color-btn-active-bg,hsla(220,14%,93%,1)));border-color:var(--button-default-borderColor-active,var(--button-default-borderColor-active,var(--color-btn-active-border,rgba(31,35,40,0.15))));}/*!sc*/
.gGdPyq [data-component="leadingVisual"],.gGdPyq [data-component="trailingVisual"],.gGdPyq [data-component="trailingAction"]{color:var(--button-color,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gGdPyq[data-component="IconButton"][data-no-visuals]:not(:disabled){color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.dXUvFs{border-radius:6px;border:1px solid;border-color:transparent;font-family:inherit;font-weight:500;font-size:14px;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-text-decoration:none;text-decoration:none;text-align:center;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;height:32px;padding:0 12px;gap:8px;min-width:-webkit-max-content;min-width:-moz-max-content;min-width:max-content;-webkit-transition:80ms cubic-bezier(0.65,0,0.35,1);transition:80ms cubic-bezier(0.65,0,0.35,1);-webkit-transition-property:color,fill,background-color,border-color;transition-property:color,fill,background-color,border-color;color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));background-color:transparent;box-shadow:none;}/*!sc*/
.dXUvFs:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.dXUvFs:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.dXUvFs:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.dXUvFs[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.dXUvFs[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.dXUvFs:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.dXUvFs:active{-webkit-transition:none;transition:none;}/*!sc*/
.dXUvFs[data-inactive]{cursor:auto;}/*!sc*/
.dXUvFs:disabled{cursor:not-allowed;box-shadow:none;color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));background-color:var(--button-invisible-bgColor-disabled,transparent);}/*!sc*/
.dXUvFs:disabled [data-component=ButtonCounter],.dXUvFs:disabled [data-component="leadingVisual"],.dXUvFs:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.dXUvFs:focus{outline:solid 1px transparent;}}/*!sc*/
.dXUvFs [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.dXUvFs[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.dXUvFs[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.dXUvFs[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.dXUvFs[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.dXUvFs[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.dXUvFs[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.dXUvFs[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.dXUvFs[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.dXUvFs[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.dXUvFs[data-block="block"]{width:100%;}/*!sc*/
.dXUvFs[data-label-wrap="true"]{min-width:-webkit-fit-content;min-width:-moz-fit-content;min-width:fit-content;height:unset;min-height:var(--control-medium-size,2rem);}/*!sc*/
.dXUvFs[data-label-wrap="true"] [data-component="buttonContent"]{-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;-webkit-align-self:stretch;-ms-flex-item-align:stretch;align-self:stretch;padding-block:calc(var(--control-medium-paddingBlock,0.375rem) - 2px);}/*!sc*/
.dXUvFs[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.dXUvFs[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.dXUvFs[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.dXUvFs[data-label-wrap="true"][data-size="large"]{height:unset;min-height:var(--control-large-size,2.5rem);padding-inline:var(--control-large-paddingInline-spacious,1rem);}/*!sc*/
.dXUvFs[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.dXUvFs[data-inactive]:not([disabled]){background-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));border-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));color:var(--button-inactive-fgColor,var(--button-inactive-fgColor-rest,var(--color-btn-inactive-text,#57606a)));}/*!sc*/
.dXUvFs[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.dXUvFs [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dXUvFs [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.dXUvFs [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dXUvFs [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dXUvFs [data-component="buttonContent"]{-webkit-flex:1 0 auto;-ms-flex:1 0 auto;flex:1 0 auto;display:grid;grid-template-areas:"leadingVisual text trailingVisual";grid-template-columns:min-content minmax(0,auto) min-content;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-align-content:center;-ms-flex-line-pack:center;align-content:center;}/*!sc*/
.dXUvFs [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.dXUvFs [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.dXUvFs [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.dXUvFs:hover:not([disabled]){background-color:var(--control-transparent-bgColor-hover,var(--color-action-list-item-default-hover-bg,rgba(208,215,222,0.32)));}/*!sc*/
.dXUvFs:active:not([disabled]){background-color:var(--control-transparent-bgColor-active,var(--color-action-list-item-default-active-bg,rgba(208,215,222,0.48)));}/*!sc*/
.dXUvFs[aria-expanded=true]{background-color:var(--control-transparent-bgColor-selected,var(--color-action-list-item-default-selected-bg,rgba(208,215,222,0.24)));}/*!sc*/
.dXUvFs[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dXUvFs[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.dXUvFs:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.dXUvFs:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.dXUvFs:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.dXUvFs[data-size="medium"][data-no-visuals]{background-color:transparent;border:none;cursor:default;color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));font-weight:400;}/*!sc*/
.dPmZyJ{border-radius:6px;border:1px solid;border-color:transparent;font-family:inherit;font-weight:500;font-size:14px;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-text-decoration:none;text-decoration:none;text-align:center;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;height:32px;padding:0 12px;gap:8px;min-width:-webkit-max-content;min-width:-moz-max-content;min-width:max-content;-webkit-transition:80ms cubic-bezier(0.65,0,0.35,1);transition:80ms cubic-bezier(0.65,0,0.35,1);-webkit-transition-property:color,fill,background-color,border-color;transition-property:color,fill,background-color,border-color;color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));background-color:transparent;box-shadow:none;}/*!sc*/
.dPmZyJ:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.dPmZyJ:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.dPmZyJ:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.dPmZyJ[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.dPmZyJ[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.dPmZyJ:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.dPmZyJ:active{-webkit-transition:none;transition:none;}/*!sc*/
.dPmZyJ[data-inactive]{cursor:auto;}/*!sc*/
.dPmZyJ:disabled{cursor:not-allowed;box-shadow:none;color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));background-color:var(--button-invisible-bgColor-disabled,transparent);}/*!sc*/
.dPmZyJ:disabled [data-component=ButtonCounter],.dPmZyJ:disabled [data-component="leadingVisual"],.dPmZyJ:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.dPmZyJ:focus{outline:solid 1px transparent;}}/*!sc*/
.dPmZyJ [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.dPmZyJ[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.dPmZyJ[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.dPmZyJ[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.dPmZyJ[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.dPmZyJ[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.dPmZyJ[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.dPmZyJ[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.dPmZyJ[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.dPmZyJ[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.dPmZyJ[data-block="block"]{width:100%;}/*!sc*/
.dPmZyJ[data-label-wrap="true"]{min-width:-webkit-fit-content;min-width:-moz-fit-content;min-width:fit-content;height:unset;min-height:var(--control-medium-size,2rem);}/*!sc*/
.dPmZyJ[data-label-wrap="true"] [data-component="buttonContent"]{-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;-webkit-align-self:stretch;-ms-flex-item-align:stretch;align-self:stretch;padding-block:calc(var(--control-medium-paddingBlock,0.375rem) - 2px);}/*!sc*/
.dPmZyJ[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.dPmZyJ[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.dPmZyJ[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.dPmZyJ[data-label-wrap="true"][data-size="large"]{height:unset;min-height:var(--control-large-size,2.5rem);padding-inline:var(--control-large-paddingInline-spacious,1rem);}/*!sc*/
.dPmZyJ[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.dPmZyJ[data-inactive]:not([disabled]){background-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));border-color:var(--button-inactive-bgColor,var(--button-inactive-bgColor-rest,var(--color-btn-inactive-bg,#eaeef2)));color:var(--button-inactive-fgColor,var(--button-inactive-fgColor-rest,var(--color-btn-inactive-text,#57606a)));}/*!sc*/
.dPmZyJ[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.dPmZyJ [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dPmZyJ [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.dPmZyJ [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dPmZyJ [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dPmZyJ [data-component="buttonContent"]{-webkit-flex:1 0 auto;-ms-flex:1 0 auto;flex:1 0 auto;display:grid;grid-template-areas:"leadingVisual text trailingVisual";grid-template-columns:min-content minmax(0,auto) min-content;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-align-content:center;-ms-flex-line-pack:center;align-content:center;}/*!sc*/
.dPmZyJ [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.dPmZyJ [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.dPmZyJ [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.dPmZyJ:hover:not([disabled]){background-color:var(--control-transparent-bgColor-hover,var(--color-action-list-item-default-hover-bg,rgba(208,215,222,0.32)));}/*!sc*/
.dPmZyJ:active:not([disabled]){background-color:var(--control-transparent-bgColor-active,var(--color-action-list-item-default-active-bg,rgba(208,215,222,0.48)));}/*!sc*/
.dPmZyJ[aria-expanded=true]{background-color:var(--control-transparent-bgColor-selected,var(--color-action-list-item-default-selected-bg,rgba(208,215,222,0.24)));}/*!sc*/
.dPmZyJ[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.dPmZyJ[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.dPmZyJ:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.dPmZyJ:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.dPmZyJ:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
data-styled.g7[id="types__StyledButton-sc-ws60qy-0"]{content:"iQGjqs,gGdPyq,dXUvFs,dPmZyJ,"}/*!sc*/
.ezaPfa{display:inline-block;overflow:hidden;line-height:1;vertical-align:middle;border-radius:clamp(4px,var(--avatar-size) - 24px,6px);box-shadow:0 0 0 1px var(--avatar-borderColor,var(--color-avatar-border,rgba(31,35,40,0.15)));height:var(--avatar-size);width:var(--avatar-size);--avatar-size:16px;margin-right:8px;margin-top:-1px;margin-left:1px;}/*!sc*/
.kTrAEI{display:inline-block;overflow:hidden;line-height:1;vertical-align:middle;border-radius:50%;box-shadow:0 0 0 1px var(--avatar-borderColor,var(--color-avatar-border,rgba(31,35,40,0.15)));height:var(--avatar-size);width:var(--avatar-size);--avatar-size:16px;margin-right:8px;margin-top:-1px;margin-left:1px;}/*!sc*/
.eheKBp{display:inline-block;overflow:hidden;line-height:1;vertical-align:middle;border-radius:clamp(4px,var(--avatar-size) - 24px,6px);box-shadow:0 0 0 1px var(--avatar-borderColor,var(--color-avatar-border,rgba(31,35,40,0.15)));height:var(--avatar-size);width:var(--avatar-size);--avatar-size:16px;}/*!sc*/
.edGKGf{display:inline-block;overflow:hidden;line-height:1;vertical-align:middle;border-radius:50%;box-shadow:0 0 0 1px var(--avatar-borderColor,var(--color-avatar-border,rgba(31,35,40,0.15)));height:var(--avatar-size);width:var(--avatar-size);--avatar-size:16px;}/*!sc*/
data-styled.g9[id="Avatar__StyledAvatar-sc-2lv0r8-0"]{content:"ezaPfa,kTrAEI,eheKBp,edGKGf,"}/*!sc*/
.hWlpPn{position:relative;display:inline-block;}/*!sc*/
.hWlpPn::after{position:absolute;z-index:1000000;display:none;padding:0.5em 0.75em;font:normal normal 11px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI","Noto Sans",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";-webkit-font-smoothing:subpixel-antialiased;color:var(--tooltip-fgColor,var(--fgColor-onEmphasis,var(--color-fg-on-emphasis,#ffffff)));text-align:center;-webkit-text-decoration:none;text-decoration:none;text-shadow:none;text-transform:none;-webkit-letter-spacing:normal;-moz-letter-spacing:normal;-ms-letter-spacing:normal;letter-spacing:normal;word-wrap:break-word;white-space:pre;pointer-events:none;content:attr(aria-label);background:var(--tooltip-bgColor,var(--bgColor-emphasis,var(--color-neutral-emphasis-plus,#24292f)));border-radius:6px;opacity:0;}/*!sc*/
@-webkit-keyframes tooltip-appear{from{opacity:0;}to{opacity:1;}}/*!sc*/
@keyframes tooltip-appear{from{opacity:0;}to{opacity:1;}}/*!sc*/
.hWlpPn:hover::after,.hWlpPn:active::after,.hWlpPn:focus::after,.hWlpPn:focus-within::after{display:inline-block;-webkit-text-decoration:none;text-decoration:none;-webkit-animation-name:tooltip-appear;animation-name:tooltip-appear;-webkit-animation-duration:0.1s;animation-duration:0.1s;-webkit-animation-fill-mode:forwards;animation-fill-mode:forwards;-webkit-animation-timing-function:ease-in;animation-timing-function:ease-in;-webkit-animation-delay:0s;animation-delay:0s;}/*!sc*/
.hWlpPn.tooltipped-no-delay:hover::after,.hWlpPn.tooltipped-no-delay:active::after,.hWlpPn.tooltipped-no-delay:focus::after,.hWlpPn.tooltipped-no-delay:focus-within::after{-webkit-animation-delay:0s;animation-delay:0s;}/*!sc*/
.hWlpPn.tooltipped-multiline:hover::after,.hWlpPn.tooltipped-multiline:active::after,.hWlpPn.tooltipped-multiline:focus::after,.hWlpPn.tooltipped-multiline:focus-within::after{display:table-cell;}/*!sc*/
.hWlpPn.tooltipped-s::after,.hWlpPn.tooltipped-se::after,.hWlpPn.tooltipped-sw::after{top:100%;right:50%;margin-top:6px;}/*!sc*/
.hWlpPn.tooltipped-se::after{right:auto;left:50%;margin-left:-16px;}/*!sc*/
.hWlpPn.tooltipped-sw::after{margin-right:-16px;}/*!sc*/
.hWlpPn.tooltipped-n::after,.hWlpPn.tooltipped-ne::after,.hWlpPn.tooltipped-nw::after{right:50%;bottom:100%;margin-bottom:6px;}/*!sc*/
.hWlpPn.tooltipped-ne::after{right:auto;left:50%;margin-left:-16px;}/*!sc*/
.hWlpPn.tooltipped-nw::after{margin-right:-16px;}/*!sc*/
.hWlpPn.tooltipped-s::after,.hWlpPn.tooltipped-n::after{-webkit-transform:translateX(50%);-ms-transform:translateX(50%);transform:translateX(50%);}/*!sc*/
.hWlpPn.tooltipped-w::after{right:100%;bottom:50%;margin-right:6px;-webkit-transform:translateY(50%);-ms-transform:translateY(50%);transform:translateY(50%);}/*!sc*/
.hWlpPn.tooltipped-e::after{bottom:50%;left:100%;margin-left:6px;-webkit-transform:translateY(50%);-ms-transform:translateY(50%);transform:translateY(50%);}/*!sc*/
.hWlpPn.tooltipped-multiline::after{width:-webkit-max-content;width:-moz-max-content;width:max-content;max-width:250px;word-wrap:break-word;white-space:pre-line;border-collapse:separate;}/*!sc*/
.hWlpPn.tooltipped-multiline.tooltipped-s::after,.hWlpPn.tooltipped-multiline.tooltipped-n::after{right:auto;left:50%;-webkit-transform:translateX(-50%);-ms-transform:translateX(-50%);transform:translateX(-50%);}/*!sc*/
.hWlpPn.tooltipped-multiline.tooltipped-w::after,.hWlpPn.tooltipped-multiline.tooltipped-e::after{right:100%;}/*!sc*/
.hWlpPn.tooltipped-align-right-2::after{right:0;margin-right:0;}/*!sc*/
.hWlpPn.tooltipped-align-left-2::after{left:0;margin-left:0;}/*!sc*/
data-styled.g14[id="Tooltip__TooltipBase-sc-17tf59c-0"]{content:"hWlpPn,"}/*!sc*/
.dIlPa{color:var(--fgColor-accent,var(--color-accent-fg,#0969da));-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
[data-a11y-link-underlines='true'] .Link__StyledLink-sc-14289xe-0[data-inline='true']{-webkit-text-decoration:underline;text-decoration:underline;}/*!sc*/
.dIlPa:hover{-webkit-text-decoration:underline;text-decoration:underline;}/*!sc*/
.dIlPa:is(button){display:inline-block;padding:0;font-size:inherit;white-space:nowrap;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:transparent;border:0;-webkit-appearance:none;-moz-appearance:none;appearance:none;}/*!sc*/
.hxWjGz{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));-webkit-text-decoration:none;text-decoration:none;font-weight:400;white-space:nowrap;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
[data-a11y-link-underlines='true'] .Link__StyledLink-sc-14289xe-0[data-inline='true']{-webkit-text-decoration:underline;text-decoration:underline;}/*!sc*/
.hxWjGz:hover{-webkit-text-decoration:none;text-decoration:none;color:var(--fgColor-accent,var(--color-accent-fg,#0969da));}/*!sc*/
.hxWjGz:is(button){display:inline-block;padding:0;font-size:inherit;white-space:nowrap;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:transparent;border:0;-webkit-appearance:none;-moz-appearance:none;appearance:none;}/*!sc*/
.hxWjGz:hover{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));-webkit-text-decoration:underline;text-decoration:underline;}/*!sc*/
data-styled.g16[id="Link__StyledLink-sc-14289xe-0"]{content:"dIlPa,hxWjGz,"}/*!sc*/
.irOdmh{position:relative;overflow:hidden;-webkit-mask-image:radial-gradient(white,black);mask-image:radial-gradient(white,black);background-color:var(--bgColor-neutral-muted,var(--color-neutral-subtle,rgba(234,238,242,0.5)));border-radius:3px;display:block;height:1.2em;width:20px;}/*!sc*/
.irOdmh::after{-webkit-animation:crVFvv 1.5s infinite linear;animation:crVFvv 1.5s infinite linear;background:linear-gradient(90deg,transparent,var(--bgColor-neutral-muted,var(--color-neutral-subtle,rgba(234,238,242,0.5))),transparent);content:'';position:absolute;-webkit-transform:translateX(-100%);-ms-transform:translateX(-100%);transform:translateX(-100%);bottom:0;left:0;right:0;top:0;}/*!sc*/
.ihfxfT{position:relative;overflow:hidden;-webkit-mask-image:radial-gradient(white,black);mask-image:radial-gradient(white,black);background-color:var(--bgColor-neutral-muted,var(--color-neutral-subtle,rgba(234,238,242,0.5)));border-radius:3px;display:block;height:1.2em;width:62px;}/*!sc*/
.ihfxfT::after{-webkit-animation:crVFvv 1.5s infinite linear;animation:crVFvv 1.5s infinite linear;background:linear-gradient(90deg,transparent,var(--bgColor-neutral-muted,var(--color-neutral-subtle,rgba(234,238,242,0.5))),transparent);content:'';position:absolute;-webkit-transform:translateX(-100%);-ms-transform:translateX(-100%);transform:translateX(-100%);bottom:0;left:0;right:0;top:0;}/*!sc*/
data-styled.g60[id="LoadingSkeleton-sc-695d630a-0"]{content:"irOdmh,ihfxfT,"}/*!sc*/
.lirRhW{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;vertical-align:middle;isolation:isolate;}/*!sc*/
.lirRhW.lirRhW > *:not([data-loading-wrapper]){margin-inline-end:-1px;position:relative;border-radius:0;}/*!sc*/
.lirRhW.lirRhW > *:not([data-loading-wrapper]):first-child{border-top-left-radius:6px;border-bottom-left-radius:6px;}/*!sc*/
.lirRhW.lirRhW > *:not([data-loading-wrapper]):last-child{border-top-right-radius:6px;border-bottom-right-radius:6px;}/*!sc*/
.lirRhW.lirRhW > *:not([data-loading-wrapper]):focus,.lirRhW.lirRhW > *:not([data-loading-wrapper]):active,.lirRhW.lirRhW > *:not([data-loading-wrapper]):hover{z-index:1;}/*!sc*/
.lirRhW [data-loading-wrapper]:first-child button,.lirRhW [data-loading-wrapper]:first-child a{border-top-left-radius:6px;border-bottom-left-radius:6px;}/*!sc*/
.lirRhW [data-loading-wrapper]:last-child button,.lirRhW [data-loading-wrapper]:last-child a{border-top-right-radius:6px;border-bottom-right-radius:6px;}/*!sc*/
.lirRhW [data-loading-wrapper] > *{margin-inline-end:-1px;position:relative;border-radius:0;}/*!sc*/
.lirRhW [data-loading-wrapper] > *:focus,.lirRhW [data-loading-wrapper] > *:active,.lirRhW [data-loading-wrapper] > *:hover{z-index:1;}/*!sc*/
data-styled.g73[id="ButtonGroup__StyledButtonGroup-sc-1gxhls1-0"]{content:"lirRhW,"}/*!sc*/
.hzFwBi{--avatar-border-width:1px;--avatar-two-margin:calc(var(--avatar-stack-size) * -0.55);--avatar-three-margin:calc(var(--avatar-stack-size) * -0.85);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;position:relative;height:var(--avatar-stack-size);min-width:var(--avatar-stack-size);--avatar-stack-size:16px;}/*!sc*/
.hzFwBi .pc-AvatarStackBody{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;position:absolute;}/*!sc*/
.hzFwBi .pc-AvatarItem{--avatar-size:var(--avatar-stack-size);-webkit-flex-shrink:0;-ms-flex-negative:0;flex-shrink:0;height:var(--avatar-stack-size);width:var(--avatar-stack-size);box-shadow:0 0 0 var(--avatar-border-width) var(--bgColor-default,var(--color-canvas-default,#ffffff));position:relative;overflow:hidden;}/*!sc*/
.hzFwBi .pc-AvatarItem:first-child{margin-left:0;z-index:10;}/*!sc*/
.hzFwBi .pc-AvatarItem:nth-child(n + 2){margin-left:var(--avatar-two-margin);z-index:9;}/*!sc*/
.hzFwBi .pc-AvatarItem:nth-child(n + 3){margin-left:var(--avatar-three-margin);opacity:55%;z-index:8;}/*!sc*/
.hzFwBi .pc-AvatarItem:nth-child(n + 4){opacity:40%;z-index:7;}/*!sc*/
.hzFwBi .pc-AvatarItem:nth-child(n + 5){opacity:25%;z-index:6;}/*!sc*/
.hzFwBi .pc-AvatarItem:nth-child(n + 6){opacity:0;visibility:hidden;}/*!sc*/
.hzFwBi.pc-AvatarStack--two{min-width:calc( var(--avatar-stack-size) + calc(var(--avatar-stack-size) + var(--avatar-two-margin)) + var(--avatar-border-width) );}/*!sc*/
.hzFwBi.pc-AvatarStack--three{min-width:calc( var(--avatar-stack-size) + calc( calc(var(--avatar-stack-size) + var(--avatar-two-margin)) + calc(var(--avatar-stack-size) + var(--avatar-three-margin)) ) );}/*!sc*/
.hzFwBi.pc-AvatarStack--three-plus{min-width:calc( var(--avatar-stack-size) + calc( calc(var(--avatar-stack-size) + var(--avatar-two-margin)) + calc(var(--avatar-stack-size) + var(--avatar-three-margin)) * 2 ) );}/*!sc*/
.hzFwBi.pc-AvatarStack--right{-webkit-box-pack:end;-webkit-justify-content:flex-end;-ms-flex-pack:end;justify-content:flex-end;}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarItem{margin-left:0 !important;}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarItem:first-child{margin-right:0;}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarItem:nth-child(n + 2){margin-right:var(--avatar-two-margin);}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarItem:nth-child(n + 3){margin-right:var(--avatar-three-margin);}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarStackBody{-webkit-flex-direction:row-reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse;}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem{margin-right:4px!important;margin-left:0 !important;}/*!sc*/
.hzFwBi.pc-AvatarStack--right .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:first-child{margin-right:0 !important;}/*!sc*/
.hzFwBi .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover{width:auto;}/*!sc*/
.hzFwBi .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem{margin-left:4px;opacity:100%;visibility:visible;-webkit-transition:margin 0.2s ease-in-out,opacity 0.2s ease-in-out,visibility 0.2s ease-in-out,box-shadow 0.1s ease-in-out;transition:margin 0.2s ease-in-out,opacity 0.2s ease-in-out,visibility 0.2s ease-in-out,box-shadow 0.1s ease-in-out;}/*!sc*/
.hzFwBi .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem box-shadow:inset 0 0 0 4px function(_){return(0,C.Jt)(_.theme,a,o);}/*!sc*/
.hzFwBi .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:first-child{margin-left:0;}/*!sc*/
.hzFwBi .pc-AvatarStack--disableExpand{position:relative;}/*!sc*/
data-styled.g74[id="AvatarStack__AvatarStackWrapper-sc-4pdg6v-0"]{content:"hzFwBi,"}/*!sc*/
.jkwhqe{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;}/*!sc*/
.jkwhqe .Timeline-Item:first-child{padding-top:0;}/*!sc*/
.jkwhqe .Timeline-Item:last-child{padding-bottom:0;}/*!sc*/
data-styled.g86[id="Timeline-sc-1nkzbnu-0"]{content:"jkwhqe,"}/*!sc*/
.iKZSls{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;position:relative;padding:16px 0;margin-left:16px;padding-top:0;padding-bottom:4px;}/*!sc*/
.iKZSls::before{position:absolute;top:0;bottom:0;left:0;display:block;width:2px;content:'';background-color:var(--borderColor-muted,var(--color-border-muted,hsla(210,18%,87%,1)));}/*!sc*/
.kDdNwA{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;position:relative;padding:16px 0;margin-left:16px;padding-top:4px;padding-bottom:4px;}/*!sc*/
.kDdNwA::before{position:absolute;top:0;bottom:0;left:0;display:block;width:2px;content:'';background-color:var(--borderColor-muted,var(--color-border-muted,hsla(210,18%,87%,1)));}/*!sc*/
data-styled.g87[id="Timeline__TimelineItem-sc-1nkzbnu-1"]{content:"iKZSls,kDdNwA,"}/*!sc*/
.eYvRDq{min-width:0;max-width:100%;margin-top:4px;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));-webkit-flex:auto;-ms-flex:auto;flex:auto;font-size:14px;}/*!sc*/
data-styled.g88[id="Timeline__TimelineBody-sc-1nkzbnu-2"]{content:"eYvRDq,"}/*!sc*/
@-webkit-keyframes crVFvv{0%{-webkit-transform:translateX(-100%);-ms-transform:translateX(-100%);transform:translateX(-100%);}50%{-webkit-transform:translateX(100%);-ms-transform:translateX(100%);transform:translateX(100%);}100%{-webkit-transform:translateX(100%);-ms-transform:translateX(100%);transform:translateX(100%);}}/*!sc*/
@keyframes crVFvv{0%{-webkit-transform:translateX(-100%);-ms-transform:translateX(-100%);transform:translateX(-100%);}50%{-webkit-transform:translateX(100%);-ms-transform:translateX(100%);transform:translateX(100%);}100%{-webkit-transform:translateX(100%);-ms-transform:translateX(100%);transform:translateX(100%);}}/*!sc*/
data-styled.g96[id="sc-keyframes-crVFvv"]{content:"crVFvv,"}/*!sc*/
</style> <!-- --> <div style="--sticky-pane-height:100vh" class="Box-sc-g0xbh4-0 kkWQEA"><div class="Box-sc-g0xbh4-0 bSJDXx"><header class="Box-sc-g0xbh4-0 jPRcNF"><div class="Box-sc-g0xbh4-0 hOfjFo"><div class="d-flex flex-items-center flex-justify-between"><h1 class="f2 text-normal pb-2 prc-Heading-Heading-6CmGO" id="commits-pagehead">Commits</h1></div></div><div class="Box-sc-g0xbh4-0 gKBBxN"></div></header><div class="Box-sc-g0xbh4-0 kowOcT"><div class="Box-sc-g0xbh4-0 dQkwwl"><div class="Box-sc-g0xbh4-0"></div><div class="Box-sc-g0xbh4-0 FxAyp"><div><div class="Box-sc-g0xbh4-0 gwHaUx"><h2 class="sr-only prc-Heading-Heading-6CmGO">Branch selector</h2><button type="button" aria-haspopup="true" aria-expanded="false" tabindex="0" data-hotkey="w" aria-label="master branch" data-testid="anchor-button" class="types__StyledButton-sc-ws60qy-0 iQGjqs" data-loading="false" data-size="medium" aria-describedby="branch-picker-commits-loading-announcement" id="branch-picker-commits"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="text"><div class="Box-sc-g0xbh4-0 bZBlpz"><div class="Box-sc-g0xbh4-0 lhTYNA"><svg aria-hidden="true" focusable="false" class="octicon octicon-git-branch" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M9.5 3.25a2.25 2.25 0 1 1 3 2.122V6A2.5 2.5 0 0 1 10 8.5H6a1 1 0 0 0-1 1v1.128a2.251 2.251 0 1 1-1.5 0V5.372a2.25 2.25 0 1 1 1.5 0v1.836A2.493 2.493 0 0 1 6 7h4a1 1 0 0 0 1-1v-.628A2.25 2.25 0 0 1 9.5 3.25Zm-6 0a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Zm8.25-.75a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5ZM4.25 12a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Z"></path></svg></div><div class="Box-sc-g0xbh4-0 dbrgmi ref-selector-button-text-container"><span class="Text__StyledText-sc-17v1xeu-0 eMMFM"> <!-- -->master</span></div></div></span><span data-component="trailingVisual" class="Box-sc-g0xbh4-0 hzSPyu"><svg aria-hidden="true" focusable="false" class="octicon octicon-triangle-down" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m4.427 7.427 3.396 3.396a.25.25 0 0 0 .354 0l3.396-3.396A.25.25 0 0 0 11.396 7H4.604a.25.25 0 0 0-.177.427Z"></path></svg></span></span></button><button hidden="" data-hotkey="w" data-hotkey-scope="read-only-cursor-text-area"></button><div class="d-flex flex-column flex-sm-row gap-2"><h2 class="sr-only prc-Heading-Heading-6CmGO">User selector</h2><div><button type="button" data-testid="user-selector-button" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 gGdPyq" data-loading="false" data-size="medium" aria-describedby=":R1crab:-loading-announcement" id=":R1crab:"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="text"><div class="Box-sc-g0xbh4-0 cSURfY"><div class="Box-sc-g0xbh4-0 hjDqIa"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0 knLhXt" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M2 5.5a3.5 3.5 0 1 1 5.898 2.549 5.508 5.508 0 0 1 3.034 4.084.75.75 0 1 1-1.482.235 4 4 0 0 0-7.9 0 .75.75 0 0 1-1.482-.236A5.507 5.507 0 0 1 3.102 8.05 3.493 3.493 0 0 1 2 5.5ZM11 4a3.001 3.001 0 0 1 2.22 5.018 5.01 5.01 0 0 1 2.56 3.012.749.749 0 0 1-.885.954.752.752 0 0 1-.549-.514 3.507 3.507 0 0 0-2.522-2.372.75.75 0 0 1-.574-.73v-.352a.75.75 0 0 1 .416-.672A1.5 1.5 0 0 0 11 5.5.75.75 0 0 1 11 4Zm-5.5-.5a2 2 0 1 0-.001 3.999A2 2 0 0 0 5.5 3.5Z"></path></svg></div><div class="Box-sc-g0xbh4-0 dGVxWp"><span>All users</span></div></div></span></span><span data-component="trailingAction" class="Box-sc-g0xbh4-0 hzSPyu"><svg aria-hidden="true" focusable="false" class="octicon octicon-triangle-down" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m4.427 7.427 3.396 3.396a.25.25 0 0 0 .354 0l3.396-3.396A.25.25 0 0 0 11.396 7H4.604a.25.25 0 0 0-.177.427Z"></path></svg></span></button></div><!--$--><h2 class="sr-only prc-Heading-Heading-6CmGO">Datepicker</h2><button type="button" aria-haspopup="true" tabindex="0" data-testid="date-picker-commits" class="types__StyledButton-sc-ws60qy-0 gGdPyq" data-loading="false" data-size="medium" aria-describedby=":Rlsrab:-loading-announcement"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="leadingVisual" class="Box-sc-g0xbh4-0 hzSPyu"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0 WGJwj fgColor-muted" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M4.75 0a.75.75 0 0 1 .75.75V2h5V.75a.75.75 0 0 1 1.5 0V2h1.25c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0 1 13.25 16H2.75A1.75 1.75 0 0 1 1 14.25V3.75C1 2.784 1.784 2 2.75 2H4V.75A.75.75 0 0 1 4.75 0ZM2.5 7.5v6.75c0 .138.112.25.25.25h10.5a.25.25 0 0 0 .25-.25V7.5Zm10.75-4H2.75a.25.25 0 0 0-.25.25V6h11V3.75a.25.25 0 0 0-.25-.25Z"></path></svg></span><span data-component="text">All time</span><span data-component="trailingVisual" class="Box-sc-g0xbh4-0 hzSPyu"><svg aria-hidden="true" focusable="false" class="octicon octicon-triangle-down" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m4.427 7.427 3.396 3.396a.25.25 0 0 0 .354 0l3.396-3.396A.25.25 0 0 0 11.396 7H4.604a.25.25 0 0 0-.177.427Z"></path></svg></span></span></button><!--/$--></div></div><div class="mb-3" data-hpc="true"><h2 class="sr-only prc-Heading-Heading-6CmGO">Commit History</h2><div class="Timeline-sc-1nkzbnu-0 jkwhqe"><div class="Timeline__TimelineItem-sc-1nkzbnu-1 iKZSls Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rd5rab:" data-testid="commit-group-title">Commits on Oct 11, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R58d5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rd5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R58d5rab:-list-view-node-:R7t8d5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (#689)

Bumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).


Updates `roda` from 3.84.0 to 3.85.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.84.0...3.85.0)

---
updated-dependencies:
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859">chore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2582254361" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/689" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/689/hovercard" href="https://github.com/html2rss/html2rss-web/pull/689">#689</a><a data-pjax="true" title="chore(deps): bump roda from 3.84.0 to 3.85.0 in the rubygems group (#689)

Bumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).


Updates `roda` from 3.84.0 to 3.85.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.84.0...3.85.0)

---
updated-dependencies:
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 8eeb9e6" id="show-description-8eeb9e6" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-8eeb9e6" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Oct 11, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnt8d5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">8eeb9e6</span></span></a></span><div><div aria-describedby=":R9rnt8d5rab:"><button aria-label="Copy full SHA for 8eeb9e6" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-8eeb9e6" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-8eeb9e6" href="/html2rss/html2rss-web/tree/8eeb9e69a1c57f3c61ca00469083604e25066859" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rl5rab:" data-testid="commit-group-title">Commits on Oct 9, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R58l5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rl5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R58l5rab:-list-view-node-:R7t8l5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#688)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `560c66c` to `9673d2b`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/560c66c8fb08abdc2e485a9576b8b414480b377d...9673d2b091e5d10bb6fa3c161b1ba97070921fd4)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e">chore(deps): bump html2rss-configs in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2577103680" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/688" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/688/hovercard" href="https://github.com/html2rss/html2rss-web/pull/688">#688</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#688)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `560c66c` to `9673d2b`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/560c66c8fb08abdc2e485a9576b8b414480b377d...9673d2b091e5d10bb6fa3c161b1ba97070921fd4)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 6596478" id="show-description-6596478" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-6596478" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Oct 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnt8l5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">6596478</span></span></a></span><div><div aria-describedby=":R9rnt8l5rab:"><button aria-label="Copy full SHA for 6596478" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-6596478" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-6596478" href="/html2rss/html2rss-web/tree/65964787b26ab6406ca1e9f1f64de67adb66b49e" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rt5rab:" data-testid="commit-group-title">Commits on Oct 8, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R58t5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rt5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R58t5rab:-list-view-node-:R7t8t5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (#687)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).


Updates `html2rss` from 0.13.0 to 0.14.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.13.0...v0.14.0)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f">chore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2572881396" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/687" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/687/hovercard" href="https://github.com/html2rss/html2rss-web/pull/687">#687</a><a data-pjax="true" title="chore(deps): bump html2rss from 0.13.0 to 0.14.0 in the rubygems group (#687)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).


Updates `html2rss` from 0.13.0 to 0.14.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.13.0...v0.14.0)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 9ff3cc1" id="show-description-9ff3cc1" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-9ff3cc1" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Oct 8, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnt8t5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">9ff3cc1</span></span></a></span><div><div aria-describedby=":R9rnt8t5rab:"><button aria-label="Copy full SHA for 9ff3cc1" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-9ff3cc1" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-9ff3cc1" href="/html2rss/html2rss-web/tree/9ff3cc1a706ebdea7b75e560ea263caab79ce68f" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R155rab:" data-testid="commit-group-title">Commits on Sep 19, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5955rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R155rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5955rab:-list-view-node-:R7t955rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (#686)

Bumps the rubygems group with 1 update: [puma](https://github.com/puma/puma).


Updates `puma` from 6.4.2 to 6.4.3
- [Release notes](https://github.com/puma/puma/releases)
- [Changelog](https://github.com/puma/puma/blob/master/History.md)
- [Commits](https://github.com/puma/puma/compare/v6.4.2...v6.4.3)

---
updated-dependencies:
- dependency-name: puma
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163">chore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2537463374" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/686" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/686/hovercard" href="https://github.com/html2rss/html2rss-web/pull/686">#686</a><a data-pjax="true" title="chore(deps): bump puma from 6.4.2 to 6.4.3 in the rubygems group (#686)

Bumps the rubygems group with 1 update: [puma](https://github.com/puma/puma).


Updates `puma` from 6.4.2 to 6.4.3
- [Release notes](https://github.com/puma/puma/releases)
- [Changelog](https://github.com/puma/puma/blob/master/History.md)
- [Commits](https://github.com/puma/puma/compare/v6.4.2...v6.4.3)

---
updated-dependencies:
- dependency-name: puma
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 9d81615" id="show-description-9d81615" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-9d81615" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Sep 19, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnt955rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">9d81615</span></span></a></span><div><div aria-describedby=":R9rnt955rab:"><button aria-label="Copy full SHA for 9d81615" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-9d81615" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-9d81615" href="/html2rss/html2rss-web/tree/9d81615cc9c178127b86c45fa108bc3bf92ba163" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R1d5rab:" data-testid="commit-group-title">Commits on Sep 12, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R59d5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R1d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R59d5rab:-list-view-node-:R7t9d5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (#685)

Bumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).


Updates `roda` from 3.83.0 to 3.84.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.83.0...3.84.0)

---
updated-dependencies:
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e">chore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2523481129" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/685" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/685/hovercard" href="https://github.com/html2rss/html2rss-web/pull/685">#685</a><a data-pjax="true" title="chore(deps): bump roda from 3.83.0 to 3.84.0 in the rubygems group (#685)

Bumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).


Updates `roda` from 3.83.0 to 3.84.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.83.0...3.84.0)

---
updated-dependencies:
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 2d1b250" id="show-description-2d1b250" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-2d1b250" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Sep 12, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnt9d5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">2d1b250</span></span></a></span><div><div aria-describedby=":R9rnt9d5rab:"><button aria-label="Copy full SHA for 2d1b250" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-2d1b250" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-2d1b250" href="/html2rss/html2rss-web/tree/2d1b2506699897694d47244748fd6ece6dedbd4e" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R1l5rab:" data-testid="commit-group-title">Commits on Sep 5, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R59l5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R1l5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R59l5rab:-list-view-node-:R7t9l5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (#684)

Bumps ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20.

---
updated-dependencies:
- dependency-name: ruby
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989">chore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2507217874" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/684" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/684/hovercard" href="https://github.com/html2rss/html2rss-web/pull/684">#684</a><a data-pjax="true" title="chore(deps): bump ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20 (#684)

Bumps ruby from 3.3.4-alpine3.20 to 3.3.5-alpine3.20.

---
updated-dependencies:
- dependency-name: ruby
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for ac21f2e" id="show-description-ac21f2e" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-ac21f2e" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Sep 5, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnt9l5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">ac21f2e</span></span></a></span><div><div aria-describedby=":R9rnt9l5rab:"><button aria-label="Copy full SHA for ac21f2e" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-ac21f2e" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-ac21f2e" href="/html2rss/html2rss-web/tree/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R1t5rab:" data-testid="commit-group-title">Commits on Aug 22, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R59t5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R1t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R59t5rab:-list-view-node-:Rbt9t5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#683)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `86f7f48` to `560c66c`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/86f7f48f4ed613c53da36f21ed6fa0021b6afa6a...560c66c8fb08abdc2e485a9576b8b414480b377d)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874">chore(deps): bump html2rss-configs in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2481937369" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/683" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/683/hovercard" href="https://github.com/html2rss/html2rss-web/pull/683">#683</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#683)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `86f7f48` to `560c66c`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/86f7f48f4ed613c53da36f21ed6fa0021b6afa6a...560c66c8fb08abdc2e485a9576b8b414480b377d)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for b457637" id="show-description-b457637" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-b457637" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 22, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbnbt9t5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">b457637</span></span></a></span><div><div aria-describedby=":Rjnbt9t5rab:"><button aria-label="Copy full SHA for b457637" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-b457637" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-b457637" href="/html2rss/html2rss-web/tree/b45763778438aa153e7cd3d18a8b84e521624874" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R59t5rab:-list-view-node-:Rdt9t5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump rexml from 3.3.5 to 3.3.6 (#682)

Bumps [rexml](https://github.com/ruby/rexml) from 3.3.5 to 3.3.6.
- [Release notes](https://github.com/ruby/rexml/releases)
- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)
- [Commits](https://github.com/ruby/rexml/compare/v3.3.5...v3.3.6)

---
updated-dependencies:
- dependency-name: rexml
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d">chore(deps): bump rexml from 3.3.5 to 3.3.6 (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2481717985" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/682" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/682/hovercard" href="https://github.com/html2rss/html2rss-web/pull/682">#682</a><a data-pjax="true" title="chore(deps): bump rexml from 3.3.5 to 3.3.6 (#682)

Bumps [rexml](https://github.com/ruby/rexml) from 3.3.5 to 3.3.6.
- [Release notes](https://github.com/ruby/rexml/releases)
- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)
- [Commits](https://github.com/ruby/rexml/compare/v3.3.5...v3.3.6)

---
updated-dependencies:
- dependency-name: rexml
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for dca8278" id="show-description-dca8278" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-dca8278" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 22, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbndt9t5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">dca8278</span></span></a></span><div><div aria-describedby=":Rjndt9t5rab:"><button aria-label="Copy full SHA for dca8278" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-dca8278" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-dca8278" href="/html2rss/html2rss-web/tree/dca827891199a7a8b6979ccd4e36487d1798ed0d" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R255rab:" data-testid="commit-group-title">Commits on Aug 19, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5a55rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R255rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5a55rab:-list-view-node-:R7ta55rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#677)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `27f9f9a` to `86f7f48`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/27f9f9adcd0a85310f5dfe1a61ed2f96b6638697...86f7f48f4ed613c53da36f21ed6fa0021b6afa6a)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c">chore(deps): bump html2rss-configs in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2474391321" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/677" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/677/hovercard" href="https://github.com/html2rss/html2rss-web/pull/677">#677</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#677)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `27f9f9a` to `86f7f48`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/27f9f9adcd0a85310f5dfe1a61ed2f96b6638697...86f7f48f4ed613c53da36f21ed6fa0021b6afa6a)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 5ebc9ec" id="show-description-5ebc9ec" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-5ebc9ec" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 19, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rnta55rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">5ebc9ec</span></span></a></span><div><div aria-describedby=":R9rnta55rab:"><button aria-label="Copy full SHA for 5ebc9ec" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-5ebc9ec" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-5ebc9ec" href="/html2rss/html2rss-web/tree/5ebc9ec5de9799d9da28b93275cfbdc775240f0c" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R2d5rab:" data-testid="commit-group-title">Commits on Aug 17, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5ad5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R2d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5ad5rab:-list-view-node-:R7tad5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="refactor: improve structure to follow more Roda conventions (#675)" class="color-fg-default" href="/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a">refactor: improve structure to follow more Roda conventions (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2471098036" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/675" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/675/hovercard" href="https://github.com/html2rss/html2rss-web/pull/675">#675</a><a data-pjax="true" title="refactor: improve structure to follow more Roda conventions (#675)" class="color-fg-default" href="/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 17, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntad5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">929ae67</span></span></a></span><div><div aria-describedby=":R9rntad5rab:"><button aria-label="Copy full SHA for 929ae67" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-929ae67" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-929ae67" href="/html2rss/html2rss-web/tree/929ae671dade0457a5af781982d3db5a39c8676a" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R2l5rab:" data-testid="commit-group-title">Commits on Aug 16, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5al5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R2l5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5al5rab:-list-view-node-:Rbtal5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates

Bumps the rubygems group with 2 updates: [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [parallel](https://github.com/grosser/parallel).


Updates `html2rss-configs` from `721dc23` to `27f9f9a`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/721dc23e3cc84e7d6fd1183ff453f71e55ba5ab1...27f9f9adcd0a85310f5dfe1a61ed2f96b6638697)

Updates `parallel` from 1.26.2 to 1.26.3
- [Commits](https://github.com/grosser/parallel/compare/v1.26.2...v1.26.3)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: parallel
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/59831cddd1ed24f722ac60c388141a5b65d8e269">chore(deps): bump the rubygems group with 2 updates</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 59831cd" id="show-description-59831cd" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-59831cd" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><span class="AvatarStack__AvatarStackWrapper-sc-4pdg6v-0 hzFwBi pc-AvatarStack--three"><div class="Box-sc-g0xbh4-0 pc-AvatarStackBody"> <img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 eheKBp pc-AvatarItem" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="commit-stack-avatar" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard" height="16" width="16"/><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 edGKGf pc-AvatarItem" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="commit-stack-avatar" data-hovercard-url="/users/gildesmarais/hovercard" height="16" width="16"/></div></span><div data-testid="author-link" class="Box-sc-g0xbh4-0 iCHGgS"><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored and</span><div data-testid="author-link" class="Box-sc-g0xbh4-0 iCHGgS"><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 16, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbnbtal5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/59831cddd1ed24f722ac60c388141a5b65d8e269" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">59831cd</span></span></a></span><div><div aria-describedby=":Rjnbtal5rab:"><button aria-label="Copy full SHA for 59831cd" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-59831cd" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-59831cd" href="/html2rss/html2rss-web/tree/59831cddd1ed24f722ac60c388141a5b65d8e269" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5al5rab:-list-view-node-:Rdtal5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (#672)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).


Updates `html2rss` from 0.12.0 to 0.13.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.12.0...v0.13.0)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4">chore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2470397038" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/672" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/672/hovercard" href="https://github.com/html2rss/html2rss-web/pull/672">#672</a><a data-pjax="true" title="chore(deps): bump html2rss from 0.12.0 to 0.13.0 in the rubygems group (#672)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).


Updates `html2rss` from 0.12.0 to 0.13.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.12.0...v0.13.0)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 83772a1" id="show-description-83772a1" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-83772a1" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 16, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbndtal5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">83772a1</span></span></a></span><div><div aria-describedby=":Rjndtal5rab:"><button aria-label="Copy full SHA for 83772a1" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-83772a1" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-83772a1" href="/html2rss/html2rss-web/tree/83772a132ca489c0b58d8becc716710896d348e4" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R2t5rab:" data-testid="commit-group-title">Commits on Aug 12, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5at5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R2t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5at5rab:-list-view-node-:R7tat5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#671)

Bumps the rubygems group with 2 updates: [parallel](https://github.com/grosser/parallel) and [roda](https://github.com/jeremyevans/roda).


Updates `parallel` from 1.26.1 to 1.26.2
- [Commits](https://github.com/grosser/parallel/compare/v1.26.1...v1.26.2)

Updates `roda` from 3.82.0 to 3.83.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.82.0...3.83.0)

---
updated-dependencies:
- dependency-name: parallel
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: rubygems
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31">chore(deps): bump the rubygems group with 2 updates (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2462016360" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/671" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/671/hovercard" href="https://github.com/html2rss/html2rss-web/pull/671">#671</a><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#671)

Bumps the rubygems group with 2 updates: [parallel](https://github.com/grosser/parallel) and [roda](https://github.com/jeremyevans/roda).


Updates `parallel` from 1.26.1 to 1.26.2
- [Commits](https://github.com/grosser/parallel/compare/v1.26.1...v1.26.2)

Updates `roda` from 3.82.0 to 3.83.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.82.0...3.83.0)

---
updated-dependencies:
- dependency-name: parallel
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: rubygems
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 1f46606" id="show-description-1f46606" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-1f46606" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 12, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntat5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">1f46606</span></span></a></span><div><div aria-describedby=":R9rntat5rab:"><button aria-label="Copy full SHA for 1f46606" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-1f46606" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-1f46606" href="/html2rss/html2rss-web/tree/1f466065612bd289933b28747e7e6f76a628bc31" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R355rab:" data-testid="commit-group-title">Commits on Aug 10, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5b55rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R355rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5b55rab:-list-view-node-:Rbtb55rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `fef08c6` to `721dc23`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/fef08c6fc2696e8936173e68403fa991846ff6c6...721dc23e3cc84e7d6fd1183ff453f71e55ba5ab1)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/6ae606229ae48d9c1cd3c7d0339172eb244ce8eb">chore(deps): bump html2rss-configs in the rubygems group</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 6ae6062" id="show-description-6ae6062" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-6ae6062" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><span class="AvatarStack__AvatarStackWrapper-sc-4pdg6v-0 hzFwBi pc-AvatarStack--three"><div class="Box-sc-g0xbh4-0 pc-AvatarStackBody"> <img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 eheKBp pc-AvatarItem" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="commit-stack-avatar" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard" height="16" width="16"/><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 edGKGf pc-AvatarItem" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="commit-stack-avatar" data-hovercard-url="/users/gildesmarais/hovercard" height="16" width="16"/></div></span><div data-testid="author-link" class="Box-sc-g0xbh4-0 iCHGgS"><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored and</span><div data-testid="author-link" class="Box-sc-g0xbh4-0 iCHGgS"><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 10, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbnbtb55rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/6ae606229ae48d9c1cd3c7d0339172eb244ce8eb" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">6ae6062</span></span></a></span><div><div aria-describedby=":Rjnbtb55rab:"><button aria-label="Copy full SHA for 6ae6062" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-6ae6062" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-6ae6062" href="/html2rss/html2rss-web/tree/6ae606229ae48d9c1cd3c7d0339172eb244ce8eb" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5b55rab:-list-view-node-:Rdtb55rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (#669)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).


Updates `html2rss` from 0.11.0 to 0.12.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.11.0...v0.12.0)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/36e06a98c472e78a89abb6c6979e0bb9a11f2e75">chore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2459068748" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/669" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/669/hovercard" href="https://github.com/html2rss/html2rss-web/pull/669">#669</a><a data-pjax="true" title="chore(deps): bump html2rss from 0.11.0 to 0.12.0 in the rubygems group (#669)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).


Updates `html2rss` from 0.11.0 to 0.12.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.11.0...v0.12.0)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/36e06a98c472e78a89abb6c6979e0bb9a11f2e75">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 36e06a9" id="show-description-36e06a9" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-36e06a9" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 10, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbndtb55rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/36e06a98c472e78a89abb6c6979e0bb9a11f2e75" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">36e06a9</span></span></a></span><div><div aria-describedby=":Rjndtb55rab:"><button aria-label="Copy full SHA for 36e06a9" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-36e06a9" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-36e06a9" href="/html2rss/html2rss-web/tree/36e06a98c472e78a89abb6c6979e0bb9a11f2e75" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R3d5rab:" data-testid="commit-group-title">Commits on Aug 9, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5bd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R3d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5bd5rab:-list-view-node-:R13tbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): update ruby deps" class="color-fg-default" href="/html2rss/html2rss-web/commit/a207c788cbc147e3c8b28a597caa70adaf09374d">chore(deps): update ruby deps</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1et3tbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/a207c788cbc147e3c8b28a597caa70adaf09374d" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">a207c78</span></span></a></span><div><div aria-describedby=":R2et3tbd5rab:"><button aria-label="Copy full SHA for a207c78" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-a207c78" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-a207c78" href="/html2rss/html2rss-web/tree/a207c788cbc147e3c8b28a597caa70adaf09374d" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R15tbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="style(rubocop): enable Layout/ClassStructure cop" class="color-fg-default" href="/html2rss/html2rss-web/commit/dca3bc3e42876c7681e05a3805f4c33af885d472">style(rubocop): enable Layout/ClassStructure cop</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1et5tbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/dca3bc3e42876c7681e05a3805f4c33af885d472" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">dca3bc3</span></span></a></span><div><div aria-describedby=":R2et5tbd5rab:"><button aria-label="Copy full SHA for dca3bc3" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-dca3bc3" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-dca3bc3" href="/html2rss/html2rss-web/tree/dca3bc3e42876c7681e05a3805f4c33af885d472" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R17tbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump the rubygems group with 3 updates (#667)

Bumps the rubygems group with 3 updates: [html2rss](https://github.com/gildesmarais/html2rss), [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [parallel](https://github.com/grosser/parallel).


Updates `html2rss` from 0.10.0 to 0.11.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.10.0...v0.11.0)

Updates `html2rss-configs` from `07bbadc` to `fef08c6`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/07bbadcc2be501488a3772352ab0f8c7b05235a3...fef08c6fc2696e8936173e68403fa991846ff6c6)

Updates `parallel` from 1.24.0 to 1.26.1
- [Commits](https://github.com/grosser/parallel/compare/v1.24.0...v1.26.1)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: parallel
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/164b22216df50a2cbd6e0a6715e7aa170d3ea99f">chore(deps): bump the rubygems group with 3 updates (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2458755473" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/667" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/667/hovercard" href="https://github.com/html2rss/html2rss-web/pull/667">#667</a><a data-pjax="true" title="chore(deps): bump the rubygems group with 3 updates (#667)

Bumps the rubygems group with 3 updates: [html2rss](https://github.com/gildesmarais/html2rss), [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [parallel](https://github.com/grosser/parallel).


Updates `html2rss` from 0.10.0 to 0.11.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.10.0...v0.11.0)

Updates `html2rss-configs` from `07bbadc` to `fef08c6`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/07bbadcc2be501488a3772352ab0f8c7b05235a3...fef08c6fc2696e8936173e68403fa991846ff6c6)

Updates `parallel` from 1.24.0 to 1.26.1
- [Commits](https://github.com/grosser/parallel/compare/v1.24.0...v1.26.1)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: parallel
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/164b22216df50a2cbd6e0a6715e7aa170d3ea99f">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 164b222" id="show-description-164b222" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-164b222" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1et7tbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/164b22216df50a2cbd6e0a6715e7aa170d3ea99f" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">164b222</span></span></a></span><div><div aria-describedby=":R2et7tbd5rab:"><button aria-label="Copy full SHA for 164b222" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-164b222" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-164b222" href="/html2rss/html2rss-web/tree/164b22216df50a2cbd6e0a6715e7aa170d3ea99f" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R19tbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="refactor: improve readability of docs and code performance

Signed-off-by: Gil Desmarais &lt;git@desmarais.de&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/398388dd843c121cabff6ea7cc73cb6de7b3870a">refactor: improve readability of docs and code performance</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 398388d" id="show-description-398388d" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-398388d" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1et9tbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/398388dd843c121cabff6ea7cc73cb6de7b3870a" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">398388d</span></span></a></span><div><div aria-describedby=":R2et9tbd5rab:"><button aria-label="Copy full SHA for 398388d" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-398388d" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-398388d" href="/html2rss/html2rss-web/tree/398388dd843c121cabff6ea7cc73cb6de7b3870a" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R1btbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="feat: use parallel processing for feed retrieval in health_check.rb (#665)" class="color-fg-default" href="/html2rss/html2rss-web/commit/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7">feat: use parallel processing for feed retrieval in health_check.rb (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2458394104" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/665" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/665/hovercard" href="https://github.com/html2rss/html2rss-web/pull/665">#665</a><a data-pjax="true" title="feat: use parallel processing for feed retrieval in health_check.rb (#665)" class="color-fg-default" href="/html2rss/html2rss-web/commit/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1etbtbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">4a24997</span></span></a></span><div><div aria-describedby=":R2etbtbd5rab:"><button aria-label="Copy full SHA for 4a24997" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-4a24997" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-4a24997" href="/html2rss/html2rss-web/tree/4a249979b2ac5caa5402e9d29ef6a09ae62b4ee7" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R1dtbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="fix: example feed in config/feeds.yml broken (#664)" class="color-fg-default" href="/html2rss/html2rss-web/commit/b9618974e7baea0fa24344b158f07dcec8175ed6">fix: example feed in config/feeds.yml broken (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2458371254" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/664" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/664/hovercard" href="https://github.com/html2rss/html2rss-web/pull/664">#664</a><a data-pjax="true" title="fix: example feed in config/feeds.yml broken (#664)" class="color-fg-default" href="/html2rss/html2rss-web/commit/b9618974e7baea0fa24344b158f07dcec8175ed6">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1etdtbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/b9618974e7baea0fa24344b158f07dcec8175ed6" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">b961897</span></span></a></span><div><div aria-describedby=":R2etdtbd5rab:"><button aria-label="Copy full SHA for b961897" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-b961897" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-b961897" href="/html2rss/html2rss-web/tree/b9618974e7baea0fa24344b158f07dcec8175ed6" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R1ftbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="fix: tzdata package not installed but required for tz conversion (#663)" class="color-fg-default" href="/html2rss/html2rss-web/commit/55814d2239463a71af9849ad8951142572316bc4">fix: tzdata package not installed but required for tz conversion (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2458364353" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/663" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/663/hovercard" href="https://github.com/html2rss/html2rss-web/pull/663">#663</a><a data-pjax="true" title="fix: tzdata package not installed but required for tz conversion (#663)" class="color-fg-default" href="/html2rss/html2rss-web/commit/55814d2239463a71af9849ad8951142572316bc4">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1etftbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/55814d2239463a71af9849ad8951142572316bc4" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">55814d2</span></span></a></span><div><div aria-describedby=":R2etftbd5rab:"><button aria-label="Copy full SHA for 55814d2" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-55814d2" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-55814d2" href="/html2rss/html2rss-web/tree/55814d2239463a71af9849ad8951142572316bc4" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R1htbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="perf: enable YJIT" class="color-fg-default" href="/html2rss/html2rss-web/commit/729f31f1b9160971a02a9ba855c880113534368e">perf: enable YJIT</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1ethtbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/729f31f1b9160971a02a9ba855c880113534368e" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">729f31f</span></span></a></span><div><div aria-describedby=":R2ethtbd5rab:"><button aria-label="Copy full SHA for 729f31f" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-729f31f" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-729f31f" href="/html2rss/html2rss-web/tree/729f31f1b9160971a02a9ba855c880113534368e" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R1jtbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(docker): update image (and with it ruby) to `3.3.4-alpine3.20`" class="color-fg-default" href="/html2rss/html2rss-web/commit/870936d5fe150916674a9a63ce8cc4bda5c4d4fb">chore(docker): update image (and with it ruby) to <code>3.3.4-alpine3.20</code></a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1etjtbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/870936d5fe150916674a9a63ce8cc4bda5c4d4fb" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">870936d</span></span></a></span><div><div aria-describedby=":R2etjtbd5rab:"><button aria-label="Copy full SHA for 870936d" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-870936d" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-870936d" href="/html2rss/html2rss-web/tree/870936d5fe150916674a9a63ce8cc4bda5c4d4fb" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bd5rab:-list-view-node-:R1ltbd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="feat(docker): use multilayer build to cut image size in half

Signed-off-by: Gil Desmarais &lt;git@desmarais.de&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/2f6e322c94776ccd33180061468e6ceaf31a73b4">feat(docker): use multilayer build to cut image size in half</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 2f6e322" id="show-description-2f6e322" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-2f6e322" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 kTrAEI" alt="gildesmarais" size="16" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=gildesmarais" aria-label="commits by gildesmarais" data-hovercard-url="/users/gildesmarais/hovercard">gildesmarais</a></div><span class="pl-1">committed</span><relative-time class="sc-aXZVg pl-1">Aug 9, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R1etltbd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/2f6e322c94776ccd33180061468e6ceaf31a73b4" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">2f6e322</span></span></a></span><div><div aria-describedby=":R2etltbd5rab:"><button aria-label="Copy full SHA for 2f6e322" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-2f6e322" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-2f6e322" href="/html2rss/html2rss-web/tree/2f6e322c94776ccd33180061468e6ceaf31a73b4" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R3l5rab:" data-testid="commit-group-title">Commits on Aug 2, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5bl5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R3l5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5bl5rab:-list-view-node-:Rbtbl5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#661)

Bumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss` from `d0a51a0` to `97d602a`
- [Release notes](https://github.com/html2rss/html2rss/releases)
- [Commits](https://github.com/html2rss/html2rss/compare/d0a51a0ca60264b9179b6982ce93b5100a4c6b4e...97d602ad42f4a3c1b11d810fb8924c29d19aee55)

Updates `html2rss-configs` from `8b2deab` to `07bbadc`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/8b2deab891846a0ef1e008c6d49bc19c97006ed9...07bbadcc2be501488a3772352ab0f8c7b05235a3)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/68dc0a48d6417ce034c5be3a69b52d75a8073ad1">chore(deps): bump the rubygems group with 2 updates (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2445841262" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/661" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/661/hovercard" href="https://github.com/html2rss/html2rss-web/pull/661">#661</a><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#661)

Bumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss` from `d0a51a0` to `97d602a`
- [Release notes](https://github.com/html2rss/html2rss/releases)
- [Commits](https://github.com/html2rss/html2rss/compare/d0a51a0ca60264b9179b6982ce93b5100a4c6b4e...97d602ad42f4a3c1b11d810fb8924c29d19aee55)

Updates `html2rss-configs` from `8b2deab` to `07bbadc`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/8b2deab891846a0ef1e008c6d49bc19c97006ed9...07bbadcc2be501488a3772352ab0f8c7b05235a3)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/68dc0a48d6417ce034c5be3a69b52d75a8073ad1">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 68dc0a4" id="show-description-68dc0a4" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-68dc0a4" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 2, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbnbtbl5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/68dc0a48d6417ce034c5be3a69b52d75a8073ad1" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">68dc0a4</span></span></a></span><div><div aria-describedby=":Rjnbtbl5rab:"><button aria-label="Copy full SHA for 68dc0a4" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-68dc0a4" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-68dc0a4" href="/html2rss/html2rss-web/tree/68dc0a48d6417ce034c5be3a69b52d75a8073ad1" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5bl5rab:-list-view-node-:Rdtbl5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump rexml from 3.3.2 to 3.3.3 (#660)

Bumps [rexml](https://github.com/ruby/rexml) from 3.3.2 to 3.3.3.
- [Release notes](https://github.com/ruby/rexml/releases)
- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)
- [Commits](https://github.com/ruby/rexml/compare/v3.3.2...v3.3.3)

---
updated-dependencies:
- dependency-name: rexml
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/727f7564cd86e9d5c60a3f5d04f496694cce3aae">chore(deps): bump rexml from 3.3.2 to 3.3.3 (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2443835056" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/660" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/660/hovercard" href="https://github.com/html2rss/html2rss-web/pull/660">#660</a><a data-pjax="true" title="chore(deps): bump rexml from 3.3.2 to 3.3.3 (#660)

Bumps [rexml](https://github.com/ruby/rexml) from 3.3.2 to 3.3.3.
- [Release notes](https://github.com/ruby/rexml/releases)
- [Changelog](https://github.com/ruby/rexml/blob/master/NEWS.md)
- [Commits](https://github.com/ruby/rexml/compare/v3.3.2...v3.3.3)

---
updated-dependencies:
- dependency-name: rexml
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/727f7564cd86e9d5c60a3f5d04f496694cce3aae">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 727f756" id="show-description-727f756" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-727f756" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Aug 2, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbndtbl5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/727f7564cd86e9d5c60a3f5d04f496694cce3aae" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">727f756</span></span></a></span><div><div aria-describedby=":Rjndtbl5rab:"><button aria-label="Copy full SHA for 727f756" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-727f756" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-727f756" href="/html2rss/html2rss-web/tree/727f7564cd86e9d5c60a3f5d04f496694cce3aae" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R3t5rab:" data-testid="commit-group-title">Commits on Jul 30, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5bt5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R3t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5bt5rab:-list-view-node-:R7tbt5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#659)

Bumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss` from `2c458a7` to `d0a51a0`
- [Release notes](https://github.com/html2rss/html2rss/releases)
- [Commits](https://github.com/html2rss/html2rss/compare/2c458a7606c2519a5fc75b58b1acca0cb4f1ace3...d0a51a0ca60264b9179b6982ce93b5100a4c6b4e)

Updates `html2rss-configs` from `8759c60` to `8b2deab`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/8759c607cc4bbe469f4294a200ee424dfa82ac48...8b2deab891846a0ef1e008c6d49bc19c97006ed9)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/4cad73b7d7ccaf826d1249f44586517131c97a64">chore(deps): bump the rubygems group with 2 updates (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2438627568" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/659" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/659/hovercard" href="https://github.com/html2rss/html2rss-web/pull/659">#659</a><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#659)

Bumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss` from `2c458a7` to `d0a51a0`
- [Release notes](https://github.com/html2rss/html2rss/releases)
- [Commits](https://github.com/html2rss/html2rss/compare/2c458a7606c2519a5fc75b58b1acca0cb4f1ace3...d0a51a0ca60264b9179b6982ce93b5100a4c6b4e)

Updates `html2rss-configs` from `8759c60` to `8b2deab`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/8759c607cc4bbe469f4294a200ee424dfa82ac48...8b2deab891846a0ef1e008c6d49bc19c97006ed9)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/4cad73b7d7ccaf826d1249f44586517131c97a64">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 4cad73b" id="show-description-4cad73b" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-4cad73b" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jul 30, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntbt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/4cad73b7d7ccaf826d1249f44586517131c97a64" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">4cad73b</span></span></a></span><div><div aria-describedby=":R9rntbt5rab:"><button aria-label="Copy full SHA for 4cad73b" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-4cad73b" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-4cad73b" href="/html2rss/html2rss-web/tree/4cad73b7d7ccaf826d1249f44586517131c97a64" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R455rab:" data-testid="commit-group-title">Commits on Jul 29, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5c55rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R455rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5c55rab:-list-view-node-:R7tc55rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#658)

Bumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss` from `aa99bd6` to `2c458a7`
- [Commits](https://github.com/html2rss/html2rss/compare/aa99bd68c7add7abd4f65d2e4b558ebe20227ee8...2c458a7606c2519a5fc75b58b1acca0cb4f1ace3)

Updates `html2rss-configs` from `f5da387` to `8759c60`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/f5da387390341a8bb5191e65740ad456c714b0b3...8759c607cc4bbe469f4294a200ee424dfa82ac48)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/5bd9e435564d3765544c7000bd26944014031461">chore(deps): bump the rubygems group with 2 updates (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2436506436" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/658" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/658/hovercard" href="https://github.com/html2rss/html2rss-web/pull/658">#658</a><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#658)

Bumps the rubygems group with 2 updates: [html2rss](https://github.com/html2rss/html2rss) and [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss` from `aa99bd6` to `2c458a7`
- [Commits](https://github.com/html2rss/html2rss/compare/aa99bd68c7add7abd4f65d2e4b558ebe20227ee8...2c458a7606c2519a5fc75b58b1acca0cb4f1ace3)

Updates `html2rss-configs` from `f5da387` to `8759c60`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/f5da387390341a8bb5191e65740ad456c714b0b3...8759c607cc4bbe469f4294a200ee424dfa82ac48)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/5bd9e435564d3765544c7000bd26944014031461">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 5bd9e43" id="show-description-5bd9e43" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-5bd9e43" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jul 29, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntc55rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/5bd9e435564d3765544c7000bd26944014031461" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">5bd9e43</span></span></a></span><div><div aria-describedby=":R9rntc55rab:"><button aria-label="Copy full SHA for 5bd9e43" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-5bd9e43" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-5bd9e43" href="/html2rss/html2rss-web/tree/5bd9e435564d3765544c7000bd26944014031461" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R4d5rab:" data-testid="commit-group-title">Commits on Jul 23, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5cd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R4d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5cd5rab:-list-view-node-:R7tcd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#657)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `2dc20ca` to `f5da387`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/2dc20caa69be420f6bb9f100271f10583b4f3c72...f5da387390341a8bb5191e65740ad456c714b0b3)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab">chore(deps): bump html2rss-configs in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2426217189" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/657" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/657/hovercard" href="https://github.com/html2rss/html2rss-web/pull/657">#657</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#657)

Bumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).


Updates `html2rss-configs` from `2dc20ca` to `f5da387`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/2dc20caa69be420f6bb9f100271f10583b4f3c72...f5da387390341a8bb5191e65740ad456c714b0b3)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 25a21ae" id="show-description-25a21ae" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-25a21ae" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jul 23, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntcd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">25a21ae</span></span></a></span><div><div aria-describedby=":R9rntcd5rab:"><button aria-label="Copy full SHA for 25a21ae" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-25a21ae" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-25a21ae" href="/html2rss/html2rss-web/tree/25a21ae0b63ff4a64b15bb81b4fb13fb8978ddab" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R4l5rab:" data-testid="commit-group-title">Commits on Jul 19, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5cl5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R4l5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5cl5rab:-list-view-node-:Rbtcl5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss in the rubygems group (#656)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).


Updates `html2rss` from `a21f089` to `aa99bd6`
- [Commits](https://github.com/html2rss/html2rss/compare/a21f0898c4a9b8359293ffef0ed8cb4beebeafa8...aa99bd68c7add7abd4f65d2e4b558ebe20227ee8)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4">chore(deps): bump html2rss in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2420048120" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/656" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/656/hovercard" href="https://github.com/html2rss/html2rss-web/pull/656">#656</a><a data-pjax="true" title="chore(deps): bump html2rss in the rubygems group (#656)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).


Updates `html2rss` from `a21f089` to `aa99bd6`
- [Commits](https://github.com/html2rss/html2rss/compare/a21f0898c4a9b8359293ffef0ed8cb4beebeafa8...aa99bd68c7add7abd4f65d2e4b558ebe20227ee8)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for b4627fe" id="show-description-b4627fe" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-b4627fe" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jul 19, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbnbtcl5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">b4627fe</span></span></a></span><div><div aria-describedby=":Rjnbtcl5rab:"><button aria-label="Copy full SHA for b4627fe" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-b4627fe" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-b4627fe" href="/html2rss/html2rss-web/tree/b4627fe9dd55c3d5099b9a4e682661098bf4dfb4" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li><li id=":R5cl5rab:-list-view-node-:Rdtcl5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump html2rss in the rubygems group (#655)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).


Updates `html2rss` from `d8f0e66` to `a21f089`
- [Commits](https://github.com/html2rss/html2rss/compare/d8f0e66108d6c63718628ad35004744c512c9b04...a21f0898c4a9b8359293ffef0ed8cb4beebeafa8)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/65df84038d36c01ccee385e73aa9659b23cbf756">chore(deps): bump html2rss in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2419312136" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/655" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/655/hovercard" href="https://github.com/html2rss/html2rss-web/pull/655">#655</a><a data-pjax="true" title="chore(deps): bump html2rss in the rubygems group (#655)

Bumps the rubygems group with 1 update: [html2rss](https://github.com/html2rss/html2rss).


Updates `html2rss` from `d8f0e66` to `a21f089`
- [Commits](https://github.com/html2rss/html2rss/compare/d8f0e66108d6c63718628ad35004744c512c9b04...a21f0898c4a9b8359293ffef0ed8cb4beebeafa8)

---
updated-dependencies:
- dependency-name: html2rss
  dependency-type: direct:production
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/65df84038d36c01ccee385e73aa9659b23cbf756">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 65df840" id="show-description-65df840" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-65df840" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jul 19, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":Rbndtcl5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/65df84038d36c01ccee385e73aa9659b23cbf756" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">65df840</span></span></a></span><div><div aria-describedby=":Rjndtcl5rab:"><button aria-label="Copy full SHA for 65df840" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-65df840" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-65df840" href="/html2rss/html2rss-web/tree/65df84038d36c01ccee385e73aa9659b23cbf756" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R4t5rab:" data-testid="commit-group-title">Commits on Jul 12, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5ct5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R4t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5ct5rab:-list-view-node-:R7tct5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (#654)

Bumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).


Updates `roda` from 3.81.0 to 3.82.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.81.0...3.82.0)

---
updated-dependencies:
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/006ed07532c7ad88c7ee070b8cc1a7f458cc0990">chore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2406407623" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/654" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/654/hovercard" href="https://github.com/html2rss/html2rss-web/pull/654">#654</a><a data-pjax="true" title="chore(deps): bump roda from 3.81.0 to 3.82.0 in the rubygems group (#654)

Bumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).


Updates `roda` from 3.81.0 to 3.82.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.81.0...3.82.0)

---
updated-dependencies:
- dependency-name: roda
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/006ed07532c7ad88c7ee070b8cc1a7f458cc0990">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 006ed07" id="show-description-006ed07" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-006ed07" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jul 12, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntct5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/006ed07532c7ad88c7ee070b8cc1a7f458cc0990" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">006ed07</span></span></a></span><div><div aria-describedby=":R9rntct5rab:"><button aria-label="Copy full SHA for 006ed07" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-006ed07" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-006ed07" href="/html2rss/html2rss-web/tree/006ed07532c7ad88c7ee070b8cc1a7f458cc0990" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R555rab:" data-testid="commit-group-title">Commits on Jun 27, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5d55rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R555rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5d55rab:-list-view-node-:R7td55rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (#653)

Bumps the rubygems group with 1 update: [tilt](https://github.com/jeremyevans/tilt).


Updates `tilt` from 2.3.0 to 2.4.0
- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)
- [Commits](https://github.com/jeremyevans/tilt/compare/v2.3.0...v2.4.0)

---
updated-dependencies:
- dependency-name: tilt
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/d11fda09d15f52eecb4108fe55e52202072617eb">chore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2379171054" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/653" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/653/hovercard" href="https://github.com/html2rss/html2rss-web/pull/653">#653</a><a data-pjax="true" title="chore(deps): bump tilt from 2.3.0 to 2.4.0 in the rubygems group (#653)

Bumps the rubygems group with 1 update: [tilt](https://github.com/jeremyevans/tilt).


Updates `tilt` from 2.3.0 to 2.4.0
- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)
- [Commits](https://github.com/jeremyevans/tilt/compare/v2.3.0...v2.4.0)

---
updated-dependencies:
- dependency-name: tilt
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/d11fda09d15f52eecb4108fe55e52202072617eb">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for d11fda0" id="show-description-d11fda0" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-d11fda0" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jun 27, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntd55rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/d11fda09d15f52eecb4108fe55e52202072617eb" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">d11fda0</span></span></a></span><div><div aria-describedby=":R9rntd55rab:"><button aria-label="Copy full SHA for d11fda0" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-d11fda0" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-d11fda0" href="/html2rss/html2rss-web/tree/d11fda09d15f52eecb4108fe55e52202072617eb" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div><div class="Timeline__TimelineItem-sc-1nkzbnu-1 kDdNwA Timeline-Item"><div class="Box-sc-g0xbh4-0 izArLR"><div display="flex" class="Box-sc-g0xbh4-0 bbNsBg TimelineItem-Badge" overflow="hidden" color="fg.muted" width="32px" height="32px"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M11.93 8.5a4.002 4.002 0 0 1-7.86 0H.75a.75.75 0 0 1 0-1.5h3.32a4.002 4.002 0 0 1 7.86 0h3.32a.75.75 0 0 1 0 1.5Zm-1.43-.75a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path></svg></div></div><div class="Timeline__TimelineBody-sc-1nkzbnu-2 eYvRDq mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R5d5rab:" data-testid="commit-group-title">Commits on Jun 13, 2024</h3><div class="color-bg-default position-relative border rounded-2 color-border-default mt-2 d-flex flex-column CommitGroup-module__panel--tvFMx"><div id=":R5dd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R5d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":R5dd5rab:-list-view-node-:R7tdd5rab:" role="listitem" class="Box-sc-g0xbh4-0 cdHayA ListItem-module__listItem--kHali" tabindex="-1" aria-label="More information available below." data-testid="commit-row-item"><div data-testid="list-view-item-title-container" class="Box-sc-g0xbh4-0 jJRiHe Title-module__container--l9xi7"><h4 class="Text__StyledText-sc-17v1xeu-0 ljLSiW markdown-title Title-module__heading--upUxW"><span class="Text__StyledText-sc-17v1xeu-0 hWqAbU TitleHeader-module__inline--rL27T Title-module__anchor--SyQM6 Title-module__markdown--KiFgL"><a data-pjax="true" title="chore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (#652)

Bumps the rubygems group with 1 update: [erubi](https://github.com/jeremyevans/erubi).


Updates `erubi` from 1.12.0 to 1.13.0
- [Changelog](https://github.com/jeremyevans/erubi/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/erubi/compare/1.12.0...1.13.0)

---
updated-dependencies:
- dependency-name: erubi
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/36a9a59468a8f3db5ddee6c2c585609761754119">chore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2352141017" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/652" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/652/hovercard" href="https://github.com/html2rss/html2rss-web/pull/652">#652</a><a data-pjax="true" title="chore(deps): bump erubi from 1.12.0 to 1.13.0 in the rubygems group (#652)

Bumps the rubygems group with 1 update: [erubi](https://github.com/jeremyevans/erubi).


Updates `erubi` from 1.12.0 to 1.13.0
- [Changelog](https://github.com/jeremyevans/erubi/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/erubi/compare/1.12.0...1.13.0)

---
updated-dependencies:
- dependency-name: erubi
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: rubygems
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;
Co-authored-by: dependabot[bot] &lt;49699333+dependabot[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/36a9a59468a8f3db5ddee6c2c585609761754119">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><span role="tooltip" aria-label="Show description for 36a9a59" id="show-description-36a9a59" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn ml-1 tooltipped-se"><button class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-show-description-button" aria-labelledby="show-description-36a9a59" aria-pressed="false" aria-expanded="false"><svg aria-hidden="true" focusable="false" class="octicon octicon-ellipsis" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 5.75C0 4.784.784 4 1.75 4h12.5c.966 0 1.75.784 1.75 1.75v4.5A1.75 1.75 0 0 1 14.25 12H1.75A1.75 1.75 0 0 1 0 10.25ZM12 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2ZM7 8a1 1 0 1 0 2 0 1 1 0 0 0-2 0ZM4 7a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"></path></svg></button></span></div><div class="px-1"></div><div data-testid="list-view-item-main-content" class="MainContent-module__container--ry4iL"><div class="MainContent-module__inner--bU_tk"><div data-testid="list-view-item-description" class="Box-sc-g0xbh4-0 Description-module__container--b3n6F"><div class="Box-sc-g0xbh4-0 dpBUfI"><div data-testid="author-avatar" class="Box-sc-g0xbh4-0 hKWjvQ"><a class="Link__StyledLink-sc-14289xe-0 dIlPa" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Avatar__StyledAvatar-sc-2lv0r8-0 ezaPfa" alt="dependabot[bot]" size="16" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]" height="16" width="16"/></a><a class="Link__StyledLink-sc-14289xe-0 hxWjGz" muted="" href="/html2rss/html2rss-web/commits?author=dependabot%5Bbot%5D" aria-label="commits by dependabot[bot]" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard">dependabot[bot]</a></div><span class="pl-1">authored</span><relative-time class="sc-aXZVg pl-1">Jun 13, 2024</relative-time><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 fIQuDd irOdmh d-none d-sm-flex ml-2" width="20px"></div><div class="d-none d-sm-flex"></div></div></div></div></div><div class="Box-sc-g0xbh4-0 MetadataContainer-module__container--lj6YE" data-testid="list-view-item-metadata"><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 EDqVA Metadata-module__metadata--yvrod Metadata-module__secondary--zMgLx"><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 dNbsEP ihfxfT d-none d-sm-flex" width="62px"></div></div><div data-testid="list-view-item-metadata-item" class="Box-sc-g0xbh4-0 Metadata-module__metadata--yvrod Metadata-module__primary--cJgJU d-none d-sm-flex px-0 gap-2"><div class="d-flex"><span role="tooltip" aria-label="View commit details" id=":R5rntdd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/36a9a59468a8f3db5ddee6c2c585609761754119" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">36a9a59</span></span></a></span><div><div aria-describedby=":R9rntdd5rab:"><button aria-label="Copy full SHA for 36a9a59" tabindex="0" class="Button Button--iconOnly Button--invisible Button--small "><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path></svg></button></div></div></div><span role="tooltip" aria-label="Browse repository at this point" id="browse-repo-36a9a59" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-36a9a59" href="/html2rss/html2rss-web/tree/36a9a59468a8f3db5ddee6c2c585609761754119" class="Button Button--iconOnly Button--invisible Button--small" data-testid="commit-row-browse-repo"><svg aria-hidden="true" focusable="false" class="octicon octicon-code" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg></a></span></div></div><!--$!--><template></template><!--/$--></li></ul></div></div></div></div></div></div><h2 class="sr-only prc-Heading-Heading-6CmGO">Pagination</h2><div class="d-flex flex-justify-center mt-2"><div class="ButtonGroup__StyledButtonGroup-sc-1gxhls1-0 lirRhW"><a sx="[object Object]" aria-disabled="true" style="--button-color:primer.fg.disabled" type="button" tabindex="0" data-testid="pagination-prev-button" class="types__StyledButton-sc-ws60qy-0 dXUvFs fgColor-accent text-normal" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":R39rab:-loading-announcement" href="/html2rss/html2rss-web/commits/master?before=8eeb9e69a1c57f3c61ca00469083604e25066859+0"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="text">Previous</span></span></a><a sx="[object Object]" type="button" tabindex="0" data-testid="pagination-next-button" class="types__StyledButton-sc-ws60qy-0 dPmZyJ fgColor-accent text-normal" data-loading="false" data-size="medium" aria-describedby=":R59rab:-loading-announcement" href="/html2rss/html2rss-web/commits/master?after=8eeb9e69a1c57f3c61ca00469083604e25066859+34"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="text">Next</span><span data-component="trailingVisual" class="Box-sc-g0xbh4-0 hzSPyu"><svg aria-hidden="true" focusable="false" class="Octicon-sc-9kayk9-0 fgColor-accent" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" style="display:inline-block;user-select:none;vertical-align:text-bottom;overflow:visible"><path d="M6.22 3.22a.75.75 0 0 1 1.06 0l4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L9.94 8 6.22 4.28a.75.75 0 0 1 0-1.06Z"></path></svg></span></span></a></div></div></div></div><div class="Box-sc-g0xbh4-0"></div></div></div></div></div> <!-- --> <script type="application/json" id="__PRIMER_DATA_:R0:__">{"resolvedServerColorMode":"day"}</script></div>
</react-app>




  </div>

</turbo-frame>

    </main>
  </div>

  </div>

          <footer class="footer pt-8 pb-6 f6 color-fg-muted p-responsive" role="contentinfo" >
  <h2 class='sr-only'>Footer</h2>

  


  <div class="d-flex flex-justify-center flex-items-center flex-column-reverse flex-lg-row flex-wrap flex-lg-nowrap">
    <div class="d-flex flex-items-center flex-shrink-0 mx-2">
      <a aria-label="Homepage" title="GitHub" class="footer-octicon mr-2" href="https://github.com">
        <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-mark-github">
    <path d="M12.5.75C6.146.75 1 5.896 1 12.25c0 5.089 3.292 9.387 7.863 10.91.575.101.79-.244.79-.546 0-.273-.014-1.178-.014-2.142-2.889.532-3.636-.704-3.866-1.35-.13-.331-.69-1.352-1.18-1.625-.402-.216-.977-.748-.014-.762.906-.014 1.553.834 1.769 1.179 1.035 1.74 2.688 1.25 3.349.948.1-.747.402-1.25.733-1.538-2.559-.287-5.232-1.279-5.232-5.678 0-1.25.445-2.285 1.178-3.09-.115-.288-.517-1.467.115-3.048 0 0 .963-.302 3.163 1.179.92-.259 1.897-.388 2.875-.388.977 0 1.955.13 2.875.388 2.2-1.495 3.162-1.179 3.162-1.179.633 1.581.23 2.76.115 3.048.733.805 1.179 1.825 1.179 3.09 0 4.413-2.688 5.39-5.247 5.678.417.36.776 1.05.776 2.128 0 1.538-.014 2.774-.014 3.162 0 .302.216.662.79.547C20.709 21.637 24 17.324 24 12.25 24 5.896 18.854.75 12.5.75Z"></path>
</svg>
</a>
      <span>
        &copy; 2024 GitHub,&nbsp;Inc.
      </span>
    </div>

    <nav aria-label="Footer">
      <h3 class="sr-only" id="sr-footer-heading">Footer navigation</h3>

      <ul class="list-style-none d-flex flex-justify-center flex-wrap mb-2 mb-lg-0" aria-labelledby="sr-footer-heading">

          <li class="mx-2">
            <a data-analytics-event="{&quot;category&quot;:&quot;Footer&quot;,&quot;action&quot;:&quot;go to Terms&quot;,&quot;label&quot;:&quot;text:terms&quot;}" href="https://docs.github.com/site-policy/github-terms/github-terms-of-service" data-view-component="true" class="Link--secondary Link">Terms</a>
          </li>

          <li class="mx-2">
            <a data-analytics-event="{&quot;category&quot;:&quot;Footer&quot;,&quot;action&quot;:&quot;go to privacy&quot;,&quot;label&quot;:&quot;text:privacy&quot;}" href="https://docs.github.com/site-policy/privacy-policies/github-privacy-statement" data-view-component="true" class="Link--secondary Link">Privacy</a>
          </li>

          <li class="mx-2">
            <a data-analytics-event="{&quot;category&quot;:&quot;Footer&quot;,&quot;action&quot;:&quot;go to security&quot;,&quot;label&quot;:&quot;text:security&quot;}" href="https://github.com/security" data-view-component="true" class="Link--secondary Link">Security</a>
          </li>

          <li class="mx-2">
            <a data-analytics-event="{&quot;category&quot;:&quot;Footer&quot;,&quot;action&quot;:&quot;go to status&quot;,&quot;label&quot;:&quot;text:status&quot;}" href="https://www.githubstatus.com/" data-view-component="true" class="Link--secondary Link">Status</a>
          </li>

          <li class="mx-2">
            <a data-analytics-event="{&quot;category&quot;:&quot;Footer&quot;,&quot;action&quot;:&quot;go to docs&quot;,&quot;label&quot;:&quot;text:docs&quot;}" href="https://docs.github.com/" data-view-component="true" class="Link--secondary Link">Docs</a>
          </li>

          <li class="mx-2">
            <a data-analytics-event="{&quot;category&quot;:&quot;Footer&quot;,&quot;action&quot;:&quot;go to contact&quot;,&quot;label&quot;:&quot;text:contact&quot;}" href="https://support.github.com?tags=dotcom-footer" data-view-component="true" class="Link--secondary Link">Contact</a>
          </li>

          <li class="mr-3" >
  <cookie-consent-link>
    <button
      type="button"
      class="Link--secondary underline-on-hover border-0 p-0 color-bg-transparent"
      data-action="click:cookie-consent-link#showConsentManagement"
      data-analytics-event="{&quot;location&quot;:&quot;footer&quot;,&quot;action&quot;:&quot;cookies&quot;,&quot;context&quot;:&quot;subfooter&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;cookies_link_subfooter_footer&quot;}"
    >
      Manage cookies
    </button>
  </cookie-consent-link>
</li>

<li class="mr-3">
  <cookie-consent-link>
    <button
      type="button"
      class="Link--secondary underline-on-hover border-0 p-0 color-bg-transparent"
      data-action="click:cookie-consent-link#showConsentManagement"
      data-analytics-event="{&quot;location&quot;:&quot;footer&quot;,&quot;action&quot;:&quot;dont_share_info&quot;,&quot;context&quot;:&quot;subfooter&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;dont_share_info_link_subfooter_footer&quot;}"
    >
      Do not share my personal information
    </button>
  </cookie-consent-link>
</li>

      </ul>
    </nav>
  </div>
</footer>




    <ghcc-consent id="ghcc" class="position-fixed bottom-0 left-0" style="z-index: 999999" data-initial-cookie-consent-allowed="" data-cookie-consent-required="true"></ghcc-consent>


  <div id="ajax-error-message" class="ajax-error-message flash flash-error" hidden>
    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-alert">
    <path d="M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path>
</svg>
    <button type="button" class="flash-close js-ajax-error-dismiss" aria-label="Dismiss error">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x">
    <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path>
</svg>
    </button>
    You can’t perform that action at this time.
  </div>

    <template id="site-details-dialog">
  <details class="details-reset details-overlay details-overlay-dark lh-default color-fg-default hx_rsm" open>
    <summary role="button" aria-label="Close dialog"></summary>
    <details-dialog class="Box Box--overlay d-flex flex-column anim-fade-in fast hx_rsm-dialog hx_rsm-modal">
      <button class="Box-btn-octicon m-0 btn-octicon position-absolute right-0 top-0" type="button" aria-label="Close dialog" data-close-dialog>
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x">
    <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path>
</svg>
      </button>
      <div class="octocat-spinner my-6 js-details-dialog-spinner"></div>
    </details-dialog>
  </details>
</template>

    <div class="Popover js-hovercard-content position-absolute" style="display: none; outline: none;">
  <div class="Popover-message Popover-message--bottom-left Popover-message--large Box color-shadow-large" style="width:360px;">
  </div>
</div>

    <template id="snippet-clipboard-copy-button">
  <div class="zeroclipboard-container position-absolute right-0 top-0">
    <clipboard-copy aria-label="Copy" class="ClipboardButton btn js-clipboard-copy m-2 p-0" data-copy-feedback="Copied!" data-tooltip-direction="w">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon m-2">
    <path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>
</svg>
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-check js-clipboard-check-icon color-fg-success d-none m-2">
    <path d="M13.78 4.22a.75.75 0 0 1 0 1.06l-7.25 7.25a.75.75 0 0 1-1.06 0L2.22 9.28a.751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018L6 10.94l6.72-6.72a.75.75 0 0 1 1.06 0Z"></path>
</svg>
    </clipboard-copy>
  </div>
</template>
<template id="snippet-clipboard-copy-button-unpositioned">
  <div class="zeroclipboard-container">
    <clipboard-copy aria-label="Copy" class="ClipboardButton btn btn-invisible js-clipboard-copy m-2 p-0 d-flex flex-justify-center flex-items-center" data-copy-feedback="Copied!" data-tooltip-direction="w">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
    <path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>
</svg>
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-check js-clipboard-check-icon color-fg-success d-none">
    <path d="M13.78 4.22a.75.75 0 0 1 0 1.06l-7.25 7.25a.75.75 0 0 1-1.06 0L2.22 9.28a.751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018L6 10.94l6.72-6.72a.75.75 0 0 1 1.06 0Z"></path>
</svg>
    </clipboard-copy>
  </div>
</template>




    </div>

    <div id="js-global-screen-reader-notice" class="sr-only mt-n1" aria-live="polite" aria-atomic="true" ></div>
    <div id="js-global-screen-reader-notice-assertive" class="sr-only mt-n1" aria-live="assertive" aria-atomic="true"></div>
  </body>
</html>


+  recorded_at: Sun, 20 Oct 2024 16:33:57 GMT
+recorded_with: VCR 6.2.0
diff --git a/spec/html2rss/web/app_spec.rb b/spec/html2rss/web/app_spec.rb
index 08b3efc2..a7d93713 100644
--- a/spec/html2rss/web/app_spec.rb
+++ b/spec/html2rss/web/app_spec.rb
@@ -6,4 +6,49 @@
 
 RSpec.describe Html2rss::Web::App do
   it { expect(described_class).to be < Roda }
+
+  context 'with Rack::Test' do
+    include Rack::Test::Methods
+
+    def app = described_class
+
+    it 'responds to /' do
+      get '/'
+      expect(last_response).to be_ok
+    end
+
+    it 'sets CSP headers' do # rubocop:disable RSpec/ExampleLength
+      get '/'
+
+      expect(last_response.headers['Content-Security-Policy']).to eq <<~HEADERS.gsub(/\n\s*/, ' ')
+        default-src 'none';
+        style-src 'self';
+        script-src 'self';
+        connect-src 'self';
+        img-src 'self';
+        font-src 'self' data:;
+        form-action 'self';
+        base-uri 'none';
+        frame-ancestors 'self';
+        frame-src 'self';
+        block-all-mixed-content;
+      HEADERS
+    end
+  end
+
+  describe '.development?' do
+    subject { described_class.development? }
+
+    context 'when RACK_ENV is development' do
+      before { ENV['RACK_ENV'] = 'development' }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when RACK_ENV is not development' do
+      before { ENV['RACK_ENV'] = 'test' }
+
+      it { is_expected.to be false }
+    end
+  end
 end
diff --git a/spec/html2rss/web/helpers/auto_source_spec.rb b/spec/html2rss/web/helpers/auto_source_spec.rb
new file mode 100644
index 00000000..b290ec83
--- /dev/null
+++ b/spec/html2rss/web/helpers/auto_source_spec.rb
@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rss'
+require 'roda'
+require 'base64'
+require_relative '../../../../helpers/auto_source'
+
+describe Html2rss::Web::AutoSource do # rubocop:disable RSpec/SpecFilePathFormat
+  context 'when ENV variables are not set' do
+    describe '.enabled?' do
+      subject { described_class.enabled? }
+
+      it { is_expected.to be false }
+    end
+
+    describe '.username' do
+      it 'raises an error' do
+        expect { described_class.username }.to raise_error(KeyError)
+      end
+    end
+
+    describe '.password' do
+      it 'raises an error' do
+        expect { described_class.password }.to raise_error(KeyError)
+      end
+    end
+
+    describe '.allowed_origins' do
+      subject { described_class.allowed_origins }
+
+      it { is_expected.to eq Set[] }
+    end
+  end
+
+  context 'when ENV variables are set' do
+    around do |example|
+      ClimateControl.modify AUTO_SOURCE_ENABLED: 'true',
+                            AUTO_SOURCE_USERNAME: 'foo',
+                            AUTO_SOURCE_PASSWORD: 'bar',
+                            AUTO_SOURCE_ALLOWED_ORIGINS: 'localhost,example.com, ' do
+        example.run
+      end
+    end
+
+    describe '.username' do
+      subject { described_class.username }
+
+      it { is_expected.to eq 'foo' }
+    end
+
+    describe '.password' do
+      subject { described_class.password }
+
+      it { is_expected.to eq 'bar' }
+    end
+
+    describe '.allowed_origins' do
+      subject { described_class.allowed_origins }
+
+      it { is_expected.to eq Set['localhost', 'example.com'] }
+    end
+  end
+
+  describe '.ttl_in_seconds' do
+    subject { described_class.ttl_in_seconds(rss, default_in_minutes: 60) }
+
+    context 'when rss.channel.ttl is present' do
+      let(:rss) do
+        instance_double(RSS::Rss, channel: instance_double(RSS::Rss::Channel, ttl: 2))
+      end
+
+      it { is_expected.to eq 120 }
+    end
+
+    context 'when rss.channel.ttl is not present' do
+      let(:rss) do
+        nil
+      end
+
+      it { is_expected.to eq 3600 }
+    end
+  end
+
+  # rubocop:disable RSpec/NamedSubject, RSpec/MessageSpies
+  describe '.check_request_origin!' do
+    subject { described_class.check_request_origin!(request, response, allowed_origins) }
+
+    let(:request) { instance_double(Roda::RodaRequest, env: { 'HTTP_HOST' => 'localhost' }, halt: nil) }
+    let(:response) { instance_double(Roda::RodaResponse, write: nil, 'status=': nil) }
+    let(:allowed_origins) { Set['localhost'] }
+
+    context 'when origin is allowed' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'when allowed_origins is empty' do
+      let(:allowed_origins) { Set[] }
+
+      it 'writes a message to the response' do
+        message = 'No allowed origins are configured. Please set AUTO_SOURCE_ALLOWED_ORIGINS.'
+        expect(response).to receive(:write).with(message)
+        subject
+      end
+    end
+
+    context 'when origin is not allowed' do
+      let(:request) { instance_double(Roda::RodaRequest, env: { 'HTTP_HOST' => 'example.com' }, halt: nil) }
+
+      it 'writes a message to the response' do
+        expect(response).to receive(:write).with('Origin is not allowed.')
+        subject
+      end
+
+      it 'sets the response status to 403' do
+        expect(response).to receive(:status=).with(403)
+        subject
+      end
+
+      it 'halts the request' do
+        expect(request).to receive(:halt)
+        subject
+      end
+    end
+
+    context 'when origin is not allowed and X-Forwarded-Host is set' do
+      let(:request) { instance_double(Roda::RodaRequest, env: { 'HTTP_X_FORWARDED_HOST' => 'example.com' }, halt: nil) }
+
+      it 'writes a message to the response' do
+        expect(response).to receive(:write).with('Origin is not allowed.')
+        subject
+      end
+    end
+
+    context 'when origin is not allowed and both HTTP_HOST and X-Forwarded-Host are set' do
+      let(:request) do
+        instance_double(Roda::RodaRequest,
+                        env: { 'HTTP_HOST' => 'proxy.example.com',
+                               'HTTP_X_FORWARDED_HOST' => 'example.com' },
+                        halt: nil)
+      end
+
+      it 'writes a message to the response' do
+        expect(response).to receive(:write).with('Origin is not allowed.')
+        subject
+      end
+    end
+  end
+  # rubocop:enable RSpec/NamedSubject, RSpec/MessageSpies
+
+  describe '.build_auto_source_from_encoded_url' do
+    subject(:feed) do
+      VCR.use_cassette('auto_source-github-h2r-web', match_requests_on: %i[method path]) do
+        described_class.build_auto_source_from_encoded_url(encoded_url)
+      end
+    end
+
+    let(:encoded_url) { Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web/commits/master') }
+
+    it 'returns an RSS::Rss object' do
+      expect(feed).to be_a(RSS::Rss)
+    end
+  end
+end
diff --git a/spec/routes/auto_source_spec.rb b/spec/routes/auto_source_spec.rb
new file mode 100644
index 00000000..4b4a01bc
--- /dev/null
+++ b/spec/routes/auto_source_spec.rb
@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rss'
+require_relative '../../app'
+
+describe Html2rss::Web::App do # rubocop:disable RSpec/SpecFilePathFormat
+  include Rack::Test::Methods
+  def app = described_class
+
+  let(:request_headers) do
+    { 'HTTP_HOST' => 'localhost' }
+  end
+
+  let(:username) { 'username' }
+  let(:password) { 'password' }
+
+  let(:feed) do
+    RSS::Maker.make('2.0') do |maker|
+      maker.channel.title = 'title'
+      maker.channel.link = 'link'
+      maker.channel.description = 'description'
+    end
+  end
+
+  before do
+    allow(Html2rss::Web::AutoSource).to receive_messages(enabled?: true,
+                                                         username:,
+                                                         password:,
+                                                         allowed_origins: Set['localhost'],
+                                                         build_auto_source_from_encoded_url: feed)
+  end
+
+  describe "GET '/auto_source/'" do
+    context 'without provided basic auth' do
+      it 'sets header "www-authenticate" in response', :aggregate_failures do
+        get '/auto_source/', {}, request_headers
+
+        expect(last_response.has_header?('www-authenticate')).to be true
+        expect(last_response).to be_unauthorized
+      end
+    end
+
+    context 'with provided basic auth' do
+      it 'responds successfully to /auto_source/', :aggregate_failures do
+        get '/auto_source/', {},
+            request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password))
+
+        expect(last_response).to be_ok
+        expect(last_response.body).to include('Automatically sources') &
+                                      include('<iframe loading="lazy"></iframe>')
+      end
+    end
+
+    context 'when request origin is not allowed' do
+      it 'responds with 403 Forbidden' do
+        get '/auto_source/', {},
+            request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password),
+                                  'HTTP_HOST' => 'http://example.com')
+
+        expect(last_response).to be_forbidden
+      end
+    end
+  end
+
+  describe "GET '/auto_source/:encoded_url'" do
+    context 'with provided basic auth' do
+      subject(:response) do
+        get "/auto_source/#{Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web')}",
+            {},
+            request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password))
+      end
+
+      it 'responds successfully', :aggregate_failures do
+        expect(response).to be_ok
+        expect(response.body).to start_with '<?xml version="1.0" encoding="UTF-8"?>'
+        expect(response.get_header('cache-control')).to eq 'must-revalidate, private, max-age=3600'
+        expect(response.get_header('content-type')).to eq described_class::CONTENT_TYPE_RSS
+      end
+    end
+  end
+
+  context 'when auto_source feature is disabled' do
+    before do
+      allow(Html2rss::Web::AutoSource).to receive(:enabled?).and_return(false)
+    end
+
+    describe "GET '/auto_source/'" do
+      it 'responds with 400 Bad Request' do
+        get '/auto_source/', {},
+            request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password))
+
+        expect(last_response).to be_bad_request
+      end
+    end
+
+    describe "GET '/auto_source/:encoded_url'" do
+      it 'responds with 400 Bad Request', :aggregate_failures do
+        get "/auto_source/#{Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web')}",
+            {},
+            request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password))
+
+        expect(last_response).to be_bad_request
+        expect(last_response.body).to eq 'The auto source feature is disabled.'
+      end
+    end
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 36e91dc0..a3b03157 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -5,15 +5,20 @@
 
   SimpleCov.start do
     add_filter '/spec/'
+    add_filter '/config/'
+
     track_files '**/*.rb'
   end
 end
 
+require_relative 'support/climate_control'
+
+require 'rack/test'
 require 'vcr'
 
 VCR.configure do |config|
   config.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
-  config.hook_into :faraday
+  config.hook_into :faraday, :webmock
 end
 
 # This file was generated by the `rspec --init` command. Conventionally, all
@@ -113,4 +118,6 @@
   #   # test failures related to randomization by passing the same `--seed` value
   #   # as the one that triggered the failure.
   #   Kernel.srand config.seed
+
+  config.include(EnvHelper)
 end
diff --git a/spec/support/climate_control.rb b/spec/support/climate_control.rb
new file mode 100644
index 00000000..998e05a6
--- /dev/null
+++ b/spec/support/climate_control.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'climate_control'
+
+module EnvHelper
+  def with_modified_env(options, &)
+    ClimateControl.modify(options, &)
+  end
+end
diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
new file mode 100644
index 00000000..3bc2955a
--- /dev/null
+++ b/views/auto_source/index.erb
@@ -0,0 +1,61 @@
+<% content_for :css do %>
+<link href="/auto_source.css" rel="stylesheet"/>
+<% end %>
+
+<% content_for :scripts do %>
+<script src="/auto_source.js" defer></script>
+<% end %>
+
+<section class="auto_source">
+  <h1>Auto Source</h1>
+  <p>
+    Automatically sources an RSS feed from a website.
+  </p>
+
+  <form>
+    <input
+      id="url"
+      type="url"
+      placeholder="https://"
+      pattern="http[s]://(?!.*@).*"
+      autocomplete="on"
+      token-list="url"
+      autofocus
+      required>
+    <input type="submit" value="Generate">
+  </form>
+
+  <label>
+    <img src="/feed.svg" height="16" width="16" alt="the orange RSS icon" role="presentation"/>
+      Feed URL
+      <input type="url" id="rss_url" readonly>
+  </label>
+
+  <nav>
+    <button id="resetCredentials" class="muted">Remove credentials</button>
+    <button id="copy">Copy URL</button>
+    <button id="goto">Open</button>
+    <button id="openInFeed">Subscribe</button>
+  </nav>
+
+  <iframe loading="lazy"></iframe>
+</section>
+
+<aside>
+  <h2>Utilities</h2>
+  <p>
+    Several utilities exist to make the Auto Source feature easier to use.
+  </p>
+  <article>
+    <h3>Bookmarklet</h3>
+
+    <p>
+      Drag this link to your bookmarks and click it on any page:
+      <a id="bookmarklet" class="auto_source__bookmarklet" href="#">Html2Rss</a>
+    </p>
+  </article>
+</aside>
+
+<nav>
+  <a href="/">‹ Back to Home</a>
+</nav>
diff --git a/views/layout.erb b/views/layout.erb
index bdaef979..f5d2a77c 100644
--- a/views/layout.erb
+++ b/views/layout.erb
@@ -9,6 +9,7 @@
     <title>html2rss-web<% if @page_title %> - <%= @page_title %><% end %></title>
     <link href="/water.css" rel="stylesheet"/>
     <link href="/styles.css" rel="stylesheet"/>
+    <%== content_for :css %>
   </head>
   <body>
     <aside class="aside-icon">
@@ -18,5 +19,6 @@
     </aside>
 
     <%== yield %>
+    <%== content_for :scripts %>
   </body>
 </html>