From 6ea001417544ab71e484cf38191aed3671ce6dfd Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sat, 17 Aug 2024 15:18:18 +0200
Subject: [PATCH 01/25] feat: add development? env check

---
 app.rb                                         | 7 +------
 helpers/{error_handlers.rb => handle_error.rb} | 4 +++-
 2 files changed, 4 insertions(+), 7 deletions(-)
 rename helpers/{error_handlers.rb => handle_error.rb} (93%)

diff --git a/app.rb b/app.rb
index 37976e93..bbd46412 100644
--- a/app.rb
+++ b/app.rb
@@ -12,12 +12,7 @@ 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
-
-      def development? = self.class.development?
+      def self.development? = ENV['RACK_ENV'] == 'development'
 
       opts[:check_dynamic_arity] = false
       opts[:check_arity] = :warn
diff --git a/helpers/error_handlers.rb b/helpers/handle_error.rb
similarity index 93%
rename from helpers/error_handlers.rb
rename to helpers/handle_error.rb
index e5f93236..6571abe9 100644
--- a/helpers/error_handlers.rb
+++ b/helpers/handle_error.rb
@@ -19,11 +19,13 @@ def handle_error(error) # rubocop:disable Metrics/MethodLength
           set_error_response('Internal Server Error', 500)
         end
 
-        @show_backtrace = ENV.fetch('RACK_ENV', nil) == 'development'
+        @show_backtrace = self.class.development?
         @error = error
         view 'error'
       end
 
+      private
+
       def set_error_response(page_title, status)
         @page_title = page_title
         response.status = status

From 1ffeb5054c6d383f658dd1ad76627a4743dced78 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sat, 17 Aug 2024 15:59:13 +0200
Subject: [PATCH 02/25] feat: expose endpoint which calls H2r.auto_source

---
 Gemfile                 |  1 +
 Gemfile.lock            |  2 ++
 README.md               |  4 ++++
 helpers/handle_error.rb |  2 ++
 routes/auto_source.rb   | 43 +++++++++++++++++++++++++++++++++++++++++
 5 files changed, 52 insertions(+)
 create mode 100644 routes/auto_source.rb

diff --git a/Gemfile b/Gemfile
index 87c56a70..ff80ee1d 100644
--- a/Gemfile
+++ b/Gemfile
@@ -11,6 +11,7 @@ gem 'html2rss-configs', github: 'html2rss/html2rss-configs'
 # gem 'html2rss', path: '../html2rss'
 # gem 'html2rss-configs', path: '../html2rss-configs'
 
+gem 'base64'
 gem 'erubi'
 gem 'parallel'
 gem 'rack-cache'
diff --git a/Gemfile.lock b/Gemfile.lock
index 46bfddc5..4d4344a1 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -11,6 +11,7 @@ GEM
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.2)
+    base64 (0.2.0)
     byebug (11.1.3)
     concurrent-ruby (1.3.4)
     crass (1.0.6)
@@ -151,6 +152,7 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  base64
   byebug
   erubi
   html2rss
diff --git a/README.md b/README.md
index d30ae229..a8c10c82 100644
--- a/README.md
+++ b/README.md
@@ -66,6 +66,10 @@ 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
+
+1. add `FEATURE_AUTO_SOURCE_ENABLED=true` to your `docker-compose.yml` file
+
 ## 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)
diff --git a/helpers/handle_error.rb b/helpers/handle_error.rb
index 6571abe9..f9ccd37c 100644
--- a/helpers/handle_error.rb
+++ b/helpers/handle_error.rb
@@ -15,6 +15,8 @@ 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
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
new file mode 100644
index 00000000..5017182e
--- /dev/null
+++ b/routes/auto_source.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Html2rss
+  module Web
+    class App
+      if ENV['AUTO_SOURCE_ENABLED'].to_s == 'true'
+        hash_branch 'auto_source' do |r|
+          with_basic_auth(realm: 'Auto Source',
+                          username: ENV.fetch('AUTO_SOURCE_USERNAME'),
+                          password: ENV.fetch('AUTO_SOURCE_PASSWORD')) do
+            r.get 'test' do |_r|
+              'AUTO'
+            end
+
+            r.on String, method: :get do |encoded_url|
+              url = Base64.urlsafe_decode64(encoded_url)
+
+              rss = Html2rss.auto_source(url)
+              ttl = (rss.channel.ttl || 60) * 60
+
+              HttpCache.expires(response, ttl, cache_control: 'private, max-age=0, must-revalidate')
+
+              response['Content-Type'] = 'application/rss+xml'
+
+              rss.to_s
+            end
+          end
+        end
+
+      else
+        # auto_source feature is disabled
+        hash_branch 'auto_source' do |r|
+          r.on do
+            response.status = 403
+            'The auto source feature is disabled.'
+          end
+        end
+      end
+    end
+  end
+end

From 24734c7368396feea1d81cbb9a684aa36243e5ca Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sat, 17 Aug 2024 17:10:31 +0200
Subject: [PATCH 03/25] feat: use ssrf_filter to request user provided urls

---
 Gemfile               |  1 +
 Gemfile.lock          |  5 ++++-
 routes/auto_source.rb | 16 ++++++++--------
 3 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/Gemfile b/Gemfile
index ff80ee1d..07be6e75 100644
--- a/Gemfile
+++ b/Gemfile
@@ -18,6 +18,7 @@ gem 'rack-cache'
 gem 'rack-timeout'
 gem 'rack-unreloader'
 gem 'roda'
+gem 'ssrf_filter'
 gem 'tilt'
 
 gem 'puma', require: false
diff --git a/Gemfile.lock b/Gemfile.lock
index 4d4344a1..83fc97a5 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -133,7 +133,9 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    thor (1.3.2)
+    ssrf_filter (1.1.2)
+    strscan (3.1.0)
+    thor (1.3.1)
     tilt (2.4.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
@@ -171,6 +173,7 @@ DEPENDENCIES
   rubocop-rspec
   rubocop-thread_safety
   simplecov
+  ssrf_filter
   tilt
   vcr
   yard
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
index 5017182e..17e1ee83 100644
--- a/routes/auto_source.rb
+++ b/routes/auto_source.rb
@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'addressable'
 require 'base64'
+require 'ssrf_filter'
+require 'html2rss'
 
 module Html2rss
   module Web
@@ -10,17 +13,14 @@ class App
           with_basic_auth(realm: 'Auto Source',
                           username: ENV.fetch('AUTO_SOURCE_USERNAME'),
                           password: ENV.fetch('AUTO_SOURCE_PASSWORD')) do
-            r.get 'test' do |_r|
-              'AUTO'
-            end
-
             r.on String, method: :get do |encoded_url|
-              url = Base64.urlsafe_decode64(encoded_url)
+              url = Addressable::URI.parse(Base64.urlsafe_decode64(encoded_url))
+
+              rss = Html2rss::AutoSource.build_from_response(SsrfFilter.get(url), url)
 
-              rss = Html2rss.auto_source(url)
-              ttl = (rss.channel.ttl || 60) * 60
+              max_age = (rss.channel.ttl || 60) * 60
 
-              HttpCache.expires(response, ttl, cache_control: 'private, max-age=0, must-revalidate')
+              HttpCache.expires(response, max_age, cache_control: 'private, must-revalidate')
 
               response['Content-Type'] = 'application/rss+xml'
 

From 0070399b1c2d8a819524b83c64412c89ff1b8464 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sat, 17 Aug 2024 17:26:52 +0200
Subject: [PATCH 04/25] feat: use hash_branch_view_dir

---
 app.rb                  | 2 +-
 helpers/handle_error.rb | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/app.rb b/app.rb
index bbd46412..e328fac9 100644
--- a/app.rb
+++ b/app.rb
@@ -48,7 +48,7 @@ def self.development? = ENV['RACK_ENV'] == 'development'
         handle_error(error)
       end
 
-      plugin :hash_branches
+      plugin :hash_branch_view_subdir
       plugin :public
       plugin :render, escape: true, layout: 'layout'
       plugin :typecast_params
diff --git a/helpers/handle_error.rb b/helpers/handle_error.rb
index f9ccd37c..97f905e1 100644
--- a/helpers/handle_error.rb
+++ b/helpers/handle_error.rb
@@ -23,6 +23,8 @@ def handle_error(error) # rubocop:disable Metrics/MethodLength
 
         @show_backtrace = self.class.development?
         @error = error
+
+        set_view_subdir nil
         view 'error'
       end
 

From 7588413b70818f887a829ba1a96ef38ce832fd25 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 18 Aug 2024 13:08:40 +0200
Subject: [PATCH 05/25] feat: adapt to changed auto_source constructor
 signature

---
 routes/auto_source.rb | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/routes/auto_source.rb b/routes/auto_source.rb
index 17e1ee83..ec629f89 100644
--- a/routes/auto_source.rb
+++ b/routes/auto_source.rb
@@ -9,18 +9,19 @@ module Html2rss
   module Web
     class App
       if ENV['AUTO_SOURCE_ENABLED'].to_s == 'true'
+
         hash_branch 'auto_source' do |r|
           with_basic_auth(realm: 'Auto Source',
                           username: ENV.fetch('AUTO_SOURCE_USERNAME'),
                           password: ENV.fetch('AUTO_SOURCE_PASSWORD')) do
-            r.on String, method: :get do |encoded_url|
-              url = Addressable::URI.parse(Base64.urlsafe_decode64(encoded_url))
-
-              rss = Html2rss::AutoSource.build_from_response(SsrfFilter.get(url), url)
+            r.get '/' do
+              view 'index', layout: '/layout'
+            end
 
-              max_age = (rss.channel.ttl || 60) * 60
+            r.on String, method: :get do |encoded_url|
+              rss = build_auto_source_from_encoded_url(encoded_url)
 
-              HttpCache.expires(response, max_age, cache_control: 'private, must-revalidate')
+              HttpCache.expires(response, ttl_in_seconds(rss), cache_control: 'private, must-revalidate')
 
               response['Content-Type'] = 'application/rss+xml'
 
@@ -29,6 +30,23 @@ class App
           end
         end
 
+        private
+
+        def build_auto_source_from_encoded_url(encoded_url)
+          url = Addressable::URI.parse Base64.urlsafe_decode64(encoded_url)
+          request = SsrfFilter.get(url)
+
+          auto_source = Html2rss::AutoSource.new(url,
+                                                 body: request.body,
+                                                 headers: request.to_hash.transform_values(&:first))
+
+          auto_source.build
+        end
+
+        def ttl_in_seconds(rss, default_in_minutes: 60)
+          (rss.channel.ttl || default_in_minutes) * 60
+        end
+
       else
         # auto_source feature is disabled
         hash_branch 'auto_source' do |r|

From b2da9124031324c12786d4b35670a50477d04e1f Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 19 Aug 2024 16:36:38 +0200
Subject: [PATCH 06/25] feat: add auto_source#index

---
 app.rb                      |  4 ++--
 public/auto_source.js       | 33 +++++++++++++++++++++++++++++++++
 public/rss.xsl              |  2 +-
 public/styles.css           | 35 ++++++++++++++++++++++++++++++++++-
 routes/auto_source.rb       | 11 ++++++-----
 views/auto_source/index.erb | 20 ++++++++++++++++++++
 6 files changed, 96 insertions(+), 9 deletions(-)
 create mode 100644 public/auto_source.js
 create mode 100644 views/auto_source/index.erb

diff --git a/app.rb b/app.rb
index e328fac9..556a4f4f 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,6 +11,8 @@ module Web
     #
     # It is built with [Roda](https://roda.jeremyevans.net/).
     class App < Roda
+      CONTENT_TYPE_RSS = 'application/xml'
+
       def self.development? = ENV['RACK_ENV'] == 'development'
 
       opts[:check_dynamic_arity] = false
@@ -64,7 +65,6 @@ def self.development? = ENV['RACK_ENV'] == 'development'
 
       route do |r|
         r.public
-
         r.hash_branches('')
 
         r.root { view 'index' }
diff --git a/public/auto_source.js b/public/auto_source.js
new file mode 100644
index 00000000..0ec2097a
--- /dev/null
+++ b/public/auto_source.js
@@ -0,0 +1,33 @@
+// TODO: when a ?url=%s param is available, set the value of the url input field to %s
+const $form = document.querySelector("form");
+const $url = document.querySelector("#url");
+const $iframe = document.querySelector("iframe");
+const $rssUrl = document.querySelector("#rss_url");
+
+$url?.addEventListener("change", (event) => {
+  delete $iframe.src;
+  delete $rssUrl.value;
+});
+
+$form?.addEventListener("submit", async (event) => {
+  event.preventDefault();
+
+  if ($url && $rssUrl) {
+    const url = $url?.value;
+
+    if (!url || `${url}`.trim() === "" || !url.startsWith("http")) {
+      return;
+    }
+
+    const encodedUrl = btoa(url).replace(/=/g, "");
+    const baseUrl = new URL(window.location.origin);
+    const autoSourceUrl = `${baseUrl}auto_source/${encodedUrl}`;
+
+    $rssUrl.value = autoSourceUrl;
+    $rssUrl.select();
+  }
+});
+
+$rssUrl?.addEventListener("focus", () => {
+  $iframe.src = `${$rssUrl.value}#feed`;
+});
diff --git a/public/rss.xsl b/public/rss.xsl
index ab38a3e3..9cc65fe8 100644
--- a/public/rss.xsl
+++ b/public/rss.xsl
@@ -41,7 +41,7 @@
       <input id="url" type="text"/>
     </p>
 
-    <h2>Feed content preview</h2>
+    <h2 id="feed">Feed content preview</h2>
     <ol class="items">
       <xsl:for-each select="rss/channel/item">
         <li>
diff --git a/public/styles.css b/public/styles.css
index 553bbb1e..3a38276a 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -3,6 +3,10 @@
   --highlight: #ff9300;
 }
 
+::selection {
+  background-color: var(--highlight);
+}
+
 label {
   font-weight: bold;
   cursor: pointer;
@@ -57,7 +61,9 @@ 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,
@@ -65,3 +71,30 @@ body > h2 {
   border-color: currentColor;
   opacity: 0.9;
 }
+
+.auto_source {
+  display: flex;
+  flex-direction: column;
+}
+
+.auto_source input {
+  width: 100%;
+  max-width: unset;
+}
+
+.auto_source > form {
+  display: flex;
+  flex-wrap: wrap;
+}
+
+.auto_source iframe:not([src]) {
+  display: none;
+}
+
+.auto_source iframe[src] {
+  display: block;
+  width: 100%;
+  min-height: 50em;
+  max-height: 80vh;
+  border: 0;
+}
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
index ec629f89..959a4645 100644
--- a/routes/auto_source.rb
+++ b/routes/auto_source.rb
@@ -14,7 +14,7 @@ class App
           with_basic_auth(realm: 'Auto Source',
                           username: ENV.fetch('AUTO_SOURCE_USERNAME'),
                           password: ENV.fetch('AUTO_SOURCE_PASSWORD')) do
-            r.get '/' do
+            r.root do
               view 'index', layout: '/layout'
             end
 
@@ -23,7 +23,7 @@ class App
 
               HttpCache.expires(response, ttl_in_seconds(rss), cache_control: 'private, must-revalidate')
 
-              response['Content-Type'] = 'application/rss+xml'
+              response['Content-Type'] = CONTENT_TYPE_RSS
 
               rss.to_s
             end
@@ -35,10 +35,11 @@ class App
         def 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: 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
diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
new file mode 100644
index 00000000..0c541cd9
--- /dev/null
+++ b/views/auto_source/index.erb
@@ -0,0 +1,20 @@
+<nav>
+  <a href="/">‹ Back to Home</a>
+</nav>
+
+<h1>Auto Source</h1>
+<p>
+  Generate an RSS feed from a website.
+</p>
+
+<section class="auto_source">
+  <form>
+    <input id="url" type="url" placeholder="https://" pattern="http[s]://.*"  required>
+    <input type="submit" value="Generate">
+    <input type="url" id="rss_url" readonly>
+  </form>
+
+<iframe loading="lazy"></iframe>
+</section>
+
+<script src="/auto_source.js"></script>

From 1d6fd452971fbc39de5845aefabc4de449422da6 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 19 Aug 2024 16:37:00 +0200
Subject: [PATCH 07/25] feat: use content-type constant

---
 helpers/handle_html2rss_configs.rb   | 2 +-
 helpers/handle_local_config_feeds.rb | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

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

From 8d98dffe47a128c14813ab10600f003c576ca243 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 19 Aug 2024 16:37:15 +0200
Subject: [PATCH 08/25] feat: rack-timeout only when RACK_ENV!=development

---
 config.ru | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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 }
 

From b2fedc8ad51104beacccae764a9b48f0cbe2a9d8 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 19 Aug 2024 16:52:20 +0200
Subject: [PATCH 09/25] fix: rendering of iframe prevented

Signed-off-by: Gil Desmarais <git@desmarais.de>
---
 app.rb                      |  6 +++---
 public/auto_source.js       |  2 +-
 public/rss.xsl              |  6 +++---
 public/styles.css           | 30 ++++++++++++++++++++++++------
 routes/auto_source.rb       |  2 +-
 views/auto_source/index.erb |  9 +++++++--
 6 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/app.rb b/app.rb
index 556a4f4f..be2b2a73 100644
--- a/app.rb
+++ b/app.rb
@@ -29,16 +29,16 @@ def self.development? = ENV['RACK_ENV'] == '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'
 
diff --git a/public/auto_source.js b/public/auto_source.js
index 0ec2097a..14e4032f 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -29,5 +29,5 @@ $form?.addEventListener("submit", async (event) => {
 });
 
 $rssUrl?.addEventListener("focus", () => {
-  $iframe.src = `${$rssUrl.value}#feed`;
+  $iframe.src = `${$rssUrl.value}#items`;
 });
diff --git a/public/rss.xsl b/public/rss.xsl
index 9cc65fe8..1d5258e9 100644
--- a/public/rss.xsl
+++ b/public/rss.xsl
@@ -41,12 +41,12 @@
       <input id="url" type="text"/>
     </p>
 
-    <h2 id="feed">Feed content preview</h2>
-    <ol class="items">
+    <h2>Feed content preview</h2>
+    <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 3a38276a..4fca9e4a 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -7,10 +7,19 @@
   background-color: var(--highlight);
 }
 
+html {
+  box-sizing: border-box;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: inherit;
+}
+
 label {
   font-weight: bold;
   cursor: pointer;
-  margin-top: 0.5em;
 }
 
 input[type="text"] {
@@ -24,8 +33,8 @@ body > h2 {
 
 .items {
   list-style: none;
+  padding-top: 2em;
   padding-left: 0;
-  margin-top: 2em;
 }
 
 .items > li {
@@ -68,7 +77,7 @@ body > h2 {
 
 .aside-icon > a:hover > img,
 .aside-icon > a:focus > img {
-  border-color: currentColor;
+  border-color: var(--highlight);
   opacity: 0.9;
 }
 
@@ -84,7 +93,18 @@ body > h2 {
 
 .auto_source > form {
   display: flex;
-  flex-wrap: wrap;
+}
+
+.auto_source > form input[type="submit"] {
+  flex: 1 1 20em;
+  margin-right: 0;
+}
+
+.auto_source iframe {
+  margin-top: 2em;
+  border-color: var(--background);
+  border-style: groove;
+  border-radius: 6px;
 }
 
 .auto_source iframe:not([src]) {
@@ -93,8 +113,6 @@ body > h2 {
 
 .auto_source iframe[src] {
   display: block;
-  width: 100%;
   min-height: 50em;
   max-height: 80vh;
-  border: 0;
 }
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
index 959a4645..1ffac75e 100644
--- a/routes/auto_source.rb
+++ b/routes/auto_source.rb
@@ -39,7 +39,7 @@ def build_auto_source_from_encoded_url(encoded_url)
 
           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.channel.stylesheets << Html2rss::RssBuilder::Stylesheet.new(href: '/rss.xsl', type: 'text/xsl')
 
           auto_source.build
         end
diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
index 0c541cd9..a2ccf9d4 100644
--- a/views/auto_source/index.erb
+++ b/views/auto_source/index.erb
@@ -9,11 +9,16 @@
 
 <section class="auto_source">
   <form>
-    <input id="url" type="url" placeholder="https://" pattern="http[s]://.*"  required>
+    <input id="url" type="url" placeholder="https://" pattern="http[s]://.*" autocomplete="on" token-list="url" required>
     <input type="submit" value="Generate">
-    <input type="url" id="rss_url" readonly>
   </form>
 
+  <label for="rss_url">
+    <img src="/feed.svg" height="16" width="16" alt="the orange RSS icon" role="presentation"/>
+      Feed URL
+    </label>
+  <input type="url" id="rss_url" readonly>
+
 <iframe loading="lazy"></iframe>
 </section>
 

From 97a855600e0319f1354d4e3022fc9150fb3a7944 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 19 Aug 2024 18:10:11 +0200
Subject: [PATCH 10/25] refactor: improve auto_source form handling and styles

---
 public/auto_source.css      |  57 +++++++++++++++
 public/auto_source.js       | 138 ++++++++++++++++++++++++++++++------
 public/styles.css           |  19 +++--
 views/auto_source/index.erb |   2 +-
 4 files changed, 182 insertions(+), 34 deletions(-)
 create mode 100644 public/auto_source.css

diff --git a/public/auto_source.css b/public/auto_source.css
new file mode 100644
index 00000000..082e907a
--- /dev/null
+++ b/public/auto_source.css
@@ -0,0 +1,57 @@
+/* Auto Source Form */
+.auto_source {
+  display: flex;
+  flex-direction: column;
+}
+
+.auto_source input,
+.auto_source button {
+  width: 100%;
+  font-family: monospace;
+}
+
+.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 button.muted {
+  color: var(--text-muted);
+  border: 1px solid var(--background-alt);
+}
+
+.auto_source iframe {
+  margin-top: 2em;
+  border: 2px groove var(--highlight);
+  border-radius: 0.5em;
+  display: none; /* Hide by default */
+}
+
+.auto_source iframe[src] {
+  display: block;
+  min-height: 50em;
+  max-height: 80vh;
+}
diff --git a/public/auto_source.js b/public/auto_source.js
index 14e4032f..85eb66b7 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -1,33 +1,125 @@
-// TODO: when a ?url=%s param is available, set the value of the url input field to %s
-const $form = document.querySelector("form");
-const $url = document.querySelector("#url");
-const $iframe = document.querySelector("iframe");
-const $rssUrl = document.querySelector("#rss_url");
+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");
 
-$url?.addEventListener("change", (event) => {
-  delete $iframe.src;
-  delete $rssUrl.value;
-});
+    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();
+  }
 
-$form?.addEventListener("submit", async (event) => {
-  event.preventDefault();
+  /**
+   * Initializes event listeners for form elements.
+   */
+  initEventListeners() {
+    // Event listener for URL input change
+    this.urlInput.addEventListener("change", () => this.clearRssUrl());
 
-  if ($url && $rssUrl) {
-    const url = $url?.value;
+    // Event listener for form submit
+    this.form.addEventListener("submit", (event) =>
+      this.handleFormSubmit(event),
+    );
 
-    if (!url || `${url}`.trim() === "" || !url.startsWith("http")) {
-      return;
+    // 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;
     }
+  }
+
+  /**
+   * Clears the RSS URL input value.
+   */
+  clearRssUrl() {
+    this.rssUrlInput.value = "";
+  }
+
+  /**
+   * Handles form submission.
+   * @param {Event} event - The form submit event.
+   */
+  handleFormSubmit(event) {
+    event.preventDefault();
+    const url = this.urlInput.value;
 
-    const encodedUrl = btoa(url).replace(/=/g, "");
+    if (this.isValidUrl(url)) {
+      const encodedUrl = this.encodeUrl(url);
+      const autoSourceUrl = this.generateAutoSourceUrl(encodedUrl);
+
+      this.rssUrlInput.value = autoSourceUrl;
+      this.rssUrlInput.select();
+    }
+  }
+
+  /**
+   * 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 BASE_URL = "auto_source"; // Use constant to avoid magic strings
     const baseUrl = new URL(window.location.origin);
-    const autoSourceUrl = `${baseUrl}auto_source/${encodedUrl}`;
+    return `${baseUrl}${BASE_URL}/${encodedUrl}`;
+  }
 
-    $rssUrl.value = autoSourceUrl;
-    $rssUrl.select();
+  /**
+   * Updates the iframe source.
+   * @param {string} rssUrlValue - The RSS URL value.
+   */
+  updateIframeSrc(rssUrlValue) {
+    this.iframe.src = rssUrlValue === "" ? "" : `${rssUrlValue}#items`;
   }
-});
+}
 
-$rssUrl?.addEventListener("focus", () => {
-  $iframe.src = `${$rssUrl.value}#items`;
-});
+// Initialize FormHandler when the document is ready
+if (document.readyState === "complete") {
+  new FormHandler();
+} else {
+  document.addEventListener("DOMContentLoaded", () => new FormHandler());
+}
diff --git a/public/styles.css b/public/styles.css
index 4fca9e4a..c2c6ed06 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -17,6 +17,7 @@ html {
   box-sizing: inherit;
 }
 
+/* General Styles */
 label {
   font-weight: bold;
   cursor: pointer;
@@ -31,10 +32,10 @@ body > h2 {
   margin-top: 2em;
 }
 
+/* List Items */
 .items {
   list-style: none;
-  padding-top: 2em;
-  padding-left: 0;
+  padding: 2em 0 0 0;
 }
 
 .items > li {
@@ -52,11 +53,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;
@@ -81,6 +83,7 @@ body > h2 {
   opacity: 0.9;
 }
 
+/* Auto Source Form */
 .auto_source {
   display: flex;
   flex-direction: column;
@@ -88,7 +91,6 @@ body > h2 {
 
 .auto_source input {
   width: 100%;
-  max-width: unset;
 }
 
 .auto_source > form {
@@ -100,15 +102,12 @@ body > h2 {
   margin-right: 0;
 }
 
+/* Iframe Styles */
 .auto_source iframe {
   margin-top: 2em;
-  border-color: var(--background);
-  border-style: groove;
+  border: 1px groove var(--background);
   border-radius: 6px;
-}
-
-.auto_source iframe:not([src]) {
-  display: none;
+  display: none; /* Hide by default */
 }
 
 .auto_source iframe[src] {
diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
index a2ccf9d4..d648d42d 100644
--- a/views/auto_source/index.erb
+++ b/views/auto_source/index.erb
@@ -22,4 +22,4 @@
 <iframe loading="lazy"></iframe>
 </section>
 
-<script src="/auto_source.js"></script>
+<script src="/auto_source.js" defer></script>

From f577f1beb56554f2fc2f8e266261d0893355e068 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 19 Aug 2024 18:18:00 +0200
Subject: [PATCH 11/25] feat(auto_source): automatically submit form when ?url=
 is present

---
 public/auto_source.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/public/auto_source.js b/public/auto_source.js
index 85eb66b7..025b545b 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -47,6 +47,7 @@ class FormHandler {
     const initialUrl = params.get("url");
     if (initialUrl) {
       this.urlInput.value = initialUrl;
+      this.form.dispatchEvent(new Event("submit"));
     }
   }
 
@@ -71,6 +72,10 @@ class FormHandler {
 
       this.rssUrlInput.value = autoSourceUrl;
       this.rssUrlInput.select();
+
+      if (window.location.search !== `?url=${url}`) {
+        window.history.pushState({}, "", `?url=${url}`);
+      }
     }
   }
 

From 621a154b3406168ad81f9312e59b3517dc1bbafd Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Tue, 20 Aug 2024 15:23:09 +0200
Subject: [PATCH 12/25] feat(auto_source): integrate content_for plugin and
 enhance UX

Added `content_for` plugin to manage CSS and scripts. Implemented new bookmarklet, button handlers, and form improvements for better user interaction.

Signed-off-by: Gil Desmarais <git@desmarais.de>
---
 app.rb                      |   1 +
 public/auto_source.js       | 393 ++++++++++++++++++++++++++----------
 public/styles.css           |  33 ---
 views/auto_source/index.erb |  51 +++--
 views/layout.erb            |   2 +
 5 files changed, 330 insertions(+), 150 deletions(-)

diff --git a/app.rb b/app.rb
index be2b2a73..a75142cd 100644
--- a/app.rb
+++ b/app.rb
@@ -51,6 +51,7 @@ def self.development? = ENV['RACK_ENV'] == 'development'
 
       plugin :hash_branch_view_subdir
       plugin :public
+      plugin :content_for
       plugin :render, escape: true, layout: 'layout'
       plugin :typecast_params
       plugin :basic_auth
diff --git a/public/auto_source.js b/public/auto_source.js
index 025b545b..29b24e99 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -1,130 +1,313 @@
-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.",
-      );
+const autoSource = (function () {
+  const ALLOWED_ORIGINS = ["127.0.0.1", "::1"];
+
+  function assertAllowedOrigin() {
+    const allowedOrigin = ALLOWED_ORIGINS.includes(location.host.split(":")[0]);
+
+    if (allowedOrigin) {
       return;
     }
 
-    // Bind event handlers
-    this.initEventListeners();
-    this.setInitialUrl();
+    if (location.protocol !== "https:") {
+      throw new Error("You must use HTTPS for the auto_source feature.");
+    }
   }
 
-  /**
-   * 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());
+  class Bookmarklet {
+    constructor() {
+      const $bookmarklet = document.querySelector("a#bookmarklet");
+
+      if (!$bookmarklet) {
+        console.error("Bookmarklet element not found in the DOM.");
+        return;
       }
-    });
-  }
 
-  /**
-   * 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"));
+      $bookmarklet.href = this.generateBookmarkletHref();
     }
-  }
 
-  /**
-   * Clears the RSS URL input value.
-   */
-  clearRssUrl() {
-    this.rssUrlInput.value = "";
+    generateBookmarkletHref() {
+      const h2rUrl = new URL(window.location.origin);
+      h2rUrl.pathname = "auto_source/";
+      h2rUrl.search = `?url=`;
+      h2rUrl.hash = "";
+
+      return `javascript:window.location.href='${h2rUrl.toString()}'+window.location.href;`;
+    }
   }
 
-  /**
-   * Handles form submission.
-   * @param {Event} event - The form submit event.
-   */
-  handleFormSubmit(event) {
-    event.preventDefault();
-    const url = this.urlInput.value;
+  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();
+    }
 
-    if (this.isValidUrl(url)) {
-      const encodedUrl = this.encodeUrl(url);
-      const autoSourceUrl = this.generateAutoSourceUrl(encodedUrl);
+    /**
+     * Initializes event listeners for form elements.
+     */
+    initEventListeners() {
+      // Event listener for URL input change
+      this.urlInput.addEventListener("change", () => this.clearRssUrl());
 
-      this.rssUrlInput.value = autoSourceUrl;
-      this.rssUrlInput.select();
+      // Event listener for form submit
+      this.form.addEventListener("submit", (event) => this.handleFormSubmit(event));
 
-      if (window.location.search !== `?url=${url}`) {
-        window.history.pushState({}, "", `?url=${url}`);
+      // 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"));
       }
     }
-  }
 
-  /**
-   * 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;
+    /**
+     * 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 BASE_URL = "auto_source"; // Use constant to avoid magic strings
+      const baseUrl = new URL(window.location.origin);
+      return `${baseUrl}${BASE_URL}/${encodedUrl}`;
+    }
+
+    /**
+     * Updates the iframe source.
+     * @param {string} rssUrlValue - The RSS URL value.
+     */
+    updateIframeSrc(rssUrlValue) {
+      this.iframe.src = rssUrlValue === "" ? "" : `${rssUrlValue}#items`;
     }
   }
 
-  /**
-   * 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, "");
+  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);
+        console.log("Text copied to clipboard:", 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() {
+      assertAllowedOrigin();
+
+      const feedUrl = this.rssUrlField.value;
+      const storedUser = LocalStorageFacade.getOrAskUser("username");
+      const storedPassword = LocalStorageFacade.getOrAskUser("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.");
+    }
   }
 
-  /**
-   * Generates an auto-source URL.
-   * @param {string} encodedUrl - The base64 encoded URL.
-   * @returns {string} The generated auto-source URL.
-   */
-  generateAutoSourceUrl(encodedUrl) {
-    const BASE_URL = "auto_source"; // Use constant to avoid magic strings
-    const baseUrl = new URL(window.location.origin);
-    return `${baseUrl}${BASE_URL}/${encodedUrl}`;
+  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 getOrAskUser(columnName) {
+      let value = LocalStorageFacade.get(columnName);
+
+      while (typeof value !== "string" || value === "") {
+        value = window.prompt(`Please enter your ${columnName}:`);
+
+        if (!value || value.trim() === "") {
+          alert(`Blank ${columnName} submitted. Try again!`);
+        } else {
+          LocalStorageFacade.set(columnName, value);
+        }
+      }
+
+      return value;
+    }
+
+    static encode(value) {
+      return btoa(value.trim()).replace(/=/g, "");
+    }
+
+    static decode(value) {
+      if (typeof value !== "string") {
+        return null;
+      }
+
+      return atob(value);
+    }
   }
 
-  /**
-   * Updates the iframe source.
-   * @param {string} rssUrlValue - The RSS URL value.
-   */
-  updateIframeSrc(rssUrlValue) {
-    this.iframe.src = rssUrlValue === "" ? "" : `${rssUrlValue}#items`;
+  function init() {
+    new Bookmarklet();
+    new FormHandler();
+    new ButtonHandler();
   }
-}
-
-// Initialize FormHandler when the document is ready
-if (document.readyState === "complete") {
-  new FormHandler();
-} else {
-  document.addEventListener("DOMContentLoaded", () => new FormHandler());
-}
+
+  return { init: init };
+})();
+
+document.readyState === "complete"
+  ? autoSource.init()
+  : document.addEventListener("DOMContentLoaded", autoSource.init());
diff --git a/public/styles.css b/public/styles.css
index c2c6ed06..5f86282f 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -82,36 +82,3 @@ body > h2 {
   border-color: var(--highlight);
   opacity: 0.9;
 }
-
-/* Auto Source Form */
-.auto_source {
-  display: flex;
-  flex-direction: column;
-}
-
-.auto_source input {
-  width: 100%;
-}
-
-.auto_source > form {
-  display: flex;
-}
-
-.auto_source > form input[type="submit"] {
-  flex: 1 1 20em;
-  margin-right: 0;
-}
-
-/* Iframe Styles */
-.auto_source iframe {
-  margin-top: 2em;
-  border: 1px groove var(--background);
-  border-radius: 6px;
-  display: none; /* Hide by default */
-}
-
-.auto_source iframe[src] {
-  display: block;
-  min-height: 50em;
-  max-height: 80vh;
-}
diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
index d648d42d..a3fe2cb2 100644
--- a/views/auto_source/index.erb
+++ b/views/auto_source/index.erb
@@ -1,25 +1,52 @@
-<nav>
-  <a href="/">‹ Back to Home</a>
-</nav>
+<% content_for :css do %>
+<link href="/auto_source.css" rel="stylesheet"/>
+<% end %>
 
-<h1>Auto Source</h1>
-<p>
-  Generate an RSS feed from a website.
-</p>
+<% content_for :scripts do %>
+<script src="/auto_source.js" defer></script>
+<% end %>
 
 <section class="auto_source">
+  <h1>Auto Source</h1>
+  <p>
+    Automatically generate an RSS feed from a website.
+  </p>
+
   <form>
     <input id="url" type="url" placeholder="https://" pattern="http[s]://.*" autocomplete="on" token-list="url" required>
     <input type="submit" value="Generate">
   </form>
 
-  <label for="rss_url">
+  <label>
     <img src="/feed.svg" height="16" width="16" alt="the orange RSS icon" role="presentation"/>
       Feed URL
-    </label>
-  <input type="url" id="rss_url" readonly>
+      <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>
+  <iframe loading="lazy"></iframe>
 </section>
 
-<script src="/auto_source.js" defer></script>
+<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" 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>

From d9a076d4895c494682eea44ca8893fe6144f7aa5 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Wed, 2 Oct 2024 16:36:44 +0200
Subject: [PATCH 13/25] fix(auto_source): update index.erb to improve input
 validation and UX

Enhanced URL pattern to exclude user info, added autofocus for better user experience.
---
 views/auto_source/index.erb | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
index a3fe2cb2..13e431df 100644
--- a/views/auto_source/index.erb
+++ b/views/auto_source/index.erb
@@ -9,11 +9,19 @@
 <section class="auto_source">
   <h1>Auto Source</h1>
   <p>
-    Automatically generate an RSS feed from a website.
+    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" required>
+    <input
+      id="url"
+      type="url"
+      placeholder="https://"
+      pattern="http[s]://(?!.*@).*"
+      autocomplete="on"
+      token-list="url"
+      autofocus
+      required>
     <input type="submit" value="Generate">
   </form>
 

From 98a3ea095efddc15c51ffc72d2f8ca1c910c860c Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Tue, 8 Oct 2024 11:18:31 +0200
Subject: [PATCH 14/25] feat: assert request sources from allowed host/origin

---
 public/auto_source.js | 16 ----------------
 routes/auto_source.rb | 18 ++++++++++++++++++
 2 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/public/auto_source.js b/public/auto_source.js
index 29b24e99..985737aa 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -1,18 +1,4 @@
 const autoSource = (function () {
-  const ALLOWED_ORIGINS = ["127.0.0.1", "::1"];
-
-  function assertAllowedOrigin() {
-    const allowedOrigin = ALLOWED_ORIGINS.includes(location.host.split(":")[0]);
-
-    if (allowedOrigin) {
-      return;
-    }
-
-    if (location.protocol !== "https:") {
-      throw new Error("You must use HTTPS for the auto_source feature.");
-    }
-  }
-
   class Bookmarklet {
     constructor() {
       const $bookmarklet = document.querySelector("a#bookmarklet");
@@ -223,8 +209,6 @@ const autoSource = (function () {
      * Subscribes to the feed specified in the text field.
      */
     async subscribeToFeed() {
-      assertAllowedOrigin();
-
       const feedUrl = this.rssUrlField.value;
       const storedUser = LocalStorageFacade.getOrAskUser("username");
       const storedPassword = LocalStorageFacade.getOrAskUser("password");
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
index 1ffac75e..b13cc161 100644
--- a/routes/auto_source.rb
+++ b/routes/auto_source.rb
@@ -19,6 +19,8 @@ class App
             end
 
             r.on String, method: :get do |encoded_url|
+              assert_allowed_request_origin!
+
               rss = build_auto_source_from_encoded_url(encoded_url)
 
               HttpCache.expires(response, ttl_in_seconds(rss), cache_control: 'private, must-revalidate')
@@ -32,6 +34,22 @@ class App
 
         private
 
+        def assert_allowed_request_origin!
+          allowed_origins = ENV.fetch('AUTO_SOURCE_ALLOWED_ORIGINS', '').split(',').to_set
+
+          if allowed_origins.empty?
+            response.write 'No allowed origins are configured. Please set AUTO_SOURCE_ALLOWED_ORIGINS.'
+          else
+            origin = request.env['HTTP_HOST']
+
+            return if allowed_origins.include?(origin)
+
+            response.write "Origin '#{origin}' is not allowed."
+          end
+
+          request.halt
+        end
+
         def build_auto_source_from_encoded_url(encoded_url)
           url = Addressable::URI.parse Base64.urlsafe_decode64(encoded_url)
           request = SsrfFilter.get(url)

From f78f44ad8d8dd653932fd5138568924c9dda2934 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Tue, 8 Oct 2024 11:42:51 +0200
Subject: [PATCH 15/25] docs(readme): add instructions for auto_source usage

---
 README.md | 64 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 50 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index a8c10c82..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:
@@ -68,7 +75,28 @@ The `docker-compose.yml` above contains a service description for watchtower.
 
 ## How to use automatic feed generation
 
-1. add `FEATURE_AUTO_SOURCE_ENABLED=true` to your `docker-compose.yml` file
+> [!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
 
@@ -89,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
 
@@ -116,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`
 

From b95cdab9ce30334ad4cb4afe1e80bd1b16bea16d Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Tue, 8 Oct 2024 11:43:28 +0200
Subject: [PATCH 16/25] feat: use smooth scroll-behaviour

---
 public/styles.css | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/public/styles.css b/public/styles.css
index 5f86282f..d62d7f0b 100644
--- a/public/styles.css
+++ b/public/styles.css
@@ -17,6 +17,10 @@ html {
   box-sizing: inherit;
 }
 
+body {
+  scroll-behavior: smooth;
+}
+
 /* General Styles */
 label {
   font-weight: bold;

From bfa6791200d717bb4cb9d933f575f3eaac66cf83 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Tue, 8 Oct 2024 12:44:29 +0200
Subject: [PATCH 17/25] chore(deps): depend on minimum html2rss version of
 v0.14

---
 Gemfile      | 2 +-
 Gemfile.lock | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Gemfile b/Gemfile
index 07be6e75..7636c1ae 100644
--- a/Gemfile
+++ b/Gemfile
@@ -4,7 +4,7 @@ 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:
diff --git a/Gemfile.lock b/Gemfile.lock
index 83fc97a5..135686d8 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -135,7 +135,7 @@ GEM
     simplecov_json_formatter (0.1.4)
     ssrf_filter (1.1.2)
     strscan (3.1.0)
-    thor (1.3.1)
+    thor (1.3.2)
     tilt (2.4.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
@@ -157,7 +157,7 @@ DEPENDENCIES
   base64
   byebug
   erubi
-  html2rss
+  html2rss (~> 0.14)
   html2rss-configs!
   parallel
   puma

From c4ebb734520252e61ebd0e5be5df2ce368365322 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 11:30:27 +0200
Subject: [PATCH 18/25] feat(auto_source): add specs and re-structure files

---
 Gemfile                                       |   2 +
 Gemfile.lock                                  |  14 ++-
 helpers/auto_source.rb                        |  49 +++++++++
 helpers/handle_error.rb                       |   3 +
 routes/auto_source.rb                         |  72 +++----------
 .../auto_source-github-h2r-web.yml            | 102 ++++++++++++++++++
 spec/html2rss/web/app_spec.rb                 |  27 +++++
 spec/routes/auto_source_spec.rb               | 101 +++++++++++++++++
 spec/spec_helper.rb                           |   3 +-
 9 files changed, 316 insertions(+), 57 deletions(-)
 create mode 100644 helpers/auto_source.rb
 create mode 100644 spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml
 create mode 100644 spec/routes/auto_source_spec.rb

diff --git a/Gemfile b/Gemfile
index 7636c1ae..fbc473e2 100644
--- a/Gemfile
+++ b/Gemfile
@@ -35,7 +35,9 @@ group :development do
 end
 
 group :test do
+  gem 'rack-test'
   gem 'rspec'
   gem 'simplecov', require: false
   gem 'vcr'
+  gem 'webmock'
 end
diff --git a/Gemfile.lock b/Gemfile.lock
index 135686d8..18b7bf2e 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -12,8 +12,12 @@ GEM
       public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.2)
     base64 (0.2.0)
+    bigdecimal (3.1.8)
     byebug (11.1.3)
     concurrent-ruby (1.3.4)
+    crack (1.0.0)
+      bigdecimal
+      rexml
     crass (1.0.6)
     diff-lcs (1.5.1)
     docile (1.4.1)
@@ -26,6 +30,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)
@@ -76,6 +81,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)
@@ -134,7 +141,6 @@ GEM
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
     ssrf_filter (1.1.2)
-    strscan (3.1.0)
     thor (1.3.2)
     tilt (2.4.0)
     tzinfo (2.0.6)
@@ -142,6 +148,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)
 
@@ -162,6 +172,7 @@ DEPENDENCIES
   parallel
   puma
   rack-cache
+  rack-test
   rack-timeout
   rack-unreloader
   rake
@@ -176,6 +187,7 @@ DEPENDENCIES
   ssrf_filter
   tilt
   vcr
+  webmock
   yard
 
 BUNDLED WITH
diff --git a/helpers/auto_source.rb b/helpers/auto_source.rb
new file mode 100644
index 00000000..8cf8489f
--- /dev/null
+++ b/helpers/auto_source.rb
@@ -0,0 +1,49 @@
+# 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(',').to_set
+
+      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
+
+      def self.ttl_in_seconds(rss, default_in_minutes: 60)
+        (rss.channel.ttl || default_in_minutes) * 60
+      end
+
+      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 '#{origin}' is not allowed."
+        end
+
+        response.status = 403
+        request.halt
+      end
+    end
+  end
+end
diff --git a/helpers/handle_error.rb b/helpers/handle_error.rb
index 97f905e1..b3245c0e 100644
--- a/helpers/handle_error.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
diff --git a/routes/auto_source.rb b/routes/auto_source.rb
index b13cc161..12969c98 100644
--- a/routes/auto_source.rb
+++ b/routes/auto_source.rb
@@ -1,77 +1,39 @@
 # frozen_string_literal: true
 
-require 'addressable'
-require 'base64'
-require 'ssrf_filter'
-require 'html2rss'
+require_relative '../app/http_cache'
+require_relative '../helpers/auto_source'
 
 module Html2rss
   module Web
     class App
-      if ENV['AUTO_SOURCE_ENABLED'].to_s == 'true'
+      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)
 
-        hash_branch 'auto_source' do |r|
-          with_basic_auth(realm: 'Auto Source',
-                          username: ENV.fetch('AUTO_SOURCE_USERNAME'),
-                          password: ENV.fetch('AUTO_SOURCE_PASSWORD')) do
+          if AutoSource.enabled?
             r.root do
               view 'index', layout: '/layout'
             end
 
             r.on String, method: :get do |encoded_url|
-              assert_allowed_request_origin!
+              rss = AutoSource.build_auto_source_from_encoded_url(encoded_url)
 
-              rss = build_auto_source_from_encoded_url(encoded_url)
-
-              HttpCache.expires(response, ttl_in_seconds(rss), cache_control: 'private, must-revalidate')
+              HttpCache.expires response,
+                                AutoSource.ttl_in_seconds(rss),
+                                cache_control: 'private, must-revalidate'
 
               response['Content-Type'] = CONTENT_TYPE_RSS
 
               rss.to_s
             end
-          end
-        end
-
-        private
-
-        def assert_allowed_request_origin!
-          allowed_origins = ENV.fetch('AUTO_SOURCE_ALLOWED_ORIGINS', '').split(',').to_set
-
-          if allowed_origins.empty?
-            response.write 'No allowed origins are configured. Please set AUTO_SOURCE_ALLOWED_ORIGINS.'
           else
-            origin = request.env['HTTP_HOST']
-
-            return if allowed_origins.include?(origin)
-
-            response.write "Origin '#{origin}' is not allowed."
-          end
-
-          request.halt
-        end
-
-        def 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
-
-        def ttl_in_seconds(rss, default_in_minutes: 60)
-          (rss.channel.ttl || default_in_minutes) * 60
-        end
-
-      else
-        # auto_source feature is disabled
-        hash_branch 'auto_source' do |r|
-          r.on do
-            response.status = 403
-            'The auto source feature is disabled.'
+            # auto_source feature is disabled
+            r.on do
+              response.status = 400
+              'The auto source feature is disabled.'
+            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..7ac4be92
--- /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.4/html2rss/html2rss-web
+    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 09:25:10 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/"72e34d709a25d76a8a2fd7b2c1e6d6de"
+      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=2w82sGklNNansPeQarwhz0yd793BchubUyh8N3%2Bm7rJ7p3dICd8UKdQEqo2BWyFnwVl4xODEtDfQAGCVxN1zTIP%2BOnWIGKhzzNF2LwnWSVuKl6DutmDNCXHbsT3KAU%2FwVjSFcYdUFs0%2BHQl29LYjdrGM181gocPJpsp9NeShytil774SovDepirKW51PYJzB2nVyW%2Fri85THbjLd%2BzwfYkQ2tR3fkqP%2FHByNXFLL9fMs1U%2F8cX1jR%2F5SIfVEqXu6dWduE7gteixmBeQgLjw5%2BA%3D%3D--IF9ZAdMjN%2FLLRLZE--R3%2BGZEw6StxKt1WgK9npqg%3D%3D;
+        Path=/; HttpOnly; Secure; SameSite=Lax
+      - _octo=GH1.1.1029570928.1729416310; Path=/; Domain=github.com; Expires=Mon,
+        20 Oct 2025 09:25:10 GMT; Secure; SameSite=Lax
+      - logged_in=no; Path=/; Domain=github.com; Expires=Mon, 20 Oct 2025 09:25:10
+        GMT; HttpOnly; Secure; SameSite=Lax
+      Accept-Ranges:
+      - bytes
+      Transfer-Encoding:
+      - chunked
+      X-Github-Request-Id:
+      - C1D0:15CD96:635B3DB:66073E4:6714CC76
+    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_remote-form_dist_index_js-node_modules_delegated-events_dist_inde-e53a3f-96e856171702.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/codespaces-00f8bdb5a024.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/repositories-e391e0092c62.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_github_catalyst_lib_inde-dbbea9-e73b311a14f1.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/code-menu-2b308c1236c2.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/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" />

  <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>GitHub - html2rss/html2rss-web: 🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly.</title>



  <meta name="route-pattern" content="/:user_id/:repository" data-turbo-transient>
  <meta name="route-controller" content="files" data-turbo-transient>
  <meta name="route-action" content="disambiguate" data-turbo-transient>

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


  <meta name="request-id" content="C1D0:15CD96:635B3DB:66073E4:6714CC76" data-pjax-transient="true"/><meta name="html-safe-nonce" content="5fc3a1fbe7875d3256ad5a0258ee00cedcc5c61d9b81bf9e4c72a7552dbc06da" data-pjax-transient="true"/><meta name="visitor-payload" content="eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJDMUQwOjE1Q0Q5Njo2MzVCM0RCOjY2MDczRTQ6NjcxNENDNzYiLCJ2aXNpdG9yX2lkIjoiNDQyMTk3MzQ2NjQwMTc4Njk5OCIsInJlZ2lvbl9lZGdlIjoiZnJhIiwicmVnaW9uX3JlbmRlciI6ImZyYSJ9" data-pjax-transient="true"/><meta name="visitor-hmac" content="01b1ba8adfc241d1d6a39a96a4e875dbfb0a57c88e9c913268ffc7116e1aaf4c" data-pjax-transient="true"/>


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


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

  <meta name="selected-link" value="repo_source" 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;" 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. - 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" />

      <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="GitHub - html2rss/html2rss-web: 🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly." /><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. - 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. - html2rss/html2rss-web" /><meta property="og:site_name" content="GitHub" /><meta property="og:type" content="object" /><meta property="og:title" content="GitHub - html2rss/html2rss-web: 🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly." /><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. - 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 data-hydrostats="publish">
  <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" />



      <link rel="canonical" href="https://github.com/html2rss/html2rss-web" data-turbo-transient>


    <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/ui_packages_ui-commands_ui-commands_ts-d25fac54a6bc.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"
            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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="a3a1bbd7d1c3e1c79352c258c7daa3c7116b1a05c0ffe18d5429cc3d716c6d7b"
            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="neu-CYTjdijt8Bhfqa31naGjQ54NKpH3cPVQ2SOBcjWJTx1cnXLDOD4Ra7qYJCK2QKbO0Fl-1i9mZk5zmLONcA" 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-a160117d-a85b-4139-a1e2-ec69bc0daccb" 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-a160117d-a85b-4139-a1e2-ec69bc0daccb" 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="D4eGNdIt+lc2jrnNj3TNIgqwwqjfEer1adLfk9dY0DTYKHy4mzWxwAnwpfUASSiuP0utLQGIuXus/LIg4L2W9A==" />
          <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="7D/LG6iKBxj3kGkoMehYN6cgEIanbFeNpVS2UBLZOPn6q+3f4bkJZfysg+6SwtCv1qEvqPuGXMNdHjY8cGM8zg==" />
          <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="qNI5aPrAQqLcQqNrop9fjIcw7xPZrU1fCy9u4TrED5rGAlhJaeq/VwSqPHoLcY4ng3g1lC4nnjPvxrRkWxDGyQ==" />
            </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"
                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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="a3a1bbd7d1c3e1c79352c258c7daa3c7116b1a05c0ffe18d5429cc3d716c6d7b"
                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&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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="a3a1bbd7d1c3e1c79352c258c7daa3c7116b1a05c0ffe18d5429cc3d716c6d7b"
                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;;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-b962ca4f-aad3-40e7-9e7e-f521394b18a1" aria-labelledby="tooltip-c9cf702f-56eb-49c0-aef3-1e9c75b66a1e" 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-c9cf702f-56eb-49c0-aef3-1e9c75b66a1e" for="icon-button-b962ca4f-aad3-40e7-9e7e-f521394b18a1" 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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="49012a60a791911c076582402aa91990e6c56e8c45906f92bd2ea3df071a802d" 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-8985a91c-b1a4-496e-8aed-59a6f754ee0b" 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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="5892fe882b0c64177168fed1f469c0dae6112701d9537b02499ff7498a3fae48" 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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="8150680232ae9580183a8ef009c7852c6ebf142dc7f184be9fc8f4ffcf83b6f6" 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 class="d-block d-md-none mb-2 px-3 px-md-4 px-lg-5">
      <p class="f4 mb-3 ">
        🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly.
      </p>
      <div class="mb-2 d-flex flex-items-center Link--secondary">
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link flex-shrink-0 mr-2">
    <path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path>
</svg>
        <span class="flex-auto min-width-0 css-truncate css-truncate-target width-fit">
          <a title="https://html2rss.github.io/components/html2rss-web" role="link" target="_blank" class="text-bold" rel="noopener noreferrer" href="https://html2rss.github.io/components/html2rss-web">html2rss.github.io/components/html2rss-web</a>
        </span>
      </div>

    
      <h3 class="sr-only">License</h3>
  <div class="mb-2">
    <a href="/html2rss/html2rss-web/blob/master/LICENSE"
      class="Link--muted"
      
      data-analytics-event="{&quot;category&quot;:&quot;Repository Overview&quot;,&quot;action&quot;:&quot;click&quot;,&quot;label&quot;:&quot;location:sidebar;file:license&quot;}"
    >
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-law mr-2">
    <path d="M8.75.75V2h.985c.304 0 .603.08.867.231l1.29.736c.038.022.08.033.124.033h2.234a.75.75 0 0 1 0 1.5h-.427l2.111 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.006.005-.01.01-.045.04c-.21.176-.441.327-.686.45C14.556 10.78 13.88 11 13 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L12.178 4.5h-.162c-.305 0-.604-.079-.868-.231l-1.29-.736a.245.245 0 0 0-.124-.033H8.75V13h2.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1 0-1.5h2.5V3.5h-.984a.245.245 0 0 0-.124.033l-1.289.737c-.265.15-.564.23-.869.23h-.162l2.112 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.016.015-.045.04c-.21.176-.441.327-.686.45C4.556 10.78 3.88 11 3 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L2.178 4.5H1.75a.75.75 0 0 1 0-1.5h2.234a.249.249 0 0 0 .125-.033l1.288-.737c.265-.15.564-.23.869-.23h.984V.75a.75.75 0 0 1 1.5 0Zm2.945 8.477c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327Zm-10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327Z"></path>
</svg>
     MIT license
    </a>
  </div>


    <div class="mb-3">
        <a class="Link--secondary no-underline mr-3" href="/html2rss/html2rss-web/stargazers">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-star mr-1">
    <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 class="text-bold">86</span>
          stars
</a>        <a class="Link--secondary no-underline mr-3" href="/html2rss/html2rss-web/forks">
          <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-1">
    <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>
          <span class="text-bold">11</span>
          forks
</a>        <a class="Link--secondary no-underline mr-3 d-inline-block" href="/html2rss/html2rss-web/branches">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-branch mr-1">
    <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>
          <span>Branches</span>
</a>        <a class="Link--secondary no-underline d-inline-block" href="/html2rss/html2rss-web/tags">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-tag mr-1">
    <path d="M1 7.775V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 0 1 0 2.474l-5.026 5.026a1.75 1.75 0 0 1-2.474 0l-6.25-6.25A1.752 1.752 0 0 1 1 7.775Zm1.5 0c0 .066.026.13.073.177l6.25 6.25a.25.25 0 0 0 .354 0l5.025-5.025a.25.25 0 0 0 0-.354l-6.25-6.25a.25.25 0 0 0-.177-.073H2.75a.25.25 0 0 0-.25.25ZM6 5a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"></path>
</svg>
          <span>Tags</span>
</a>        <a class="Link--secondary no-underline d-inline-block" href="/html2rss/html2rss-web/activity">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-pulse mr-1">
    <path d="M6 2c.306 0 .582.187.696.471L10 10.731l1.304-3.26A.751.751 0 0 1 12 7h3.25a.75.75 0 0 1 0 1.5h-2.742l-1.812 4.528a.751.751 0 0 1-1.392 0L6 4.77 4.696 8.03A.75.75 0 0 1 4 8.5H.75a.75.75 0 0 1 0-1.5h2.742l1.812-4.529A.751.751 0 0 1 6 2Z"></path>
</svg>
          <span>Activity</span>
</a>    </div>

      <div class="d-flex flex-wrap gap-2">
        <div class="flex-1">
            <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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="8150680232ae9580183a8ef009c7852c6ebf142dc7f184be9fc8f4ffcf83b6f6" aria-label="You must be signed in to star a repository" data-view-component="true" class="tooltipped tooltipped-sw btn-sm btn btn-block">    <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>
</a></div>
        </div>
        <div class="flex-1">
                <a href="/login?return_to=%2Fhtml2rss%2Fhtml2rss-web" rel="nofollow" id="files-overview-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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="49012a60a791911c076582402aa91990e6c56e8c45906f92bd2ea3df071a802d" aria-label="You must be signed in to change notification settings" data-view-component="true" class="btn-sm btn btn-block">    <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-a263d4a3-b58b-49e1-ab27-54422f41f74b" for="files-overview-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>

        </div>
        <span>
          

        </span>
      </div>
  </div>

</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;}" aria-current="page" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item selected">
    
              <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-8c310d38-d208-43db-a403-eda5269767a3-button" popovertarget="action-menu-8c310d38-d208-43db-a403-eda5269767a3-overlay" aria-controls="action-menu-8c310d38-d208-43db-a403-eda5269767a3-list" aria-haspopup="true" aria-labelledby="tooltip-19281707-2110-43e8-88bf-47c4bba1a5fe" 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-19281707-2110-43e8-88bf-47c4bba1a5fe" for="action-menu-8c310d38-d208-43db-a403-eda5269767a3-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-8c310d38-d208-43db-a403-eda5269767a3-overlay" anchor="action-menu-8c310d38-d208-43db-a403-eda5269767a3-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-8c310d38-d208-43db-a403-eda5269767a3-button" id="action-menu-8c310d38-d208-43db-a403-eda5269767a3-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-e629cfce-ad9d-4c81-be31-211e0f4dbea7" 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-b90f5b86-9a71-44e6-8eff-dba7cb3721d8" 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-37c3d6a6-55d9-44b0-afd6-73de12b5c933" 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-f63d8e92-de6f-4d4e-9cd7-9be3a78442f0" 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-31797c4b-b8fe-4ad3-856b-7f14f395a076" 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-9a1a8f62-fda2-40d7-9bd5-18cc0bd5b220" 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-bcc173aa-77a9-4f91-a4d3-be0d90f3a1d3" 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 " >
    



    
      
  <h1 class='sr-only'>html2rss/html2rss-web</h1>
  <div class="clearfix container-xl px-md-4 px-lg-5 px-3">
    <div>


  <div style="max-width: 100%" data-view-component="true" class="Layout Layout--flowRow-until-md react-repos-overview-margin Layout--sidebarPosition-end Layout--sidebarPosition-flowRow-end">
  <div data-view-component="true" class="Layout-main">      <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_tanstack_query-core_build_modern_query_js-node_modules_tanstack_react-qu-e4a133-25f9fad0b763.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_tanstack_query-core_build_modern_queryObserver_js-node_modules_tanstack_-defd52-7aa5ebad499a.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_github_hydro-analytics-client_-d56e55-4533ead6a048.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_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_verified-fetch_verified-fetch_ts-ui_packages_code-view-shared_components_SharedMa-058d4a-af37e21c9cbd.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_code-view-shared_hooks_use-canonical-object_ts-ui_packages_code-view-shared_hooks-2170c0-a950e6dae777.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_commit-attribution_index_ts-ui_packages_commit-checks-status_index_ts-ui_packages-4cf6a5-49c666deb721.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/repos-overview-010de2739dfa.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/repos-overview.47b2222c697daf78496d.module.css" />

<react-partial
  partial-name="repos-overview"
  data-ssr="true"
  data-attempted-ssr="true"
>
  
  <script type="application/json" data-target="react-partial.embeddedData">{"props":{"initialPayload":{"allShortcutsEnabled":false,"path":"/","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},"currentUser":null,"refInfo":{"name":"master","listCacheKey":"v0:1728684225.0","canEdit":false,"refType":"branch","currentOid":"8eeb9e69a1c57f3c61ca00469083604e25066859"},"tree":{"items":[{"name":".github","path":".github","contentType":"directory"},{"name":"app","path":"app","contentType":"directory"},{"name":"bin","path":"bin","contentType":"directory"},{"name":"config","path":"config","contentType":"directory"},{"name":"docs","path":"docs","contentType":"directory"},{"name":"helpers","path":"helpers","contentType":"directory"},{"name":"public","path":"public","contentType":"directory"},{"name":"roda/roda_plugins","path":"roda/roda_plugins","contentType":"directory","hasSimplifiedPath":true},{"name":"spec","path":"spec","contentType":"directory"},{"name":"tmp","path":"tmp","contentType":"directory"},{"name":"views","path":"views","contentType":"directory"},{"name":".dockerignore","path":".dockerignore","contentType":"file"},{"name":".gitignore","path":".gitignore","contentType":"file"},{"name":".mergify.yml","path":".mergify.yml","contentType":"file"},{"name":".rspec","path":".rspec","contentType":"file"},{"name":".rubocop.yml","path":".rubocop.yml","contentType":"file"},{"name":".ruby-version","path":".ruby-version","contentType":"file"},{"name":"Dockerfile","path":"Dockerfile","contentType":"file"},{"name":"Gemfile","path":"Gemfile","contentType":"file"},{"name":"Gemfile.lock","path":"Gemfile.lock","contentType":"file"},{"name":"LICENSE","path":"LICENSE","contentType":"file"},{"name":"Procfile","path":"Procfile","contentType":"file"},{"name":"README.md","path":"README.md","contentType":"file"},{"name":"Rakefile","path":"Rakefile","contentType":"file"},{"name":"app.json","path":"app.json","contentType":"file"},{"name":"app.rb","path":"app.rb","contentType":"file"},{"name":"config.ru","path":"config.ru","contentType":"file"}],"templateDirectorySuggestionUrl":null,"readme":null,"totalCount":27,"showBranchInfobar":false},"fileTree":null,"fileTreeProcessingTime":null,"foldersToFetch":[],"treeExpanded":false,"symbolsExpanded":false,"isOverview":true,"overview":{"banners":{"shouldRecommendReadme":false,"isPersonalRepo":false,"showUseActionBanner":false,"actionSlug":null,"actionId":null,"showProtectBranchBanner":false,"publishBannersInfo":{"dismissActionNoticePath":"/settings/dismiss-notice/publish_action_from_repo","releasePath":"/html2rss/html2rss-web/releases/new?marketplace=true","showPublishActionBanner":false},"interactionLimitBanner":null,"showInvitationBanner":false,"inviterName":null,"actionsMigrationBannerInfo":{"releaseTags":[],"showImmutableActionsMigrationBanner":false,"initialMigrationStatus":null}},"codeButton":{"contactPath":"/contact","isEnterprise":false,"local":{"protocolInfo":{"httpAvailable":true,"sshAvailable":null,"httpUrl":"https://github.com/html2rss/html2rss-web.git","showCloneWarning":null,"sshUrl":null,"sshCertificatesRequired":null,"sshCertificatesAvailable":null,"ghCliUrl":"gh repo clone html2rss/html2rss-web","defaultProtocol":"http","newSshKeyUrl":"/settings/ssh/new","setProtocolPath":"/users/set_protocol"},"platformInfo":{"cloneUrl":"https://desktop.github.com","showVisualStudioCloneButton":false,"visualStudioCloneUrl":"https://windows.github.com","showXcodeCloneButton":false,"xcodeCloneUrl":"xcode://clone?repo=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web","zipballUrl":"/html2rss/html2rss-web/archive/refs/heads/master.zip"}},"newCodespacePath":"/codespaces/new?hide_repo_select=true\u0026repo=135929870"},"popovers":{"rename":null,"renamedParentRepo":null},"commitCount":"819","overviewFiles":[{"displayName":"README.md","repoName":"html2rss-web","refName":"master","path":"README.md","preferredFileType":"readme","tabName":"README","richText":"\u003carticle class=\"markdown-body entry-content container-lg\" itemprop=\"text\"\u003e\u003cp dir=\"auto\"\u003e\u003ca target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://github.com/html2rss/html2rss/raw/master/support/logo.png\"\u003e\u003cimg src=\"https://github.com/html2rss/html2rss/raw/master/support/logo.png\" alt=\"html2rss logo\" style=\"max-width: 100%;\"\u003e\u003c/a\u003e\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch1 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003ehtml2rss-web\u003c/h1\u003e\u003ca id=\"user-content-html2rss-web\" class=\"anchor\" aria-label=\"Permalink: html2rss-web\" href=\"#html2rss-web\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis web application scrapes websites to build and deliver RSS 2.0 feeds.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003e\u003cstrong\u003eFeatures:\u003c/strong\u003e\u003c/p\u003e\n\u003cul dir=\"auto\"\u003e\n\u003cli\u003e\u003ca href=\"#how-to-build-your-rss-feeds\"\u003eCreate your custom feeds\u003c/a\u003e!\u003c/li\u003e\n\u003cli\u003eComes with plenty of \u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003eincluded configs\u003c/a\u003e out of the box.\u003c/li\u003e\n\u003cli\u003eHandles request caching.\u003c/li\u003e\n\u003cli\u003eSets caching-related HTTP headers.\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp dir=\"auto\"\u003eThe functionality of scraping websites and building the RSS feeds is provided by the Ruby gem \u003ca href=\"https://github.com/html2rss/html2rss\"\u003e\u003ccode\u003ehtml2rss\u003c/code\u003e\u003c/a\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eGet started\u003c/h2\u003e\u003ca id=\"user-content-get-started\" class=\"anchor\" aria-label=\"Permalink: Get started\" href=\"#get-started\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis application should be used with Docker. It is designed to require as little maintenance as possible. See \u003ca href=\"#versioning-and-releases\"\u003eVersioning and Releases\u003c/a\u003e and \u003ca href=\"#docker-automatically-keep-the-html2rss-web-image-up-to-date\"\u003econsider automatic updates\u003c/a\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eWith Docker\u003c/h3\u003e\u003ca id=\"user-content-with-docker\" class=\"anchor\" aria-label=\"Permalink: With Docker\" href=\"#with-docker\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cdiv class=\"highlight highlight-source-shell notranslate position-relative overflow-auto\" dir=\"auto\" data-snippet-clipboard-copy-content=\"docker run -p 3000:3000 gilcreator/html2rss-web\"\u003e\u003cpre\u003edocker run -p 3000:3000 gilcreator/html2rss-web\u003c/pre\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThen open \u003ca href=\"http://127.0.0.1:3000/\" rel=\"nofollow\"\u003ehttp://127.0.0.1:3000/\u003c/a\u003e in your browser and click the example feed link.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eThis is the quickest way to get started. However, it's also the option with the least flexibility: it doesn't allow you to use custom feed configs and doesn't update automatically.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you want more flexibility and automatic updates sound good to you, read on to get started \u003cem\u003ewith docker compose\u003c/em\u003e…\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eWith \u003ccode\u003edocker compose\u003c/code\u003e\u003c/h3\u003e\u003ca id=\"user-content-with-docker-compose\" class=\"anchor\" aria-label=\"Permalink: With docker compose\" href=\"#with-docker-compose\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eCreate a \u003ccode\u003edocker-compose.yml\u003c/code\u003e file and paste the following into it:\u003c/p\u003e\n\u003cdiv class=\"highlight highlight-source-yaml notranslate position-relative overflow-auto\" dir=\"auto\" data-snippet-clipboard-copy-content=\"services:\n  html2rss-web:\n    image: gilcreator/html2rss-web\n    ports:\n      - \u0026quot;3000:3000\u0026quot;\n    volumes:\n      - type: bind\n        source: ./feeds.yml\n        target: /app/config/feeds.yml\n        read_only: true\n    environment:\n      - RACK_ENV=production\n      - HEALTH_CHECK_USERNAME=health\n      - HEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!\n  watchtower:\n    image: containrrr/watchtower\n    volumes:\n      - /var/run/docker.sock:/var/run/docker.sock\n      - \u0026quot;~/.docker/config.json:/config.json\u0026quot;\n    command: --cleanup --interval 7200\"\u003e\u003cpre\u003e\u003cspan class=\"pl-ent\"\u003eservices\u003c/span\u003e:\n  \u003cspan class=\"pl-ent\"\u003ehtml2rss-web\u003c/span\u003e:\n    \u003cspan class=\"pl-ent\"\u003eimage\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003egilcreator/html2rss-web\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003eports\u003c/span\u003e:\n      - \u003cspan class=\"pl-s\"\u003e\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e3000:3000\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003evolumes\u003c/span\u003e:\n      - \u003cspan class=\"pl-ent\"\u003etype\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003ebind\u003c/span\u003e\n        \u003cspan class=\"pl-ent\"\u003esource\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003e./feeds.yml\u003c/span\u003e\n        \u003cspan class=\"pl-ent\"\u003etarget\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003e/app/config/feeds.yml\u003c/span\u003e\n        \u003cspan class=\"pl-ent\"\u003eread_only\u003c/span\u003e: \u003cspan class=\"pl-c1\"\u003etrue\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003eenvironment\u003c/span\u003e:\n      - \u003cspan class=\"pl-s\"\u003eRACK_ENV=production\u003c/span\u003e\n      - \u003cspan class=\"pl-s\"\u003eHEALTH_CHECK_USERNAME=health\u003c/span\u003e\n      - \u003cspan class=\"pl-s\"\u003eHEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!\u003c/span\u003e\n  \u003cspan class=\"pl-ent\"\u003ewatchtower\u003c/span\u003e:\n    \u003cspan class=\"pl-ent\"\u003eimage\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003econtainrrr/watchtower\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003evolumes\u003c/span\u003e:\n      - \u003cspan class=\"pl-s\"\u003e/var/run/docker.sock:/var/run/docker.sock\u003c/span\u003e\n      - \u003cspan class=\"pl-s\"\u003e\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e~/.docker/config.json:/config.json\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003ecommand\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003e--cleanup --interval 7200\u003c/span\u003e\u003c/pre\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eStart it up with: \u003ccode\u003edocker compose up\u003c/code\u003e.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you have not created your \u003ccode\u003efeeds.yml\u003c/code\u003e yet, download \u003ca href=\"https://raw.githubusercontent.com/html2rss/html2rss-web/master/config/feeds.yml\" rel=\"nofollow\"\u003ethis \u003ccode\u003efeeds.yml\u003c/code\u003e as a blueprint\u003c/a\u003e into the directory containing the \u003ccode\u003edocker-compose.yml\u003c/code\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eDocker: Automatically keep the html2rss-web image up-to-date\u003c/h2\u003e\u003ca id=\"user-content-docker-automatically-keep-the-html2rss-web-image-up-to-date\" class=\"anchor\" aria-label=\"Permalink: Docker: Automatically keep the html2rss-web image up-to-date\" href=\"#docker-automatically-keep-the-html2rss-web-image-up-to-date\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThe \u003ca href=\"https://containrrr.dev/watchtower/\" rel=\"nofollow\"\u003ewatchtower\u003c/a\u003e service automatically pulls running Docker images and checks for updates. If an update is available, it will automatically start the updated image with the same configuration as the running one. Please read its manual.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eThe \u003ccode\u003edocker-compose.yml\u003c/code\u003e above contains a service description for watchtower.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eHow to use the included configs\u003c/h2\u003e\u003ca id=\"user-content-how-to-use-the-included-configs\" class=\"anchor\" aria-label=\"Permalink: How to use the included configs\" href=\"#how-to-use-the-included-configs\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003ehtml2rss-web comes with many feed configs out of the box. \u003ca href=\"https://github.com/html2rss/html2rss-configs/tree/master/lib/html2rss/configs\"\u003eSee the file list of all configs.\u003c/a\u003e\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eTo use a config from there, build the URL like this:\u003c/p\u003e\n\u003cmarkdown-accessiblity-table\u003e\u003ctable\u003e\n\u003cthead\u003e\n\u003ctr\u003e\n\u003cth\u003e\u003c/th\u003e\n\u003cth\u003e\u003c/th\u003e\n\u003c/tr\u003e\n\u003c/thead\u003e\n\u003ctbody\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003elib/html2rss/configs/\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003e\u003ccode\u003edomainname.tld/whatever.yml\u003c/code\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003eWould become this URL:\u003c/td\u003e\n\u003ctd\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003ehttp://localhost:3000/\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003e\u003ccode\u003edomainname.tld/whatever.rss\u003c/code\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003c/td\u003e\n\u003ctd\u003e\u003ccode\u003e^^^^^^^^^^^^^^^^^^^^^^^^^^^\u003c/code\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003c/tbody\u003e\n\u003c/table\u003e\u003c/markdown-accessiblity-table\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eHow to build your RSS feeds\u003c/h2\u003e\u003ca id=\"user-content-how-to-build-your-rss-feeds\" class=\"anchor\" aria-label=\"Permalink: How to build your RSS feeds\" href=\"#how-to-build-your-rss-feeds\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eTo build your own RSS feed, you need to create a \u003cem\u003efeed config\u003c/em\u003e.\u003cbr\u003e\nThat \u003cem\u003efeed config\u003c/em\u003e goes into the file \u003ccode\u003efeeds.yml\u003c/code\u003e.\u003cbr\u003e\nCheck out the \u003ca href=\"https://github.com/html2rss/html2rss-web/blob/master/config/feeds.yml#L9\"\u003e\u003ccode\u003eexample\u003c/code\u003e feed config\u003c/a\u003e.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003ePlease refer to \u003ca href=\"https://github.com/html2rss/html2rss#the-feed-config-and-its-options\"\u003ehtml2rss' README for a description of \u003cem\u003ethe feed config and its options\u003c/em\u003e\u003c/a\u003e. html2rss-web is just a small web application that depends on html2rss.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eVersioning and releases\u003c/h2\u003e\u003ca id=\"user-content-versioning-and-releases\" class=\"anchor\" aria-label=\"Permalink: Versioning and releases\" href=\"#versioning-and-releases\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis web application is distributed in a \u003ca href=\"https://en.wikipedia.org/wiki/Rolling_release\" rel=\"nofollow\"\u003erolling release\u003c/a\u003e fashion from the \u003ccode\u003emaster\u003c/code\u003e branch.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eFor the latest commit passing GitHub CI/CD on the master branch, an updated Docker image will be pushed to \u003ca href=\"https://hub.docker.com/r/gilcreator/html2rss-web\" rel=\"nofollow\"\u003eDocker Hub: \u003ccode\u003egilcreator/html2rss-web\u003c/code\u003e\u003c/a\u003e.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eGitHub's @dependabot is enabled for dependency updates and they are automatically merged to the \u003ccode\u003emaster\u003c/code\u003e branch when the CI gives the green light.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you use Docker, you should update to the latest image automatically by \u003ca href=\"#get-started\"\u003esetting up \u003cem\u003ewatchtower\u003c/em\u003e as described\u003c/a\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eUse in production\u003c/h2\u003e\u003ca id=\"user-content-use-in-production\" class=\"anchor\" aria-label=\"Permalink: Use in production\" href=\"#use-in-production\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis app is published on Docker Hub and therefore easy to use with Docker.\u003cbr\u003e\nThe above \u003ccode\u003edocker-compose.yml\u003c/code\u003e is a good starting point.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you're going to host a public instance, \u003cem\u003eplease, please, please\u003c/em\u003e:\u003c/p\u003e\n\u003cul dir=\"auto\"\u003e\n\u003cli\u003ePut the application behind a reverse proxy.\u003c/li\u003e\n\u003cli\u003eAllow outside connections only via HTTPS.\u003c/li\u003e\n\u003cli\u003eHave an auto-update strategy (e.g., watchtower).\u003c/li\u003e\n\u003cli\u003eMonitor your \u003ccode\u003e/health_check.txt\u003c/code\u003e endpoint.\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"https://github.com/html2rss/html2rss-web/wiki/Instances\"\u003eLet the world know and add your instance to the wiki\u003c/a\u003e -- thank you!\u003c/li\u003e\n\u003c/ul\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eSupported ENV variables\u003c/h3\u003e\u003ca id=\"user-content-supported-env-variables\" class=\"anchor\" aria-label=\"Permalink: Supported ENV variables\" href=\"#supported-env-variables\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cmarkdown-accessiblity-table\u003e\u003ctable\u003e\n\u003cthead\u003e\n\u003ctr\u003e\n\u003cth\u003eName\u003c/th\u003e\n\u003cth\u003eDescription\u003c/th\u003e\n\u003c/tr\u003e\n\u003c/thead\u003e\n\u003ctbody\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003ePORT\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 3000\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eRACK_ENV\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 'development'\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eRACK_TIMEOUT_SERVICE_TIMEOUT\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 15\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eWEB_CONCURRENCY\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 2\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eWEB_MAX_THREADS\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 5\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eHEALTH_CHECK_USERNAME\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: auto-generated on start\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eHEALTH_CHECK_PASSWORD\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: auto-generated on start\u003c/td\u003e\n\u003c/tr\u003e\n\u003c/tbody\u003e\n\u003c/table\u003e\u003c/markdown-accessiblity-table\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eRuntime monitoring via \u003ccode\u003eGET /health_check.txt\u003c/code\u003e\u003c/h3\u003e\u003ca id=\"user-content-runtime-monitoring-via-get-health_checktxt\" class=\"anchor\" aria-label=\"Permalink: Runtime monitoring via GET /health_check.txt\" href=\"#runtime-monitoring-via-get-health_checktxt\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eIt is recommended to set up monitoring of the \u003ccode\u003e/health_check.txt\u003c/code\u003e endpoint. With that, you can find out when one of \u003cem\u003eyour own\u003c/em\u003e configs breaks. The endpoint uses HTTP Basic authentication.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eFirst, set the username and password via these environment variables: \u003ccode\u003eHEALTH_CHECK_USERNAME\u003c/code\u003e and \u003ccode\u003eHEALTH_CHECK_PASSWORD\u003c/code\u003e. If these are not set, html2rss-web will generate a new random username and password on \u003cem\u003eeach\u003c/em\u003e start.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eAn authenticated \u003ccode\u003eGET /health_check.txt\u003c/code\u003e request will respond with:\u003c/p\u003e\n\u003cul dir=\"auto\"\u003e\n\u003cli\u003eIf the feeds are generatable: \u003ccode\u003esuccess\u003c/code\u003e.\u003c/li\u003e\n\u003cli\u003eOtherwise: the names of the broken configs.\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp dir=\"auto\"\u003eTo get notified when one of your configs breaks, set up monitoring of this endpoint.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003e\u003ca href=\"https://uptimerobot.com/\" rel=\"nofollow\"\u003eUptimeRobot's free plan\u003c/a\u003e is sufficient for basic monitoring (every 5 minutes).\u003cbr\u003e\nCreate a monitor of type \u003cem\u003eKeyword\u003c/em\u003e with this information and make it aware of your username and password:\u003c/p\u003e\n\u003cp dir=\"auto\"\u003e\u003ca target=\"_blank\" rel=\"noopener noreferrer\" href=\"/html2rss/html2rss-web/blob/master/docs/uptimerobot_monitor.jpg\"\u003e\u003cimg src=\"/html2rss/html2rss-web/raw/master/docs/uptimerobot_monitor.jpg\" alt=\"A screenshot showing the Keyword Monitor: a name, the instance's URL to /health_check.txt, and an interval.\" style=\"max-width: 100%;\"\u003e\u003c/a\u003e\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eSetup for development\u003c/h2\u003e\u003ca id=\"user-content-setup-for-development\" class=\"anchor\" aria-label=\"Permalink: Setup for development\" href=\"#setup-for-development\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eCheck out the git repository and…\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eUsing Docker\u003c/h3\u003e\u003ca id=\"user-content-using-docker\" class=\"anchor\" aria-label=\"Permalink: Using Docker\" href=\"#using-docker\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis approach allows you to experiment without installing Ruby on your machine.\nAll you need to do is install and run Docker.\u003c/p\u003e\n\u003cdiv class=\"highlight highlight-source-shell notranslate position-relative overflow-auto\" dir=\"auto\" data-snippet-clipboard-copy-content=\"# Build image from Dockerfile and name/tag it as html2rss-web:\ndocker build -t html2rss-web -f Dockerfile .\n\n# Run the image and name it html2rss-web-dev:\ndocker run \\\n  --detach \\\n  --mount type=bind,source=$(pwd)/config,target=/app/config \\\n  --name html2rss-web-dev \\\n  html2rss-web\n\n# Open an interactive TTY with the shell `sh`:\ndocker exec -ti html2rss-web-dev sh\n\n# Stop and clean up the container\ndocker stop html2rss-web-dev\ndocker rm html2rss-web-dev\n\n# Remove the image\ndocker rmi html2rss-web\"\u003e\u003cpre\u003e\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Build image from Dockerfile and name/tag it as html2rss-web:\u003c/span\u003e\ndocker build -t html2rss-web -f Dockerfile \u003cspan class=\"pl-c1\"\u003e.\u003c/span\u003e\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Run the image and name it html2rss-web-dev:\u003c/span\u003e\ndocker run \\\n  --detach \\\n  --mount type=bind,source=\u003cspan class=\"pl-s\"\u003e\u003cspan class=\"pl-pds\"\u003e$(\u003c/span\u003epwd\u003cspan class=\"pl-pds\"\u003e)\u003c/span\u003e\u003c/span\u003e/config,target=/app/config \\\n  --name html2rss-web-dev \\\n  html2rss-web\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Open an interactive TTY with the shell `sh`:\u003c/span\u003e\ndocker \u003cspan class=\"pl-c1\"\u003eexec\u003c/span\u003e -ti html2rss-web-dev sh\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Stop and clean up the container\u003c/span\u003e\ndocker stop html2rss-web-dev\ndocker rm html2rss-web-dev\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Remove the image\u003c/span\u003e\ndocker rmi html2rss-web\u003c/pre\u003e\u003c/div\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eUsing installed Ruby\u003c/h3\u003e\u003ca id=\"user-content-using-installed-ruby\" class=\"anchor\" aria-label=\"Permalink: Using installed Ruby\" href=\"#using-installed-ruby\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eIf you're comfortable with installing Ruby directly on your machine, follow these instructions:\u003c/p\u003e\n\u003col dir=\"auto\"\u003e\n\u003cli\u003eInstall Ruby \u003ccode\u003e\u0026gt;= 3.2\u003c/code\u003e\u003c/li\u003e\n\u003cli\u003e\u003ccode\u003egem install bundler foreman\u003c/code\u003e\u003c/li\u003e\n\u003cli\u003e\u003ccode\u003ebundle\u003c/code\u003e\u003c/li\u003e\n\u003cli\u003e\u003ccode\u003eforeman start\u003c/code\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp dir=\"auto\"\u003e\u003cem\u003ehtml2rss-web\u003c/em\u003e now listens on port \u003cstrong\u003e3000\u003c/strong\u003e for requests.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eContribute\u003c/h2\u003e\u003ca id=\"user-content-contribute\" class=\"anchor\" aria-label=\"Permalink: Contribute\" href=\"#contribute\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eContributions are welcome!\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eOpen a pull request with your changes,\u003cbr\u003e\nopen an issue, or\u003cbr\u003e\n\u003ca href=\"https://github.com/orgs/html2rss/discussions\"\u003ejoin discussions on html2rss\u003c/a\u003e.\u003c/p\u003e\n\u003c/article\u003e","loaded":true,"timedOut":false,"errorMessage":null,"headerInfo":{"toc":[{"level":1,"text":"html2rss-web","anchor":"html2rss-web","htmlText":"html2rss-web"},{"level":2,"text":"Get started","anchor":"get-started","htmlText":"Get started"},{"level":3,"text":"With Docker","anchor":"with-docker","htmlText":"With Docker"},{"level":3,"text":"With docker compose","anchor":"with-docker-compose","htmlText":"With docker compose"},{"level":2,"text":"Docker: Automatically keep the html2rss-web image up-to-date","anchor":"docker-automatically-keep-the-html2rss-web-image-up-to-date","htmlText":"Docker: Automatically keep the html2rss-web image up-to-date"},{"level":2,"text":"How to use the included configs","anchor":"how-to-use-the-included-configs","htmlText":"How to use the included configs"},{"level":2,"text":"How to build your RSS feeds","anchor":"how-to-build-your-rss-feeds","htmlText":"How to build your RSS feeds"},{"level":2,"text":"Versioning and releases","anchor":"versioning-and-releases","htmlText":"Versioning and releases"},{"level":2,"text":"Use in production","anchor":"use-in-production","htmlText":"Use in production"},{"level":3,"text":"Supported ENV variables","anchor":"supported-env-variables","htmlText":"Supported ENV variables"},{"level":3,"text":"Runtime monitoring via GET /health_check.txt","anchor":"runtime-monitoring-via-get-health_checktxt","htmlText":"Runtime monitoring via GET /health_check.txt"},{"level":2,"text":"Setup for development","anchor":"setup-for-development","htmlText":"Setup for development"},{"level":3,"text":"Using Docker","anchor":"using-docker","htmlText":"Using Docker"},{"level":3,"text":"Using installed Ruby","anchor":"using-installed-ruby","htmlText":"Using installed Ruby"},{"level":2,"text":"Contribute","anchor":"contribute","htmlText":"Contribute"}],"siteNavLoginPath":"/login?return_to=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web"}},{"displayName":"LICENSE","repoName":"html2rss-web","refName":"master","path":"LICENSE","preferredFileType":"license","tabName":"MIT","richText":null,"loaded":false,"timedOut":false,"errorMessage":null,"headerInfo":{"toc":null,"siteNavLoginPath":"/login?return_to=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web"}}],"overviewFilesProcessingTime":0}},"appPayload":{"helpUrl":"https://docs.github.com","findFileWorkerPath":"/assets-cdn/worker/find-file-worker-1583894afd38.js","findInFileWorkerPath":"/assets-cdn/worker/find-in-file-worker-f653046cb227.js","githubDevUrl":null,"enabled_features":{"code_nav_ui_events":false,"overview_shared_code_dropdown_button":false,"react_blob_overlay":false,"copilot_conversational_ux_embedding_update":false,"copilot_smell_icebreaker_ux":true,"copilot_workspace":false,"blob_edit_unsaved_changes_storage":false,"accessible_code_button":true,"overview_branch_and_tag_count":true,"overview_spoofed_commit_banner_react":true}}}}</script>
  <div data-target="react-partial.reactRoot"><style data-styled="true" data-styled-version="5.3.11">.iVEunk{margin-top:16px;margin-bottom:16px;}/*!sc*/
.jzuOtQ{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;}/*!sc*/
.bGojzy{margin-bottom:0;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;row-gap:16px;}/*!sc*/
.iNSVHo{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;padding-bottom:16px;padding-top:8px;}/*!sc*/
.bVgnfw{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;gap:8px;}/*!sc*/
@media screen and (max-width:320px){.bVgnfw{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}}/*!sc*/
.CEgMp{position:relative;}/*!sc*/
@media screen and (max-width:380px){.CEgMp .ref-selector-button-text-container{max-width:80px;}}/*!sc*/
@media screen and (max-width:320px){.CEgMp{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}.CEgMp .overview-ref-selector{width:100%;}.CEgMp .overview-ref-selector > span{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}.CEgMp .overview-ref-selector > span > span[data-component="text"]{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}}/*!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*/
.ffLUq{font-size:14px;min-width:0;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*/
.fLXEGX{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (max-width:1079px){.fLXEGX{display:none;}}/*!sc*/
.dqfxud{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (min-width:1080px){.dqfxud{display:none;}}/*!sc*/
@media screen and (max-width:543px){.dqfxud{display:none;}}/*!sc*/
.jxTzTd{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;padding-left:8px;gap:8px;}/*!sc*/
.gqqBXN{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;gap:8px;}/*!sc*/
@media screen and (max-width:543px){.gqqBXN{display:none;}}/*!sc*/
.dzXgxt{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (max-width:1011px){.dzXgxt{display:none;}}/*!sc*/
.YUPas{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (min-width:1012px){.YUPas{display:none;}}/*!sc*/
.izFOf{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (min-width:544px){.izFOf{display:none;}}/*!sc*/
.vIPPs{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;gap:16px;}/*!sc*/
.fdROMU{width:100%;border-collapse:separate;border-spacing:0;border:1px solid;border-color:var(--borderColor-default,var(--color-border-default,#d0d7de));border-radius:6px;table-layout:fixed;overflow:unset;}/*!sc*/
.jGKpsv{height:0px;line-height:0px;}/*!sc*/
.jGKpsv tr{height:0px;font-size:0px;}/*!sc*/
.jdgHnn{padding:16px;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));font-size:12px;text-align:left;height:40px;}/*!sc*/
.jdgHnn th{padding-left:16px;background-color:var(--bgColor-muted,var(--color-canvas-subtle,#f6f8fa));}/*!sc*/
.bQivRW{width:100%;border-top-left-radius:6px;}/*!sc*/
@media screen and (min-width:544px){.bQivRW{display:none;}}/*!sc*/
.ldkMIO{width:40%;border-top-left-radius:6px;}/*!sc*/
@media screen and (max-width:543px){.ldkMIO{display:none;}}/*!sc*/
.jMbWeI{text-align:right;padding-right:16px;width:136px;border-top-right-radius:6px;}/*!sc*/
.gpqjiB{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));font-size:12px;height:40px;}/*!sc*/
.dzCJzi{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-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;gap:8px;min-width:273px;padding:8px;}/*!sc*/
@media screen and (min-width:544px){.dzCJzi{-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;}}/*!sc*/
.eNCcrz{text-align:center;vertical-align:center;height:40px;border-top:1px solid;border-color:var(--borderColor-default,var(--color-border-default,#d0d7de));}/*!sc*/
.bHTcCe{border-top:1px solid var(--borderColor-default,var(--color-border-default));cursor:pointer;}/*!sc*/
.csrIcr{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;gap:16px;}/*!sc*/
.bUQNHB{border:1px solid;border-color:var(--borderColor-default,var(--color-border-default,#d0d7de));border-radius:6px;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
@media screen and (max-width:543px){.bUQNHB{margin-left:-16px;margin-right:-16px;max-width:calc(100% + 32px);}}/*!sc*/
@media screen and (min-width:544px){.bUQNHB{max-width:100%;}}/*!sc*/
.jPdcfu{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;border-bottom:1px solid;border-bottom-color:var(--borderColor-default,var(--color-border-default,#d0d7de));-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding-right:8px;position:-webkit-sticky;position:sticky;top:0;background-color:var(--bgColor-default,var(--color-canvas-default,#ffffff));z-index:1;border-top-left-radius:6px;border-top-right-radius:6px;}/*!sc*/
.hUCRAk{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
.QkQOb{padding:32px;overflow:auto;}/*!sc*/
data-styled.g1[id="Box-sc-g0xbh4-0"]{content:"iVEunk,jzuOtQ,bGojzy,iNSVHo,bVgnfw,CEgMp,gUkoLg,bZBlpz,lhTYNA,ffLUq,hzSPyu,fLXEGX,dqfxud,jxTzTd,gqqBXN,dzXgxt,YUPas,izFOf,vIPPs,fdROMU,jGKpsv,jdgHnn,bQivRW,ldkMIO,jMbWeI,gpqjiB,dzCJzi,eNCcrz,bHTcCe,csrIcr,bUQNHB,jPdcfu,hUCRAk,QkQOb,"}/*!sc*/
.gVXRRg{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*/
.gVXRRg:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gVXRRg:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.gVXRRg:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gVXRRg[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.gVXRRg[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.gVXRRg:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.gVXRRg:active{-webkit-transition:none;transition:none;}/*!sc*/
.gVXRRg[data-inactive]{cursor:auto;}/*!sc*/
.gVXRRg: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*/
.gVXRRg:disabled [data-component=ButtonCounter]{color:inherit;}/*!sc*/
@media (forced-colors:active){.gVXRRg:focus{outline:solid 1px transparent;}}/*!sc*/
.gVXRRg [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*/
.gVXRRg[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.gVXRRg[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.gVXRRg[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.gVXRRg[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gVXRRg[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.gVXRRg[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.gVXRRg[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.gVXRRg[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gVXRRg[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.gVXRRg[data-block="block"]{width:100%;}/*!sc*/
.gVXRRg[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*/
.gVXRRg[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*/
.gVXRRg[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.gVXRRg[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.gVXRRg[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.gVXRRg[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*/
.gVXRRg[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.gVXRRg[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*/
.gVXRRg[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.gVXRRg [data-component="leadingVisual"]{grid-area:leadingVisual;}/*!sc*/
.gVXRRg [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.gVXRRg [data-component="trailingVisual"]{grid-area:trailingVisual;}/*!sc*/
.gVXRRg [data-component="trailingAction"]{margin-right:-4px;}/*!sc*/
.gVXRRg [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*/
.gVXRRg [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gVXRRg [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gVXRRg [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.gVXRRg: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*/
.gVXRRg: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*/
.gVXRRg[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*/
.gVXRRg [data-component="leadingVisual"],.gVXRRg [data-component="trailingVisual"],.gVXRRg [data-component="trailingAction"]{color:var(--button-color,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gVXRRg[data-component="IconButton"][data-no-visuals]:not(:disabled){color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gVXRRg[data-size="medium"]{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;min-width:0;}/*!sc*/
.gVXRRg[data-size="medium"] svg{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gVXRRg[data-size="medium"] > span{width:inherit;}/*!sc*/
.loAzyw{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*/
.loAzyw:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.loAzyw:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.loAzyw:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.loAzyw[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.loAzyw[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.loAzyw:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.loAzyw:active{-webkit-transition:none;transition:none;}/*!sc*/
.loAzyw[data-inactive]{cursor:auto;}/*!sc*/
.loAzyw: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*/
.loAzyw:disabled [data-component=ButtonCounter],.loAzyw:disabled [data-component="leadingVisual"],.loAzyw:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.loAzyw:focus{outline:solid 1px transparent;}}/*!sc*/
.loAzyw [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.loAzyw[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.loAzyw[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.loAzyw[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.loAzyw[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.loAzyw[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.loAzyw[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.loAzyw[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.loAzyw[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.loAzyw[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.loAzyw[data-block="block"]{width:100%;}/*!sc*/
.loAzyw[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*/
.loAzyw[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*/
.loAzyw[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.loAzyw[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.loAzyw[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.loAzyw[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*/
.loAzyw[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.loAzyw[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*/
.loAzyw[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.loAzyw [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.loAzyw [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw [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*/
.loAzyw [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.loAzyw [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.loAzyw [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.loAzyw: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*/
.loAzyw: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*/
.loAzyw[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*/
.loAzyw[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.loAzyw:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.loAzyw:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.loAzyw:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.loAzyw[data-size="medium"]{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));padding-left:4px;padding-right:4px;}/*!sc*/
.loAzyw[data-size="medium"] span[data-component="leadingVisual"]{margin-right:4px !important;}/*!sc*/
.cXsOlJ{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*/
.cXsOlJ:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.cXsOlJ:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.cXsOlJ:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.cXsOlJ[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.cXsOlJ[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.cXsOlJ:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.cXsOlJ:active{-webkit-transition:none;transition:none;}/*!sc*/
.cXsOlJ[data-inactive]{cursor:auto;}/*!sc*/
.cXsOlJ: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*/
.cXsOlJ:disabled [data-component=ButtonCounter],.cXsOlJ:disabled [data-component="leadingVisual"],.cXsOlJ:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.cXsOlJ:focus{outline:solid 1px transparent;}}/*!sc*/
.cXsOlJ [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.cXsOlJ[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.cXsOlJ[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.cXsOlJ[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.cXsOlJ[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.cXsOlJ[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.cXsOlJ[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.cXsOlJ[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.cXsOlJ[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.cXsOlJ[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.cXsOlJ[data-block="block"]{width:100%;}/*!sc*/
.cXsOlJ[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*/
.cXsOlJ[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*/
.cXsOlJ[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.cXsOlJ[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.cXsOlJ[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.cXsOlJ[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*/
.cXsOlJ[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.cXsOlJ[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*/
.cXsOlJ[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.cXsOlJ [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.cXsOlJ [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ [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*/
.cXsOlJ [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.cXsOlJ [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.cXsOlJ [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.cXsOlJ: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*/
.cXsOlJ: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*/
.cXsOlJ[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*/
.cXsOlJ[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.cXsOlJ:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.cXsOlJ:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.cXsOlJ:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.cXsOlJ[data-size="medium"][data-no-visuals]{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!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*/
.bmlmSe{border-radius:6px;border:1px solid;border-color:var(--button-primary-borderColor-rest,var(--color-btn-primary-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-primary-fgColor-rest,var(--color-btn-primary-text,#ffffff));background-color:var(--button-primary-bgColor-rest,var(--color-btn-primary-bg,#1f883d));box-shadow:var(--shadow-resting-small,var(--color-btn-primary-shadow,0 1px 0 rgba(31,35,40,0.1)));}/*!sc*/
.bmlmSe:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.bmlmSe:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.bmlmSe:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.bmlmSe[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.bmlmSe[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.bmlmSe:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.bmlmSe:active{-webkit-transition:none;transition:none;}/*!sc*/
.bmlmSe[data-inactive]{cursor:auto;}/*!sc*/
.bmlmSe:disabled{cursor:not-allowed;box-shadow:none;color:var(--button-primary-fgColor-disabled,var(--color-btn-primary-disabled-text,rgba(255,255,255,0.8)));background-color:var(--button-primary-bgColor-disabled,var(--color-btn-primary-disabled-bg,#94d3a2));border-color:var(--button-primary-borderColor-disabled,var(--color-btn-primary-disabled-border,rgba(31,35,40,0.15)));}/*!sc*/
.bmlmSe:disabled [data-component=ButtonCounter]{color:inherit;}/*!sc*/
@media (forced-colors:active){.bmlmSe:focus{outline:solid 1px transparent;}}/*!sc*/
.bmlmSe [data-component=ButtonCounter]{font-size:12px;background-color:var(--buttonCounter-primary-bgColor-rest,var(--color-btn-primary-counter-bg,rgba(0,45,17,0.2)));color:var(--button-primary-fgColor-rest,var(--color-btn-primary-text,#ffffff));}/*!sc*/
.bmlmSe[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.bmlmSe[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.bmlmSe[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.bmlmSe[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.bmlmSe[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.bmlmSe[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.bmlmSe[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.bmlmSe[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.bmlmSe[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.bmlmSe[data-block="block"]{width:100%;}/*!sc*/
.bmlmSe[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*/
.bmlmSe[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*/
.bmlmSe[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.bmlmSe[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.bmlmSe[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.bmlmSe[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*/
.bmlmSe[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.bmlmSe[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*/
.bmlmSe[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.bmlmSe [data-component="leadingVisual"]{grid-area:leadingVisual;}/*!sc*/
.bmlmSe [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.bmlmSe [data-component="trailingVisual"]{grid-area:trailingVisual;}/*!sc*/
.bmlmSe [data-component="trailingAction"]{margin-right:-4px;}/*!sc*/
.bmlmSe [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*/
.bmlmSe [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.bmlmSe [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.bmlmSe [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.bmlmSe:hover:not([disabled]):not([data-inactive]){color:btn.primary.hoverText;background-color:var(--button-primary-bgColor-hover,var(--color-btn-primary-hover-bg,#1a7f37));}/*!sc*/
.bmlmSe:focus:not([disabled]){box-shadow:inset 0 0 0 3px;}/*!sc*/
.bmlmSe:focus-visible:not([disabled]){box-shadow:inset 0 0 0 3px;}/*!sc*/
.bmlmSe:active:not([disabled]):not([data-inactive]){background-color:var(--button-primary-bgColor-active,var(--color-btn-primary-selected-bg,hsla(137,66%,28%,1)));box-shadow:var(--button-primary-shadow-selected,var(--color-btn-primary-selected-shadow,inset 0 1px 0 rgba(0,45,17,0.2)));}/*!sc*/
.bmlmSe[aria-expanded=true]{background-color:var(--button-primary-bgColor-active,var(--color-btn-primary-selected-bg,hsla(137,66%,28%,1)));box-shadow:var(--button-primary-shadow-selected,var(--color-btn-primary-selected-shadow,inset 0 1px 0 rgba(0,45,17,0.2)));}/*!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*/
.gXPTqA{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*/
.gXPTqA:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gXPTqA:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.gXPTqA:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gXPTqA[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.gXPTqA[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.gXPTqA:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.gXPTqA:active{-webkit-transition:none;transition:none;}/*!sc*/
.gXPTqA[data-inactive]{cursor:auto;}/*!sc*/
.gXPTqA: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*/
.gXPTqA:disabled [data-component=ButtonCounter],.gXPTqA:disabled [data-component="leadingVisual"],.gXPTqA:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.gXPTqA:focus{outline:solid 1px transparent;}}/*!sc*/
.gXPTqA [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gXPTqA[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.gXPTqA[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.gXPTqA[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.gXPTqA[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gXPTqA[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.gXPTqA[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.gXPTqA[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.gXPTqA[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gXPTqA[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.gXPTqA[data-block="block"]{width:100%;}/*!sc*/
.gXPTqA[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*/
.gXPTqA[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*/
.gXPTqA[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.gXPTqA[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.gXPTqA[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.gXPTqA[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*/
.gXPTqA[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.gXPTqA[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*/
.gXPTqA[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.gXPTqA [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.gXPTqA [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA [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*/
.gXPTqA [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gXPTqA [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gXPTqA [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.gXPTqA: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*/
.gXPTqA: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*/
.gXPTqA[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*/
.gXPTqA[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.gXPTqA:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.gXPTqA:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.gXPTqA:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.gXPTqA[data-size="medium"]{color:var(--fgColor-muted,var(--color-fg-subtle,#6e7781));padding-left:8px;padding-right:8px;}/*!sc*/
data-styled.g4[id="types__StyledButton-sc-ws60qy-0"]{content:"gVXRRg,loAzyw,cXsOlJ,gGdPyq,bmlmSe,dPmZyJ,gXPTqA,"}/*!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*/
data-styled.g10[id="Link__StyledLink-sc-14289xe-0"]{content:"dIlPa,"}/*!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.g11[id="Tooltip__TooltipBase-sc-17tf59c-0"]{content:"hWlpPn,"}/*!sc*/
.brGdpi{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;-webkit-clip:rect(0,0,0,0);clip:rect(0,0,0,0);white-space:nowrap;border-width:0;}/*!sc*/
data-styled.g12[id="_VisuallyHidden__VisuallyHidden-sc-11jhm7a-0"]{content:"brGdpi,"}/*!sc*/
.liVpTx{display:inline-block;overflow:hidden;text-overflow:ellipsis;vertical-align:top;white-space:nowrap;max-width:125px;}/*!sc*/
data-styled.g14[id="Truncate__StyledTruncate-sc-23o1d2-0"]{content:"liVpTx,"}/*!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*/
data-styled.g23[id="Text__StyledText-sc-17v1xeu-0"]{content:"eMMFM,"}/*!sc*/
.iBVwpg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;padding-inline:var(--stack-padding-normal,16px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:var(--control-xlarge-size,48px);box-shadow:inset 0px -1px var(--borderColor-muted,var(--borderColor-muted,var(--color-border-muted,hsla(210,18%,87%,1))));-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;border-bottom:none;max-width:100%;padding-left:8px;padding-right:8px;}/*!sc*/
data-styled.g24[id="UnderlineTabbedInterface__StyledUnderlineWrapper-sc-4ilrg0-0"]{content:"iBVwpg,"}/*!sc*/
.gJyWUl{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;list-style:none;white-space:nowrap;padding:0;margin:0;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;gap:8px;position:relative;}/*!sc*/
data-styled.g25[id="UnderlineTabbedInterface__StyledUnderlineItemList-sc-4ilrg0-1"]{content:"gJyWUl,"}/*!sc*/
.beOdPj{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border:0;cursor:pointer;font:inherit;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;color:var(--fgColor-default,var(--color-fg-default,#1F2328));text-align:center;-webkit-text-decoration:none;text-decoration:none;line-height:var(--text-body-lineHeight-medium,1.4285);border-radius:var(--borderRadius-medium,6px);font-size:var(--text-body-size-medium,14px);padding-inline:var(--control-medium-paddingInline-condensed,8px);padding-block:var(--control-medium-paddingBlock,6px);-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
@media (hover:hover){.beOdPj:hover{background-color:var(--bgColor-neutral-muted,var(--bgColor-neutral-muted,var(--color-neutral-subtle,rgba(234,238,242,0.5))));-webkit-transition:background 0.12s ease-out;transition:background 0.12s ease-out;-webkit-text-decoration:none;text-decoration:none;}}/*!sc*/
.beOdPj:focus:{outline:2px solid transparent;box-shadow:inset 0 0 0 2px var(--fgColor-accent,var(--fgColor-accent,var(--color-accent-fg,#0969da)));}/*!sc*/
.beOdPj:focus::not(:focus-visible){box-shadow:none;}/*!sc*/
.beOdPj:focus-visible{outline:2px solid transparent;box-shadow:inset 0 0 0 2px var(--fgColor-accent,var(--fgColor-accent,var(--color-accent-fg,#0969da)));}/*!sc*/
.beOdPj [data-content]::before{content:attr(data-content);display:block;height:0;font-weight:var(--base-text-weight-semibold,500);visibility:hidden;white-space:nowrap;}/*!sc*/
.beOdPj [data-component='icon']{color:var(--fgColor-muted,var(--fgColor-muted,var(--color-fg-muted,#656d76)));-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;margin-inline-end:var(--control-medium-gap,8px);}/*!sc*/
.beOdPj [data-component='counter']{margin-inline-start:var(--control-medium-gap,8px);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;}/*!sc*/
.beOdPj::after{position:absolute;right:50%;bottom:calc(50% - calc(var(--control-xlarge-size,48px) / 2 + 1px));width:100%;height:2px;content:'';background-color:transparent;border-radius:0;-webkit-transform:translate(50%,-50%);-ms-transform:translate(50%,-50%);transform:translate(50%,-50%);}/*!sc*/
.beOdPj[aria-current]:not([aria-current='false']) [data-component='text'],.beOdPj[aria-selected='true'] [data-component='text']{font-weight:var(--base-text-weight-semibold,500);}/*!sc*/
.beOdPj[aria-current]:not([aria-current='false'])::after,.beOdPj[aria-selected='true']::after{background-color:var(--underlineNav-borderColor-active,var(--color-primer-border-active,#fd8c73));}/*!sc*/
@media (forced-colors:active){.beOdPj[aria-current]:not([aria-current='false'])::after,.beOdPj[aria-selected='true']::after{background-color:LinkText;}}/*!sc*/
data-styled.g26[id="UnderlineTabbedInterface__StyledUnderlineItem-sc-4ilrg0-2"]{content:"beOdPj,"}/*!sc*/
</style> <!-- --> <!-- --> <div class="Box-sc-g0xbh4-0 iVEunk"><div class="Box-sc-g0xbh4-0 jzuOtQ"><div class="Box-sc-g0xbh4-0 bGojzy"></div></div><div class="Box-sc-g0xbh4-0 iNSVHo"><div class="Box-sc-g0xbh4-0 bVgnfw"><div class="Box-sc-g0xbh4-0 CEgMp"><button type="button" aria-haspopup="true" aria-expanded="false" tabindex="0" aria-label="master branch" data-testid="anchor-button" class="types__StyledButton-sc-ws60qy-0 gVXRRg overview-ref-selector width-full" data-loading="false" data-size="medium" aria-describedby="branch-picker-repos-header-ref-selector-loading-announcement" id="branch-picker-repos-header-ref-selector"><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 ffLUq 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-scope="read-only-cursor-text-area"></button></div><div class="Box-sc-g0xbh4-0 fLXEGX"><a style="--button-color:fg.muted" type="button" href="/html2rss/html2rss-web/branches" class="types__StyledButton-sc-ws60qy-0 loAzyw" data-loading="false" data-size="medium" aria-describedby=":Rclab:-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 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></span><span data-component="text">Branches</span></span></a><a style="--button-color:fg.muted" type="button" href="/html2rss/html2rss-web/tags" class="types__StyledButton-sc-ws60qy-0 loAzyw" data-loading="false" data-size="medium" aria-describedby=":Rklab:-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 octicon-tag" 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="M1 7.775V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 0 1 0 2.474l-5.026 5.026a1.75 1.75 0 0 1-2.474 0l-6.25-6.25A1.752 1.752 0 0 1 1 7.775Zm1.5 0c0 .066.026.13.073.177l6.25 6.25a.25.25 0 0 0 .354 0l5.025-5.025a.25.25 0 0 0 0-.354l-6.25-6.25a.25.25 0 0 0-.177-.073H2.75a.25.25 0 0 0-.25.25ZM6 5a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"></path></svg></span><span data-component="text">Tags</span></span></a></div><div class="Box-sc-g0xbh4-0 dqfxud"><a style="--button-color:fg.muted" type="button" aria-label="Go to Branches page" href="/html2rss/html2rss-web/branches" class="types__StyledButton-sc-ws60qy-0 cXsOlJ" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":Relab:-loading-announcement"><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></a><a style="--button-color:fg.muted" type="button" aria-label="Go to Tags page" href="/html2rss/html2rss-web/tags" class="types__StyledButton-sc-ws60qy-0 cXsOlJ" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":Rmlab:-loading-announcement"><svg aria-hidden="true" focusable="false" class="octicon octicon-tag" 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="M1 7.775V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 0 1 0 2.474l-5.026 5.026a1.75 1.75 0 0 1-2.474 0l-6.25-6.25A1.752 1.752 0 0 1 1 7.775Zm1.5 0c0 .066.026.13.073.177l6.25 6.25a.25.25 0 0 0 .354 0l5.025-5.025a.25.25 0 0 0 0-.354l-6.25-6.25a.25.25 0 0 0-.177-.073H2.75a.25.25 0 0 0-.25.25ZM6 5a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"></path></svg></a></div></div><div class="Box-sc-g0xbh4-0 jxTzTd"><div class="Box-sc-g0xbh4-0 gqqBXN"><div class="Box-sc-g0xbh4-0 dzXgxt"><!--$!--><template></template><!--/$--></div><div class="Box-sc-g0xbh4-0 YUPas"><button type="button" class="types__StyledButton-sc-ws60qy-0 gGdPyq" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":Rr5ab:-loading-announcement"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="text">Go to file</span></span></button></div><div class="react-directory-add-file-icon"></div><div class="react-directory-remove-file-icon"></div></div><button type="button" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 bmlmSe" data-loading="false" data-size="medium" aria-describedby=":R55ab:-loading-announcement" id=":R55ab:"><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="hide-sm" 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></span><span data-component="text">Code</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 class="Box-sc-g0xbh4-0 izFOf"><button data-component="IconButton" type="button" aria-label="Open more actions menu" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 gGdPyq prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":R75ab:-loading-announcement" id=":R75ab:"><svg aria-hidden="true" focusable="false" class="octicon octicon-kebab-horizontal" 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="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></div></div></div><div class="Box-sc-g0xbh4-0 vIPPs"><div data-hpc="true"><button hidden="" data-testid="focus-next-element-button" data-hotkey="j"></button><button hidden="" data-testid="focus-previous-element-button" data-hotkey="k"></button><h2 class="sr-only prc-Heading-Heading-6CmGO" data-testid="screen-reader-heading" id="folders-and-files">Folders and files</h2><table aria-labelledby="folders-and-files" class="Box-sc-g0xbh4-0 fdROMU"><thead class="Box-sc-g0xbh4-0 jGKpsv"><tr class="Box-sc-g0xbh4-0 jdgHnn"><th colSpan="2" class="Box-sc-g0xbh4-0 bQivRW"><span class="text-bold">Name</span></th><th colSpan="1" class="Box-sc-g0xbh4-0 ldkMIO"><span class="text-bold">Name</span></th><th class="hide-sm"><div title="Last commit message" class="Truncate__StyledTruncate-sc-23o1d2-0 liVpTx width-fit"><span class="text-bold">Last commit message</span></div></th><th colSpan="1" class="Box-sc-g0xbh4-0 jMbWeI"><div title="Last commit date" class="Truncate__StyledTruncate-sc-23o1d2-0 liVpTx width-fit"><span class="text-bold">Last commit date</span></div></th></tr></thead><tbody><tr class="Box-sc-g0xbh4-0 gpqjiB"><td colSpan="3" class="bgColor-muted p-1 rounded-top-2"><div class="Box-sc-g0xbh4-0 dzCJzi"><h2 class="sr-only prc-Heading-Heading-6CmGO" data-testid="screen-reader-heading">Latest commit</h2><div style="width:120px" class="Skeleton Skeleton--text" data-testid="loading"> </div><div class="d-flex flex-shrink-0 gap-2"><div data-testid="latest-commit-details" class="d-none d-sm-flex flex-items-center"></div><div class="d-flex gap-2"><h2 class="sr-only prc-Heading-Heading-6CmGO" data-testid="screen-reader-heading">History</h2><a href="/html2rss/html2rss-web/commits/master/" class="types__StyledButton-sc-ws60qy-0 dPmZyJ d-none d-lg-flex LinkButton-module__code-view-link-button--xvCGA flex-items-center fgColor-default" data-loading="false" data-size="small" aria-describedby=":Raqj8pab:-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 octicon-history" 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="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></span><span data-component="text"><span class="fgColor-default">819 Commits</span></span></span></a><div class="d-sm-none"></div><div class="d-flex d-lg-none"><span role="tooltip" aria-label="819 Commits" id="history-icon-button-tooltip" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-n"><a href="/html2rss/html2rss-web/commits/master/" class="types__StyledButton-sc-ws60qy-0 dPmZyJ LinkButton-module__code-view-link-button--xvCGA flex-items-center fgColor-default" data-loading="false" data-size="small" aria-describedby=":R1iqj8pab:-loading-announcement history-icon-button-tooltip"><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 octicon-history" 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="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></span></span></a></span></div></div></div></div></td></tr><tr class="react-directory-row undefined" id="folder-row-0"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".github" aria-label=".github, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/.github">.github</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".github" aria-label=".github, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/.github">.github</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-1"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app" aria-label="app, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/app">app</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app" aria-label="app, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/app">app</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-2"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="bin" aria-label="bin, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/bin">bin</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="bin" aria-label="bin, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/bin">bin</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-3"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config" aria-label="config, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/config">config</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config" aria-label="config, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/config">config</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-4"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="docs" aria-label="docs, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/docs">docs</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="docs" aria-label="docs, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/docs">docs</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-5"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="helpers" aria-label="helpers, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/helpers">helpers</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="helpers" aria-label="helpers, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/helpers">helpers</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-6"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="public" aria-label="public, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/public">public</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="public" aria-label="public, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/public">public</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-7"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="This path skips through empty directories" aria-label="roda/roda_plugins, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/roda/roda_plugins"><span class="react-directory-default-color" data-testid="path-name-segment">roda/</span><span class="" data-testid="path-name-segment">roda_plugins</span></a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="This path skips through empty directories" aria-label="roda/roda_plugins, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/roda/roda_plugins"><span class="react-directory-default-color" data-testid="path-name-segment">roda/</span><span class="" data-testid="path-name-segment">roda_plugins</span></a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-8"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="spec" aria-label="spec, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/spec">spec</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="spec" aria-label="spec, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/spec">spec</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-9"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="tmp" aria-label="tmp, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/tmp">tmp</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="tmp" aria-label="tmp, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/tmp">tmp</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-10"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="views" aria-label="views, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/views">views</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="views" aria-label="views, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/views">views</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-11"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".dockerignore" aria-label=".dockerignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.dockerignore">.dockerignore</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".dockerignore" aria-label=".dockerignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.dockerignore">.dockerignore</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-12"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".gitignore" aria-label=".gitignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.gitignore">.gitignore</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".gitignore" aria-label=".gitignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.gitignore">.gitignore</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-13"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".mergify.yml" aria-label=".mergify.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.mergify.yml">.mergify.yml</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".mergify.yml" aria-label=".mergify.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.mergify.yml">.mergify.yml</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-14"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rspec" aria-label=".rspec, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rspec">.rspec</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rspec" aria-label=".rspec, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rspec">.rspec</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-15"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rubocop.yml" aria-label=".rubocop.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rubocop.yml">.rubocop.yml</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rubocop.yml" aria-label=".rubocop.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rubocop.yml">.rubocop.yml</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-16"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".ruby-version" aria-label=".ruby-version, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.ruby-version">.ruby-version</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".ruby-version" aria-label=".ruby-version, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.ruby-version">.ruby-version</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-17"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Dockerfile" aria-label="Dockerfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Dockerfile">Dockerfile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Dockerfile" aria-label="Dockerfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Dockerfile">Dockerfile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-18"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile" aria-label="Gemfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile">Gemfile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile" aria-label="Gemfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile">Gemfile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-19"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile.lock" aria-label="Gemfile.lock, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile.lock">Gemfile.lock</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile.lock" aria-label="Gemfile.lock, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile.lock">Gemfile.lock</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-20"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="LICENSE" aria-label="LICENSE, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/LICENSE">LICENSE</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="LICENSE" aria-label="LICENSE, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/LICENSE">LICENSE</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-21"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Procfile" aria-label="Procfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Procfile">Procfile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Procfile" aria-label="Procfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Procfile">Procfile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-22"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="README.md" aria-label="README.md, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/README.md">README.md</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="README.md" aria-label="README.md, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/README.md">README.md</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-23"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Rakefile" aria-label="Rakefile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Rakefile">Rakefile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Rakefile" aria-label="Rakefile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Rakefile">Rakefile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-24"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.json" aria-label="app.json, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.json">app.json</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.json" aria-label="app.json, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.json">app.json</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-25"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.rb" aria-label="app.rb, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.rb">app.rb</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.rb" aria-label="app.rb, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.rb">app.rb</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-26"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config.ru" aria-label="config.ru, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/config.ru">config.ru</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config.ru" aria-label="config.ru, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/config.ru">config.ru</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="Box-sc-g0xbh4-0 eNCcrz show-for-mobile" data-testid="view-all-files-row"><td colSpan="3" class="Box-sc-g0xbh4-0 bHTcCe"><div><button class="Link__StyledLink-sc-14289xe-0 dIlPa">View all files</button></div></td></tr></tbody></table></div><div class="Box-sc-g0xbh4-0 csrIcr"><div class="Box-sc-g0xbh4-0 bUQNHB"><div itemscope="" itemType="https://schema.org/abstract" class="Box-sc-g0xbh4-0 jPdcfu"><h2 class="_VisuallyHidden__VisuallyHidden-sc-11jhm7a-0 brGdpi">Repository files navigation</h2><nav aria-label="Repository files" class="UnderlineTabbedInterface__StyledUnderlineWrapper-sc-4ilrg0-0 iBVwpg"><ul role="list" class="UnderlineTabbedInterface__StyledUnderlineItemList-sc-4ilrg0-1 gJyWUl"><li class="Box-sc-g0xbh4-0 hUCRAk"><a href="#" aria-current="page" class="UnderlineTabbedInterface__StyledUnderlineItem-sc-4ilrg0-2 beOdPj"><span data-component="icon"><svg aria-hidden="true" focusable="false" class="octicon octicon-book" 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 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-component="text" data-content="README">README</span></a></li><li class="Box-sc-g0xbh4-0 hUCRAk"><a href="#" class="UnderlineTabbedInterface__StyledUnderlineItem-sc-4ilrg0-2 beOdPj"><span data-component="icon"><svg aria-hidden="true" focusable="false" class="octicon octicon-law" 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="M8.75.75V2h.985c.304 0 .603.08.867.231l1.29.736c.038.022.08.033.124.033h2.234a.75.75 0 0 1 0 1.5h-.427l2.111 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.006.005-.01.01-.045.04c-.21.176-.441.327-.686.45C14.556 10.78 13.88 11 13 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L12.178 4.5h-.162c-.305 0-.604-.079-.868-.231l-1.29-.736a.245.245 0 0 0-.124-.033H8.75V13h2.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1 0-1.5h2.5V3.5h-.984a.245.245 0 0 0-.124.033l-1.289.737c-.265.15-.564.23-.869.23h-.162l2.112 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.016.015-.045.04c-.21.176-.441.327-.686.45C4.556 10.78 3.88 11 3 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L2.178 4.5H1.75a.75.75 0 0 1 0-1.5h2.234a.249.249 0 0 0 .125-.033l1.288-.737c.265-.15.564-.23.869-.23h.984V.75a.75.75 0 0 1 1.5 0Zm2.945 8.477c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327Zm-10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327Z"></path></svg></span><span data-component="text" data-content="MIT license">MIT license</span></a></li></ul></nav><button style="--button-color:fg.subtle" type="button" aria-label="Outline" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 gXPTqA" data-loading="false" data-size="medium" aria-describedby=":Rr9ab:-loading-announcement" id=":Rr9ab:"><svg aria-hidden="true" focusable="false" class="octicon octicon-list-unordered" 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="M5.75 2.5h8.5a.75.75 0 0 1 0 1.5h-8.5a.75.75 0 0 1 0-1.5Zm0 5h8.5a.75.75 0 0 1 0 1.5h-8.5a.75.75 0 0 1 0-1.5Zm0 5h8.5a.75.75 0 0 1 0 1.5h-8.5a.75.75 0 0 1 0-1.5ZM2 14a1 1 0 1 1 0-2 1 1 0 0 1 0 2Zm1-6a1 1 0 1 1-2 0 1 1 0 0 1 2 0ZM2 4a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg></button></div><div class="Box-sc-g0xbh4-0 QkQOb js-snippet-clipboard-copy-unpositioned" data-hpc="true"><article class="markdown-body entry-content container-lg" itemprop="text"><p dir="auto"><a target="_blank" rel="noopener noreferrer" href="https://github.com/html2rss/html2rss/raw/master/support/logo.png"><img src="https://github.com/html2rss/html2rss/raw/master/support/logo.png" alt="html2rss logo" style="max-width: 100%;"></a></p>
<div class="markdown-heading" dir="auto"><h1 tabindex="-1" class="heading-element" dir="auto">html2rss-web</h1><a id="user-content-html2rss-web" class="anchor" aria-label="Permalink: html2rss-web" href="#html2rss-web"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This web application scrapes websites to build and deliver RSS 2.0 feeds.</p>
<p dir="auto"><strong>Features:</strong></p>
<ul dir="auto">
<li><a href="#how-to-build-your-rss-feeds">Create your custom feeds</a>!</li>
<li>Comes with plenty of <a href="https://github.com/html2rss/html2rss-configs">included configs</a> out of the box.</li>
<li>Handles request caching.</li>
<li>Sets caching-related HTTP headers.</li>
</ul>
<p dir="auto">The functionality of scraping websites and building the RSS feeds is provided by the Ruby gem <a href="https://github.com/html2rss/html2rss"><code>html2rss</code></a>.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Get started</h2><a id="user-content-get-started" class="anchor" aria-label="Permalink: Get started" href="#get-started"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This application should be used with Docker. It is designed to require as little maintenance as possible. See <a href="#versioning-and-releases">Versioning and Releases</a> and <a href="#docker-automatically-keep-the-html2rss-web-image-up-to-date">consider automatic updates</a>.</p>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">With Docker</h3><a id="user-content-with-docker" class="anchor" aria-label="Permalink: With Docker" href="#with-docker"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<div class="highlight highlight-source-shell notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="docker run -p 3000:3000 gilcreator/html2rss-web"><pre>docker run -p 3000:3000 gilcreator/html2rss-web</pre></div>
<p dir="auto">Then open <a href="http://127.0.0.1:3000/" rel="nofollow">http://127.0.0.1:3000/</a> in your browser and click the example feed link.</p>
<p dir="auto">This is the quickest way to get started. However, it's also the option with the least flexibility: it doesn't allow you to use custom feed configs and doesn't update automatically.</p>
<p dir="auto">If you want more flexibility and automatic updates sound good to you, read on to get started <em>with docker compose</em>…</p>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">With <code>docker compose</code></h3><a id="user-content-with-docker-compose" class="anchor" aria-label="Permalink: With docker compose" href="#with-docker-compose"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">Create a <code>docker-compose.yml</code> file and paste the following into it:</p>
<div class="highlight highlight-source-yaml notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="services:
  html2rss-web:
    image: gilcreator/html2rss-web
    ports:
      - &quot;3000:3000&quot;
    volumes:
      - type: bind
        source: ./feeds.yml
        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!
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - &quot;~/.docker/config.json:/config.json&quot;
    command: --cleanup --interval 7200"><pre><span class="pl-ent">services</span>:
  <span class="pl-ent">html2rss-web</span>:
    <span class="pl-ent">image</span>: <span class="pl-s">gilcreator/html2rss-web</span>
    <span class="pl-ent">ports</span>:
      - <span class="pl-s"><span class="pl-pds">"</span>3000:3000<span class="pl-pds">"</span></span>
    <span class="pl-ent">volumes</span>:
      - <span class="pl-ent">type</span>: <span class="pl-s">bind</span>
        <span class="pl-ent">source</span>: <span class="pl-s">./feeds.yml</span>
        <span class="pl-ent">target</span>: <span class="pl-s">/app/config/feeds.yml</span>
        <span class="pl-ent">read_only</span>: <span class="pl-c1">true</span>
    <span class="pl-ent">environment</span>:
      - <span class="pl-s">RACK_ENV=production</span>
      - <span class="pl-s">HEALTH_CHECK_USERNAME=health</span>
      - <span class="pl-s">HEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!</span>
  <span class="pl-ent">watchtower</span>:
    <span class="pl-ent">image</span>: <span class="pl-s">containrrr/watchtower</span>
    <span class="pl-ent">volumes</span>:
      - <span class="pl-s">/var/run/docker.sock:/var/run/docker.sock</span>
      - <span class="pl-s"><span class="pl-pds">"</span>~/.docker/config.json:/config.json<span class="pl-pds">"</span></span>
    <span class="pl-ent">command</span>: <span class="pl-s">--cleanup --interval 7200</span></pre></div>
<p dir="auto">Start it up with: <code>docker compose up</code>.</p>
<p dir="auto">If you have not created your <code>feeds.yml</code> yet, download <a href="https://raw.githubusercontent.com/html2rss/html2rss-web/master/config/feeds.yml" rel="nofollow">this <code>feeds.yml</code> as a blueprint</a> into the directory containing the <code>docker-compose.yml</code>.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Docker: Automatically keep the html2rss-web image up-to-date</h2><a id="user-content-docker-automatically-keep-the-html2rss-web-image-up-to-date" class="anchor" aria-label="Permalink: Docker: Automatically keep the html2rss-web image up-to-date" href="#docker-automatically-keep-the-html2rss-web-image-up-to-date"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">The <a href="https://containrrr.dev/watchtower/" rel="nofollow">watchtower</a> service automatically pulls running Docker images and checks for updates. If an update is available, it will automatically start the updated image with the same configuration as the running one. Please read its manual.</p>
<p dir="auto">The <code>docker-compose.yml</code> above contains a service description for watchtower.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">How to use the included configs</h2><a id="user-content-how-to-use-the-included-configs" class="anchor" aria-label="Permalink: How to use the included configs" href="#how-to-use-the-included-configs"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">html2rss-web comes with many feed configs out of the box. <a href="https://github.com/html2rss/html2rss-configs/tree/master/lib/html2rss/configs">See the file list of all configs.</a></p>
<p dir="auto">To use a config from there, build the URL like this:</p>
<markdown-accessiblity-table><table>
<thead>
<tr>
<th></th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td><code>lib/html2rss/configs/</code></td>
<td><code>domainname.tld/whatever.yml</code></td>
</tr>
<tr>
<td>Would become this URL:</td>
<td></td>
</tr>
<tr>
<td><code>http://localhost:3000/</code></td>
<td><code>domainname.tld/whatever.rss</code></td>
</tr>
<tr>
<td></td>
<td><code>^^^^^^^^^^^^^^^^^^^^^^^^^^^</code></td>
</tr>
</tbody>
</table></markdown-accessiblity-table>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">How to build your RSS feeds</h2><a id="user-content-how-to-build-your-rss-feeds" class="anchor" aria-label="Permalink: How to build your RSS feeds" href="#how-to-build-your-rss-feeds"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">To build your own RSS feed, you need to create a <em>feed config</em>.<br>
That <em>feed config</em> goes into the file <code>feeds.yml</code>.<br>
Check out the <a href="https://github.com/html2rss/html2rss-web/blob/master/config/feeds.yml#L9"><code>example</code> feed config</a>.</p>
<p dir="auto">Please refer to <a href="https://github.com/html2rss/html2rss#the-feed-config-and-its-options">html2rss' README for a description of <em>the feed config and its options</em></a>. html2rss-web is just a small web application that depends on html2rss.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Versioning and releases</h2><a id="user-content-versioning-and-releases" class="anchor" aria-label="Permalink: Versioning and releases" href="#versioning-and-releases"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This web application is distributed in a <a href="https://en.wikipedia.org/wiki/Rolling_release" rel="nofollow">rolling release</a> fashion from the <code>master</code> branch.</p>
<p dir="auto">For the latest commit passing GitHub CI/CD on the master branch, an updated Docker image will be pushed to <a href="https://hub.docker.com/r/gilcreator/html2rss-web" rel="nofollow">Docker Hub: <code>gilcreator/html2rss-web</code></a>.</p>
<p dir="auto">GitHub's @dependabot is enabled for dependency updates and they are automatically merged to the <code>master</code> branch when the CI gives the green light.</p>
<p dir="auto">If you use Docker, you should update to the latest image automatically by <a href="#get-started">setting up <em>watchtower</em> as described</a>.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Use in production</h2><a id="user-content-use-in-production" class="anchor" aria-label="Permalink: Use in production" href="#use-in-production"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This app is published on Docker Hub and therefore easy to use with Docker.<br>
The above <code>docker-compose.yml</code> is a good starting point.</p>
<p dir="auto">If you're going to host a public instance, <em>please, please, please</em>:</p>
<ul dir="auto">
<li>Put the application behind a reverse proxy.</li>
<li>Allow outside connections only via HTTPS.</li>
<li>Have an auto-update strategy (e.g., watchtower).</li>
<li>Monitor your <code>/health_check.txt</code> endpoint.</li>
<li><a href="https://github.com/html2rss/html2rss-web/wiki/Instances">Let the world know and add your instance to the wiki</a> -- thank you!</li>
</ul>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Supported ENV variables</h3><a id="user-content-supported-env-variables" class="anchor" aria-label="Permalink: Supported ENV variables" href="#supported-env-variables"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<markdown-accessiblity-table><table>
<thead>
<tr>
<th>Name</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>PORT</code></td>
<td>default: 3000</td>
</tr>
<tr>
<td><code>RACK_ENV</code></td>
<td>default: 'development'</td>
</tr>
<tr>
<td><code>RACK_TIMEOUT_SERVICE_TIMEOUT</code></td>
<td>default: 15</td>
</tr>
<tr>
<td><code>WEB_CONCURRENCY</code></td>
<td>default: 2</td>
</tr>
<tr>
<td><code>WEB_MAX_THREADS</code></td>
<td>default: 5</td>
</tr>
<tr>
<td><code>HEALTH_CHECK_USERNAME</code></td>
<td>default: auto-generated on start</td>
</tr>
<tr>
<td><code>HEALTH_CHECK_PASSWORD</code></td>
<td>default: auto-generated on start</td>
</tr>
</tbody>
</table></markdown-accessiblity-table>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Runtime monitoring via <code>GET /health_check.txt</code></h3><a id="user-content-runtime-monitoring-via-get-health_checktxt" class="anchor" aria-label="Permalink: Runtime monitoring via GET /health_check.txt" href="#runtime-monitoring-via-get-health_checktxt"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">It is recommended to set up monitoring of the <code>/health_check.txt</code> endpoint. With that, you can find out when one of <em>your own</em> configs breaks. The endpoint uses HTTP Basic authentication.</p>
<p dir="auto">First, set the username and password via these environment variables: <code>HEALTH_CHECK_USERNAME</code> and <code>HEALTH_CHECK_PASSWORD</code>. If these are not set, html2rss-web will generate a new random username and password on <em>each</em> start.</p>
<p dir="auto">An authenticated <code>GET /health_check.txt</code> request will respond with:</p>
<ul dir="auto">
<li>If the feeds are generatable: <code>success</code>.</li>
<li>Otherwise: the names of the broken configs.</li>
</ul>
<p dir="auto">To get notified when one of your configs breaks, set up monitoring of this endpoint.</p>
<p dir="auto"><a href="https://uptimerobot.com/" rel="nofollow">UptimeRobot's free plan</a> is sufficient for basic monitoring (every 5 minutes).<br>
Create a monitor of type <em>Keyword</em> with this information and make it aware of your username and password:</p>
<p dir="auto"><a target="_blank" rel="noopener noreferrer" href="/html2rss/html2rss-web/blob/master/docs/uptimerobot_monitor.jpg"><img src="/html2rss/html2rss-web/raw/master/docs/uptimerobot_monitor.jpg" alt="A screenshot showing the Keyword Monitor: a name, the instance's URL to /health_check.txt, and an interval." style="max-width: 100%;"></a></p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Setup for development</h2><a id="user-content-setup-for-development" class="anchor" aria-label="Permalink: Setup for development" href="#setup-for-development"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">Check out the git repository and…</p>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Using Docker</h3><a id="user-content-using-docker" class="anchor" aria-label="Permalink: Using Docker" href="#using-docker"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This approach allows you to experiment without installing Ruby on your machine.
All you need to do is install and run Docker.</p>
<div class="highlight highlight-source-shell notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="# Build image from Dockerfile and name/tag it as html2rss-web:
docker build -t html2rss-web -f Dockerfile .

# Run the image and name it html2rss-web-dev:
docker run \
  --detach \
  --mount type=bind,source=$(pwd)/config,target=/app/config \
  --name html2rss-web-dev \
  html2rss-web

# Open an interactive TTY with the shell `sh`:
docker exec -ti html2rss-web-dev sh

# Stop and clean up the container
docker stop html2rss-web-dev
docker rm html2rss-web-dev

# Remove the image
docker rmi html2rss-web"><pre><span class="pl-c"><span class="pl-c">#</span> Build image from Dockerfile and name/tag it as html2rss-web:</span>
docker build -t html2rss-web -f Dockerfile <span class="pl-c1">.</span>

<span class="pl-c"><span class="pl-c">#</span> Run the image and name it html2rss-web-dev:</span>
docker run \
  --detach \
  --mount type=bind,source=<span class="pl-s"><span class="pl-pds">$(</span>pwd<span class="pl-pds">)</span></span>/config,target=/app/config \
  --name html2rss-web-dev \
  html2rss-web

<span class="pl-c"><span class="pl-c">#</span> Open an interactive TTY with the shell `sh`:</span>
docker <span class="pl-c1">exec</span> -ti html2rss-web-dev sh

<span class="pl-c"><span class="pl-c">#</span> Stop and clean up the container</span>
docker stop html2rss-web-dev
docker rm html2rss-web-dev

<span class="pl-c"><span class="pl-c">#</span> Remove the image</span>
docker rmi html2rss-web</pre></div>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Using installed Ruby</h3><a id="user-content-using-installed-ruby" class="anchor" aria-label="Permalink: Using installed Ruby" href="#using-installed-ruby"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">If you're comfortable with installing Ruby directly on your machine, follow these instructions:</p>
<ol dir="auto">
<li>Install Ruby <code>&gt;= 3.2</code></li>
<li><code>gem install bundler foreman</code></li>
<li><code>bundle</code></li>
<li><code>foreman start</code></li>
</ol>
<p dir="auto"><em>html2rss-web</em> now listens on port <strong>3000</strong> for requests.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Contribute</h2><a id="user-content-contribute" class="anchor" aria-label="Permalink: Contribute" href="#contribute"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">Contributions are welcome!</p>
<p dir="auto">Open a pull request with your changes,<br>
open an issue, or<br>
<a href="https://github.com/orgs/html2rss/discussions">join discussions on html2rss</a>.</p>
</article></div></div></div></div></div> <!-- --> <!-- --> <script type="application/json" id="__PRIMER_DATA_:R0:__">{"resolvedServerColorMode":"day"}</script></div>
</react-partial>

      <input type="hidden" data-csrf="true" value="6UpVnsGgn9xD8L5Q+1maBy0YELNW+IlSmugV8o87pbP/GwEYTDbBkmPvcifj7Chb9Yl23axvChmRwOluGYUsQQ==" />
</div>
  <div data-view-component="true" class="Layout-sidebar">      

      <div class="BorderGrid about-margin" data-pjax>
        <div class="BorderGrid-row">
          <div class="BorderGrid-cell">
            <div class="hide-sm hide-md">
  <h2 class="mb-3 h4">About</h2>

      <p class="f4 my-3">
        🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly.
      </p>
      <div class="my-3 d-flex flex-items-center">
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link flex-shrink-0 mr-2">
    <path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path>
</svg>
        <span class="flex-auto min-width-0 css-truncate css-truncate-target width-fit">
          <a title="https://html2rss.github.io/components/html2rss-web" role="link" target="_blank" rel="noopener noreferrer nofollow" class="text-bold" href="https://html2rss.github.io/components/html2rss-web">html2rss.github.io/components/html2rss-web</a>
        </span>
      </div>

    <h3 class="sr-only">Topics</h3>
    <div class="my-3">
        <div class="f6">
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:ruby" href="/topics/ruby" title="Topic: ruby" data-view-component="true" class="topic-tag topic-tag-link">
  ruby
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:docker" href="/topics/docker" title="Topic: docker" data-view-component="true" class="topic-tag topic-tag-link">
  docker
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss" href="/topics/rss" title="Topic: rss" data-view-component="true" class="topic-tag topic-tag-link">
  rss
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:scraper" href="/topics/scraper" title="Topic: scraper" data-view-component="true" class="topic-tag topic-tag-link">
  scraper
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:builder" href="/topics/builder" title="Topic: builder" data-view-component="true" class="topic-tag topic-tag-link">
  builder
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:feed" href="/topics/feed" title="Topic: feed" data-view-component="true" class="topic-tag topic-tag-link">
  feed
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:roda" href="/topics/roda" title="Topic: roda" data-view-component="true" class="topic-tag topic-tag-link">
  roda
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss-feed" href="/topics/rss-feed" title="Topic: rss-feed" data-view-component="true" class="topic-tag topic-tag-link">
  rss-feed
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss-aggregator" href="/topics/rss-aggregator" title="Topic: rss-aggregator" data-view-component="true" class="topic-tag topic-tag-link">
  rss-aggregator
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:serves" href="/topics/serves" title="Topic: serves" data-view-component="true" class="topic-tag topic-tag-link">
  serves
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss-feed-scraper" href="/topics/rss-feed-scraper" title="Topic: rss-feed-scraper" data-view-component="true" class="topic-tag topic-tag-link">
  rss-feed-scraper
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:website-scraper" href="/topics/website-scraper" title="Topic: website-scraper" data-view-component="true" class="topic-tag topic-tag-link">
  website-scraper
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:webfeeds" href="/topics/webfeeds" title="Topic: webfeeds" data-view-component="true" class="topic-tag topic-tag-link">
  webfeeds
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:webfeed" href="/topics/webfeed" title="Topic: webfeed" data-view-component="true" class="topic-tag topic-tag-link">
  webfeed
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:html2rss" href="/topics/html2rss" title="Topic: html2rss" data-view-component="true" class="topic-tag topic-tag-link">
  html2rss
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rolling-release" href="/topics/rolling-release" title="Topic: rolling-release" data-view-component="true" class="topic-tag topic-tag-link">
  rolling-release
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:html2rss-configs" href="/topics/html2rss-configs" title="Topic: html2rss-configs" data-view-component="true" class="topic-tag topic-tag-link">
  html2rss-configs
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:feed-configs" href="/topics/feed-configs" title="Topic: feed-configs" data-view-component="true" class="topic-tag topic-tag-link">
  feed-configs
</a>
  </div>

    </div>

    <h3 class="sr-only">Resources</h3>
    <div class="mt-2">
      <a class="Link--muted" data-analytics-event="{&quot;category&quot;:&quot;Repository Overview&quot;,&quot;action&quot;:&quot;click&quot;,&quot;label&quot;:&quot;location:sidebar;file:readme&quot;}" href="#readme-ov-file">
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-book mr-2">
    <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>
        Readme
</a>    </div>

  
    <h3 class="sr-only">License</h3>
  <div class="mt-2">
    <a href="#MIT-1-ov-file"
      class="Link--muted"
      
      data-analytics-event="{&quot;category&quot;:&quot;Repository Overview&quot;,&quot;action&quot;:&quot;click&quot;,&quot;label&quot;:&quot;location:sidebar;file:license&quot;}"
    >
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-law mr-2">
    <path d="M8.75.75V2h.985c.304 0 .603.08.867.231l1.29.736c.038.022.08.033.124.033h2.234a.75.75 0 0 1 0 1.5h-.427l2.111 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.006.005-.01.01-.045.04c-.21.176-.441.327-.686.45C14.556 10.78 13.88 11 13 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L12.178 4.5h-.162c-.305 0-.604-.079-.868-.231l-1.29-.736a.245.245 0 0 0-.124-.033H8.75V13h2.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1 0-1.5h2.5V3.5h-.984a.245.245 0 0 0-.124.033l-1.289.737c-.265.15-.564.23-.869.23h-.162l2.112 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.016.015-.045.04c-.21.176-.441.327-.686.45C4.556 10.78 3.88 11 3 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L2.178 4.5H1.75a.75.75 0 0 1 0-1.5h2.234a.249.249 0 0 0 .125-.033l1.288-.737c.265-.15.564-.23.869-.23h.984V.75a.75.75 0 0 1 1.5 0Zm2.945 8.477c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327Zm-10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327Z"></path>
</svg>
     MIT license
    </a>
  </div>




  <include-fragment  src="/html2rss/html2rss-web/hovercards/citation/sidebar_partial?tree_name=master">
  </include-fragment>

  <div class="mt-2">
    <a href="/html2rss/html2rss-web/activity" data-view-component="true" class="Link Link--muted">
      <svg text="gray" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-pulse mr-2">
    <path d="M6 2c.306 0 .582.187.696.471L10 10.731l1.304-3.26A.751.751 0 0 1 12 7h3.25a.75.75 0 0 1 0 1.5h-2.742l-1.812 4.528a.751.751 0 0 1-1.392 0L6 4.77 4.696 8.03A.75.75 0 0 1 4 8.5H.75a.75.75 0 0 1 0-1.5h2.742l1.812-4.529A.751.751 0 0 1 6 2Z"></path>
</svg>
      <span class="color-fg-muted">Activity</span>
</a>  </div>

    <div class="mt-2">
      <a href="/html2rss/html2rss-web/custom-properties" data-view-component="true" class="Link Link--muted">
        <svg text="gray" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-note mr-2">
    <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.25Zm1.75-.25a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-8.5a.25.25 0 0 0-.25-.25ZM3.5 6.25a.75.75 0 0 1 .75-.75h7a.75.75 0 0 1 0 1.5h-7a.75.75 0 0 1-.75-.75Zm.75 2.25h4a.75.75 0 0 1 0 1.5h-4a.75.75 0 0 1 0-1.5Z"></path>
</svg>
        <span class="color-fg-muted">Custom properties</span>
</a>    </div>

  <h3 class="sr-only">Stars</h3>
  <div class="mt-2">
    <a href="/html2rss/html2rss-web/stargazers" data-view-component="true" class="Link Link--muted">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-star 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>
      <strong>86</strong>
      stars
</a>  </div>

  <h3 class="sr-only">Watchers</h3>
  <div class="mt-2">
    <a href="/html2rss/html2rss-web/watchers" data-view-component="true" class="Link Link--muted">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-eye mr-2">
    <path d="M8 2c1.981 0 3.671.992 4.933 2.078 1.27 1.091 2.187 2.345 2.637 3.023a1.62 1.62 0 0 1 0 1.798c-.45.678-1.367 1.932-2.637 3.023C11.67 13.008 9.981 14 8 14c-1.981 0-3.671-.992-4.933-2.078C1.797 10.83.88 9.576.43 8.898a1.62 1.62 0 0 1 0-1.798c.45-.677 1.367-1.931 2.637-3.022C4.33 2.992 6.019 2 8 2ZM1.679 7.932a.12.12 0 0 0 0 .136c.411.622 1.241 1.75 2.366 2.717C5.176 11.758 6.527 12.5 8 12.5c1.473 0 2.825-.742 3.955-1.715 1.124-.967 1.954-2.096 2.366-2.717a.12.12 0 0 0 0-.136c-.412-.621-1.242-1.75-2.366-2.717C10.824 4.242 9.473 3.5 8 3.5c-1.473 0-2.825.742-3.955 1.715-1.124.967-1.954 2.096-2.366 2.717ZM8 10a2 2 0 1 1-.001-3.999A2 2 0 0 1 8 10Z"></path>
</svg>
      <strong>4</strong>
      watching
</a>  </div>

  <h3 class="sr-only">Forks</h3>
  <div class="mt-2">
    <a href="/html2rss/html2rss-web/forks" data-view-component="true" class="Link Link--muted">
      <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>
      <strong>11</strong>
      forks
</a>  </div>

    <div class="mt-2">
      <a class="Link--muted" href="/contact/report-content?content_url=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web&amp;report=html2rss+%28user%29">
          Report repository
</a>    </div>
</div>

          </div>
        </div>

        
        
            <div class="BorderGrid-row">
              <div class="BorderGrid-cell">
                
<h2 class="h4 mb-3">Sponsor this project</h2>
<include-fragment src="/html2rss/html2rss-web/sponsors_list?block_button=true&amp;current_repository=html2rss-web" aria-busy="true" aria-label="Loading sponsorable links">
        <div class="d-flex mb-3">
          <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          <div class="Skeleton Skeleton--text flex-1 flex-self-center f4">&nbsp;</div>
        </div>
          <button type="button" disabled="disabled" data-view-component="true" class="btn btn-block">    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-heart icon-sponsor mr-1 color-fg-sponsors">
    <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> Sponsor
</button></include-fragment>  <div class="text-small mt-3">
    <a href="/sponsors">Learn more about GitHub Sponsors</a>
  </div>

              </div>
            </div>

        
        
            <div class="BorderGrid-row" hidden>
              <div class="BorderGrid-cell">
                <include-fragment src="/html2rss/html2rss-web/used_by_list" accept="text/fragment+html">
</include-fragment>
              </div>
            </div>

        
            <div class="BorderGrid-row">
              <div class="BorderGrid-cell">
                <h2 class="h4 mb-3">
  <a href="/html2rss/html2rss-web/graphs/contributors" data-view-component="true" class="Link--primary no-underline Link d-flex flex-items-center">
    Contributors
      <span title="12" data-view-component="true" class="Counter ml-1">12</span>
</a></h2>


    <include-fragment src="/html2rss/html2rss-web/contributors_list?count=12&amp;current_repository=html2rss-web&amp;items_to_show=12" aria-busy="true" aria-label="Loading contributors">
      <ul class="list-style-none d-flex flex-wrap mb-n2">
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
      </ul>
</include-fragment>


              </div>
            </div>

        
        
            <div class="BorderGrid-row">
              <div class="BorderGrid-cell">
                <h2 class="h4 mb-3">Languages</h2>
<div class="mb-2">
  <span data-view-component="true" class="Progress">
    <span style="background-color:#701516 !important;;width: 81.2%;" itemprop="keywords" aria-label="Ruby 81.2" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#EB8CEB !important;;width: 6.4%;" itemprop="keywords" aria-label="XSLT 6.4" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#384d54 !important;;width: 4.3%;" itemprop="keywords" aria-label="Dockerfile 4.3" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#e34c26 !important;;width: 4.1%;" itemprop="keywords" aria-label="HTML 4.1" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#563d7c !important;;width: 2.7%;" itemprop="keywords" aria-label="CSS 2.7" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#89e051 !important;;width: 0.6%;" itemprop="keywords" aria-label="Shell 0.6" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#ededed !important;;width: 0.7%;" itemprop="keywords" aria-label="Other 0.7" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
</span></div>
<ul class="list-style-none">
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=ruby"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#701516;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">Ruby</span>
          <span>81.2%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=xslt"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#EB8CEB;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">XSLT</span>
          <span>6.4%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=dockerfile"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#384d54;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">Dockerfile</span>
          <span>4.3%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=html"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#e34c26;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">HTML</span>
          <span>4.1%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=css"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#563d7c;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">CSS</span>
          <span>2.7%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=shell"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#89e051;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">Shell</span>
          <span>0.6%</span>
        </a>
    </li>
    <li class="d-inline">
      <span class="d-inline-flex flex-items-center flex-nowrap text-small mr-3">
        <svg style="color:#ededed;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
        <span class="color-fg-default text-bold mr-1">Other</span>
        <span>0.7%</span>
      </span>
    </li>
</ul>

              </div>
            </div>

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

  </div>


  </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 09:25:10 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..6be1fd27 100644
--- a/spec/html2rss/web/app_spec.rb
+++ b/spec/html2rss/web/app_spec.rb
@@ -6,4 +6,31 @@
 
 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
+  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/routes/auto_source_spec.rb b/spec/routes/auto_source_spec.rb
new file mode 100644
index 00000000..bc9abcc5
--- /dev/null
+++ b/spec/routes/auto_source_spec.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+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' }
+
+  before do
+    allow(Html2rss::Web::AutoSource).to receive_messages(enabled?: true,
+                                                         username:,
+                                                         password:,
+                                                         allowed_origins: Set['localhost'])
+  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
+        VCR.use_cassette('auto_source-github-h2r-web') do
+          get "/auto_source/#{Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web')}",
+              {},
+              request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password))
+        end
+      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=0'
+        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..05dfcee6 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -9,11 +9,12 @@
   end
 end
 
+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

From ba5da643e9d331cba3de8eb98d299b7a5ba8c4dc Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 11:48:45 +0200
Subject: [PATCH 19/25] feat(auto_source): add bookmarklet css and style js

---
 public/auto_source.css      | 6 ++++++
 public/auto_source.js       | 9 +++++----
 views/auto_source/index.erb | 3 ++-
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/public/auto_source.css b/public/auto_source.css
index 082e907a..60a79f55 100644
--- a/public/auto_source.css
+++ b/public/auto_source.css
@@ -38,6 +38,12 @@
   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);
diff --git a/public/auto_source.js b/public/auto_source.js
index 985737aa..6b85d055 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -1,4 +1,6 @@
 const autoSource = (function () {
+  const BASE_PATH = "auto_source";
+
   class Bookmarklet {
     constructor() {
       const $bookmarklet = document.querySelector("a#bookmarklet");
@@ -13,8 +15,8 @@ const autoSource = (function () {
 
     generateBookmarkletHref() {
       const h2rUrl = new URL(window.location.origin);
-      h2rUrl.pathname = "auto_source/";
-      h2rUrl.search = `?url=`;
+      h2rUrl.pathname = `${BASE_PATH}/`;
+      h2rUrl.search = "?url=";
       h2rUrl.hash = "";
 
       return `javascript:window.location.href='${h2rUrl.toString()}'+window.location.href;`;
@@ -131,9 +133,8 @@ const autoSource = (function () {
      * @returns {string} The generated auto-source URL.
      */
     generateAutoSourceUrl(encodedUrl) {
-      const BASE_URL = "auto_source"; // Use constant to avoid magic strings
       const baseUrl = new URL(window.location.origin);
-      return `${baseUrl}${BASE_URL}/${encodedUrl}`;
+      return `${baseUrl}${BASE_PATH}/${encodedUrl}`;
     }
 
     /**
diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb
index 13e431df..3bc2955a 100644
--- a/views/auto_source/index.erb
+++ b/views/auto_source/index.erb
@@ -50,7 +50,8 @@
     <h3>Bookmarklet</h3>
 
     <p>
-      Drag this link to your bookmarks and click it on any page: <a id="bookmarklet" href="#">Html2Rss</a>
+      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>

From 67275bb7049b709dae91edd57842d8480bcf049b Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 12:43:10 +0200
Subject: [PATCH 20/25] test: setup climate_control to safely modify env
 variables

---
 Gemfile                         | 1 +
 Gemfile.lock                    | 2 ++
 spec/spec_helper.rb             | 4 ++++
 spec/support/climate_control.rb | 9 +++++++++
 4 files changed, 16 insertions(+)
 create mode 100644 spec/support/climate_control.rb

diff --git a/Gemfile b/Gemfile
index fbc473e2..68f2952c 100644
--- a/Gemfile
+++ b/Gemfile
@@ -35,6 +35,7 @@ group :development do
 end
 
 group :test do
+  gem 'climate_control'
   gem 'rack-test'
   gem 'rspec'
   gem 'simplecov', require: false
diff --git a/Gemfile.lock b/Gemfile.lock
index 18b7bf2e..87cc5f17 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -14,6 +14,7 @@ GEM
     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
@@ -166,6 +167,7 @@ PLATFORMS
 DEPENDENCIES
   base64
   byebug
+  climate_control
   erubi
   html2rss (~> 0.14)
   html2rss-configs!
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 05dfcee6..4e215d2f 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -9,6 +9,8 @@
   end
 end
 
+require_relative 'support/climate_control'
+
 require 'rack/test'
 require 'vcr'
 
@@ -114,4 +116,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

From e0ffd1e2f8893b402ea42ed07328bae5d0a9be9d Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 13:04:44 +0200
Subject: [PATCH 21/25] test(auto_source): add specs for helpers

---
 helpers/auto_source.rb                        |  19 +-
 spec/html2rss/web/helpers/auto_source_spec.rb | 164 ++++++++++++++++++
 2 files changed, 180 insertions(+), 3 deletions(-)
 create mode 100644 spec/html2rss/web/helpers/auto_source_spec.rb

diff --git a/helpers/auto_source.rb b/helpers/auto_source.rb
index 8cf8489f..fbf8e1a5 100644
--- a/helpers/auto_source.rb
+++ b/helpers/auto_source.rb
@@ -13,8 +13,15 @@ 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(',').to_set
 
+      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)
@@ -27,10 +34,16 @@ def self.build_auto_source_from_encoded_url(encoded_url)
         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
+        (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.'
@@ -38,7 +51,7 @@ def self.check_request_origin!(request, response, allowed_origins = AutoSource.a
           origin = Set[request.env['HTTP_HOST'], request.env['HTTP_X_FORWARDED_HOST']].delete(nil)
           return if allowed_origins.intersect?(origin)
 
-          response.write "Origin '#{origin}' is not allowed."
+          response.write 'Origin is not allowed.'
         end
 
         response.status = 403
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

From 322b365a92f2c20c4e50c68a6acde28c74bc23ea Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 14:29:21 +0200
Subject: [PATCH 22/25] test: add specs for app

---
 spec/html2rss/web/app_spec.rb | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/spec/html2rss/web/app_spec.rb b/spec/html2rss/web/app_spec.rb
index 6be1fd27..a7d93713 100644
--- a/spec/html2rss/web/app_spec.rb
+++ b/spec/html2rss/web/app_spec.rb
@@ -16,6 +16,24 @@ def app = described_class
       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

From 8f87efad11b74019f51d4f9ebaceec14069193f9 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 14:35:57 +0200
Subject: [PATCH 23/25] test: tell simplecov to ignore files in config/

---
 spec/spec_helper.rb | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 4e215d2f..a3b03157 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -5,6 +5,8 @@
 
   SimpleCov.start do
     add_filter '/spec/'
+    add_filter '/config/'
+
     track_files '**/*.rb'
   end
 end

From 28794c3a2a007d599bba74b0155bfbb33e364cc9 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Sun, 20 Oct 2024 17:20:22 +0200
Subject: [PATCH 24/25] test(auto_source): add spec for routes

---
 .../auto_source-github-h2r-web.yml            | 20 ++++++++--------
 spec/routes/auto_source_spec.rb               | 23 ++++++++++++-------
 2 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml b/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml
index 7ac4be92..cccb4119 100644
--- a/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml
+++ b/spec/fixtures/vcr_cassettes/auto_source-github-h2r-web.yml
@@ -2,7 +2,7 @@
 http_interactions:
 - request:
     method: get
-    uri: https://140.82.121.4/html2rss/html2rss-web
+    uri: https://140.82.121.3/html2rss/html2rss-web/commits/master
     body:
       encoding: US-ASCII
       string: ''
@@ -23,14 +23,14 @@ http_interactions:
       Server:
       - GitHub.com
       Date:
-      - Sun, 20 Oct 2024 09:25:10 GMT
+      - 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/"72e34d709a25d76a8a2fd7b2c1e6d6de"
+      - W/"05a7012808772ba0e0bd352531fa0e7a"
       Cache-Control:
       - max-age=0, private, must-revalidate
       Strict-Transport-Security:
@@ -82,21 +82,21 @@ http_interactions:
         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=2w82sGklNNansPeQarwhz0yd793BchubUyh8N3%2Bm7rJ7p3dICd8UKdQEqo2BWyFnwVl4xODEtDfQAGCVxN1zTIP%2BOnWIGKhzzNF2LwnWSVuKl6DutmDNCXHbsT3KAU%2FwVjSFcYdUFs0%2BHQl29LYjdrGM181gocPJpsp9NeShytil774SovDepirKW51PYJzB2nVyW%2Fri85THbjLd%2BzwfYkQ2tR3fkqP%2FHByNXFLL9fMs1U%2F8cX1jR%2F5SIfVEqXu6dWduE7gteixmBeQgLjw5%2BA%3D%3D--IF9ZAdMjN%2FLLRLZE--R3%2BGZEw6StxKt1WgK9npqg%3D%3D;
+      - _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.1029570928.1729416310; Path=/; Domain=github.com; Expires=Mon,
-        20 Oct 2025 09:25:10 GMT; Secure; SameSite=Lax
-      - logged_in=no; Path=/; Domain=github.com; Expires=Mon, 20 Oct 2025 09:25:10
+      - _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:
-      - C1D0:15CD96:635B3DB:66073E4:6714CC76
+      - 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_remote-form_dist_index_js-node_modules_delegated-events_dist_inde-e53a3f-96e856171702.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/codespaces-00f8bdb5a024.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/repositories-e391e0092c62.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_github_catalyst_lib_inde-dbbea9-e73b311a14f1.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/code-menu-2b308c1236c2.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/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" />

  <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>GitHub - html2rss/html2rss-web: 🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly.</title>



  <meta name="route-pattern" content="/:user_id/:repository" data-turbo-transient>
  <meta name="route-controller" content="files" data-turbo-transient>
  <meta name="route-action" content="disambiguate" data-turbo-transient>

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


  <meta name="request-id" content="C1D0:15CD96:635B3DB:66073E4:6714CC76" data-pjax-transient="true"/><meta name="html-safe-nonce" content="5fc3a1fbe7875d3256ad5a0258ee00cedcc5c61d9b81bf9e4c72a7552dbc06da" data-pjax-transient="true"/><meta name="visitor-payload" content="eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJDMUQwOjE1Q0Q5Njo2MzVCM0RCOjY2MDczRTQ6NjcxNENDNzYiLCJ2aXNpdG9yX2lkIjoiNDQyMTk3MzQ2NjQwMTc4Njk5OCIsInJlZ2lvbl9lZGdlIjoiZnJhIiwicmVnaW9uX3JlbmRlciI6ImZyYSJ9" data-pjax-transient="true"/><meta name="visitor-hmac" content="01b1ba8adfc241d1d6a39a96a4e875dbfb0a57c88e9c913268ffc7116e1aaf4c" data-pjax-transient="true"/>


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


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

  <meta name="selected-link" value="repo_source" 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;" 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. - 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" />

      <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="GitHub - html2rss/html2rss-web: 🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly." /><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. - 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. - html2rss/html2rss-web" /><meta property="og:site_name" content="GitHub" /><meta property="og:type" content="object" /><meta property="og:title" content="GitHub - html2rss/html2rss-web: 🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly." /><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. - 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 data-hydrostats="publish">
  <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" />



      <link rel="canonical" href="https://github.com/html2rss/html2rss-web" data-turbo-transient>


    <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/ui_packages_ui-commands_ui-commands_ts-d25fac54a6bc.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"
            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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="a3a1bbd7d1c3e1c79352c258c7daa3c7116b1a05c0ffe18d5429cc3d716c6d7b"
            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="neu-CYTjdijt8Bhfqa31naGjQ54NKpH3cPVQ2SOBcjWJTx1cnXLDOD4Ra7qYJCK2QKbO0Fl-1i9mZk5zmLONcA" 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-a160117d-a85b-4139-a1e2-ec69bc0daccb" 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-a160117d-a85b-4139-a1e2-ec69bc0daccb" 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="D4eGNdIt+lc2jrnNj3TNIgqwwqjfEer1adLfk9dY0DTYKHy4mzWxwAnwpfUASSiuP0utLQGIuXus/LIg4L2W9A==" />
          <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="7D/LG6iKBxj3kGkoMehYN6cgEIanbFeNpVS2UBLZOPn6q+3f4bkJZfysg+6SwtCv1qEvqPuGXMNdHjY8cGM8zg==" />
          <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="qNI5aPrAQqLcQqNrop9fjIcw7xPZrU1fCy9u4TrED5rGAlhJaeq/VwSqPHoLcY4ng3g1lC4nnjPvxrRkWxDGyQ==" />
            </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"
                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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="a3a1bbd7d1c3e1c79352c258c7daa3c7116b1a05c0ffe18d5429cc3d716c6d7b"
                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&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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="a3a1bbd7d1c3e1c79352c258c7daa3c7116b1a05c0ffe18d5429cc3d716c6d7b"
                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;;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-b962ca4f-aad3-40e7-9e7e-f521394b18a1" aria-labelledby="tooltip-c9cf702f-56eb-49c0-aef3-1e9c75b66a1e" 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-c9cf702f-56eb-49c0-aef3-1e9c75b66a1e" for="icon-button-b962ca4f-aad3-40e7-9e7e-f521394b18a1" 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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="49012a60a791911c076582402aa91990e6c56e8c45906f92bd2ea3df071a802d" 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-8985a91c-b1a4-496e-8aed-59a6f754ee0b" 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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="5892fe882b0c64177168fed1f469c0dae6112701d9537b02499ff7498a3fae48" 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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="8150680232ae9580183a8ef009c7852c6ebf142dc7f184be9fc8f4ffcf83b6f6" 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 class="d-block d-md-none mb-2 px-3 px-md-4 px-lg-5">
      <p class="f4 mb-3 ">
        🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly.
      </p>
      <div class="mb-2 d-flex flex-items-center Link--secondary">
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link flex-shrink-0 mr-2">
    <path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path>
</svg>
        <span class="flex-auto min-width-0 css-truncate css-truncate-target width-fit">
          <a title="https://html2rss.github.io/components/html2rss-web" role="link" target="_blank" class="text-bold" rel="noopener noreferrer" href="https://html2rss.github.io/components/html2rss-web">html2rss.github.io/components/html2rss-web</a>
        </span>
      </div>

    
      <h3 class="sr-only">License</h3>
  <div class="mb-2">
    <a href="/html2rss/html2rss-web/blob/master/LICENSE"
      class="Link--muted"
      
      data-analytics-event="{&quot;category&quot;:&quot;Repository Overview&quot;,&quot;action&quot;:&quot;click&quot;,&quot;label&quot;:&quot;location:sidebar;file:license&quot;}"
    >
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-law mr-2">
    <path d="M8.75.75V2h.985c.304 0 .603.08.867.231l1.29.736c.038.022.08.033.124.033h2.234a.75.75 0 0 1 0 1.5h-.427l2.111 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.006.005-.01.01-.045.04c-.21.176-.441.327-.686.45C14.556 10.78 13.88 11 13 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L12.178 4.5h-.162c-.305 0-.604-.079-.868-.231l-1.29-.736a.245.245 0 0 0-.124-.033H8.75V13h2.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1 0-1.5h2.5V3.5h-.984a.245.245 0 0 0-.124.033l-1.289.737c-.265.15-.564.23-.869.23h-.162l2.112 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.016.015-.045.04c-.21.176-.441.327-.686.45C4.556 10.78 3.88 11 3 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L2.178 4.5H1.75a.75.75 0 0 1 0-1.5h2.234a.249.249 0 0 0 .125-.033l1.288-.737c.265-.15.564-.23.869-.23h.984V.75a.75.75 0 0 1 1.5 0Zm2.945 8.477c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327Zm-10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327Z"></path>
</svg>
     MIT license
    </a>
  </div>


    <div class="mb-3">
        <a class="Link--secondary no-underline mr-3" href="/html2rss/html2rss-web/stargazers">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-star mr-1">
    <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 class="text-bold">86</span>
          stars
</a>        <a class="Link--secondary no-underline mr-3" href="/html2rss/html2rss-web/forks">
          <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-1">
    <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>
          <span class="text-bold">11</span>
          forks
</a>        <a class="Link--secondary no-underline mr-3 d-inline-block" href="/html2rss/html2rss-web/branches">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-branch mr-1">
    <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>
          <span>Branches</span>
</a>        <a class="Link--secondary no-underline d-inline-block" href="/html2rss/html2rss-web/tags">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-tag mr-1">
    <path d="M1 7.775V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 0 1 0 2.474l-5.026 5.026a1.75 1.75 0 0 1-2.474 0l-6.25-6.25A1.752 1.752 0 0 1 1 7.775Zm1.5 0c0 .066.026.13.073.177l6.25 6.25a.25.25 0 0 0 .354 0l5.025-5.025a.25.25 0 0 0 0-.354l-6.25-6.25a.25.25 0 0 0-.177-.073H2.75a.25.25 0 0 0-.25.25ZM6 5a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"></path>
</svg>
          <span>Tags</span>
</a>        <a class="Link--secondary no-underline d-inline-block" href="/html2rss/html2rss-web/activity">
          <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-pulse mr-1">
    <path d="M6 2c.306 0 .582.187.696.471L10 10.731l1.304-3.26A.751.751 0 0 1 12 7h3.25a.75.75 0 0 1 0 1.5h-2.742l-1.812 4.528a.751.751 0 0 1-1.392 0L6 4.77 4.696 8.03A.75.75 0 0 1 4 8.5H.75a.75.75 0 0 1 0-1.5h2.742l1.812-4.529A.751.751 0 0 1 6 2Z"></path>
</svg>
          <span>Activity</span>
</a>    </div>

      <div class="d-flex flex-wrap gap-2">
        <div class="flex-1">
            <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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="8150680232ae9580183a8ef009c7852c6ebf142dc7f184be9fc8f4ffcf83b6f6" aria-label="You must be signed in to star a repository" data-view-component="true" class="tooltipped tooltipped-sw btn-sm btn btn-block">    <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>
</a></div>
        </div>
        <div class="flex-1">
                <a href="/login?return_to=%2Fhtml2rss%2Fhtml2rss-web" rel="nofollow" id="files-overview-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&quot;,&quot;user_id&quot;:null}}" data-hydro-click-hmac="49012a60a791911c076582402aa91990e6c56e8c45906f92bd2ea3df071a802d" aria-label="You must be signed in to change notification settings" data-view-component="true" class="btn-sm btn btn-block">    <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-a263d4a3-b58b-49e1-ab27-54422f41f74b" for="files-overview-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>

        </div>
        <span>
          

        </span>
      </div>
  </div>

</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;}" aria-current="page" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item selected">
    
              <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-8c310d38-d208-43db-a403-eda5269767a3-button" popovertarget="action-menu-8c310d38-d208-43db-a403-eda5269767a3-overlay" aria-controls="action-menu-8c310d38-d208-43db-a403-eda5269767a3-list" aria-haspopup="true" aria-labelledby="tooltip-19281707-2110-43e8-88bf-47c4bba1a5fe" 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-19281707-2110-43e8-88bf-47c4bba1a5fe" for="action-menu-8c310d38-d208-43db-a403-eda5269767a3-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-8c310d38-d208-43db-a403-eda5269767a3-overlay" anchor="action-menu-8c310d38-d208-43db-a403-eda5269767a3-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-8c310d38-d208-43db-a403-eda5269767a3-button" id="action-menu-8c310d38-d208-43db-a403-eda5269767a3-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-e629cfce-ad9d-4c81-be31-211e0f4dbea7" 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-b90f5b86-9a71-44e6-8eff-dba7cb3721d8" 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-37c3d6a6-55d9-44b0-afd6-73de12b5c933" 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-f63d8e92-de6f-4d4e-9cd7-9be3a78442f0" 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-31797c4b-b8fe-4ad3-856b-7f14f395a076" 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-9a1a8f62-fda2-40d7-9bd5-18cc0bd5b220" 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-bcc173aa-77a9-4f91-a4d3-be0d90f3a1d3" 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 " >
    



    
      
  <h1 class='sr-only'>html2rss/html2rss-web</h1>
  <div class="clearfix container-xl px-md-4 px-lg-5 px-3">
    <div>


  <div style="max-width: 100%" data-view-component="true" class="Layout Layout--flowRow-until-md react-repos-overview-margin Layout--sidebarPosition-end Layout--sidebarPosition-flowRow-end">
  <div data-view-component="true" class="Layout-main">      <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_tanstack_query-core_build_modern_query_js-node_modules_tanstack_react-qu-e4a133-25f9fad0b763.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_tanstack_query-core_build_modern_queryObserver_js-node_modules_tanstack_-defd52-7aa5ebad499a.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_github_hydro-analytics-client_-d56e55-4533ead6a048.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_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_verified-fetch_verified-fetch_ts-ui_packages_code-view-shared_components_SharedMa-058d4a-af37e21c9cbd.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_code-view-shared_hooks_use-canonical-object_ts-ui_packages_code-view-shared_hooks-2170c0-a950e6dae777.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_commit-attribution_index_ts-ui_packages_commit-checks-status_index_ts-ui_packages-4cf6a5-49c666deb721.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/repos-overview-010de2739dfa.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/repos-overview.47b2222c697daf78496d.module.css" />

<react-partial
  partial-name="repos-overview"
  data-ssr="true"
  data-attempted-ssr="true"
>
  
  <script type="application/json" data-target="react-partial.embeddedData">{"props":{"initialPayload":{"allShortcutsEnabled":false,"path":"/","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},"currentUser":null,"refInfo":{"name":"master","listCacheKey":"v0:1728684225.0","canEdit":false,"refType":"branch","currentOid":"8eeb9e69a1c57f3c61ca00469083604e25066859"},"tree":{"items":[{"name":".github","path":".github","contentType":"directory"},{"name":"app","path":"app","contentType":"directory"},{"name":"bin","path":"bin","contentType":"directory"},{"name":"config","path":"config","contentType":"directory"},{"name":"docs","path":"docs","contentType":"directory"},{"name":"helpers","path":"helpers","contentType":"directory"},{"name":"public","path":"public","contentType":"directory"},{"name":"roda/roda_plugins","path":"roda/roda_plugins","contentType":"directory","hasSimplifiedPath":true},{"name":"spec","path":"spec","contentType":"directory"},{"name":"tmp","path":"tmp","contentType":"directory"},{"name":"views","path":"views","contentType":"directory"},{"name":".dockerignore","path":".dockerignore","contentType":"file"},{"name":".gitignore","path":".gitignore","contentType":"file"},{"name":".mergify.yml","path":".mergify.yml","contentType":"file"},{"name":".rspec","path":".rspec","contentType":"file"},{"name":".rubocop.yml","path":".rubocop.yml","contentType":"file"},{"name":".ruby-version","path":".ruby-version","contentType":"file"},{"name":"Dockerfile","path":"Dockerfile","contentType":"file"},{"name":"Gemfile","path":"Gemfile","contentType":"file"},{"name":"Gemfile.lock","path":"Gemfile.lock","contentType":"file"},{"name":"LICENSE","path":"LICENSE","contentType":"file"},{"name":"Procfile","path":"Procfile","contentType":"file"},{"name":"README.md","path":"README.md","contentType":"file"},{"name":"Rakefile","path":"Rakefile","contentType":"file"},{"name":"app.json","path":"app.json","contentType":"file"},{"name":"app.rb","path":"app.rb","contentType":"file"},{"name":"config.ru","path":"config.ru","contentType":"file"}],"templateDirectorySuggestionUrl":null,"readme":null,"totalCount":27,"showBranchInfobar":false},"fileTree":null,"fileTreeProcessingTime":null,"foldersToFetch":[],"treeExpanded":false,"symbolsExpanded":false,"isOverview":true,"overview":{"banners":{"shouldRecommendReadme":false,"isPersonalRepo":false,"showUseActionBanner":false,"actionSlug":null,"actionId":null,"showProtectBranchBanner":false,"publishBannersInfo":{"dismissActionNoticePath":"/settings/dismiss-notice/publish_action_from_repo","releasePath":"/html2rss/html2rss-web/releases/new?marketplace=true","showPublishActionBanner":false},"interactionLimitBanner":null,"showInvitationBanner":false,"inviterName":null,"actionsMigrationBannerInfo":{"releaseTags":[],"showImmutableActionsMigrationBanner":false,"initialMigrationStatus":null}},"codeButton":{"contactPath":"/contact","isEnterprise":false,"local":{"protocolInfo":{"httpAvailable":true,"sshAvailable":null,"httpUrl":"https://github.com/html2rss/html2rss-web.git","showCloneWarning":null,"sshUrl":null,"sshCertificatesRequired":null,"sshCertificatesAvailable":null,"ghCliUrl":"gh repo clone html2rss/html2rss-web","defaultProtocol":"http","newSshKeyUrl":"/settings/ssh/new","setProtocolPath":"/users/set_protocol"},"platformInfo":{"cloneUrl":"https://desktop.github.com","showVisualStudioCloneButton":false,"visualStudioCloneUrl":"https://windows.github.com","showXcodeCloneButton":false,"xcodeCloneUrl":"xcode://clone?repo=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web","zipballUrl":"/html2rss/html2rss-web/archive/refs/heads/master.zip"}},"newCodespacePath":"/codespaces/new?hide_repo_select=true\u0026repo=135929870"},"popovers":{"rename":null,"renamedParentRepo":null},"commitCount":"819","overviewFiles":[{"displayName":"README.md","repoName":"html2rss-web","refName":"master","path":"README.md","preferredFileType":"readme","tabName":"README","richText":"\u003carticle class=\"markdown-body entry-content container-lg\" itemprop=\"text\"\u003e\u003cp dir=\"auto\"\u003e\u003ca target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://github.com/html2rss/html2rss/raw/master/support/logo.png\"\u003e\u003cimg src=\"https://github.com/html2rss/html2rss/raw/master/support/logo.png\" alt=\"html2rss logo\" style=\"max-width: 100%;\"\u003e\u003c/a\u003e\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch1 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003ehtml2rss-web\u003c/h1\u003e\u003ca id=\"user-content-html2rss-web\" class=\"anchor\" aria-label=\"Permalink: html2rss-web\" href=\"#html2rss-web\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis web application scrapes websites to build and deliver RSS 2.0 feeds.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003e\u003cstrong\u003eFeatures:\u003c/strong\u003e\u003c/p\u003e\n\u003cul dir=\"auto\"\u003e\n\u003cli\u003e\u003ca href=\"#how-to-build-your-rss-feeds\"\u003eCreate your custom feeds\u003c/a\u003e!\u003c/li\u003e\n\u003cli\u003eComes with plenty of \u003ca href=\"https://github.com/html2rss/html2rss-configs\"\u003eincluded configs\u003c/a\u003e out of the box.\u003c/li\u003e\n\u003cli\u003eHandles request caching.\u003c/li\u003e\n\u003cli\u003eSets caching-related HTTP headers.\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp dir=\"auto\"\u003eThe functionality of scraping websites and building the RSS feeds is provided by the Ruby gem \u003ca href=\"https://github.com/html2rss/html2rss\"\u003e\u003ccode\u003ehtml2rss\u003c/code\u003e\u003c/a\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eGet started\u003c/h2\u003e\u003ca id=\"user-content-get-started\" class=\"anchor\" aria-label=\"Permalink: Get started\" href=\"#get-started\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis application should be used with Docker. It is designed to require as little maintenance as possible. See \u003ca href=\"#versioning-and-releases\"\u003eVersioning and Releases\u003c/a\u003e and \u003ca href=\"#docker-automatically-keep-the-html2rss-web-image-up-to-date\"\u003econsider automatic updates\u003c/a\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eWith Docker\u003c/h3\u003e\u003ca id=\"user-content-with-docker\" class=\"anchor\" aria-label=\"Permalink: With Docker\" href=\"#with-docker\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cdiv class=\"highlight highlight-source-shell notranslate position-relative overflow-auto\" dir=\"auto\" data-snippet-clipboard-copy-content=\"docker run -p 3000:3000 gilcreator/html2rss-web\"\u003e\u003cpre\u003edocker run -p 3000:3000 gilcreator/html2rss-web\u003c/pre\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThen open \u003ca href=\"http://127.0.0.1:3000/\" rel=\"nofollow\"\u003ehttp://127.0.0.1:3000/\u003c/a\u003e in your browser and click the example feed link.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eThis is the quickest way to get started. However, it's also the option with the least flexibility: it doesn't allow you to use custom feed configs and doesn't update automatically.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you want more flexibility and automatic updates sound good to you, read on to get started \u003cem\u003ewith docker compose\u003c/em\u003e…\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eWith \u003ccode\u003edocker compose\u003c/code\u003e\u003c/h3\u003e\u003ca id=\"user-content-with-docker-compose\" class=\"anchor\" aria-label=\"Permalink: With docker compose\" href=\"#with-docker-compose\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eCreate a \u003ccode\u003edocker-compose.yml\u003c/code\u003e file and paste the following into it:\u003c/p\u003e\n\u003cdiv class=\"highlight highlight-source-yaml notranslate position-relative overflow-auto\" dir=\"auto\" data-snippet-clipboard-copy-content=\"services:\n  html2rss-web:\n    image: gilcreator/html2rss-web\n    ports:\n      - \u0026quot;3000:3000\u0026quot;\n    volumes:\n      - type: bind\n        source: ./feeds.yml\n        target: /app/config/feeds.yml\n        read_only: true\n    environment:\n      - RACK_ENV=production\n      - HEALTH_CHECK_USERNAME=health\n      - HEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!\n  watchtower:\n    image: containrrr/watchtower\n    volumes:\n      - /var/run/docker.sock:/var/run/docker.sock\n      - \u0026quot;~/.docker/config.json:/config.json\u0026quot;\n    command: --cleanup --interval 7200\"\u003e\u003cpre\u003e\u003cspan class=\"pl-ent\"\u003eservices\u003c/span\u003e:\n  \u003cspan class=\"pl-ent\"\u003ehtml2rss-web\u003c/span\u003e:\n    \u003cspan class=\"pl-ent\"\u003eimage\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003egilcreator/html2rss-web\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003eports\u003c/span\u003e:\n      - \u003cspan class=\"pl-s\"\u003e\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e3000:3000\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003evolumes\u003c/span\u003e:\n      - \u003cspan class=\"pl-ent\"\u003etype\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003ebind\u003c/span\u003e\n        \u003cspan class=\"pl-ent\"\u003esource\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003e./feeds.yml\u003c/span\u003e\n        \u003cspan class=\"pl-ent\"\u003etarget\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003e/app/config/feeds.yml\u003c/span\u003e\n        \u003cspan class=\"pl-ent\"\u003eread_only\u003c/span\u003e: \u003cspan class=\"pl-c1\"\u003etrue\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003eenvironment\u003c/span\u003e:\n      - \u003cspan class=\"pl-s\"\u003eRACK_ENV=production\u003c/span\u003e\n      - \u003cspan class=\"pl-s\"\u003eHEALTH_CHECK_USERNAME=health\u003c/span\u003e\n      - \u003cspan class=\"pl-s\"\u003eHEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!\u003c/span\u003e\n  \u003cspan class=\"pl-ent\"\u003ewatchtower\u003c/span\u003e:\n    \u003cspan class=\"pl-ent\"\u003eimage\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003econtainrrr/watchtower\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003evolumes\u003c/span\u003e:\n      - \u003cspan class=\"pl-s\"\u003e/var/run/docker.sock:/var/run/docker.sock\u003c/span\u003e\n      - \u003cspan class=\"pl-s\"\u003e\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e~/.docker/config.json:/config.json\u003cspan class=\"pl-pds\"\u003e\"\u003c/span\u003e\u003c/span\u003e\n    \u003cspan class=\"pl-ent\"\u003ecommand\u003c/span\u003e: \u003cspan class=\"pl-s\"\u003e--cleanup --interval 7200\u003c/span\u003e\u003c/pre\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eStart it up with: \u003ccode\u003edocker compose up\u003c/code\u003e.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you have not created your \u003ccode\u003efeeds.yml\u003c/code\u003e yet, download \u003ca href=\"https://raw.githubusercontent.com/html2rss/html2rss-web/master/config/feeds.yml\" rel=\"nofollow\"\u003ethis \u003ccode\u003efeeds.yml\u003c/code\u003e as a blueprint\u003c/a\u003e into the directory containing the \u003ccode\u003edocker-compose.yml\u003c/code\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eDocker: Automatically keep the html2rss-web image up-to-date\u003c/h2\u003e\u003ca id=\"user-content-docker-automatically-keep-the-html2rss-web-image-up-to-date\" class=\"anchor\" aria-label=\"Permalink: Docker: Automatically keep the html2rss-web image up-to-date\" href=\"#docker-automatically-keep-the-html2rss-web-image-up-to-date\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThe \u003ca href=\"https://containrrr.dev/watchtower/\" rel=\"nofollow\"\u003ewatchtower\u003c/a\u003e service automatically pulls running Docker images and checks for updates. If an update is available, it will automatically start the updated image with the same configuration as the running one. Please read its manual.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eThe \u003ccode\u003edocker-compose.yml\u003c/code\u003e above contains a service description for watchtower.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eHow to use the included configs\u003c/h2\u003e\u003ca id=\"user-content-how-to-use-the-included-configs\" class=\"anchor\" aria-label=\"Permalink: How to use the included configs\" href=\"#how-to-use-the-included-configs\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003ehtml2rss-web comes with many feed configs out of the box. \u003ca href=\"https://github.com/html2rss/html2rss-configs/tree/master/lib/html2rss/configs\"\u003eSee the file list of all configs.\u003c/a\u003e\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eTo use a config from there, build the URL like this:\u003c/p\u003e\n\u003cmarkdown-accessiblity-table\u003e\u003ctable\u003e\n\u003cthead\u003e\n\u003ctr\u003e\n\u003cth\u003e\u003c/th\u003e\n\u003cth\u003e\u003c/th\u003e\n\u003c/tr\u003e\n\u003c/thead\u003e\n\u003ctbody\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003elib/html2rss/configs/\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003e\u003ccode\u003edomainname.tld/whatever.yml\u003c/code\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003eWould become this URL:\u003c/td\u003e\n\u003ctd\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003ehttp://localhost:3000/\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003e\u003ccode\u003edomainname.tld/whatever.rss\u003c/code\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003c/td\u003e\n\u003ctd\u003e\u003ccode\u003e^^^^^^^^^^^^^^^^^^^^^^^^^^^\u003c/code\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\u003c/tbody\u003e\n\u003c/table\u003e\u003c/markdown-accessiblity-table\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eHow to build your RSS feeds\u003c/h2\u003e\u003ca id=\"user-content-how-to-build-your-rss-feeds\" class=\"anchor\" aria-label=\"Permalink: How to build your RSS feeds\" href=\"#how-to-build-your-rss-feeds\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eTo build your own RSS feed, you need to create a \u003cem\u003efeed config\u003c/em\u003e.\u003cbr\u003e\nThat \u003cem\u003efeed config\u003c/em\u003e goes into the file \u003ccode\u003efeeds.yml\u003c/code\u003e.\u003cbr\u003e\nCheck out the \u003ca href=\"https://github.com/html2rss/html2rss-web/blob/master/config/feeds.yml#L9\"\u003e\u003ccode\u003eexample\u003c/code\u003e feed config\u003c/a\u003e.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003ePlease refer to \u003ca href=\"https://github.com/html2rss/html2rss#the-feed-config-and-its-options\"\u003ehtml2rss' README for a description of \u003cem\u003ethe feed config and its options\u003c/em\u003e\u003c/a\u003e. html2rss-web is just a small web application that depends on html2rss.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eVersioning and releases\u003c/h2\u003e\u003ca id=\"user-content-versioning-and-releases\" class=\"anchor\" aria-label=\"Permalink: Versioning and releases\" href=\"#versioning-and-releases\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis web application is distributed in a \u003ca href=\"https://en.wikipedia.org/wiki/Rolling_release\" rel=\"nofollow\"\u003erolling release\u003c/a\u003e fashion from the \u003ccode\u003emaster\u003c/code\u003e branch.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eFor the latest commit passing GitHub CI/CD on the master branch, an updated Docker image will be pushed to \u003ca href=\"https://hub.docker.com/r/gilcreator/html2rss-web\" rel=\"nofollow\"\u003eDocker Hub: \u003ccode\u003egilcreator/html2rss-web\u003c/code\u003e\u003c/a\u003e.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eGitHub's @dependabot is enabled for dependency updates and they are automatically merged to the \u003ccode\u003emaster\u003c/code\u003e branch when the CI gives the green light.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you use Docker, you should update to the latest image automatically by \u003ca href=\"#get-started\"\u003esetting up \u003cem\u003ewatchtower\u003c/em\u003e as described\u003c/a\u003e.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eUse in production\u003c/h2\u003e\u003ca id=\"user-content-use-in-production\" class=\"anchor\" aria-label=\"Permalink: Use in production\" href=\"#use-in-production\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis app is published on Docker Hub and therefore easy to use with Docker.\u003cbr\u003e\nThe above \u003ccode\u003edocker-compose.yml\u003c/code\u003e is a good starting point.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eIf you're going to host a public instance, \u003cem\u003eplease, please, please\u003c/em\u003e:\u003c/p\u003e\n\u003cul dir=\"auto\"\u003e\n\u003cli\u003ePut the application behind a reverse proxy.\u003c/li\u003e\n\u003cli\u003eAllow outside connections only via HTTPS.\u003c/li\u003e\n\u003cli\u003eHave an auto-update strategy (e.g., watchtower).\u003c/li\u003e\n\u003cli\u003eMonitor your \u003ccode\u003e/health_check.txt\u003c/code\u003e endpoint.\u003c/li\u003e\n\u003cli\u003e\u003ca href=\"https://github.com/html2rss/html2rss-web/wiki/Instances\"\u003eLet the world know and add your instance to the wiki\u003c/a\u003e -- thank you!\u003c/li\u003e\n\u003c/ul\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eSupported ENV variables\u003c/h3\u003e\u003ca id=\"user-content-supported-env-variables\" class=\"anchor\" aria-label=\"Permalink: Supported ENV variables\" href=\"#supported-env-variables\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cmarkdown-accessiblity-table\u003e\u003ctable\u003e\n\u003cthead\u003e\n\u003ctr\u003e\n\u003cth\u003eName\u003c/th\u003e\n\u003cth\u003eDescription\u003c/th\u003e\n\u003c/tr\u003e\n\u003c/thead\u003e\n\u003ctbody\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003ePORT\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 3000\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eRACK_ENV\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 'development'\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eRACK_TIMEOUT_SERVICE_TIMEOUT\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 15\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eWEB_CONCURRENCY\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 2\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eWEB_MAX_THREADS\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: 5\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eHEALTH_CHECK_USERNAME\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: auto-generated on start\u003c/td\u003e\n\u003c/tr\u003e\n\u003ctr\u003e\n\u003ctd\u003e\u003ccode\u003eHEALTH_CHECK_PASSWORD\u003c/code\u003e\u003c/td\u003e\n\u003ctd\u003edefault: auto-generated on start\u003c/td\u003e\n\u003c/tr\u003e\n\u003c/tbody\u003e\n\u003c/table\u003e\u003c/markdown-accessiblity-table\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eRuntime monitoring via \u003ccode\u003eGET /health_check.txt\u003c/code\u003e\u003c/h3\u003e\u003ca id=\"user-content-runtime-monitoring-via-get-health_checktxt\" class=\"anchor\" aria-label=\"Permalink: Runtime monitoring via GET /health_check.txt\" href=\"#runtime-monitoring-via-get-health_checktxt\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eIt is recommended to set up monitoring of the \u003ccode\u003e/health_check.txt\u003c/code\u003e endpoint. With that, you can find out when one of \u003cem\u003eyour own\u003c/em\u003e configs breaks. The endpoint uses HTTP Basic authentication.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eFirst, set the username and password via these environment variables: \u003ccode\u003eHEALTH_CHECK_USERNAME\u003c/code\u003e and \u003ccode\u003eHEALTH_CHECK_PASSWORD\u003c/code\u003e. If these are not set, html2rss-web will generate a new random username and password on \u003cem\u003eeach\u003c/em\u003e start.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eAn authenticated \u003ccode\u003eGET /health_check.txt\u003c/code\u003e request will respond with:\u003c/p\u003e\n\u003cul dir=\"auto\"\u003e\n\u003cli\u003eIf the feeds are generatable: \u003ccode\u003esuccess\u003c/code\u003e.\u003c/li\u003e\n\u003cli\u003eOtherwise: the names of the broken configs.\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp dir=\"auto\"\u003eTo get notified when one of your configs breaks, set up monitoring of this endpoint.\u003c/p\u003e\n\u003cp dir=\"auto\"\u003e\u003ca href=\"https://uptimerobot.com/\" rel=\"nofollow\"\u003eUptimeRobot's free plan\u003c/a\u003e is sufficient for basic monitoring (every 5 minutes).\u003cbr\u003e\nCreate a monitor of type \u003cem\u003eKeyword\u003c/em\u003e with this information and make it aware of your username and password:\u003c/p\u003e\n\u003cp dir=\"auto\"\u003e\u003ca target=\"_blank\" rel=\"noopener noreferrer\" href=\"/html2rss/html2rss-web/blob/master/docs/uptimerobot_monitor.jpg\"\u003e\u003cimg src=\"/html2rss/html2rss-web/raw/master/docs/uptimerobot_monitor.jpg\" alt=\"A screenshot showing the Keyword Monitor: a name, the instance's URL to /health_check.txt, and an interval.\" style=\"max-width: 100%;\"\u003e\u003c/a\u003e\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eSetup for development\u003c/h2\u003e\u003ca id=\"user-content-setup-for-development\" class=\"anchor\" aria-label=\"Permalink: Setup for development\" href=\"#setup-for-development\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eCheck out the git repository and…\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eUsing Docker\u003c/h3\u003e\u003ca id=\"user-content-using-docker\" class=\"anchor\" aria-label=\"Permalink: Using Docker\" href=\"#using-docker\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eThis approach allows you to experiment without installing Ruby on your machine.\nAll you need to do is install and run Docker.\u003c/p\u003e\n\u003cdiv class=\"highlight highlight-source-shell notranslate position-relative overflow-auto\" dir=\"auto\" data-snippet-clipboard-copy-content=\"# Build image from Dockerfile and name/tag it as html2rss-web:\ndocker build -t html2rss-web -f Dockerfile .\n\n# Run the image and name it html2rss-web-dev:\ndocker run \\\n  --detach \\\n  --mount type=bind,source=$(pwd)/config,target=/app/config \\\n  --name html2rss-web-dev \\\n  html2rss-web\n\n# Open an interactive TTY with the shell `sh`:\ndocker exec -ti html2rss-web-dev sh\n\n# Stop and clean up the container\ndocker stop html2rss-web-dev\ndocker rm html2rss-web-dev\n\n# Remove the image\ndocker rmi html2rss-web\"\u003e\u003cpre\u003e\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Build image from Dockerfile and name/tag it as html2rss-web:\u003c/span\u003e\ndocker build -t html2rss-web -f Dockerfile \u003cspan class=\"pl-c1\"\u003e.\u003c/span\u003e\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Run the image and name it html2rss-web-dev:\u003c/span\u003e\ndocker run \\\n  --detach \\\n  --mount type=bind,source=\u003cspan class=\"pl-s\"\u003e\u003cspan class=\"pl-pds\"\u003e$(\u003c/span\u003epwd\u003cspan class=\"pl-pds\"\u003e)\u003c/span\u003e\u003c/span\u003e/config,target=/app/config \\\n  --name html2rss-web-dev \\\n  html2rss-web\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Open an interactive TTY with the shell `sh`:\u003c/span\u003e\ndocker \u003cspan class=\"pl-c1\"\u003eexec\u003c/span\u003e -ti html2rss-web-dev sh\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Stop and clean up the container\u003c/span\u003e\ndocker stop html2rss-web-dev\ndocker rm html2rss-web-dev\n\n\u003cspan class=\"pl-c\"\u003e\u003cspan class=\"pl-c\"\u003e#\u003c/span\u003e Remove the image\u003c/span\u003e\ndocker rmi html2rss-web\u003c/pre\u003e\u003c/div\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch3 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eUsing installed Ruby\u003c/h3\u003e\u003ca id=\"user-content-using-installed-ruby\" class=\"anchor\" aria-label=\"Permalink: Using installed Ruby\" href=\"#using-installed-ruby\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eIf you're comfortable with installing Ruby directly on your machine, follow these instructions:\u003c/p\u003e\n\u003col dir=\"auto\"\u003e\n\u003cli\u003eInstall Ruby \u003ccode\u003e\u0026gt;= 3.2\u003c/code\u003e\u003c/li\u003e\n\u003cli\u003e\u003ccode\u003egem install bundler foreman\u003c/code\u003e\u003c/li\u003e\n\u003cli\u003e\u003ccode\u003ebundle\u003c/code\u003e\u003c/li\u003e\n\u003cli\u003e\u003ccode\u003eforeman start\u003c/code\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp dir=\"auto\"\u003e\u003cem\u003ehtml2rss-web\u003c/em\u003e now listens on port \u003cstrong\u003e3000\u003c/strong\u003e for requests.\u003c/p\u003e\n\u003cdiv class=\"markdown-heading\" dir=\"auto\"\u003e\u003ch2 tabindex=\"-1\" class=\"heading-element\" dir=\"auto\"\u003eContribute\u003c/h2\u003e\u003ca id=\"user-content-contribute\" class=\"anchor\" aria-label=\"Permalink: Contribute\" href=\"#contribute\"\u003e\u003csvg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"\u003e\u003cpath d=\"m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z\"\u003e\u003c/path\u003e\u003c/svg\u003e\u003c/a\u003e\u003c/div\u003e\n\u003cp dir=\"auto\"\u003eContributions are welcome!\u003c/p\u003e\n\u003cp dir=\"auto\"\u003eOpen a pull request with your changes,\u003cbr\u003e\nopen an issue, or\u003cbr\u003e\n\u003ca href=\"https://github.com/orgs/html2rss/discussions\"\u003ejoin discussions on html2rss\u003c/a\u003e.\u003c/p\u003e\n\u003c/article\u003e","loaded":true,"timedOut":false,"errorMessage":null,"headerInfo":{"toc":[{"level":1,"text":"html2rss-web","anchor":"html2rss-web","htmlText":"html2rss-web"},{"level":2,"text":"Get started","anchor":"get-started","htmlText":"Get started"},{"level":3,"text":"With Docker","anchor":"with-docker","htmlText":"With Docker"},{"level":3,"text":"With docker compose","anchor":"with-docker-compose","htmlText":"With docker compose"},{"level":2,"text":"Docker: Automatically keep the html2rss-web image up-to-date","anchor":"docker-automatically-keep-the-html2rss-web-image-up-to-date","htmlText":"Docker: Automatically keep the html2rss-web image up-to-date"},{"level":2,"text":"How to use the included configs","anchor":"how-to-use-the-included-configs","htmlText":"How to use the included configs"},{"level":2,"text":"How to build your RSS feeds","anchor":"how-to-build-your-rss-feeds","htmlText":"How to build your RSS feeds"},{"level":2,"text":"Versioning and releases","anchor":"versioning-and-releases","htmlText":"Versioning and releases"},{"level":2,"text":"Use in production","anchor":"use-in-production","htmlText":"Use in production"},{"level":3,"text":"Supported ENV variables","anchor":"supported-env-variables","htmlText":"Supported ENV variables"},{"level":3,"text":"Runtime monitoring via GET /health_check.txt","anchor":"runtime-monitoring-via-get-health_checktxt","htmlText":"Runtime monitoring via GET /health_check.txt"},{"level":2,"text":"Setup for development","anchor":"setup-for-development","htmlText":"Setup for development"},{"level":3,"text":"Using Docker","anchor":"using-docker","htmlText":"Using Docker"},{"level":3,"text":"Using installed Ruby","anchor":"using-installed-ruby","htmlText":"Using installed Ruby"},{"level":2,"text":"Contribute","anchor":"contribute","htmlText":"Contribute"}],"siteNavLoginPath":"/login?return_to=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web"}},{"displayName":"LICENSE","repoName":"html2rss-web","refName":"master","path":"LICENSE","preferredFileType":"license","tabName":"MIT","richText":null,"loaded":false,"timedOut":false,"errorMessage":null,"headerInfo":{"toc":null,"siteNavLoginPath":"/login?return_to=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web"}}],"overviewFilesProcessingTime":0}},"appPayload":{"helpUrl":"https://docs.github.com","findFileWorkerPath":"/assets-cdn/worker/find-file-worker-1583894afd38.js","findInFileWorkerPath":"/assets-cdn/worker/find-in-file-worker-f653046cb227.js","githubDevUrl":null,"enabled_features":{"code_nav_ui_events":false,"overview_shared_code_dropdown_button":false,"react_blob_overlay":false,"copilot_conversational_ux_embedding_update":false,"copilot_smell_icebreaker_ux":true,"copilot_workspace":false,"blob_edit_unsaved_changes_storage":false,"accessible_code_button":true,"overview_branch_and_tag_count":true,"overview_spoofed_commit_banner_react":true}}}}</script>
  <div data-target="react-partial.reactRoot"><style data-styled="true" data-styled-version="5.3.11">.iVEunk{margin-top:16px;margin-bottom:16px;}/*!sc*/
.jzuOtQ{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;}/*!sc*/
.bGojzy{margin-bottom:0;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;row-gap:16px;}/*!sc*/
.iNSVHo{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;padding-bottom:16px;padding-top:8px;}/*!sc*/
.bVgnfw{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;gap:8px;}/*!sc*/
@media screen and (max-width:320px){.bVgnfw{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}}/*!sc*/
.CEgMp{position:relative;}/*!sc*/
@media screen and (max-width:380px){.CEgMp .ref-selector-button-text-container{max-width:80px;}}/*!sc*/
@media screen and (max-width:320px){.CEgMp{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}.CEgMp .overview-ref-selector{width:100%;}.CEgMp .overview-ref-selector > span{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}.CEgMp .overview-ref-selector > span > span[data-component="text"]{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}}/*!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*/
.ffLUq{font-size:14px;min-width:0;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*/
.fLXEGX{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (max-width:1079px){.fLXEGX{display:none;}}/*!sc*/
.dqfxud{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (min-width:1080px){.dqfxud{display:none;}}/*!sc*/
@media screen and (max-width:543px){.dqfxud{display:none;}}/*!sc*/
.jxTzTd{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;padding-left:8px;gap:8px;}/*!sc*/
.gqqBXN{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;gap:8px;}/*!sc*/
@media screen and (max-width:543px){.gqqBXN{display:none;}}/*!sc*/
.dzXgxt{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (max-width:1011px){.dzXgxt{display:none;}}/*!sc*/
.YUPas{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (min-width:1012px){.YUPas{display:none;}}/*!sc*/
.izFOf{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media screen and (min-width:544px){.izFOf{display:none;}}/*!sc*/
.vIPPs{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;gap:16px;}/*!sc*/
.fdROMU{width:100%;border-collapse:separate;border-spacing:0;border:1px solid;border-color:var(--borderColor-default,var(--color-border-default,#d0d7de));border-radius:6px;table-layout:fixed;overflow:unset;}/*!sc*/
.jGKpsv{height:0px;line-height:0px;}/*!sc*/
.jGKpsv tr{height:0px;font-size:0px;}/*!sc*/
.jdgHnn{padding:16px;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));font-size:12px;text-align:left;height:40px;}/*!sc*/
.jdgHnn th{padding-left:16px;background-color:var(--bgColor-muted,var(--color-canvas-subtle,#f6f8fa));}/*!sc*/
.bQivRW{width:100%;border-top-left-radius:6px;}/*!sc*/
@media screen and (min-width:544px){.bQivRW{display:none;}}/*!sc*/
.ldkMIO{width:40%;border-top-left-radius:6px;}/*!sc*/
@media screen and (max-width:543px){.ldkMIO{display:none;}}/*!sc*/
.jMbWeI{text-align:right;padding-right:16px;width:136px;border-top-right-radius:6px;}/*!sc*/
.gpqjiB{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));font-size:12px;height:40px;}/*!sc*/
.dzCJzi{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-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;gap:8px;min-width:273px;padding:8px;}/*!sc*/
@media screen and (min-width:544px){.dzCJzi{-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;}}/*!sc*/
.eNCcrz{text-align:center;vertical-align:center;height:40px;border-top:1px solid;border-color:var(--borderColor-default,var(--color-border-default,#d0d7de));}/*!sc*/
.bHTcCe{border-top:1px solid var(--borderColor-default,var(--color-border-default));cursor:pointer;}/*!sc*/
.csrIcr{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;gap:16px;}/*!sc*/
.bUQNHB{border:1px solid;border-color:var(--borderColor-default,var(--color-border-default,#d0d7de));border-radius:6px;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
@media screen and (max-width:543px){.bUQNHB{margin-left:-16px;margin-right:-16px;max-width:calc(100% + 32px);}}/*!sc*/
@media screen and (min-width:544px){.bUQNHB{max-width:100%;}}/*!sc*/
.jPdcfu{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;border-bottom:1px solid;border-bottom-color:var(--borderColor-default,var(--color-border-default,#d0d7de));-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding-right:8px;position:-webkit-sticky;position:sticky;top:0;background-color:var(--bgColor-default,var(--color-canvas-default,#ffffff));z-index:1;border-top-left-radius:6px;border-top-right-radius:6px;}/*!sc*/
.hUCRAk{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
.QkQOb{padding:32px;overflow:auto;}/*!sc*/
data-styled.g1[id="Box-sc-g0xbh4-0"]{content:"iVEunk,jzuOtQ,bGojzy,iNSVHo,bVgnfw,CEgMp,gUkoLg,bZBlpz,lhTYNA,ffLUq,hzSPyu,fLXEGX,dqfxud,jxTzTd,gqqBXN,dzXgxt,YUPas,izFOf,vIPPs,fdROMU,jGKpsv,jdgHnn,bQivRW,ldkMIO,jMbWeI,gpqjiB,dzCJzi,eNCcrz,bHTcCe,csrIcr,bUQNHB,jPdcfu,hUCRAk,QkQOb,"}/*!sc*/
.gVXRRg{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*/
.gVXRRg:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gVXRRg:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.gVXRRg:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gVXRRg[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.gVXRRg[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.gVXRRg:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.gVXRRg:active{-webkit-transition:none;transition:none;}/*!sc*/
.gVXRRg[data-inactive]{cursor:auto;}/*!sc*/
.gVXRRg: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*/
.gVXRRg:disabled [data-component=ButtonCounter]{color:inherit;}/*!sc*/
@media (forced-colors:active){.gVXRRg:focus{outline:solid 1px transparent;}}/*!sc*/
.gVXRRg [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*/
.gVXRRg[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.gVXRRg[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.gVXRRg[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.gVXRRg[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gVXRRg[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.gVXRRg[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.gVXRRg[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.gVXRRg[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gVXRRg[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.gVXRRg[data-block="block"]{width:100%;}/*!sc*/
.gVXRRg[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*/
.gVXRRg[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*/
.gVXRRg[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.gVXRRg[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.gVXRRg[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.gVXRRg[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*/
.gVXRRg[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.gVXRRg[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*/
.gVXRRg[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.gVXRRg [data-component="leadingVisual"]{grid-area:leadingVisual;}/*!sc*/
.gVXRRg [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.gVXRRg [data-component="trailingVisual"]{grid-area:trailingVisual;}/*!sc*/
.gVXRRg [data-component="trailingAction"]{margin-right:-4px;}/*!sc*/
.gVXRRg [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*/
.gVXRRg [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gVXRRg [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gVXRRg [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.gVXRRg: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*/
.gVXRRg: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*/
.gVXRRg[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*/
.gVXRRg [data-component="leadingVisual"],.gVXRRg [data-component="trailingVisual"],.gVXRRg [data-component="trailingAction"]{color:var(--button-color,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gVXRRg[data-component="IconButton"][data-no-visuals]:not(:disabled){color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gVXRRg[data-size="medium"]{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;min-width:0;}/*!sc*/
.gVXRRg[data-size="medium"] svg{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gVXRRg[data-size="medium"] > span{width:inherit;}/*!sc*/
.loAzyw{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*/
.loAzyw:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.loAzyw:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.loAzyw:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.loAzyw[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.loAzyw[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.loAzyw:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.loAzyw:active{-webkit-transition:none;transition:none;}/*!sc*/
.loAzyw[data-inactive]{cursor:auto;}/*!sc*/
.loAzyw: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*/
.loAzyw:disabled [data-component=ButtonCounter],.loAzyw:disabled [data-component="leadingVisual"],.loAzyw:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.loAzyw:focus{outline:solid 1px transparent;}}/*!sc*/
.loAzyw [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.loAzyw[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.loAzyw[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.loAzyw[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.loAzyw[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.loAzyw[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.loAzyw[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.loAzyw[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.loAzyw[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.loAzyw[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.loAzyw[data-block="block"]{width:100%;}/*!sc*/
.loAzyw[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*/
.loAzyw[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*/
.loAzyw[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.loAzyw[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.loAzyw[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.loAzyw[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*/
.loAzyw[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.loAzyw[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*/
.loAzyw[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.loAzyw [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.loAzyw [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw [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*/
.loAzyw [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.loAzyw [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.loAzyw [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.loAzyw: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*/
.loAzyw: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*/
.loAzyw[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*/
.loAzyw[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.loAzyw[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.loAzyw:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.loAzyw:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.loAzyw:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.loAzyw[data-size="medium"]{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));padding-left:4px;padding-right:4px;}/*!sc*/
.loAzyw[data-size="medium"] span[data-component="leadingVisual"]{margin-right:4px !important;}/*!sc*/
.cXsOlJ{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*/
.cXsOlJ:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.cXsOlJ:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.cXsOlJ:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.cXsOlJ[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.cXsOlJ[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.cXsOlJ:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.cXsOlJ:active{-webkit-transition:none;transition:none;}/*!sc*/
.cXsOlJ[data-inactive]{cursor:auto;}/*!sc*/
.cXsOlJ: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*/
.cXsOlJ:disabled [data-component=ButtonCounter],.cXsOlJ:disabled [data-component="leadingVisual"],.cXsOlJ:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.cXsOlJ:focus{outline:solid 1px transparent;}}/*!sc*/
.cXsOlJ [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.cXsOlJ[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.cXsOlJ[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.cXsOlJ[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.cXsOlJ[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.cXsOlJ[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.cXsOlJ[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.cXsOlJ[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.cXsOlJ[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.cXsOlJ[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.cXsOlJ[data-block="block"]{width:100%;}/*!sc*/
.cXsOlJ[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*/
.cXsOlJ[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*/
.cXsOlJ[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.cXsOlJ[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.cXsOlJ[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.cXsOlJ[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*/
.cXsOlJ[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.cXsOlJ[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*/
.cXsOlJ[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.cXsOlJ [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.cXsOlJ [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ [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*/
.cXsOlJ [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.cXsOlJ [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.cXsOlJ [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.cXsOlJ: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*/
.cXsOlJ: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*/
.cXsOlJ[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*/
.cXsOlJ[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.cXsOlJ[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.cXsOlJ:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.cXsOlJ:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.cXsOlJ:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.cXsOlJ[data-size="medium"][data-no-visuals]{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!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*/
.bmlmSe{border-radius:6px;border:1px solid;border-color:var(--button-primary-borderColor-rest,var(--color-btn-primary-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-primary-fgColor-rest,var(--color-btn-primary-text,#ffffff));background-color:var(--button-primary-bgColor-rest,var(--color-btn-primary-bg,#1f883d));box-shadow:var(--shadow-resting-small,var(--color-btn-primary-shadow,0 1px 0 rgba(31,35,40,0.1)));}/*!sc*/
.bmlmSe:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.bmlmSe:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.bmlmSe:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.bmlmSe[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.bmlmSe[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.bmlmSe:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.bmlmSe:active{-webkit-transition:none;transition:none;}/*!sc*/
.bmlmSe[data-inactive]{cursor:auto;}/*!sc*/
.bmlmSe:disabled{cursor:not-allowed;box-shadow:none;color:var(--button-primary-fgColor-disabled,var(--color-btn-primary-disabled-text,rgba(255,255,255,0.8)));background-color:var(--button-primary-bgColor-disabled,var(--color-btn-primary-disabled-bg,#94d3a2));border-color:var(--button-primary-borderColor-disabled,var(--color-btn-primary-disabled-border,rgba(31,35,40,0.15)));}/*!sc*/
.bmlmSe:disabled [data-component=ButtonCounter]{color:inherit;}/*!sc*/
@media (forced-colors:active){.bmlmSe:focus{outline:solid 1px transparent;}}/*!sc*/
.bmlmSe [data-component=ButtonCounter]{font-size:12px;background-color:var(--buttonCounter-primary-bgColor-rest,var(--color-btn-primary-counter-bg,rgba(0,45,17,0.2)));color:var(--button-primary-fgColor-rest,var(--color-btn-primary-text,#ffffff));}/*!sc*/
.bmlmSe[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.bmlmSe[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.bmlmSe[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.bmlmSe[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.bmlmSe[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.bmlmSe[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.bmlmSe[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.bmlmSe[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.bmlmSe[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.bmlmSe[data-block="block"]{width:100%;}/*!sc*/
.bmlmSe[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*/
.bmlmSe[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*/
.bmlmSe[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.bmlmSe[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.bmlmSe[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.bmlmSe[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*/
.bmlmSe[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.bmlmSe[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*/
.bmlmSe[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.bmlmSe [data-component="leadingVisual"]{grid-area:leadingVisual;}/*!sc*/
.bmlmSe [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.bmlmSe [data-component="trailingVisual"]{grid-area:trailingVisual;}/*!sc*/
.bmlmSe [data-component="trailingAction"]{margin-right:-4px;}/*!sc*/
.bmlmSe [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*/
.bmlmSe [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.bmlmSe [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.bmlmSe [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.bmlmSe:hover:not([disabled]):not([data-inactive]){color:btn.primary.hoverText;background-color:var(--button-primary-bgColor-hover,var(--color-btn-primary-hover-bg,#1a7f37));}/*!sc*/
.bmlmSe:focus:not([disabled]){box-shadow:inset 0 0 0 3px;}/*!sc*/
.bmlmSe:focus-visible:not([disabled]){box-shadow:inset 0 0 0 3px;}/*!sc*/
.bmlmSe:active:not([disabled]):not([data-inactive]){background-color:var(--button-primary-bgColor-active,var(--color-btn-primary-selected-bg,hsla(137,66%,28%,1)));box-shadow:var(--button-primary-shadow-selected,var(--color-btn-primary-selected-shadow,inset 0 1px 0 rgba(0,45,17,0.2)));}/*!sc*/
.bmlmSe[aria-expanded=true]{background-color:var(--button-primary-bgColor-active,var(--color-btn-primary-selected-bg,hsla(137,66%,28%,1)));box-shadow:var(--button-primary-shadow-selected,var(--color-btn-primary-selected-shadow,inset 0 1px 0 rgba(0,45,17,0.2)));}/*!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*/
.gXPTqA{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*/
.gXPTqA:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gXPTqA:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.gXPTqA:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:-2px;}/*!sc*/
.gXPTqA[href]{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}/*!sc*/
.gXPTqA[href]:hover{-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.gXPTqA:hover{-webkit-transition-duration:80ms;transition-duration:80ms;}/*!sc*/
.gXPTqA:active{-webkit-transition:none;transition:none;}/*!sc*/
.gXPTqA[data-inactive]{cursor:auto;}/*!sc*/
.gXPTqA: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*/
.gXPTqA:disabled [data-component=ButtonCounter],.gXPTqA:disabled [data-component="leadingVisual"],.gXPTqA:disabled [data-component="trailingAction"]{color:inherit;}/*!sc*/
@media (forced-colors:active){.gXPTqA:focus{outline:solid 1px transparent;}}/*!sc*/
.gXPTqA [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gXPTqA[data-component=IconButton]{display:inline-grid;padding:unset;place-content:center;width:32px;min-width:unset;}/*!sc*/
.gXPTqA[data-size="small"]{padding:0 8px;height:28px;gap:4px;font-size:12px;}/*!sc*/
.gXPTqA[data-size="small"] [data-component="text"]{line-height:1.6666667;}/*!sc*/
.gXPTqA[data-size="small"] [data-component=ButtonCounter]{font-size:12px;}/*!sc*/
.gXPTqA[data-size="small"] [data-component="buttonContent"] > :not(:last-child){margin-right:4px;}/*!sc*/
.gXPTqA[data-size="small"][data-component=IconButton]{width:28px;padding:unset;}/*!sc*/
.gXPTqA[data-size="large"]{padding:0 16px;height:40px;gap:8px;}/*!sc*/
.gXPTqA[data-size="large"] [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gXPTqA[data-size="large"][data-component=IconButton]{width:40px;padding:unset;}/*!sc*/
.gXPTqA[data-block="block"]{width:100%;}/*!sc*/
.gXPTqA[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*/
.gXPTqA[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*/
.gXPTqA[data-label-wrap="true"] [data-component="text"]{white-space:unset;word-break:break-word;}/*!sc*/
.gXPTqA[data-label-wrap="true"][data-size="small"]{height:unset;min-height:var(--control-small-size,1.75rem);}/*!sc*/
.gXPTqA[data-label-wrap="true"][data-size="small"] [data-component="buttonContent"]{padding-block:calc(var(--control-small-paddingBlock,0.25rem) - 2px);}/*!sc*/
.gXPTqA[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*/
.gXPTqA[data-label-wrap="true"][data-size="large"] [data-component="buttonContent"]{padding-block:calc(var(--control-large-paddingBlock,0.625rem) - 2px);}/*!sc*/
.gXPTqA[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*/
.gXPTqA[data-inactive]:not([disabled]):focus-visible{box-shadow:none;}/*!sc*/
.gXPTqA [data-component="leadingVisual"]{grid-area:leadingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA [data-component="text"]{grid-area:text;line-height:1.4285714;white-space:nowrap;}/*!sc*/
.gXPTqA [data-component="trailingVisual"]{grid-area:trailingVisual;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA [data-component="trailingAction"]{margin-right:-4px;color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA [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*/
.gXPTqA [data-component="buttonContent"] > :not(:last-child){margin-right:8px;}/*!sc*/
.gXPTqA [data-component="loadingSpinner"]{grid-area:text;margin-right:0px !important;place-self:center;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.gXPTqA [data-component="loadingSpinner"] + [data-component="text"]{visibility:hidden;}/*!sc*/
.gXPTqA: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*/
.gXPTqA: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*/
.gXPTqA[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*/
.gXPTqA[data-component="IconButton"][data-no-visuals]{color:var(--button-invisible-iconColor-rest,var(--fgColor-muted,var(--color-fg-muted,#656d76)));}/*!sc*/
.gXPTqA[data-no-visuals]{color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.gXPTqA:has([data-component="ButtonCounter"]){color:var(--button-invisible-fgColor-rest,var(--button-default-fgColor-rest,var(--color-btn-text,#24292f)));}/*!sc*/
.gXPTqA:disabled[data-no-visuals]{color:var(--fgColor-disabled,var(--color-primer-fg-disabled,#8c959f));}/*!sc*/
.gXPTqA:disabled[data-no-visuals] [data-component=ButtonCounter]{color:inherit;}/*!sc*/
.gXPTqA[data-size="medium"]{color:var(--fgColor-muted,var(--color-fg-subtle,#6e7781));padding-left:8px;padding-right:8px;}/*!sc*/
data-styled.g4[id="types__StyledButton-sc-ws60qy-0"]{content:"gVXRRg,loAzyw,cXsOlJ,gGdPyq,bmlmSe,dPmZyJ,gXPTqA,"}/*!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*/
data-styled.g10[id="Link__StyledLink-sc-14289xe-0"]{content:"dIlPa,"}/*!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.g11[id="Tooltip__TooltipBase-sc-17tf59c-0"]{content:"hWlpPn,"}/*!sc*/
.brGdpi{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;-webkit-clip:rect(0,0,0,0);clip:rect(0,0,0,0);white-space:nowrap;border-width:0;}/*!sc*/
data-styled.g12[id="_VisuallyHidden__VisuallyHidden-sc-11jhm7a-0"]{content:"brGdpi,"}/*!sc*/
.liVpTx{display:inline-block;overflow:hidden;text-overflow:ellipsis;vertical-align:top;white-space:nowrap;max-width:125px;}/*!sc*/
data-styled.g14[id="Truncate__StyledTruncate-sc-23o1d2-0"]{content:"liVpTx,"}/*!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*/
data-styled.g23[id="Text__StyledText-sc-17v1xeu-0"]{content:"eMMFM,"}/*!sc*/
.iBVwpg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;padding-inline:var(--stack-padding-normal,16px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:var(--control-xlarge-size,48px);box-shadow:inset 0px -1px var(--borderColor-muted,var(--borderColor-muted,var(--color-border-muted,hsla(210,18%,87%,1))));-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;border-bottom:none;max-width:100%;padding-left:8px;padding-right:8px;}/*!sc*/
data-styled.g24[id="UnderlineTabbedInterface__StyledUnderlineWrapper-sc-4ilrg0-0"]{content:"iBVwpg,"}/*!sc*/
.gJyWUl{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;list-style:none;white-space:nowrap;padding:0;margin:0;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;gap:8px;position:relative;}/*!sc*/
data-styled.g25[id="UnderlineTabbedInterface__StyledUnderlineItemList-sc-4ilrg0-1"]{content:"gJyWUl,"}/*!sc*/
.beOdPj{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:transparent;border:0;cursor:pointer;font:inherit;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;color:var(--fgColor-default,var(--color-fg-default,#1F2328));text-align:center;-webkit-text-decoration:none;text-decoration:none;line-height:var(--text-body-lineHeight-medium,1.4285);border-radius:var(--borderRadius-medium,6px);font-size:var(--text-body-size-medium,14px);padding-inline:var(--control-medium-paddingInline-condensed,8px);padding-block:var(--control-medium-paddingBlock,6px);-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
@media (hover:hover){.beOdPj:hover{background-color:var(--bgColor-neutral-muted,var(--bgColor-neutral-muted,var(--color-neutral-subtle,rgba(234,238,242,0.5))));-webkit-transition:background 0.12s ease-out;transition:background 0.12s ease-out;-webkit-text-decoration:none;text-decoration:none;}}/*!sc*/
.beOdPj:focus:{outline:2px solid transparent;box-shadow:inset 0 0 0 2px var(--fgColor-accent,var(--fgColor-accent,var(--color-accent-fg,#0969da)));}/*!sc*/
.beOdPj:focus::not(:focus-visible){box-shadow:none;}/*!sc*/
.beOdPj:focus-visible{outline:2px solid transparent;box-shadow:inset 0 0 0 2px var(--fgColor-accent,var(--fgColor-accent,var(--color-accent-fg,#0969da)));}/*!sc*/
.beOdPj [data-content]::before{content:attr(data-content);display:block;height:0;font-weight:var(--base-text-weight-semibold,500);visibility:hidden;white-space:nowrap;}/*!sc*/
.beOdPj [data-component='icon']{color:var(--fgColor-muted,var(--fgColor-muted,var(--color-fg-muted,#656d76)));-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;margin-inline-end:var(--control-medium-gap,8px);}/*!sc*/
.beOdPj [data-component='counter']{margin-inline-start:var(--control-medium-gap,8px);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;}/*!sc*/
.beOdPj::after{position:absolute;right:50%;bottom:calc(50% - calc(var(--control-xlarge-size,48px) / 2 + 1px));width:100%;height:2px;content:'';background-color:transparent;border-radius:0;-webkit-transform:translate(50%,-50%);-ms-transform:translate(50%,-50%);transform:translate(50%,-50%);}/*!sc*/
.beOdPj[aria-current]:not([aria-current='false']) [data-component='text'],.beOdPj[aria-selected='true'] [data-component='text']{font-weight:var(--base-text-weight-semibold,500);}/*!sc*/
.beOdPj[aria-current]:not([aria-current='false'])::after,.beOdPj[aria-selected='true']::after{background-color:var(--underlineNav-borderColor-active,var(--color-primer-border-active,#fd8c73));}/*!sc*/
@media (forced-colors:active){.beOdPj[aria-current]:not([aria-current='false'])::after,.beOdPj[aria-selected='true']::after{background-color:LinkText;}}/*!sc*/
data-styled.g26[id="UnderlineTabbedInterface__StyledUnderlineItem-sc-4ilrg0-2"]{content:"beOdPj,"}/*!sc*/
</style> <!-- --> <!-- --> <div class="Box-sc-g0xbh4-0 iVEunk"><div class="Box-sc-g0xbh4-0 jzuOtQ"><div class="Box-sc-g0xbh4-0 bGojzy"></div></div><div class="Box-sc-g0xbh4-0 iNSVHo"><div class="Box-sc-g0xbh4-0 bVgnfw"><div class="Box-sc-g0xbh4-0 CEgMp"><button type="button" aria-haspopup="true" aria-expanded="false" tabindex="0" aria-label="master branch" data-testid="anchor-button" class="types__StyledButton-sc-ws60qy-0 gVXRRg overview-ref-selector width-full" data-loading="false" data-size="medium" aria-describedby="branch-picker-repos-header-ref-selector-loading-announcement" id="branch-picker-repos-header-ref-selector"><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 ffLUq 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-scope="read-only-cursor-text-area"></button></div><div class="Box-sc-g0xbh4-0 fLXEGX"><a style="--button-color:fg.muted" type="button" href="/html2rss/html2rss-web/branches" class="types__StyledButton-sc-ws60qy-0 loAzyw" data-loading="false" data-size="medium" aria-describedby=":Rclab:-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 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></span><span data-component="text">Branches</span></span></a><a style="--button-color:fg.muted" type="button" href="/html2rss/html2rss-web/tags" class="types__StyledButton-sc-ws60qy-0 loAzyw" data-loading="false" data-size="medium" aria-describedby=":Rklab:-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 octicon-tag" 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="M1 7.775V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 0 1 0 2.474l-5.026 5.026a1.75 1.75 0 0 1-2.474 0l-6.25-6.25A1.752 1.752 0 0 1 1 7.775Zm1.5 0c0 .066.026.13.073.177l6.25 6.25a.25.25 0 0 0 .354 0l5.025-5.025a.25.25 0 0 0 0-.354l-6.25-6.25a.25.25 0 0 0-.177-.073H2.75a.25.25 0 0 0-.25.25ZM6 5a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"></path></svg></span><span data-component="text">Tags</span></span></a></div><div class="Box-sc-g0xbh4-0 dqfxud"><a style="--button-color:fg.muted" type="button" aria-label="Go to Branches page" href="/html2rss/html2rss-web/branches" class="types__StyledButton-sc-ws60qy-0 cXsOlJ" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":Relab:-loading-announcement"><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></a><a style="--button-color:fg.muted" type="button" aria-label="Go to Tags page" href="/html2rss/html2rss-web/tags" class="types__StyledButton-sc-ws60qy-0 cXsOlJ" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":Rmlab:-loading-announcement"><svg aria-hidden="true" focusable="false" class="octicon octicon-tag" 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="M1 7.775V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 0 1 0 2.474l-5.026 5.026a1.75 1.75 0 0 1-2.474 0l-6.25-6.25A1.752 1.752 0 0 1 1 7.775Zm1.5 0c0 .066.026.13.073.177l6.25 6.25a.25.25 0 0 0 .354 0l5.025-5.025a.25.25 0 0 0 0-.354l-6.25-6.25a.25.25 0 0 0-.177-.073H2.75a.25.25 0 0 0-.25.25ZM6 5a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"></path></svg></a></div></div><div class="Box-sc-g0xbh4-0 jxTzTd"><div class="Box-sc-g0xbh4-0 gqqBXN"><div class="Box-sc-g0xbh4-0 dzXgxt"><!--$!--><template></template><!--/$--></div><div class="Box-sc-g0xbh4-0 YUPas"><button type="button" class="types__StyledButton-sc-ws60qy-0 gGdPyq" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":Rr5ab:-loading-announcement"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg"><span data-component="text">Go to file</span></span></button></div><div class="react-directory-add-file-icon"></div><div class="react-directory-remove-file-icon"></div></div><button type="button" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 bmlmSe" data-loading="false" data-size="medium" aria-describedby=":R55ab:-loading-announcement" id=":R55ab:"><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="hide-sm" 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></span><span data-component="text">Code</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 class="Box-sc-g0xbh4-0 izFOf"><button data-component="IconButton" type="button" aria-label="Open more actions menu" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 gGdPyq prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" aria-describedby=":R75ab:-loading-announcement" id=":R75ab:"><svg aria-hidden="true" focusable="false" class="octicon octicon-kebab-horizontal" 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="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></div></div></div><div class="Box-sc-g0xbh4-0 vIPPs"><div data-hpc="true"><button hidden="" data-testid="focus-next-element-button" data-hotkey="j"></button><button hidden="" data-testid="focus-previous-element-button" data-hotkey="k"></button><h2 class="sr-only prc-Heading-Heading-6CmGO" data-testid="screen-reader-heading" id="folders-and-files">Folders and files</h2><table aria-labelledby="folders-and-files" class="Box-sc-g0xbh4-0 fdROMU"><thead class="Box-sc-g0xbh4-0 jGKpsv"><tr class="Box-sc-g0xbh4-0 jdgHnn"><th colSpan="2" class="Box-sc-g0xbh4-0 bQivRW"><span class="text-bold">Name</span></th><th colSpan="1" class="Box-sc-g0xbh4-0 ldkMIO"><span class="text-bold">Name</span></th><th class="hide-sm"><div title="Last commit message" class="Truncate__StyledTruncate-sc-23o1d2-0 liVpTx width-fit"><span class="text-bold">Last commit message</span></div></th><th colSpan="1" class="Box-sc-g0xbh4-0 jMbWeI"><div title="Last commit date" class="Truncate__StyledTruncate-sc-23o1d2-0 liVpTx width-fit"><span class="text-bold">Last commit date</span></div></th></tr></thead><tbody><tr class="Box-sc-g0xbh4-0 gpqjiB"><td colSpan="3" class="bgColor-muted p-1 rounded-top-2"><div class="Box-sc-g0xbh4-0 dzCJzi"><h2 class="sr-only prc-Heading-Heading-6CmGO" data-testid="screen-reader-heading">Latest commit</h2><div style="width:120px" class="Skeleton Skeleton--text" data-testid="loading"> </div><div class="d-flex flex-shrink-0 gap-2"><div data-testid="latest-commit-details" class="d-none d-sm-flex flex-items-center"></div><div class="d-flex gap-2"><h2 class="sr-only prc-Heading-Heading-6CmGO" data-testid="screen-reader-heading">History</h2><a href="/html2rss/html2rss-web/commits/master/" class="types__StyledButton-sc-ws60qy-0 dPmZyJ d-none d-lg-flex LinkButton-module__code-view-link-button--xvCGA flex-items-center fgColor-default" data-loading="false" data-size="small" aria-describedby=":Raqj8pab:-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 octicon-history" 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="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></span><span data-component="text"><span class="fgColor-default">819 Commits</span></span></span></a><div class="d-sm-none"></div><div class="d-flex d-lg-none"><span role="tooltip" aria-label="819 Commits" id="history-icon-button-tooltip" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-n"><a href="/html2rss/html2rss-web/commits/master/" class="types__StyledButton-sc-ws60qy-0 dPmZyJ LinkButton-module__code-view-link-button--xvCGA flex-items-center fgColor-default" data-loading="false" data-size="small" aria-describedby=":R1iqj8pab:-loading-announcement history-icon-button-tooltip"><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 octicon-history" 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="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></span></span></a></span></div></div></div></div></td></tr><tr class="react-directory-row undefined" id="folder-row-0"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".github" aria-label=".github, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/.github">.github</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".github" aria-label=".github, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/.github">.github</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-1"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app" aria-label="app, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/app">app</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app" aria-label="app, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/app">app</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-2"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="bin" aria-label="bin, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/bin">bin</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="bin" aria-label="bin, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/bin">bin</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-3"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config" aria-label="config, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/config">config</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config" aria-label="config, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/config">config</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-4"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="docs" aria-label="docs, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/docs">docs</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="docs" aria-label="docs, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/docs">docs</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-5"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="helpers" aria-label="helpers, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/helpers">helpers</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="helpers" aria-label="helpers, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/helpers">helpers</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-6"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="public" aria-label="public, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/public">public</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="public" aria-label="public, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/public">public</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-7"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="This path skips through empty directories" aria-label="roda/roda_plugins, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/roda/roda_plugins"><span class="react-directory-default-color" data-testid="path-name-segment">roda/</span><span class="" data-testid="path-name-segment">roda_plugins</span></a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="This path skips through empty directories" aria-label="roda/roda_plugins, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/roda/roda_plugins"><span class="react-directory-default-color" data-testid="path-name-segment">roda/</span><span class="" data-testid="path-name-segment">roda_plugins</span></a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-8"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="spec" aria-label="spec, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/spec">spec</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="spec" aria-label="spec, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/spec">spec</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row undefined" id="folder-row-9"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="tmp" aria-label="tmp, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/tmp">tmp</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="tmp" aria-label="tmp, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/tmp">tmp</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-10"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="views" aria-label="views, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/views">views</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="icon-directory" 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="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="views" aria-label="views, (Directory)" class="Link--primary" href="/html2rss/html2rss-web/tree/master/views">views</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-11"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".dockerignore" aria-label=".dockerignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.dockerignore">.dockerignore</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".dockerignore" aria-label=".dockerignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.dockerignore">.dockerignore</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-12"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".gitignore" aria-label=".gitignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.gitignore">.gitignore</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".gitignore" aria-label=".gitignore, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.gitignore">.gitignore</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-13"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".mergify.yml" aria-label=".mergify.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.mergify.yml">.mergify.yml</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".mergify.yml" aria-label=".mergify.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.mergify.yml">.mergify.yml</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-14"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rspec" aria-label=".rspec, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rspec">.rspec</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rspec" aria-label=".rspec, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rspec">.rspec</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-15"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rubocop.yml" aria-label=".rubocop.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rubocop.yml">.rubocop.yml</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".rubocop.yml" aria-label=".rubocop.yml, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.rubocop.yml">.rubocop.yml</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-16"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".ruby-version" aria-label=".ruby-version, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.ruby-version">.ruby-version</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title=".ruby-version" aria-label=".ruby-version, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/.ruby-version">.ruby-version</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-17"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Dockerfile" aria-label="Dockerfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Dockerfile">Dockerfile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Dockerfile" aria-label="Dockerfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Dockerfile">Dockerfile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-18"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile" aria-label="Gemfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile">Gemfile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile" aria-label="Gemfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile">Gemfile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-19"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile.lock" aria-label="Gemfile.lock, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile.lock">Gemfile.lock</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Gemfile.lock" aria-label="Gemfile.lock, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Gemfile.lock">Gemfile.lock</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-20"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="LICENSE" aria-label="LICENSE, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/LICENSE">LICENSE</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="LICENSE" aria-label="LICENSE, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/LICENSE">LICENSE</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-21"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Procfile" aria-label="Procfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Procfile">Procfile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Procfile" aria-label="Procfile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Procfile">Procfile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-22"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="README.md" aria-label="README.md, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/README.md">README.md</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="README.md" aria-label="README.md, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/README.md">README.md</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-23"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Rakefile" aria-label="Rakefile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Rakefile">Rakefile</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="Rakefile" aria-label="Rakefile, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/Rakefile">Rakefile</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-24"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.json" aria-label="app.json, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.json">app.json</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.json" aria-label="app.json, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.json">app.json</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-25"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.rb" aria-label="app.rb, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.rb">app.rb</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="app.rb" aria-label="app.rb, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/app.rb">app.rb</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="react-directory-row truncate-for-mobile" id="folder-row-26"><td class="react-directory-row-name-cell-small-screen" colSpan="2"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config.ru" aria-label="config.ru, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/config.ru">config.ru</a></div></div></div></div></td><td class="react-directory-row-name-cell-large-screen" colSpan="1"><div class="react-directory-filename-column"><svg aria-hidden="true" focusable="false" class="color-fg-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="M2 1.75C2 .784 2.784 0 3.75 0h6.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0 1 13.25 16h-9.5A1.75 1.75 0 0 1 2 14.25Zm1.75-.25a.25.25 0 0 0-.25.25v12.5c0 .138.112.25.25.25h9.5a.25.25 0 0 0 .25-.25V6h-2.75A1.75 1.75 0 0 1 9 4.25V1.5Zm6.75.062V4.25c0 .138.112.25.25.25h2.688l-.011-.013-2.914-2.914-.013-.011Z"></path></svg><div class="overflow-hidden"><div class="react-directory-filename-cell"><div class="react-directory-truncate"><a title="config.ru" aria-label="config.ru, (File)" class="Link--primary" href="/html2rss/html2rss-web/blob/master/config.ru">config.ru</a></div></div></div></div></td><td class="react-directory-row-commit-cell"><div class="Skeleton Skeleton--text"> </div></td><td><div class="Skeleton Skeleton--text"> </div></td></tr><tr class="Box-sc-g0xbh4-0 eNCcrz show-for-mobile" data-testid="view-all-files-row"><td colSpan="3" class="Box-sc-g0xbh4-0 bHTcCe"><div><button class="Link__StyledLink-sc-14289xe-0 dIlPa">View all files</button></div></td></tr></tbody></table></div><div class="Box-sc-g0xbh4-0 csrIcr"><div class="Box-sc-g0xbh4-0 bUQNHB"><div itemscope="" itemType="https://schema.org/abstract" class="Box-sc-g0xbh4-0 jPdcfu"><h2 class="_VisuallyHidden__VisuallyHidden-sc-11jhm7a-0 brGdpi">Repository files navigation</h2><nav aria-label="Repository files" class="UnderlineTabbedInterface__StyledUnderlineWrapper-sc-4ilrg0-0 iBVwpg"><ul role="list" class="UnderlineTabbedInterface__StyledUnderlineItemList-sc-4ilrg0-1 gJyWUl"><li class="Box-sc-g0xbh4-0 hUCRAk"><a href="#" aria-current="page" class="UnderlineTabbedInterface__StyledUnderlineItem-sc-4ilrg0-2 beOdPj"><span data-component="icon"><svg aria-hidden="true" focusable="false" class="octicon octicon-book" 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 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-component="text" data-content="README">README</span></a></li><li class="Box-sc-g0xbh4-0 hUCRAk"><a href="#" class="UnderlineTabbedInterface__StyledUnderlineItem-sc-4ilrg0-2 beOdPj"><span data-component="icon"><svg aria-hidden="true" focusable="false" class="octicon octicon-law" 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="M8.75.75V2h.985c.304 0 .603.08.867.231l1.29.736c.038.022.08.033.124.033h2.234a.75.75 0 0 1 0 1.5h-.427l2.111 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.006.005-.01.01-.045.04c-.21.176-.441.327-.686.45C14.556 10.78 13.88 11 13 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L12.178 4.5h-.162c-.305 0-.604-.079-.868-.231l-1.29-.736a.245.245 0 0 0-.124-.033H8.75V13h2.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1 0-1.5h2.5V3.5h-.984a.245.245 0 0 0-.124.033l-1.289.737c-.265.15-.564.23-.869.23h-.162l2.112 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.016.015-.045.04c-.21.176-.441.327-.686.45C4.556 10.78 3.88 11 3 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L2.178 4.5H1.75a.75.75 0 0 1 0-1.5h2.234a.249.249 0 0 0 .125-.033l1.288-.737c.265-.15.564-.23.869-.23h.984V.75a.75.75 0 0 1 1.5 0Zm2.945 8.477c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327Zm-10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327Z"></path></svg></span><span data-component="text" data-content="MIT license">MIT license</span></a></li></ul></nav><button style="--button-color:fg.subtle" type="button" aria-label="Outline" aria-haspopup="true" aria-expanded="false" tabindex="0" class="types__StyledButton-sc-ws60qy-0 gXPTqA" data-loading="false" data-size="medium" aria-describedby=":Rr9ab:-loading-announcement" id=":Rr9ab:"><svg aria-hidden="true" focusable="false" class="octicon octicon-list-unordered" 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="M5.75 2.5h8.5a.75.75 0 0 1 0 1.5h-8.5a.75.75 0 0 1 0-1.5Zm0 5h8.5a.75.75 0 0 1 0 1.5h-8.5a.75.75 0 0 1 0-1.5Zm0 5h8.5a.75.75 0 0 1 0 1.5h-8.5a.75.75 0 0 1 0-1.5ZM2 14a1 1 0 1 1 0-2 1 1 0 0 1 0 2Zm1-6a1 1 0 1 1-2 0 1 1 0 0 1 2 0ZM2 4a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg></button></div><div class="Box-sc-g0xbh4-0 QkQOb js-snippet-clipboard-copy-unpositioned" data-hpc="true"><article class="markdown-body entry-content container-lg" itemprop="text"><p dir="auto"><a target="_blank" rel="noopener noreferrer" href="https://github.com/html2rss/html2rss/raw/master/support/logo.png"><img src="https://github.com/html2rss/html2rss/raw/master/support/logo.png" alt="html2rss logo" style="max-width: 100%;"></a></p>
<div class="markdown-heading" dir="auto"><h1 tabindex="-1" class="heading-element" dir="auto">html2rss-web</h1><a id="user-content-html2rss-web" class="anchor" aria-label="Permalink: html2rss-web" href="#html2rss-web"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This web application scrapes websites to build and deliver RSS 2.0 feeds.</p>
<p dir="auto"><strong>Features:</strong></p>
<ul dir="auto">
<li><a href="#how-to-build-your-rss-feeds">Create your custom feeds</a>!</li>
<li>Comes with plenty of <a href="https://github.com/html2rss/html2rss-configs">included configs</a> out of the box.</li>
<li>Handles request caching.</li>
<li>Sets caching-related HTTP headers.</li>
</ul>
<p dir="auto">The functionality of scraping websites and building the RSS feeds is provided by the Ruby gem <a href="https://github.com/html2rss/html2rss"><code>html2rss</code></a>.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Get started</h2><a id="user-content-get-started" class="anchor" aria-label="Permalink: Get started" href="#get-started"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This application should be used with Docker. It is designed to require as little maintenance as possible. See <a href="#versioning-and-releases">Versioning and Releases</a> and <a href="#docker-automatically-keep-the-html2rss-web-image-up-to-date">consider automatic updates</a>.</p>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">With Docker</h3><a id="user-content-with-docker" class="anchor" aria-label="Permalink: With Docker" href="#with-docker"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<div class="highlight highlight-source-shell notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="docker run -p 3000:3000 gilcreator/html2rss-web"><pre>docker run -p 3000:3000 gilcreator/html2rss-web</pre></div>
<p dir="auto">Then open <a href="http://127.0.0.1:3000/" rel="nofollow">http://127.0.0.1:3000/</a> in your browser and click the example feed link.</p>
<p dir="auto">This is the quickest way to get started. However, it's also the option with the least flexibility: it doesn't allow you to use custom feed configs and doesn't update automatically.</p>
<p dir="auto">If you want more flexibility and automatic updates sound good to you, read on to get started <em>with docker compose</em>…</p>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">With <code>docker compose</code></h3><a id="user-content-with-docker-compose" class="anchor" aria-label="Permalink: With docker compose" href="#with-docker-compose"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">Create a <code>docker-compose.yml</code> file and paste the following into it:</p>
<div class="highlight highlight-source-yaml notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="services:
  html2rss-web:
    image: gilcreator/html2rss-web
    ports:
      - &quot;3000:3000&quot;
    volumes:
      - type: bind
        source: ./feeds.yml
        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!
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - &quot;~/.docker/config.json:/config.json&quot;
    command: --cleanup --interval 7200"><pre><span class="pl-ent">services</span>:
  <span class="pl-ent">html2rss-web</span>:
    <span class="pl-ent">image</span>: <span class="pl-s">gilcreator/html2rss-web</span>
    <span class="pl-ent">ports</span>:
      - <span class="pl-s"><span class="pl-pds">"</span>3000:3000<span class="pl-pds">"</span></span>
    <span class="pl-ent">volumes</span>:
      - <span class="pl-ent">type</span>: <span class="pl-s">bind</span>
        <span class="pl-ent">source</span>: <span class="pl-s">./feeds.yml</span>
        <span class="pl-ent">target</span>: <span class="pl-s">/app/config/feeds.yml</span>
        <span class="pl-ent">read_only</span>: <span class="pl-c1">true</span>
    <span class="pl-ent">environment</span>:
      - <span class="pl-s">RACK_ENV=production</span>
      - <span class="pl-s">HEALTH_CHECK_USERNAME=health</span>
      - <span class="pl-s">HEALTH_CHECK_PASSWORD=please-set-YOUR-OWN-veeeeeery-l0ng-aNd-h4rd-to-gue55-Passw0rd!</span>
  <span class="pl-ent">watchtower</span>:
    <span class="pl-ent">image</span>: <span class="pl-s">containrrr/watchtower</span>
    <span class="pl-ent">volumes</span>:
      - <span class="pl-s">/var/run/docker.sock:/var/run/docker.sock</span>
      - <span class="pl-s"><span class="pl-pds">"</span>~/.docker/config.json:/config.json<span class="pl-pds">"</span></span>
    <span class="pl-ent">command</span>: <span class="pl-s">--cleanup --interval 7200</span></pre></div>
<p dir="auto">Start it up with: <code>docker compose up</code>.</p>
<p dir="auto">If you have not created your <code>feeds.yml</code> yet, download <a href="https://raw.githubusercontent.com/html2rss/html2rss-web/master/config/feeds.yml" rel="nofollow">this <code>feeds.yml</code> as a blueprint</a> into the directory containing the <code>docker-compose.yml</code>.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Docker: Automatically keep the html2rss-web image up-to-date</h2><a id="user-content-docker-automatically-keep-the-html2rss-web-image-up-to-date" class="anchor" aria-label="Permalink: Docker: Automatically keep the html2rss-web image up-to-date" href="#docker-automatically-keep-the-html2rss-web-image-up-to-date"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">The <a href="https://containrrr.dev/watchtower/" rel="nofollow">watchtower</a> service automatically pulls running Docker images and checks for updates. If an update is available, it will automatically start the updated image with the same configuration as the running one. Please read its manual.</p>
<p dir="auto">The <code>docker-compose.yml</code> above contains a service description for watchtower.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">How to use the included configs</h2><a id="user-content-how-to-use-the-included-configs" class="anchor" aria-label="Permalink: How to use the included configs" href="#how-to-use-the-included-configs"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">html2rss-web comes with many feed configs out of the box. <a href="https://github.com/html2rss/html2rss-configs/tree/master/lib/html2rss/configs">See the file list of all configs.</a></p>
<p dir="auto">To use a config from there, build the URL like this:</p>
<markdown-accessiblity-table><table>
<thead>
<tr>
<th></th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td><code>lib/html2rss/configs/</code></td>
<td><code>domainname.tld/whatever.yml</code></td>
</tr>
<tr>
<td>Would become this URL:</td>
<td></td>
</tr>
<tr>
<td><code>http://localhost:3000/</code></td>
<td><code>domainname.tld/whatever.rss</code></td>
</tr>
<tr>
<td></td>
<td><code>^^^^^^^^^^^^^^^^^^^^^^^^^^^</code></td>
</tr>
</tbody>
</table></markdown-accessiblity-table>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">How to build your RSS feeds</h2><a id="user-content-how-to-build-your-rss-feeds" class="anchor" aria-label="Permalink: How to build your RSS feeds" href="#how-to-build-your-rss-feeds"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">To build your own RSS feed, you need to create a <em>feed config</em>.<br>
That <em>feed config</em> goes into the file <code>feeds.yml</code>.<br>
Check out the <a href="https://github.com/html2rss/html2rss-web/blob/master/config/feeds.yml#L9"><code>example</code> feed config</a>.</p>
<p dir="auto">Please refer to <a href="https://github.com/html2rss/html2rss#the-feed-config-and-its-options">html2rss' README for a description of <em>the feed config and its options</em></a>. html2rss-web is just a small web application that depends on html2rss.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Versioning and releases</h2><a id="user-content-versioning-and-releases" class="anchor" aria-label="Permalink: Versioning and releases" href="#versioning-and-releases"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This web application is distributed in a <a href="https://en.wikipedia.org/wiki/Rolling_release" rel="nofollow">rolling release</a> fashion from the <code>master</code> branch.</p>
<p dir="auto">For the latest commit passing GitHub CI/CD on the master branch, an updated Docker image will be pushed to <a href="https://hub.docker.com/r/gilcreator/html2rss-web" rel="nofollow">Docker Hub: <code>gilcreator/html2rss-web</code></a>.</p>
<p dir="auto">GitHub's @dependabot is enabled for dependency updates and they are automatically merged to the <code>master</code> branch when the CI gives the green light.</p>
<p dir="auto">If you use Docker, you should update to the latest image automatically by <a href="#get-started">setting up <em>watchtower</em> as described</a>.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Use in production</h2><a id="user-content-use-in-production" class="anchor" aria-label="Permalink: Use in production" href="#use-in-production"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This app is published on Docker Hub and therefore easy to use with Docker.<br>
The above <code>docker-compose.yml</code> is a good starting point.</p>
<p dir="auto">If you're going to host a public instance, <em>please, please, please</em>:</p>
<ul dir="auto">
<li>Put the application behind a reverse proxy.</li>
<li>Allow outside connections only via HTTPS.</li>
<li>Have an auto-update strategy (e.g., watchtower).</li>
<li>Monitor your <code>/health_check.txt</code> endpoint.</li>
<li><a href="https://github.com/html2rss/html2rss-web/wiki/Instances">Let the world know and add your instance to the wiki</a> -- thank you!</li>
</ul>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Supported ENV variables</h3><a id="user-content-supported-env-variables" class="anchor" aria-label="Permalink: Supported ENV variables" href="#supported-env-variables"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<markdown-accessiblity-table><table>
<thead>
<tr>
<th>Name</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>PORT</code></td>
<td>default: 3000</td>
</tr>
<tr>
<td><code>RACK_ENV</code></td>
<td>default: 'development'</td>
</tr>
<tr>
<td><code>RACK_TIMEOUT_SERVICE_TIMEOUT</code></td>
<td>default: 15</td>
</tr>
<tr>
<td><code>WEB_CONCURRENCY</code></td>
<td>default: 2</td>
</tr>
<tr>
<td><code>WEB_MAX_THREADS</code></td>
<td>default: 5</td>
</tr>
<tr>
<td><code>HEALTH_CHECK_USERNAME</code></td>
<td>default: auto-generated on start</td>
</tr>
<tr>
<td><code>HEALTH_CHECK_PASSWORD</code></td>
<td>default: auto-generated on start</td>
</tr>
</tbody>
</table></markdown-accessiblity-table>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Runtime monitoring via <code>GET /health_check.txt</code></h3><a id="user-content-runtime-monitoring-via-get-health_checktxt" class="anchor" aria-label="Permalink: Runtime monitoring via GET /health_check.txt" href="#runtime-monitoring-via-get-health_checktxt"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">It is recommended to set up monitoring of the <code>/health_check.txt</code> endpoint. With that, you can find out when one of <em>your own</em> configs breaks. The endpoint uses HTTP Basic authentication.</p>
<p dir="auto">First, set the username and password via these environment variables: <code>HEALTH_CHECK_USERNAME</code> and <code>HEALTH_CHECK_PASSWORD</code>. If these are not set, html2rss-web will generate a new random username and password on <em>each</em> start.</p>
<p dir="auto">An authenticated <code>GET /health_check.txt</code> request will respond with:</p>
<ul dir="auto">
<li>If the feeds are generatable: <code>success</code>.</li>
<li>Otherwise: the names of the broken configs.</li>
</ul>
<p dir="auto">To get notified when one of your configs breaks, set up monitoring of this endpoint.</p>
<p dir="auto"><a href="https://uptimerobot.com/" rel="nofollow">UptimeRobot's free plan</a> is sufficient for basic monitoring (every 5 minutes).<br>
Create a monitor of type <em>Keyword</em> with this information and make it aware of your username and password:</p>
<p dir="auto"><a target="_blank" rel="noopener noreferrer" href="/html2rss/html2rss-web/blob/master/docs/uptimerobot_monitor.jpg"><img src="/html2rss/html2rss-web/raw/master/docs/uptimerobot_monitor.jpg" alt="A screenshot showing the Keyword Monitor: a name, the instance's URL to /health_check.txt, and an interval." style="max-width: 100%;"></a></p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Setup for development</h2><a id="user-content-setup-for-development" class="anchor" aria-label="Permalink: Setup for development" href="#setup-for-development"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">Check out the git repository and…</p>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Using Docker</h3><a id="user-content-using-docker" class="anchor" aria-label="Permalink: Using Docker" href="#using-docker"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">This approach allows you to experiment without installing Ruby on your machine.
All you need to do is install and run Docker.</p>
<div class="highlight highlight-source-shell notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="# Build image from Dockerfile and name/tag it as html2rss-web:
docker build -t html2rss-web -f Dockerfile .

# Run the image and name it html2rss-web-dev:
docker run \
  --detach \
  --mount type=bind,source=$(pwd)/config,target=/app/config \
  --name html2rss-web-dev \
  html2rss-web

# Open an interactive TTY with the shell `sh`:
docker exec -ti html2rss-web-dev sh

# Stop and clean up the container
docker stop html2rss-web-dev
docker rm html2rss-web-dev

# Remove the image
docker rmi html2rss-web"><pre><span class="pl-c"><span class="pl-c">#</span> Build image from Dockerfile and name/tag it as html2rss-web:</span>
docker build -t html2rss-web -f Dockerfile <span class="pl-c1">.</span>

<span class="pl-c"><span class="pl-c">#</span> Run the image and name it html2rss-web-dev:</span>
docker run \
  --detach \
  --mount type=bind,source=<span class="pl-s"><span class="pl-pds">$(</span>pwd<span class="pl-pds">)</span></span>/config,target=/app/config \
  --name html2rss-web-dev \
  html2rss-web

<span class="pl-c"><span class="pl-c">#</span> Open an interactive TTY with the shell `sh`:</span>
docker <span class="pl-c1">exec</span> -ti html2rss-web-dev sh

<span class="pl-c"><span class="pl-c">#</span> Stop and clean up the container</span>
docker stop html2rss-web-dev
docker rm html2rss-web-dev

<span class="pl-c"><span class="pl-c">#</span> Remove the image</span>
docker rmi html2rss-web</pre></div>
<div class="markdown-heading" dir="auto"><h3 tabindex="-1" class="heading-element" dir="auto">Using installed Ruby</h3><a id="user-content-using-installed-ruby" class="anchor" aria-label="Permalink: Using installed Ruby" href="#using-installed-ruby"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">If you're comfortable with installing Ruby directly on your machine, follow these instructions:</p>
<ol dir="auto">
<li>Install Ruby <code>&gt;= 3.2</code></li>
<li><code>gem install bundler foreman</code></li>
<li><code>bundle</code></li>
<li><code>foreman start</code></li>
</ol>
<p dir="auto"><em>html2rss-web</em> now listens on port <strong>3000</strong> for requests.</p>
<div class="markdown-heading" dir="auto"><h2 tabindex="-1" class="heading-element" dir="auto">Contribute</h2><a id="user-content-contribute" class="anchor" aria-label="Permalink: Contribute" href="#contribute"><svg class="octicon octicon-link" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg></a></div>
<p dir="auto">Contributions are welcome!</p>
<p dir="auto">Open a pull request with your changes,<br>
open an issue, or<br>
<a href="https://github.com/orgs/html2rss/discussions">join discussions on html2rss</a>.</p>
</article></div></div></div></div></div> <!-- --> <!-- --> <script type="application/json" id="__PRIMER_DATA_:R0:__">{"resolvedServerColorMode":"day"}</script></div>
</react-partial>

      <input type="hidden" data-csrf="true" value="6UpVnsGgn9xD8L5Q+1maBy0YELNW+IlSmugV8o87pbP/GwEYTDbBkmPvcifj7Chb9Yl23axvChmRwOluGYUsQQ==" />
</div>
  <div data-view-component="true" class="Layout-sidebar">      

      <div class="BorderGrid about-margin" data-pjax>
        <div class="BorderGrid-row">
          <div class="BorderGrid-cell">
            <div class="hide-sm hide-md">
  <h2 class="mb-3 h4">About</h2>

      <p class="f4 my-3">
        🕸 Create custom RSS feeds from any website with ease! Quick setup with Docker. Use built-in configs or tailor your own. Stay updated effortlessly.
      </p>
      <div class="my-3 d-flex flex-items-center">
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-link flex-shrink-0 mr-2">
    <path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path>
</svg>
        <span class="flex-auto min-width-0 css-truncate css-truncate-target width-fit">
          <a title="https://html2rss.github.io/components/html2rss-web" role="link" target="_blank" rel="noopener noreferrer nofollow" class="text-bold" href="https://html2rss.github.io/components/html2rss-web">html2rss.github.io/components/html2rss-web</a>
        </span>
      </div>

    <h3 class="sr-only">Topics</h3>
    <div class="my-3">
        <div class="f6">
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:ruby" href="/topics/ruby" title="Topic: ruby" data-view-component="true" class="topic-tag topic-tag-link">
  ruby
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:docker" href="/topics/docker" title="Topic: docker" data-view-component="true" class="topic-tag topic-tag-link">
  docker
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss" href="/topics/rss" title="Topic: rss" data-view-component="true" class="topic-tag topic-tag-link">
  rss
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:scraper" href="/topics/scraper" title="Topic: scraper" data-view-component="true" class="topic-tag topic-tag-link">
  scraper
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:builder" href="/topics/builder" title="Topic: builder" data-view-component="true" class="topic-tag topic-tag-link">
  builder
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:feed" href="/topics/feed" title="Topic: feed" data-view-component="true" class="topic-tag topic-tag-link">
  feed
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:roda" href="/topics/roda" title="Topic: roda" data-view-component="true" class="topic-tag topic-tag-link">
  roda
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss-feed" href="/topics/rss-feed" title="Topic: rss-feed" data-view-component="true" class="topic-tag topic-tag-link">
  rss-feed
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss-aggregator" href="/topics/rss-aggregator" title="Topic: rss-aggregator" data-view-component="true" class="topic-tag topic-tag-link">
  rss-aggregator
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:serves" href="/topics/serves" title="Topic: serves" data-view-component="true" class="topic-tag topic-tag-link">
  serves
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rss-feed-scraper" href="/topics/rss-feed-scraper" title="Topic: rss-feed-scraper" data-view-component="true" class="topic-tag topic-tag-link">
  rss-feed-scraper
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:website-scraper" href="/topics/website-scraper" title="Topic: website-scraper" data-view-component="true" class="topic-tag topic-tag-link">
  website-scraper
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:webfeeds" href="/topics/webfeeds" title="Topic: webfeeds" data-view-component="true" class="topic-tag topic-tag-link">
  webfeeds
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:webfeed" href="/topics/webfeed" title="Topic: webfeed" data-view-component="true" class="topic-tag topic-tag-link">
  webfeed
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:html2rss" href="/topics/html2rss" title="Topic: html2rss" data-view-component="true" class="topic-tag topic-tag-link">
  html2rss
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:rolling-release" href="/topics/rolling-release" title="Topic: rolling-release" data-view-component="true" class="topic-tag topic-tag-link">
  rolling-release
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:html2rss-configs" href="/topics/html2rss-configs" title="Topic: html2rss-configs" data-view-component="true" class="topic-tag topic-tag-link">
  html2rss-configs
</a>
      <a data-ga-click="Topic, repository page" data-octo-click="topic_click" data-octo-dimensions="topic:feed-configs" href="/topics/feed-configs" title="Topic: feed-configs" data-view-component="true" class="topic-tag topic-tag-link">
  feed-configs
</a>
  </div>

    </div>

    <h3 class="sr-only">Resources</h3>
    <div class="mt-2">
      <a class="Link--muted" data-analytics-event="{&quot;category&quot;:&quot;Repository Overview&quot;,&quot;action&quot;:&quot;click&quot;,&quot;label&quot;:&quot;location:sidebar;file:readme&quot;}" href="#readme-ov-file">
        <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-book mr-2">
    <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>
        Readme
</a>    </div>

  
    <h3 class="sr-only">License</h3>
  <div class="mt-2">
    <a href="#MIT-1-ov-file"
      class="Link--muted"
      
      data-analytics-event="{&quot;category&quot;:&quot;Repository Overview&quot;,&quot;action&quot;:&quot;click&quot;,&quot;label&quot;:&quot;location:sidebar;file:license&quot;}"
    >
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-law mr-2">
    <path d="M8.75.75V2h.985c.304 0 .603.08.867.231l1.29.736c.038.022.08.033.124.033h2.234a.75.75 0 0 1 0 1.5h-.427l2.111 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.006.005-.01.01-.045.04c-.21.176-.441.327-.686.45C14.556 10.78 13.88 11 13 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L12.178 4.5h-.162c-.305 0-.604-.079-.868-.231l-1.29-.736a.245.245 0 0 0-.124-.033H8.75V13h2.5a.75.75 0 0 1 0 1.5h-6.5a.75.75 0 0 1 0-1.5h2.5V3.5h-.984a.245.245 0 0 0-.124.033l-1.289.737c-.265.15-.564.23-.869.23h-.162l2.112 4.692a.75.75 0 0 1-.154.838l-.53-.53.529.531-.001.002-.002.002-.006.006-.016.015-.045.04c-.21.176-.441.327-.686.45C4.556 10.78 3.88 11 3 11a4.498 4.498 0 0 1-2.023-.454 3.544 3.544 0 0 1-.686-.45l-.045-.04-.016-.015-.006-.006-.004-.004v-.001a.75.75 0 0 1-.154-.838L2.178 4.5H1.75a.75.75 0 0 1 0-1.5h2.234a.249.249 0 0 0 .125-.033l1.288-.737c.265-.15.564-.23.869-.23h.984V.75a.75.75 0 0 1 1.5 0Zm2.945 8.477c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327Zm-10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327Z"></path>
</svg>
     MIT license
    </a>
  </div>




  <include-fragment  src="/html2rss/html2rss-web/hovercards/citation/sidebar_partial?tree_name=master">
  </include-fragment>

  <div class="mt-2">
    <a href="/html2rss/html2rss-web/activity" data-view-component="true" class="Link Link--muted">
      <svg text="gray" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-pulse mr-2">
    <path d="M6 2c.306 0 .582.187.696.471L10 10.731l1.304-3.26A.751.751 0 0 1 12 7h3.25a.75.75 0 0 1 0 1.5h-2.742l-1.812 4.528a.751.751 0 0 1-1.392 0L6 4.77 4.696 8.03A.75.75 0 0 1 4 8.5H.75a.75.75 0 0 1 0-1.5h2.742l1.812-4.529A.751.751 0 0 1 6 2Z"></path>
</svg>
      <span class="color-fg-muted">Activity</span>
</a>  </div>

    <div class="mt-2">
      <a href="/html2rss/html2rss-web/custom-properties" data-view-component="true" class="Link Link--muted">
        <svg text="gray" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-note mr-2">
    <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.25Zm1.75-.25a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-8.5a.25.25 0 0 0-.25-.25ZM3.5 6.25a.75.75 0 0 1 .75-.75h7a.75.75 0 0 1 0 1.5h-7a.75.75 0 0 1-.75-.75Zm.75 2.25h4a.75.75 0 0 1 0 1.5h-4a.75.75 0 0 1 0-1.5Z"></path>
</svg>
        <span class="color-fg-muted">Custom properties</span>
</a>    </div>

  <h3 class="sr-only">Stars</h3>
  <div class="mt-2">
    <a href="/html2rss/html2rss-web/stargazers" data-view-component="true" class="Link Link--muted">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-star 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>
      <strong>86</strong>
      stars
</a>  </div>

  <h3 class="sr-only">Watchers</h3>
  <div class="mt-2">
    <a href="/html2rss/html2rss-web/watchers" data-view-component="true" class="Link Link--muted">
      <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-eye mr-2">
    <path d="M8 2c1.981 0 3.671.992 4.933 2.078 1.27 1.091 2.187 2.345 2.637 3.023a1.62 1.62 0 0 1 0 1.798c-.45.678-1.367 1.932-2.637 3.023C11.67 13.008 9.981 14 8 14c-1.981 0-3.671-.992-4.933-2.078C1.797 10.83.88 9.576.43 8.898a1.62 1.62 0 0 1 0-1.798c.45-.677 1.367-1.931 2.637-3.022C4.33 2.992 6.019 2 8 2ZM1.679 7.932a.12.12 0 0 0 0 .136c.411.622 1.241 1.75 2.366 2.717C5.176 11.758 6.527 12.5 8 12.5c1.473 0 2.825-.742 3.955-1.715 1.124-.967 1.954-2.096 2.366-2.717a.12.12 0 0 0 0-.136c-.412-.621-1.242-1.75-2.366-2.717C10.824 4.242 9.473 3.5 8 3.5c-1.473 0-2.825.742-3.955 1.715-1.124.967-1.954 2.096-2.366 2.717ZM8 10a2 2 0 1 1-.001-3.999A2 2 0 0 1 8 10Z"></path>
</svg>
      <strong>4</strong>
      watching
</a>  </div>

  <h3 class="sr-only">Forks</h3>
  <div class="mt-2">
    <a href="/html2rss/html2rss-web/forks" data-view-component="true" class="Link Link--muted">
      <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>
      <strong>11</strong>
      forks
</a>  </div>

    <div class="mt-2">
      <a class="Link--muted" href="/contact/report-content?content_url=https%3A%2F%2Fgithub.com%2Fhtml2rss%2Fhtml2rss-web&amp;report=html2rss+%28user%29">
          Report repository
</a>    </div>
</div>

          </div>
        </div>

        
        
            <div class="BorderGrid-row">
              <div class="BorderGrid-cell">
                
<h2 class="h4 mb-3">Sponsor this project</h2>
<include-fragment src="/html2rss/html2rss-web/sponsors_list?block_button=true&amp;current_repository=html2rss-web" aria-busy="true" aria-label="Loading sponsorable links">
        <div class="d-flex mb-3">
          <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          <div class="Skeleton Skeleton--text flex-1 flex-self-center f4">&nbsp;</div>
        </div>
          <button type="button" disabled="disabled" data-view-component="true" class="btn btn-block">    <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-heart icon-sponsor mr-1 color-fg-sponsors">
    <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> Sponsor
</button></include-fragment>  <div class="text-small mt-3">
    <a href="/sponsors">Learn more about GitHub Sponsors</a>
  </div>

              </div>
            </div>

        
        
            <div class="BorderGrid-row" hidden>
              <div class="BorderGrid-cell">
                <include-fragment src="/html2rss/html2rss-web/used_by_list" accept="text/fragment+html">
</include-fragment>
              </div>
            </div>

        
            <div class="BorderGrid-row">
              <div class="BorderGrid-cell">
                <h2 class="h4 mb-3">
  <a href="/html2rss/html2rss-web/graphs/contributors" data-view-component="true" class="Link--primary no-underline Link d-flex flex-items-center">
    Contributors
      <span title="12" data-view-component="true" class="Counter ml-1">12</span>
</a></h2>


    <include-fragment src="/html2rss/html2rss-web/contributors_list?count=12&amp;current_repository=html2rss-web&amp;items_to_show=12" aria-busy="true" aria-label="Loading contributors">
      <ul class="list-style-none d-flex flex-wrap mb-n2">
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
          <li class="mb-2 ">
            <div class="Skeleton avatar avatar-user mr-2" style="width:32px;height:32px;"></div>
          </li>
      </ul>
</include-fragment>


              </div>
            </div>

        
        
            <div class="BorderGrid-row">
              <div class="BorderGrid-cell">
                <h2 class="h4 mb-3">Languages</h2>
<div class="mb-2">
  <span data-view-component="true" class="Progress">
    <span style="background-color:#701516 !important;;width: 81.2%;" itemprop="keywords" aria-label="Ruby 81.2" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#EB8CEB !important;;width: 6.4%;" itemprop="keywords" aria-label="XSLT 6.4" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#384d54 !important;;width: 4.3%;" itemprop="keywords" aria-label="Dockerfile 4.3" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#e34c26 !important;;width: 4.1%;" itemprop="keywords" aria-label="HTML 4.1" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#563d7c !important;;width: 2.7%;" itemprop="keywords" aria-label="CSS 2.7" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#89e051 !important;;width: 0.6%;" itemprop="keywords" aria-label="Shell 0.6" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
    <span style="background-color:#ededed !important;;width: 0.7%;" itemprop="keywords" aria-label="Other 0.7" data-view-component="true" class="Progress-item color-bg-success-emphasis"></span>
</span></div>
<ul class="list-style-none">
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=ruby"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#701516;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">Ruby</span>
          <span>81.2%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=xslt"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#EB8CEB;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">XSLT</span>
          <span>6.4%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=dockerfile"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#384d54;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">Dockerfile</span>
          <span>4.3%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=html"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#e34c26;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">HTML</span>
          <span>4.1%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=css"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#563d7c;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">CSS</span>
          <span>2.7%</span>
        </a>
    </li>
    <li class="d-inline">
        <a class="d-inline-flex flex-items-center flex-nowrap Link--secondary no-underline text-small mr-3" href="/html2rss/html2rss-web/search?l=shell"  data-ga-click="Repository, language stats search click, location:repo overview">
          <svg style="color:#89e051;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
          <span class="color-fg-default text-bold mr-1">Shell</span>
          <span>0.6%</span>
        </a>
    </li>
    <li class="d-inline">
      <span class="d-inline-flex flex-items-center flex-nowrap text-small mr-3">
        <svg style="color:#ededed;" aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-dot-fill mr-2">
    <path d="M8 4a4 4 0 1 1 0 8 4 4 0 0 1 0-8Z"></path>
</svg>
        <span class="color-fg-default text-bold mr-1">Other</span>
        <span>0.7%</span>
      </span>
    </li>
</ul>

              </div>
            </div>

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

  </div>


  </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 09:25:10 GMT
+        





<!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/routes/auto_source_spec.rb b/spec/routes/auto_source_spec.rb
index bc9abcc5..4b4a01bc 100644
--- a/spec/routes/auto_source_spec.rb
+++ b/spec/routes/auto_source_spec.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-
+require 'rss'
 require_relative '../../app'
 
 describe Html2rss::Web::App do # rubocop:disable RSpec/SpecFilePathFormat
@@ -15,11 +15,20 @@ def app = described_class
   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'])
+                                                         allowed_origins: Set['localhost'],
+                                                         build_auto_source_from_encoded_url: feed)
   end
 
   describe "GET '/auto_source/'" do
@@ -57,17 +66,15 @@ def app = described_class
   describe "GET '/auto_source/:encoded_url'" do
     context 'with provided basic auth' do
       subject(:response) do
-        VCR.use_cassette('auto_source-github-h2r-web') do
-          get "/auto_source/#{Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web')}",
-              {},
-              request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password))
-        end
+        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=0'
+        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

From 397db7947579cadae51c22219d9336c083119703 Mon Sep 17 00:00:00 2001
From: Gil Desmarais <git@desmarais.de>
Date: Mon, 21 Oct 2024 08:56:53 +0200
Subject: [PATCH 25/25] feat(auto_source): tweaks/adjustments on ui

---
 public/auto_source.css |  5 +++--
 public/auto_source.js  | 15 +++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/public/auto_source.css b/public/auto_source.css
index 60a79f55..00e6ae2a 100644
--- a/public/auto_source.css
+++ b/public/auto_source.css
@@ -7,7 +7,6 @@
 .auto_source input,
 .auto_source button {
   width: 100%;
-  font-family: monospace;
 }
 
 .auto_source > form {
@@ -51,13 +50,15 @@
 
 .auto_source iframe {
   margin-top: 2em;
-  border: 2px groove var(--highlight);
+  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
index 6b85d055..d4c1c06d 100644
--- a/public/auto_source.js
+++ b/public/auto_source.js
@@ -189,7 +189,6 @@ const autoSource = (function () {
       try {
         const textToCopy = this.rssUrlField.value;
         await navigator.clipboard.writeText(textToCopy);
-        console.log("Text copied to clipboard:", textToCopy);
       } catch (error) {
         console.error("Failed to copy text to clipboard:", error);
       }
@@ -211,8 +210,8 @@ const autoSource = (function () {
      */
     async subscribeToFeed() {
       const feedUrl = this.rssUrlField.value;
-      const storedUser = LocalStorageFacade.getOrAskUser("username");
-      const storedPassword = LocalStorageFacade.getOrAskUser("password");
+      const storedUser = LocalStorageFacade.getOrAsk("username");
+      const storedPassword = LocalStorageFacade.getOrAsk("password");
 
       const url = new URL(feedUrl);
       url.username = storedUser;
@@ -255,16 +254,16 @@ const autoSource = (function () {
       return localStorage.removeItem(key);
     }
 
-    static getOrAskUser(columnName) {
-      let value = LocalStorageFacade.get(columnName);
+    static getOrAsk(key) {
+      let value = LocalStorageFacade.get(key);
 
       while (typeof value !== "string" || value === "") {
-        value = window.prompt(`Please enter your ${columnName}:`);
+        value = window.prompt(`Please enter your ${key}:`);
 
         if (!value || value.trim() === "") {
-          alert(`Blank ${columnName} submitted. Try again!`);
+          alert(`Blank ${key} submitted. Try again!`);
         } else {
-          LocalStorageFacade.set(columnName, value);
+          LocalStorageFacade.set(key, value);
         }
       }