From feae0ef285959b879890d0e0ca1dee0b417b4ee6 Mon Sep 17 00:00:00 2001 From: Gil Desmarais Date: Mon, 23 Dec 2024 13:08:45 +0100 Subject: [PATCH 1/4] feat: integrate request_service and use ssrf_filter strategy by default Signed-off-by: Gil Desmarais --- app.rb | 9 ++++++ app/ssrf_filter_strategy.rb | 23 +++++++++++++ helpers/auto_source.rb | 15 --------- routes/auto_source.rb | 25 ++++++++++++--- .../auto_source-github-h2r-web.yml | 31 +++++++++--------- .../web/app/ssrf_filter_strategy_spec.rb | 29 +++++++++++++++++ spec/html2rss/web/helpers/auto_source_spec.rb | 27 ---------------- spec/routes/auto_source_spec.rb | 32 +++++++++++++++---- 8 files changed, 123 insertions(+), 68 deletions(-) create mode 100644 app/ssrf_filter_strategy.rb create mode 100644 spec/html2rss/web/app/ssrf_filter_strategy_spec.rb diff --git a/app.rb b/app.rb index a75142cd..a1c30b3a 100644 --- a/app.rb +++ b/app.rb @@ -4,6 +4,9 @@ require 'rack/cache' require_relative 'roda/roda_plugins/basic_auth' +require 'html2rss' +require_relative 'app/ssrf_filter_strategy' + module Html2rss module Web ## @@ -13,6 +16,10 @@ module Web class App < Roda CONTENT_TYPE_RSS = 'application/xml' + Html2rss::RequestService.register_strategy(:ssrf_filter, SsrfFilterStrategy) + Html2rss::RequestService.default_strategy_name = :ssrf_filter + Html2rss::RequestService.unregister_strategy(:faraday) + def self.development? = ENV['RACK_ENV'] == 'development' opts[:check_dynamic_arity] = false @@ -64,6 +71,8 @@ def self.development? = ENV['RACK_ENV'] == 'development' end end + @show_backtrace = !ENV['CI'].to_s.empty? || development? + route do |r| r.public r.hash_branches('') diff --git a/app/ssrf_filter_strategy.rb b/app/ssrf_filter_strategy.rb new file mode 100644 index 00000000..48b7541e --- /dev/null +++ b/app/ssrf_filter_strategy.rb @@ -0,0 +1,23 @@ +# frozen_string_literal: true + +require 'ssrf_filter' +require 'html2rss' +require_relative '../app/local_config' + +module Html2rss + module Web + ## + # Strategy to fetch a URL using the SSRF filter. + class SsrfFilterStrategy < Html2rss::RequestService::Strategy + def execute + headers = LocalConfig.global.fetch(:headers, {}).merge( + ctx.headers.transform_keys(&:to_sym) + ) + response = SsrfFilter.get(ctx.url, headers:) + + Html2rss::RequestService::Response.new(body: response.body, + headers: response.to_hash.transform_values(&:first)) + end + end + end +end diff --git a/helpers/auto_source.rb b/helpers/auto_source.rb index 17af5c13..19fb7981 100644 --- a/helpers/auto_source.rb +++ b/helpers/auto_source.rb @@ -3,7 +3,6 @@ require 'addressable' require 'base64' require 'html2rss' -require 'ssrf_filter' module Html2rss module Web @@ -20,20 +19,6 @@ def self.allowed_origins = ENV.fetch('AUTO_SOURCE_ALLOWED_ORIGINS', '') .reject(&:empty?) .to_set - # @param encoded_url [String] Base64 encoded URL - # @return [RSS::Rss] - def self.build_auto_source_from_encoded_url(encoded_url) - url = Addressable::URI.parse Base64.urlsafe_decode64(encoded_url) - request = SsrfFilter.get(url, headers: LocalConfig.global.fetch(:headers, {})) - headers = request.to_hash.transform_values(&:first) - - auto_source = Html2rss::AutoSource.new(url, body: request.body, headers:) - - auto_source.channel.stylesheets << Html2rss::RssBuilder::Stylesheet.new(href: '/rss.xsl', type: 'text/xsl') - - auto_source.build - end - # @param rss [RSS::Rss] # @param default_in_minutes [Integer] # @return [Integer] diff --git a/routes/auto_source.rb b/routes/auto_source.rb index 12969c98..345ac5f4 100644 --- a/routes/auto_source.rb +++ b/routes/auto_source.rb @@ -2,10 +2,12 @@ require_relative '../app/http_cache' require_relative '../helpers/auto_source' +require 'html2rss' module Html2rss module Web class App + # rubocop:disable Metrics/BlockLength hash_branch 'auto_source' do |r| with_basic_auth(realm: 'Auto Source', username: AutoSource.username, @@ -18,15 +20,29 @@ class App end r.on String, method: :get do |encoded_url| - rss = AutoSource.build_auto_source_from_encoded_url(encoded_url) + strategy = (request.params['strategy'] || :ssrf_filter).to_sym + unless Html2rss::RequestService.strategy_registered?(strategy) + raise Html2rss::RequestService::UnknownStrategy + end + + response['Content-Type'] = CONTENT_TYPE_RSS + + url = Addressable::URI.parse Base64.urlsafe_decode64(encoded_url) + rss = Html2rss.auto_source(url, strategy:) + + # Unfortunately, Ruby's rss gem does not provide a direct method to + # add an XML stylesheet to the RSS::RSS object itself. + stylesheet = Html2rss::RssBuilder::Stylesheet.new(href: '/rss.xsl', type: 'text/xsl').to_xml + + xml_content = rss.to_xml + xml_content.sub!(/^<\?xml version="1.0" encoding="UTF-8"\?>/, + "\n#{stylesheet}") HttpCache.expires response, AutoSource.ttl_in_seconds(rss), cache_control: 'private, must-revalidate' - response['Content-Type'] = CONTENT_TYPE_RSS - - rss.to_s + xml_content end else # auto_source feature is disabled @@ -37,6 +53,7 @@ class App end end end + # rubocop:enable Metrics/BlockLength 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 index cccb4119..c351d0dc 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.3/html2rss/html2rss-web/commits/master + uri: https://github.com/html2rss/html2rss-web/commits/master body: encoding: US-ASCII string: '' @@ -12,7 +12,8 @@ http_interactions: Accept: - "*/*" User-Agent: - - Ruby + - Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 + Safari/537.36 Host: - github.com response: @@ -23,14 +24,14 @@ http_interactions: Server: - GitHub.com Date: - - Sun, 20 Oct 2024 16:33:57 GMT + - Mon, 23 Dec 2024 15:50:56 GMT Content-Type: - text/html; charset=utf-8 Vary: - X-PJAX, X-PJAX-Container, Turbo-Visit, Turbo-Frame, Accept-Encoding, Accept, X-Requested-With Etag: - - W/"05a7012808772ba0e0bd352531fa0e7a" + - W/"c240683d43c94e0cdf337b0a31d65c60" Cache-Control: - max-age=0, private, must-revalidate Strict-Transport-Security: @@ -81,22 +82,22 @@ http_interactions: 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/' + Accept-Ranges: + - bytes Set-Cookie: - - _gh_sess=LeE%2BK48vEzjPkQtKqpuOwp8JGpYpIwL9xNwNlN4fRWJvuXeHMss3vP0r1vsBX1vXh6W8UVjvP29JNF%2BL2zUwczz%2FbiV1fdlLCmckJgfQUUQwTM5W%2FCrM2OOm91L%2FMY%2Fins0F8u6JTomT7zRvJlYns%2F9ghggsSqig6cyepiQHdY%2Bz%2BZgbvInoZm%2F9Y3JuJnnRNY1Xe5Wwyk4uZXx9ETqrQckia%2Bm1LiElw%2BgWnKE2yX0LAbfbM9R%2F2eDKAod2JxHVMY5Mk%2F%2F4PbtD%2BKpwZfW%2BJQ%3D%3D--wxBMY2hRrjUNiWWV--DRAFBTBsKbj5OkdSOlWdpg%3D%3D; + - _gh_sess=m%2BQeG5FP7r7zkZQIhzuXpTOWqYSq4czuCsQWy%2FN%2BCNWz4qIkvP5MMJr3gV4OqVTky5XrA%2BEiwgPSrkSzpTvTim%2FO0%2BmRMnE0rnudnIXHv7YEaZ1pyoCJsZJJqqTPtW6DLRggiYPoXAs0eYJ9Qtduv%2BxFlTNQFNjpbHDXf8YVBZiU1k9Q%2FjnSvdO3rvcqP1WVVyhPXkqOfBWbnB%2BS3PlsQr1DgF0AKj6Pjg0YAXOlyrbrWujCSXmzrfXteA%2BdsP03lWk3pnGL8DdzHYYI9%2BjXZA%3D%3D--lANaMK%2Fl3SIZM6Q%2B--PT%2BnDBB1Iyo%2BkYIblc%2F8aQ%3D%3D; Path=/; HttpOnly; Secure; SameSite=Lax - - _octo=GH1.1.1506430827.1729442036; Path=/; Domain=github.com; Expires=Mon, - 20 Oct 2025 16:33:56 GMT; Secure; SameSite=Lax - - logged_in=no; Path=/; Domain=github.com; Expires=Mon, 20 Oct 2025 16:33:56 + - _octo=GH1.1.54463972.1734969056; Path=/; Domain=github.com; Expires=Tue, 23 + Dec 2025 15:50:56 GMT; Secure; SameSite=Lax + - logged_in=no; Path=/; Domain=github.com; Expires=Tue, 23 Dec 2025 15:50:56 GMT; HttpOnly; Secure; SameSite=Lax - Accept-Ranges: - - bytes + X-Github-Request-Id: + - EEF8:1AEB75:D0FCAEC:D71AE10:676986E0 Transfer-Encoding: - chunked - X-Github-Request-Id: - - D9BC:2C9A0F:144395:14B03F:671530F4 body: encoding: ASCII-8BIT string: !binary |- - 





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



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

  


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

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

  


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

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


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



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

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


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


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


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

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

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

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

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

  




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

  

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

    

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

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

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

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




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



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


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

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

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


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

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



    

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


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

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

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

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


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

  </head>

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


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

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

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




      

          

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

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

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

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

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


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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

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

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

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

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

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

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

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

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

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

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

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

    
</a></li>

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

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

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


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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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


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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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

    
</a></li>

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


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

            </ul>
          </nav>

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


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

          </div>
      </button>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  
</div>
    </div>

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








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




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

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


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





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

    






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


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

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

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


        </div>

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

      

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

  </li>

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

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

</ul>

        </div>
      </div>

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


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

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


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


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


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


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


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

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


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


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


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

  </div>

  



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



    
      
    








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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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




  </div>

</turbo-frame>

    </main>
  </div>

  </div>

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

  


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

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

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

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

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

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

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

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

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

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

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

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




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


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

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

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

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




    </div>

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

 - recorded_at: Sun, 20 Oct 2024 16:33:57 GMT -recorded_with: VCR 6.2.0 + 





<!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-0cfd1fd8509e.css" /><link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/dark-d782f59290e2.css" /><link data-color-theme="dark_dimmed" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_dimmed-f9fbc4b99a77.css" /><link data-color-theme="dark_high_contrast" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_high_contrast-cff1c9b27b1a.css" /><link data-color-theme="dark_colorblind" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_colorblind-70097f75aec1.css" /><link data-color-theme="light_colorblind" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/light_colorblind-c2f0d49bdcd9.css" /><link data-color-theme="light_high_contrast" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/light_high_contrast-4747d7bc0bc4.css" /><link data-color-theme="light_tritanopia" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/light_tritanopia-d3f6a61c91c8.css" /><link data-color-theme="dark_tritanopia" crossorigin="anonymous" media="all" rel="stylesheet" data-href="https://github.githubassets.com/assets/dark_tritanopia-a188d53f44bb.css" />

    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-primitives-953961b66e63.css" />
    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-4430d3c2c150.css" />
    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/global-47b8b2ca21ae.css" />
    <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/github-e72829f5538b.css" />
  <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/repository-d031bcc14e1b.css" />
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/code-9e1913b328be.css" />

  


  <script type="application/json" id="client-env">{"locale":"en","featureFlags":["alive_longer_retries","bypass_copilot_indexing_quota","copilot_new_references_ui","copilot_beta_features_opt_in","copilot_chat_retry_on_error","copilot_chat_persist_submitted_input","copilot_conversational_ux_history_refs","copilot_editor_upsells","copilot_free_limited_user","copilot_implicit_context","copilot_no_floating_button","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","issues_react_new_timeline","issues_react_avatar_refactor","issues_react_remove_placeholders","issues_react_blur_item_picker_on_close","issues_react_use_react_router_in_index","marketing_pages_search_explore_provider","react_keyboard_shortcuts_dialog","remove_child_patch","sample_network_conn_type","site_metered_billing_update","site_copilot_free","lifecycle_label_name_updates"]}</script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/wp-runtime-0378f971b53c.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-9da652f58479.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-3abb8f-d7e6bc799724.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_failbot_failbot_ts-c551691a8183.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/environment-7b93e0f0c8ff.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-ea2a5d75d580.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-f6da4b3fa34c.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-node_modules_github_catalyst_-8e9f78-a74b4e0a8a6b.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-78748950cb0c.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-b5f1d7-a1760ffda83d.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_github_markdown-toolbar-element_dist_index_js-ceef33f593fa.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-c44a69-c6d035fa8dc8.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/github-elements-f991cfab5105.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/element-registry-d283cbab281e.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-7f43298e364b.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_lit-html_lit-html_js-be8cb88f481b.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-a4a1922eb55f.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-e3cbe28f1638.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_color-convert_index_js-e3180fe3bcb3.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_-69cfcc-833249ee3034.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_updatable-content_updatable-content_ts-863ef5872a03.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-917d4bda1f1a.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-b41aeef03499.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-fb43816ab83c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/behaviors-a6abce982f3f.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-f6223d90c7ba.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/notifications-global-cfcd9f4f0f23.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-3eebbd-0763620ad7bf.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-9d41fb1b6c9e.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--3c9c82-7238cfcdaa51.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/app_assets_modules_github_ref-selector_ts-842c74d2eab4.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/repositories-f3093651fb0e.js"></script>
  
  <script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/primer-react-753dc87b1e29.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-core-accb67f1350f.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-lib-2131e17288a8.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_tanstack_query-core_build_modern_queryClient_js-e6f07a7e80b7.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-37e3d5-92730c05e718.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-e7dcdd-f7cc96ebae76.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-55fea94174bf.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_dompurify_dist_purify_js-b89b98661809.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_react-relay_index_js-c5b7ce0827d5.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_lodash-es__Stack_js-node_modules_lodash-es__Uint8Array_js-node_modules_l-4faaa6-10d8eea337ce.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_date-fns_format_mjs-6e4d0f904632.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_github_hotkey_dist_index_js-node_modules_primer_live-region-element_dist-ee65d7-b5a52b9eaa01.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-a009f6007b3c.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_date-fns_getDaysInMonth_mjs-node_modules_date-fns_isAfter_mjs-node_modul-49f526-6d4bedc5c754.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_lodash-es__baseIsEqual_js-8929eb9718d5.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_combobox-nav_dist_index_js-node-6d672f-6315950b19a4.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_hydro-analytics-fa0c26-b5ce76989c0a.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-a7926fdcecf7.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_paths_index_ts-4e4d706da555.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_ui-commands_ui-commands_ts-df3b47d86af0.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-a51927b092e0.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-b55eae95552d.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-6273f6ba9f14.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_item-picker_components_RepositoryPicker_tsx-b520a2bf2450.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_use-safe-async-callback_use-safe-async-callback_ts-ui_packages_copy-to-clipboard_-4c1096-9bd5b6266162.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_issue-create_dialog_CreateIssueDialogEntry_tsx-502d10cafe95.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_ref-selector_RefSelector_tsx-9445f4afb2bc.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_commenting_constants_values_ts-ui_packages_use-analytics_use-analytics_ts-ui_pack-af4212-eb918766c747.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_code-view-shared_utilities_web-worker_ts-ui_packages_code-view-shared_worker-jobs-cdcae1-f0dc8f3ae3e0.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/commits-252a5fb0bbd7.js"></script>
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-react.797c8ec006b327590422.module.css" />
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/commits.1f3a5854808e827fcb0d.module.css" />

  <script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/primer-react-753dc87b1e29.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-core-accb67f1350f.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/react-lib-2131e17288a8.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_tanstack_query-core_build_modern_queryClient_js-e6f07a7e80b7.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-37e3d5-92730c05e718.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-e7dcdd-f7cc96ebae76.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-55fea94174bf.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/notifications-subscriptions-menu-51601778bd8d.js"></script>
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-react.797c8ec006b327590422.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="EEF8:1AEB75:D0FCAEC:D71AE10:676986E0" data-pjax-transient="true"/><meta name="html-safe-nonce" content="1667270459cd81d26776acc9bcea6bab2c32ea548d2fcd2ff259b4504babbf20" data-pjax-transient="true"/><meta name="visitor-payload" content="eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJFRUY4OjFBRUI3NTpEMEZDQUVDOkQ3MUFFMTA6Njc2OTg2RTAiLCJ2aXNpdG9yX2lkIjoiMjMzOTIwOTgwMjg1MjI4NzY4IiwicmVnaW9uX2VkZ2UiOiJmcmEiLCJyZWdpb25fcmVuZGVyIjoiZnJhIn0=" data-pjax-transient="true"/><meta name="visitor-hmac" content="36ec92dfdd22d6a59b513469f5cf637e2b0d1f45133f758002d2bf414b85331f" 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="🕸 Generates RSS feeds of any website &amp; serves to the web! Automatic scraping. Ready to use configs. Write your own. Rolling Docker releases for speedy updates. - 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="🕸 Generates RSS feeds of any website &amp; serves to the web! Automatic scraping. Ready to use configs. Write your own. Rolling Docker releases for speedy updates. - 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="🕸 Generates RSS feeds of any website &amp; serves to the web! Automatic scraping. Ready to use configs. Write your own. Rolling Docker releases for speedy updates. - 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="🕸 Generates RSS feeds of any website &amp; serves to the web! Automatic scraping. Ready to use configs. Write your own. Rolling Docker releases for speedy updates. - Commits · html2rss/html2rss-web" />
  




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



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


  <meta http-equiv="x-pjax-version" content="5fff12adca0aaccac6e7cb955f5d2a759fadf460258f88f597531bdb75eb5aeb" 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="137747501b000c3c7ab6b8b92f1ded64f18d692f67bb1c163ffcea3636000502" data-turbo-track="reload">
  <meta http-equiv="x-pjax-js-version" content="7c097e7364773a7cbb9eb0b782ca541e1a2ac4fb1ef35cf49ecbc9e198f89bb3" 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" data-base-href="https://github.githubassets.com/favicons/favicon">

<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 header-wrapper 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/keyboard-shortcuts-dialog-958cae8ecd6c.js"></script>
<link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-react.797c8ec006b327590422.module.css" />

<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-73b675cf164a.js"></script>
<script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/sessions-5d6426bbf16a.js"></script>
<header class="HeaderMktg header-logged-out js-details-container js-header Details f4 py-3" role="banner" data-is-top="true" 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>

                    <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;executive_insights&quot;,&quot;context&quot;:&quot;resources&quot;,&quot;tag&quot;:&quot;link&quot;,&quot;label&quot;:&quot;executive_insights_link_resources_navbar&quot;}" href="https://github.com/solutions/executive-insights">
      Executive Insights

    
</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="d-_ADV43QL4LR0iH1dKyUBGSIrtrPj8r4DayCEZqDsodJqvrOJfDHLJQvu-OpKkhhMTngPgdCSzBUQ_aRViAFw" 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-b7832e3a-121e-4cf5-ade7-f8173a68e1b0" 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-b7832e3a-121e-4cf5-ade7-f8173a68e1b0" 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 Overlay--disableScroll">
    <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="fUOtj1sIzlPt1wQTr2NNhLyqAvZfqu1uyUD1GG8c75z6qzMoj670gmo1jyrR5Tu4/fZGglqFlF9fpTRLG56p1w==" />
          <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 Overlay--disableScroll">
    <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="OzIcd+oVNhehN774R+Xr23V6kQI13VzbJiZxu+PAFdzmnXkU9aE8AyONz4ZxkVxNxyFEqH+vRqYG1TqisIt5dw==" />
          <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="ydakFMAIxB25HfOMn+9K/G0TWtGgvIISXJ9DkAhph/M6eDyi2U18BSi5SXhoMjqdBGlOdMl1OBolQdthgF1iXQ==" />
            </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-f9fe9161-56be-4a33-9c57-6f28a02e6bd7" aria-labelledby="tooltip-577581c7-5316-43ec-85cd-5b786e67319a" 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-577581c7-5316-43ec-85cd-5b786e67319a" for="icon-button-f9fe9161-56be-4a33-9c57-6f28a02e6bd7" 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>


    






  <div
    class="application-main "
    data-commit-hovercards-enabled
    data-discussion-hovercards-enabled
    data-issue-and-pr-hovercards-enabled
    data-project-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-9c8b58fa-ecd6-4b90-82a5-1f667d360c6e" 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="94 users starred this repository" data-singular-suffix="user starred this repository" data-plural-suffix="users starred this repository" data-turbo-replace="true" title="94" data-view-component="true" class="Counter js-social-count">94</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="3" data-view-component="true" class="Counter">3</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-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-button" popovertarget="action-menu-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-overlay" aria-controls="action-menu-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-list" aria-haspopup="true" aria-labelledby="tooltip-84edad5f-f172-494b-b6f9-0301ee2c08a5" 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-84edad5f-f172-494b-b6f9-0301ee2c08a5" for="action-menu-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-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 data-target="action-menu.overlay" id="action-menu-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-overlay" anchor="action-menu-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-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-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-button" id="action-menu-6f5e5c9c-dc3c-46b8-b438-5c4338c097e4-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-101e6d20-b1f9-4746-9a52-5b7d91450148" 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-e653051c-e775-4558-a5d6-2c2d52c3631f" 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-c1fe1114-f89d-4852-8038-6a3f48dc3873" 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-353f4025-13c4-4245-8787-1eddb5538cfa" 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-0083f326-f90c-4e1f-9638-0f7a14dbe86d" 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-1c7be605-5548-4d56-9681-5d3e78ca2b67" 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-872bf583-c501-44e7-8c89-3853569f85f8" 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":"Dec 20, 2024","commits":[{"oid":"5030b56631e7f293417b0bb47afe5551e8d494af","url":"/html2rss/html2rss-web/commit/5030b56631e7f293417b0bb47afe5551e8d494af","authoredDate":"2024-12-20T22:28:02.000Z","committedDate":"2024-12-20T22:28:02.000Z","shortMessage":"chore(deps): bump tilt from 2.4.0 to 2.5.0 in the rubygems group (#706)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump tilt from 2.4.0 to 2.5.0 in the rubygems group (#706)\n\nBumps the rubygems group with 1 update: [tilt](https://github.com/jeremyevans/tilt).\n\n\nUpdates `tilt` from 2.4.0 to 2.5.0\n- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)\n- [Commits](https://github.com/jeremyevans/tilt/compare/v2.4.0...v2.5.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/5030b56631e7f293417b0bb47afe5551e8d494af\"\u003echore(deps): bump tilt from 2.4.0 to 2.5.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2753575199\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/706\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/706/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/706\"\u003e#706\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump tilt from 2.4.0 to 2.5.0 in the rubygems group (#706)\n\nBumps the rubygems group with 1 update: [tilt](https://github.com/jeremyevans/tilt).\n\n\nUpdates `tilt` from 2.4.0 to 2.5.0\n- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)\n- [Commits](https://github.com/jeremyevans/tilt/compare/v2.4.0...v2.5.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/5030b56631e7f293417b0bb47afe5551e8d494af\"\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.4.0 to 2.5.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.4.0...v2.5.0\"\u003ejeremyevans/tilt@\u003ctt\u003ev2.4.0...v2.5.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":"Dec 19, 2024","commits":[{"oid":"e6282bfd205e908bfda6c8ffb77b03bcd00952db","url":"/html2rss/html2rss-web/commit/e6282bfd205e908bfda6c8ffb77b03bcd00952db","authoredDate":"2024-12-19T22:41:11.000Z","committedDate":"2024-12-19T22:41:11.000Z","shortMessage":"chore(deps): bump erubi from 1.13.0 to 1.13.1 in the rubygems group (#705)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump erubi from 1.13.0 to 1.13.1 in the rubygems group (#705)\n\nBumps the rubygems group with 1 update: [erubi](https://github.com/jeremyevans/erubi).\n\n\nUpdates `erubi` from 1.13.0 to 1.13.1\n- [Changelog](https://github.com/jeremyevans/erubi/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/erubi/compare/1.13.0...1.13.1)\n\n---\nupdated-dependencies:\n- dependency-name: erubi\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/e6282bfd205e908bfda6c8ffb77b03bcd00952db\"\u003echore(deps): bump erubi from 1.13.0 to 1.13.1 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2751554814\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/705\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/705/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/705\"\u003e#705\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump erubi from 1.13.0 to 1.13.1 in the rubygems group (#705)\n\nBumps the rubygems group with 1 update: [erubi](https://github.com/jeremyevans/erubi).\n\n\nUpdates `erubi` from 1.13.0 to 1.13.1\n- [Changelog](https://github.com/jeremyevans/erubi/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/erubi/compare/1.13.0...1.13.1)\n\n---\nupdated-dependencies:\n- dependency-name: erubi\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/e6282bfd205e908bfda6c8ffb77b03bcd00952db\"\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.13.0 to 1.13.1\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.13.0...1.13.1\"\u003ejeremyevans/erubi@\u003ctt\u003e1.13.0...1.13.1\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-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":"Dec 17, 2024","commits":[{"oid":"0c3540f087c223102a3ae4c24249ca993dba341d","url":"/html2rss/html2rss-web/commit/0c3540f087c223102a3ae4c24249ca993dba341d","authoredDate":"2024-12-17T22:49:17.000Z","committedDate":"2024-12-17T22:49:17.000Z","shortMessage":"chore(deps): bump roda from 3.86.0 to 3.87.0 in the rubygems group (#704)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.86.0 to 3.87.0 in the rubygems group (#704)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.86.0 to 3.87.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.86.0...3.87.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/0c3540f087c223102a3ae4c24249ca993dba341d\"\u003echore(deps): bump roda from 3.86.0 to 3.87.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2746267762\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/704\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/704/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/704\"\u003e#704\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.86.0 to 3.87.0 in the rubygems group (#704)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.86.0 to 3.87.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.86.0...3.87.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/0c3540f087c223102a3ae4c24249ca993dba341d\"\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.86.0 to 3.87.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.86.0...3.87.0\"\u003ejeremyevans/roda@\u003ctt\u003e3.86.0...3.87.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":"Nov 25, 2024","commits":[{"oid":"769dd7964c3411d7f368883ba50451b8362db658","url":"/html2rss/html2rss-web/commit/769dd7964c3411d7f368883ba50451b8362db658","authoredDate":"2024-11-25T19:41:36.000Z","committedDate":"2024-11-25T19:41:36.000Z","shortMessage":"chore(deps): bump the rubygems group with 2 updates (#703)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#703)\n\nBumps the rubygems group with 2 updates: [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [puma](https://github.com/puma/puma).\n\n\nUpdates `html2rss-configs` from `905ca2a` to `9aa87f0`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/905ca2a7da7d5cbf63d5265f8b70c64563957252...9aa87f0d713f5caebaab148c3922698655556a33)\n\nUpdates `puma` from 6.4.3 to 6.5.0\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.3...v6.5.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: puma\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/769dd7964c3411d7f368883ba50451b8362db658\"\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=\"2692016591\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/703\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/703/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/703\"\u003e#703\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump the rubygems group with 2 updates (#703)\n\nBumps the rubygems group with 2 updates: [html2rss-configs](https://github.com/html2rss/html2rss-configs) and [puma](https://github.com/puma/puma).\n\n\nUpdates `html2rss-configs` from `905ca2a` to `9aa87f0`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/905ca2a7da7d5cbf63d5265f8b70c64563957252...9aa87f0d713f5caebaab148c3922698655556a33)\n\nUpdates `puma` from 6.4.3 to 6.5.0\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.3...v6.5.0)\n\n---\nupdated-dependencies:\n- dependency-name: html2rss-configs\n  dependency-type: direct:production\n  dependency-group: rubygems\n- dependency-name: puma\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/769dd7964c3411d7f368883ba50451b8362db658\"\u003e)\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 [puma](\u003ca href=\"https://github.com/puma/puma\"\u003ehttps://github.com/puma/puma\u003c/a\u003e).\n\n\nUpdates `html2rss-configs` from `905ca2a` to `9aa87f0`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/905ca2a7da7d5cbf63d5265f8b70c64563957252...9aa87f0d713f5caebaab148c3922698655556a33\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e905ca2a...9aa87f0\u003c/tt\u003e\u003c/a\u003e)\n\nUpdates `puma` from 6.4.3 to 6.5.0\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.3...v6.5.0\"\u003epuma/puma@\u003ctt\u003ev6.4.3...v6.5.0\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: puma\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":"Nov 22, 2024","commits":[{"oid":"7808bf7445f3b2eca6fb17cdd4d748d742cdb580","url":"/html2rss/html2rss-web/commit/7808bf7445f3b2eca6fb17cdd4d748d742cdb580","authoredDate":"2024-11-22T22:50:58.000Z","committedDate":"2024-11-22T22:50:58.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#702)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#702)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `f63f74f` to `905ca2a`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/f63f74f8805177d0237a04f64235785906fa54ba...905ca2a7da7d5cbf63d5265f8b70c64563957252)\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/7808bf7445f3b2eca6fb17cdd4d748d742cdb580\"\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=\"2684847025\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/702\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/702/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/702\"\u003e#702\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#702)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `f63f74f` to `905ca2a`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/f63f74f8805177d0237a04f64235785906fa54ba...905ca2a7da7d5cbf63d5265f8b70c64563957252)\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/7808bf7445f3b2eca6fb17cdd4d748d742cdb580\"\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 `f63f74f` to `905ca2a`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/f63f74f8805177d0237a04f64235785906fa54ba...905ca2a7da7d5cbf63d5265f8b70c64563957252\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003ef63f74f...905ca2a\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":"e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8","url":"/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8","authoredDate":"2024-11-22T16:57:22.000+01:00","committedDate":"2024-11-22T16:57:22.000+01:00","shortMessage":"ci(mergify): upgrade configuration to current format (#701)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"ci(mergify): upgrade configuration to current format (#701)\n\nCo-authored-by: Mergify \u0026lt;37929162+mergify[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8\"\u003eci(mergify): upgrade configuration to current format (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2682648852\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/701\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/701/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/701\"\u003e#701\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"ci(mergify): upgrade configuration to current format (#701)\n\nCo-authored-by: Mergify \u0026lt;37929162+mergify[bot]@users.noreply.github.com\u0026gt;\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Co-authored-by: Mergify \u0026lt;37929162+mergify[bot]@users.noreply.github.com\u0026gt;","authors":[{"login":"mergify[bot]","displayName":"mergify[bot]","avatarUrl":"https://avatars.githubusercontent.com/in/10562?v=4","path":"/apps/mergify","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":"Nov 12, 2024","commits":[{"oid":"462c942c89136223eadb97b32e2d17f095456fe0","url":"/html2rss/html2rss-web/commit/462c942c89136223eadb97b32e2d17f095456fe0","authoredDate":"2024-11-12T22:54:08.000Z","committedDate":"2024-11-12T22:54:08.000Z","shortMessage":"chore(deps): bump roda from 3.85.0 to 3.86.0 in the rubygems group (#699)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.85.0 to 3.86.0 in the rubygems group (#699)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.85.0 to 3.86.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.85.0...3.86.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/462c942c89136223eadb97b32e2d17f095456fe0\"\u003echore(deps): bump roda from 3.85.0 to 3.86.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2653546861\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/699\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/699/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/699\"\u003e#699\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump roda from 3.85.0 to 3.86.0 in the rubygems group (#699)\n\nBumps the rubygems group with 1 update: [roda](https://github.com/jeremyevans/roda).\n\n\nUpdates `roda` from 3.85.0 to 3.86.0\n- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)\n- [Commits](https://github.com/jeremyevans/roda/compare/3.85.0...3.86.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/462c942c89136223eadb97b32e2d17f095456fe0\"\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.85.0 to 3.86.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.85.0...3.86.0\"\u003ejeremyevans/roda@\u003ctt\u003e3.85.0...3.86.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":"Nov 8, 2024","commits":[{"oid":"69db1a8bf7a8823d08b8cb35a51bda263c0beac6","url":"/html2rss/html2rss-web/commit/69db1a8bf7a8823d08b8cb35a51bda263c0beac6","authoredDate":"2024-11-08T22:15:21.000Z","committedDate":"2024-11-08T22:15:21.000Z","shortMessage":"chore(deps): bump ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (#698)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (#698)\n\nBumps the rubygems group with 1 update: [ssrf_filter](https://github.com/arkadiyt/ssrf_filter).\n\n\nUpdates `ssrf_filter` from 1.1.2 to 1.2.0\n- [Release notes](https://github.com/arkadiyt/ssrf_filter/releases)\n- [Changelog](https://github.com/arkadiyt/ssrf_filter/blob/main/CHANGELOG.md)\n- [Commits](https://github.com/arkadiyt/ssrf_filter/compare/1.1.2...1.2.0)\n\n---\nupdated-dependencies:\n- dependency-name: ssrf_filter\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/69db1a8bf7a8823d08b8cb35a51bda263c0beac6\"\u003echore(deps): bump ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2645264898\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/698\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/698/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/698\"\u003e#698\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (#698)\n\nBumps the rubygems group with 1 update: [ssrf_filter](https://github.com/arkadiyt/ssrf_filter).\n\n\nUpdates `ssrf_filter` from 1.1.2 to 1.2.0\n- [Release notes](https://github.com/arkadiyt/ssrf_filter/releases)\n- [Changelog](https://github.com/arkadiyt/ssrf_filter/blob/main/CHANGELOG.md)\n- [Commits](https://github.com/arkadiyt/ssrf_filter/compare/1.1.2...1.2.0)\n\n---\nupdated-dependencies:\n- dependency-name: ssrf_filter\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/69db1a8bf7a8823d08b8cb35a51bda263c0beac6\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps the rubygems group with 1 update: [ssrf_filter](\u003ca href=\"https://github.com/arkadiyt/ssrf_filter\"\u003ehttps://github.com/arkadiyt/ssrf_filter\u003c/a\u003e).\n\n\nUpdates `ssrf_filter` from 1.1.2 to 1.2.0\n- [Release notes](\u003ca href=\"https://github.com/arkadiyt/ssrf_filter/releases\"\u003ehttps://github.com/arkadiyt/ssrf_filter/releases\u003c/a\u003e)\n- [Changelog](\u003ca href=\"https://github.com/arkadiyt/ssrf_filter/blob/main/CHANGELOG.md\"\u003ehttps://github.com/arkadiyt/ssrf_filter/blob/main/CHANGELOG.md\u003c/a\u003e)\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/arkadiyt/ssrf_filter/compare/1.1.2...1.2.0\"\u003earkadiyt/ssrf_filter@\u003ctt\u003e1.1.2...1.2.0\u003c/tt\u003e\u003c/a\u003e)\n\n---\nupdated-dependencies:\n- dependency-name: ssrf_filter\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":"Nov 6, 2024","commits":[{"oid":"34bed7bcab753a523360f6da9200749255121509","url":"/html2rss/html2rss-web/commit/34bed7bcab753a523360f6da9200749255121509","authoredDate":"2024-11-06T09:36:05.000Z","committedDate":"2024-11-06T09:36:05.000Z","shortMessage":"chore(deps): bump ruby from 3.3.5-alpine3.20 to 3.3.6-alpine3.20 (#697)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump ruby from 3.3.5-alpine3.20 to 3.3.6-alpine3.20 (#697)\n\nBumps ruby from 3.3.5-alpine3.20 to 3.3.6-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/34bed7bcab753a523360f6da9200749255121509\"\u003echore(deps): bump ruby from 3.3.5-alpine3.20 to 3.3.6-alpine3.20 (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2637516983\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/697\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/697/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/697\"\u003e#697\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump ruby from 3.3.5-alpine3.20 to 3.3.6-alpine3.20 (#697)\n\nBumps ruby from 3.3.5-alpine3.20 to 3.3.6-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/34bed7bcab753a523360f6da9200749255121509\"\u003e)\u003c/a\u003e","bodyMessageHtml":"Bumps ruby from 3.3.5-alpine3.20 to 3.3.6-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":"Nov 2, 2024","commits":[{"oid":"94477d50b178cf519d1e56f82f31e27cacc223c4","url":"/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4","authoredDate":"2024-11-02T16:21:38.000+01:00","committedDate":"2024-11-02T16:21:38.000+01:00","shortMessage":"feat: optionally allow APM using Sentry via env variable (#696)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"feat: optionally allow APM using Sentry via env variable (#696)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4\"\u003efeat: optionally allow APM using Sentry via env variable (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2630513713\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/696\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/696/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/696\"\u003e#696\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"feat: optionally allow APM using Sentry via env variable (#696)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4\"\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":"Oct 31, 2024","commits":[{"oid":"59aea1416f3d0157d5e7a1027f927548fe38f6c0","url":"/html2rss/html2rss-web/commit/59aea1416f3d0157d5e7a1027f927548fe38f6c0","authoredDate":"2024-10-31T22:29:15.000Z","committedDate":"2024-10-31T22:29:15.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#695)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#695)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `d226b29` to `f63f74f`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/d226b299376893fb5863322b95bdfa6e16d78dd5...f63f74f8805177d0237a04f64235785906fa54ba)\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/59aea1416f3d0157d5e7a1027f927548fe38f6c0\"\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=\"2627934488\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/695\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/695/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/695\"\u003e#695\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#695)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `d226b29` to `f63f74f`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/d226b299376893fb5863322b95bdfa6e16d78dd5...f63f74f8805177d0237a04f64235785906fa54ba)\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/59aea1416f3d0157d5e7a1027f927548fe38f6c0\"\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 `d226b29` to `f63f74f`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/d226b299376893fb5863322b95bdfa6e16d78dd5...f63f74f8805177d0237a04f64235785906fa54ba\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003ed226b29...f63f74f\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 30, 2024","commits":[{"oid":"1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8","url":"/html2rss/html2rss-web/commit/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8","authoredDate":"2024-10-30T17:45:02.000Z","committedDate":"2024-10-30T17:45:02.000Z","shortMessage":"chore(deps): bump html2rss from 0.14.0 to 0.15.0 in the rubygems group (#694)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.14.0 to 0.15.0 in the rubygems group (#694)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.14.0 to 0.15.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.14.0...v0.15.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/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8\"\u003echore(deps): bump html2rss from 0.14.0 to 0.15.0 in the rubygems group (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2624857597\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/694\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/694/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/694\"\u003e#694\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss from 0.14.0 to 0.15.0 in the rubygems group (#694)\n\nBumps the rubygems group with 1 update: [html2rss](https://github.com/gildesmarais/html2rss).\n\n\nUpdates `html2rss` from 0.14.0 to 0.15.0\n- [Release notes](https://github.com/gildesmarais/html2rss/releases)\n- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.14.0...v0.15.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/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8\"\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.14.0 to 0.15.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.14.0...v0.15.0\"\u003ehtml2rss/html2rss@\u003ctt\u003ev0.14.0...v0.15.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":"Oct 28, 2024","commits":[{"oid":"591746729f722272cbb803cc4a73d43038c598f8","url":"/html2rss/html2rss-web/commit/591746729f722272cbb803cc4a73d43038c598f8","authoredDate":"2024-10-28T22:59:10.000Z","committedDate":"2024-10-28T22:59:10.000Z","shortMessage":"chore(deps): bump html2rss-configs in the rubygems group (#693)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#693)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `9673d2b` to `d226b29`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/9673d2b091e5d10bb6fa3c161b1ba97070921fd4...d226b299376893fb5863322b95bdfa6e16d78dd5)\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/591746729f722272cbb803cc4a73d43038c598f8\"\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=\"2619735864\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/693\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/693/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/693\"\u003e#693\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump html2rss-configs in the rubygems group (#693)\n\nBumps the rubygems group with 1 update: [html2rss-configs](https://github.com/html2rss/html2rss-configs).\n\n\nUpdates `html2rss-configs` from `9673d2b` to `d226b29`\n- [Commits](https://github.com/html2rss/html2rss-configs/compare/9673d2b091e5d10bb6fa3c161b1ba97070921fd4...d226b299376893fb5863322b95bdfa6e16d78dd5)\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/591746729f722272cbb803cc4a73d43038c598f8\"\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 `9673d2b` to `d226b29`\n- [Commits](\u003ca class=\"commit-link\" href=\"https://github.com/html2rss/html2rss-configs/compare/9673d2b091e5d10bb6fa3c161b1ba97070921fd4...d226b299376893fb5863322b95bdfa6e16d78dd5\"\u003ehtml2rss/html2rss-configs@\u003ctt\u003e9673d2b...d226b29\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":"8123508b9f07ed42ae61e807ba7903526595f817","url":"/html2rss/html2rss-web/commit/8123508b9f07ed42ae61e807ba7903526595f817","authoredDate":"2024-10-28T19:04:31.000Z","committedDate":"2024-10-28T19:04:31.000Z","shortMessage":"chore(deps): bump rexml from 3.3.8 to 3.3.9 (#692)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"chore(deps): bump rexml from 3.3.8 to 3.3.9 (#692)\n\nBumps [rexml](https://github.com/ruby/rexml) from 3.3.8 to 3.3.9.\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.8...v3.3.9)\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/8123508b9f07ed42ae61e807ba7903526595f817\"\u003echore(deps): bump rexml from 3.3.8 to 3.3.9 (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2619292681\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/692\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/692/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/692\"\u003e#692\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"chore(deps): bump rexml from 3.3.8 to 3.3.9 (#692)\n\nBumps [rexml](https://github.com/ruby/rexml) from 3.3.8 to 3.3.9.\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.8...v3.3.9)\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/8123508b9f07ed42ae61e807ba7903526595f817\"\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.8 to 3.3.9.\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.8...v3.3.9\"\u003eruby/rexml@\u003ctt\u003ev3.3.8...v3.3.9\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":"Oct 25, 2024","commits":[{"oid":"3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f","url":"/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f","authoredDate":"2024-10-25T16:57:09.000+02:00","committedDate":"2024-10-25T16:57:09.000+02:00","shortMessage":"fix(auto_source): respect headers from global config (#691)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"fix(auto_source): respect headers from global config (#691)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f\"\u003efix(auto_source): respect headers from global config (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2614338089\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/691\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/691/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/691\"\u003e#691\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"fix(auto_source): respect headers from global config (#691)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f\"\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":"Oct 22, 2024","commits":[{"oid":"d4e4d913062ee91236c610c7889368202f4ae687","url":"/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687","authoredDate":"2024-10-22T18:24:49.000+02:00","committedDate":"2024-10-22T18:24:49.000+02:00","shortMessage":"dev: update readme and test-suite configuration (#690)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"dev: update readme and test-suite configuration (#690)\n\nThis pull request includes updates to the `README.md` file and\r\nimprovements to the test suite, particularly focusing on the use of\r\n`ClimateControl` for environment variable management and some general\r\ncleanup.\r\n\r\nUpdates to documentation:\r\n\r\n*\r\n[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52):\r\nClarified and corrected the usage of environment variables, ensuring\r\nthey are correctly quoted and formatted.\r\n[[1]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52)\r\n[[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L86-R87)\r\n[[3]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L96-R97)\r\n[[4]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L155-R157)\r\n*\r\n[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R9):\r\nAdded a new feature description for providing stable URLs for feeds\r\ngenerated by automatic sourcing.\r\n\r\nImprovements to test suite:\r\n\r\n*\r\n[`spec/html2rss/web/app_spec.rb`](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4):\r\nIntroduced `ClimateControl` to manage environment variables during\r\ntests, replacing direct `ENV` manipulation.\r\n[[1]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4)\r\n[[2]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R43-R54)\r\n*\r\n[`spec/html2rss/web/helpers/auto_source_spec.rb`](diffhunk://#diff-1c878bb09df33c5882ccb5908063682ecd481c30c7a5d0bf97a8be65cb698548L4-R11):\r\nAdded `ClimateControl` and corrected the RSpec description format.\r\n*\r\n[`spec/routes/auto_source_spec.rb`](diffhunk://#diff-c88fcacaf08dea9f6768c205b268876e4b05dc517724faacbc6215eafe37f543L7-R7):\r\nUpdated to use `RSpec.describe` for consistency.\r\n\r\nGeneral cleanup:\r\n\r\n*\r\n[`spec/spec_helper.rb`](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15):\r\nRemoved the `EnvHelper` module and associated `ClimateControl` support\r\nfile, as they are no longer needed.\r\n[[1]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15)\r\n[[2]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L121-L122)\r\n[[3]](diffhunk://#diff-77b0d409fb1eaea240996a5f235354d577c0624382f9e7c19fdd075636bfd2a9L1-L9)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687\"\u003edev: update readme and test-suite configuration (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2605923029\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/690\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/690/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/690\"\u003e#690\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"dev: update readme and test-suite configuration (#690)\n\nThis pull request includes updates to the `README.md` file and\r\nimprovements to the test suite, particularly focusing on the use of\r\n`ClimateControl` for environment variable management and some general\r\ncleanup.\r\n\r\nUpdates to documentation:\r\n\r\n*\r\n[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52):\r\nClarified and corrected the usage of environment variables, ensuring\r\nthey are correctly quoted and formatted.\r\n[[1]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52)\r\n[[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L86-R87)\r\n[[3]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L96-R97)\r\n[[4]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L155-R157)\r\n*\r\n[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R9):\r\nAdded a new feature description for providing stable URLs for feeds\r\ngenerated by automatic sourcing.\r\n\r\nImprovements to test suite:\r\n\r\n*\r\n[`spec/html2rss/web/app_spec.rb`](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4):\r\nIntroduced `ClimateControl` to manage environment variables during\r\ntests, replacing direct `ENV` manipulation.\r\n[[1]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4)\r\n[[2]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R43-R54)\r\n*\r\n[`spec/html2rss/web/helpers/auto_source_spec.rb`](diffhunk://#diff-1c878bb09df33c5882ccb5908063682ecd481c30c7a5d0bf97a8be65cb698548L4-R11):\r\nAdded `ClimateControl` and corrected the RSpec description format.\r\n*\r\n[`spec/routes/auto_source_spec.rb`](diffhunk://#diff-c88fcacaf08dea9f6768c205b268876e4b05dc517724faacbc6215eafe37f543L7-R7):\r\nUpdated to use `RSpec.describe` for consistency.\r\n\r\nGeneral cleanup:\r\n\r\n*\r\n[`spec/spec_helper.rb`](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15):\r\nRemoved the `EnvHelper` module and associated `ClimateControl` support\r\nfile, as they are no longer needed.\r\n[[1]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15)\r\n[[2]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L121-L122)\r\n[[3]](diffhunk://#diff-77b0d409fb1eaea240996a5f235354d577c0624382f9e7c19fdd075636bfd2a9L1-L9)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687\"\u003e)\u003c/a\u003e","bodyMessageHtml":"This pull request includes updates to the `README.md` file and\nimprovements to the test suite, particularly focusing on the use of\n`ClimateControl` for environment variable management and some general\ncleanup.\n\nUpdates to documentation:\n\n*\n[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52):\nClarified and corrected the usage of environment variables, ensuring\nthey are correctly quoted and formatted.\n[[1]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52)\n[[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L86-R87)\n[[3]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L96-R97)\n[[4]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L155-R157)\n*\n[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R9):\nAdded a new feature description for providing stable URLs for feeds\ngenerated by automatic sourcing.\n\nImprovements to test suite:\n\n*\n[`spec/html2rss/web/app_spec.rb`](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4):\nIntroduced `ClimateControl` to manage environment variables during\ntests, replacing direct `ENV` manipulation.\n[[1]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4)\n[[2]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R43-R54)\n*\n[`spec/html2rss/web/helpers/auto_source_spec.rb`](diffhunk://#diff-1c878bb09df33c5882ccb5908063682ecd481c30c7a5d0bf97a8be65cb698548L4-R11):\nAdded `ClimateControl` and corrected the RSpec description format.\n*\n[`spec/routes/auto_source_spec.rb`](diffhunk://#diff-c88fcacaf08dea9f6768c205b268876e4b05dc517724faacbc6215eafe37f543L7-R7):\nUpdated to use `RSpec.describe` for consistency.\n\nGeneral cleanup:\n\n*\n[`spec/spec_helper.rb`](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15):\nRemoved the `EnvHelper` module and associated `ClimateControl` support\nfile, as they are no longer needed.\n[[1]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15)\n[[2]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L121-L122)\n[[3]](diffhunk://#diff-77b0d409fb1eaea240996a5f235354d577c0624382f9e7c19fdd075636bfd2a9L1-L9)","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":"d0d9e6651e13b1b7557ec13627e142ee6aa84d3f","url":"/html2rss/html2rss-web/commit/d0d9e6651e13b1b7557ec13627e142ee6aa84d3f","authoredDate":"2024-10-22T18:22:06.000+02:00","committedDate":"2024-10-22T18:22:06.000+02:00","shortMessage":"docs(readme): promote auto_source feature \u0026 fix yaml parsing in examples","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"docs(readme): promote auto_source feature \u0026amp; fix yaml parsing in examples\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/d0d9e6651e13b1b7557ec13627e142ee6aa84d3f\"\u003edocs(readme): promote auto_source feature \u0026amp; fix yaml parsing in examples\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":"e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74","url":"/html2rss/html2rss-web/commit/e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74","authoredDate":"2024-10-22T18:19:33.000+02:00","committedDate":"2024-10-22T18:19:33.000+02:00","shortMessage":"dev(test): disable rspec's monkey patching","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"dev(test): disable rspec\u0026#39;s monkey patching\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74\"\u003edev(test): disable rspec's monkey patching\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":"08db4d8bc1581670b4ac031dc2b72972740d8b7c","url":"/html2rss/html2rss-web/commit/08db4d8bc1581670b4ac031dc2b72972740d8b7c","authoredDate":"2024-10-22T18:18:50.000+02:00","committedDate":"2024-10-22T18:18:50.000+02:00","shortMessage":"dev(test): keep track of failed examples","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"dev(test): keep track of failed examples\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/08db4d8bc1581670b4ac031dc2b72972740d8b7c\"\u003edev(test): keep track of failed examples\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":"1efab5ddb930d847c3896c37b043ef7ce43ac009","url":"/html2rss/html2rss-web/commit/1efab5ddb930d847c3896c37b043ef7ce43ac009","authoredDate":"2024-10-22T18:18:18.000+02:00","committedDate":"2024-10-22T18:18:18.000+02:00","shortMessage":"dev(test): use climate control without helper indirection","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"dev(test): use climate control without helper indirection\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/1efab5ddb930d847c3896c37b043ef7ce43ac009\"\u003edev(test): use climate control without helper indirection\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}}]},{"title":"Oct 21, 2024","commits":[{"oid":"531dced02ecd53f9594670b56699ea5d2ab6842e","url":"/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e","authoredDate":"2024-10-21T09:26:20.000+02:00","committedDate":"2024-10-21T09:26:20.000+02:00","shortMessage":"feat(auto_source): add support for `auto_source` feature (#676)","shortMessageMarkdown":null,"shortMessageMarkdownLink":"\u003ca data-pjax=\"true\" title=\"feat(auto_source): add support for `auto_source` feature (#676)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e\"\u003efeat(auto_source): add support for\u003c/a\u003e \u003ccode\u003e\u003ca data-pjax=\"true\" title=\"feat(auto_source): add support for `auto_source` feature (#676)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e\"\u003eauto_source\u003c/a\u003e\u003c/code\u003e \u003ca data-pjax=\"true\" title=\"feat(auto_source): add support for `auto_source` feature (#676)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e\"\u003efeature (\u003c/a\u003e\u003ca class=\"issue-link js-issue-link\" data-error-text=\"Failed to load title\" data-id=\"2471560586\" data-permission-text=\"Title is private\" data-url=\"https://github.com/html2rss/html2rss-web/issues/676\" data-hovercard-type=\"pull_request\" data-hovercard-url=\"/html2rss/html2rss-web/pull/676/hovercard\" href=\"https://github.com/html2rss/html2rss-web/pull/676\"\u003e#676\u003c/a\u003e\u003ca data-pjax=\"true\" title=\"feat(auto_source): add support for `auto_source` feature (#676)\" class=\"color-fg-default\" href=\"/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e\"\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":"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}}]}],"currentCommit":{"oid":"5030b56631e7f293417b0bb47afe5551e8d494af"},"filters":{"since":null,"until":null,"author":null,"newPath":null,"originalBranch":null,"currentBlobPath":null,"pagination":{"startCursor":"5030b56631e7f293417b0bb47afe5551e8d494af 0","endCursor":"5030b56631e7f293417b0bb47afe5551e8d494af 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:1734955729.0","refType":"branch","currentOid":"5030b56631e7f293417b0bb47afe5551e8d494af"},"timedOutMessage":""},"title":"Commits · html2rss/html2rss-web","appPayload":{"helpUrl":"https://docs.github.com","enabled_features":{"commits_ux_refresh_compare":false,"commit_details_extra_diff_fetching":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*/
.dmxRgG[data-size="medium"]{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
.dmxRgG[data-size="medium"] svg{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.dmxRgG[data-size="medium"] > span{width:inherit;}/*!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*/
.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*/
.bbHsCC{width:16px;height:16px;margin-right:8px;margin-top:-1px;margin-left:1px;}/*!sc*/
.jRhDJg{font-weight:400;white-space:nowrap;color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.jRhDJg:hover{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));-webkit-text-decoration:underline;text-decoration:underline;}/*!sc*/
.irPhWZ{width:60px;}/*!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*/
.cQAMJB[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*/
data-styled.g1[id="Box-sc-g0xbh4-0"]{content:"kkWQEA,bSJDXx,jPRcNF,hOfjFo,gKBBxN,kowOcT,dQkwwl,FxAyp,gwHaUx,dmxRgG,gUkoLg,bZBlpz,lhTYNA,dbrgmi,cSURfY,hjDqIa,dGVxWp,izArLR,bbNsBg,cdHayA,jJRiHe,dpBUfI,hKWjvQ,bbHsCC,jRhDJg,irPhWZ,fIQuDd,EDqVA,dNbsEP,iCHGgS,cQAMJB,"}/*!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.g3[id="Text__StyledText-sc-17v1xeu-0"]{content:"eMMFM,ljLSiW,hWqAbU,"}/*!sc*/
.jOyaRH{display:none;}/*!sc*/
.jOyaRH[popover]{position:absolute;padding:0.5em 0.75em;width:-webkit-max-content;width:-moz-max-content;width:max-content;margin:auto;-webkit-clip:auto;clip:auto;white-space:normal;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;word-wrap:break-word;background:var(--tooltip-bgColor,var(--bgColor-emphasis,var(--color-neutral-emphasis-plus,#24292f)));border-radius:6px;border:0;opacity:0;max-width:250px;inset:auto;overflow:visible;}/*!sc*/
.jOyaRH[popover]:popover-open{display:block;}/*!sc*/
.jOyaRH[popover].\:popover-open{display:block;}/*!sc*/
@media (forced-colors:active){.jOyaRH{outline:1px solid transparent;}}/*!sc*/
.jOyaRH::after{position:absolute;display:block;right:0;left:0;height:var(--overlay-offset,0.25rem);content:'';}/*!sc*/
.jOyaRH[data-direction='n']::after,.jOyaRH[data-direction='ne']::after,.jOyaRH[data-direction='nw']::after{top:100%;}/*!sc*/
.jOyaRH[data-direction='s']::after,.jOyaRH[data-direction='se']::after,.jOyaRH[data-direction='sw']::after{bottom:100%;}/*!sc*/
.jOyaRH[data-direction='w']::after{position:absolute;display:block;height:100%;width:8px;content:'';bottom:0;left:100%;}/*!sc*/
.jOyaRH[data-direction='e']::after{position:absolute;display:block;height:100%;width:8px;content:'';bottom:0;right:100%;margin-left:-8px;}/*!sc*/
@-webkit-keyframes tooltip-appear{from{opacity:0;}to{opacity:1;}}/*!sc*/
@keyframes tooltip-appear{from{opacity:0;}to{opacity:1;}}/*!sc*/
.jOyaRH:popover-open,.jOyaRH:popover-open::before{-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*/
.jOyaRH.\:popover-open,.jOyaRH.\:popover-open::before{-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*/
data-styled.g17[id="Tooltip__StyledTooltip-sc-e45c7z-0"]{content:"jOyaRH,"}/*!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.g18[id="Tooltip__TooltipBase-sc-17tf59c-0"]{content:"hWlpPn,"}/*!sc*/
.knLhXt{color:var(--fgColor-muted,var(--color-fg-muted,#656d76));}/*!sc*/
.WGJwj{margin-top:2px;margin-bottom:2px;}/*!sc*/
data-styled.g58[id="Octicon-sc-9kayk9-0"]{content:"knLhXt,WGJwj,"}/*!sc*/
.irithh{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:60px;}/*!sc*/
.irithh::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*/
.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.g68[id="LoadingSkeleton-sc-695d630a-0"]{content:"irithh,irOdmh,ihfxfT,"}/*!sc*/
.hzFJAq{--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*/
.hzFJAq .pc-AvatarStackBody{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;position:absolute;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:1px;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:1px;}/*!sc*/
.hzFJAq .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);position:relative;overflow:hidden;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
.hzFJAq .pc-AvatarItem:is(img){box-shadow:0 0 0 var(--avatar-border-width) var(--bgColor-default,var(--color-canvas-default,#ffffff));}/*!sc*/
.hzFJAq .pc-AvatarItem:first-child{margin-left:0;z-index:10;}/*!sc*/
.hzFJAq .pc-AvatarItem:nth-child(n + 2){margin-left:var(--avatar-two-margin);z-index:9;}/*!sc*/
.hzFJAq .pc-AvatarItem:nth-child(n + 3){margin-left:var(--avatar-three-margin);opacity:55%;z-index:8;}/*!sc*/
.hzFJAq .pc-AvatarItem:nth-child(n + 4){opacity:40%;z-index:7;}/*!sc*/
.hzFJAq .pc-AvatarItem:nth-child(n + 5){opacity:25%;z-index:6;}/*!sc*/
.hzFJAq .pc-AvatarItem:nth-child(n + 6){opacity:0;visibility:hidden;}/*!sc*/
.hzFJAq.pc-AvatarStack--two{min-width:calc( var(--avatar-stack-size) + calc(var(--avatar-stack-size) + var(--avatar-two-margin)) + var(--avatar-border-width) );}/*!sc*/
.hzFJAq.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*/
.hzFJAq.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*/
.hzFJAq.pc-AvatarStack--right{-webkit-box-pack:end;-webkit-justify-content:flex-end;-ms-flex-pack:end;justify-content:flex-end;}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarItem{margin-left:0 !important;}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarItem:first-child{margin-right:0;}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarItem:nth-child(n + 2){margin-right:var(--avatar-two-margin);}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarItem:nth-child(n + 3){margin-right:var(--avatar-three-margin);}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarStackBody{-webkit-flex-direction:row-reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse;}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem,.hzFJAq.pc-AvatarStack--right .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem{margin-right:4px!important;margin-left:0 !important;}/*!sc*/
.hzFJAq.pc-AvatarStack--right .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:first-child,.hzFJAq.pc-AvatarStack--right .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem:first-child{margin-right:0 !important;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover,.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within{width:auto;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem,.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .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*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem box-shadow:inset 0 0 0 4px function(n),.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem box-shadow:inset 0 0 0 4px function(n){return(0,r.Jt)(n.theme,e,t);}/*!sc*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:focus:not(:disabled),.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem:focus:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:1px;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:focus:not(:disabled):not(:focus-visible),.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem:focus:not(:disabled):not(:focus-visible){outline:solid 1px transparent;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:focus-visible:not(:disabled),.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem:focus-visible:not(:disabled){box-shadow:none;outline:2px solid var(--fgColor-accent,var(--color-accent-fg,#0969da));outline-offset:1px;}/*!sc*/
.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):hover .pc-AvatarItem:first-child,.hzFJAq .pc-AvatarStackBody:not(.pc-AvatarStack--disableExpand):focus-within .pc-AvatarItem:first-child{margin-left:0;}/*!sc*/
.hzFJAq .pc-AvatarStack--disableExpand{position:relative;}/*!sc*/
data-styled.g76[id="AvatarStack__AvatarStackWrapper-sc-4pdg6v-0"]{content:"hzFJAq,"}/*!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.g107[id="ButtonGroup__StyledButtonGroup-sc-1gxhls1-0"]{content:"lirRhW,"}/*!sc*/
.eSFHqT{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;}/*!sc*/
.eSFHqT .Timeline-Item:first-child{padding-top:0;}/*!sc*/
.eSFHqT .Timeline-Item:last-child{padding-bottom:0;}/*!sc*/
data-styled.g115[id="Timeline__ToggleTimeline-sc-1nkzbnu-0"]{content:"eSFHqT,"}/*!sc*/
.fhQhVG{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*/
.fhQhVG::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*/
.eHtUWW{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*/
.eHtUWW::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.g116[id="Timeline__ToggleTimelineItem-sc-1nkzbnu-1"]{content:"fhQhVG,eHtUWW,"}/*!sc*/
.jdZjlQ{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.g117[id="Timeline__ToggleTimelineBody-sc-1nkzbnu-2"]{content:"jdZjlQ,"}/*!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.g132[id="sc-keyframes-crVFvv"]{content:"crVFvv,"}/*!sc*/
</style> <!-- --> <div style="--sticky-pane-height:100vh;--spacing:var(--spacing-normal)" 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="Box-sc-g0xbh4-0 dmxRgG prc-Button-ButtonBase-c50BI" data-loading="false" data-size="medium" data-variant="default" aria-describedby="branch-picker-commits-loading-announcement" id="branch-picker-commits"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg prc-Button-ButtonContent-HKbr-"><span data-component="text" class="prc-Button-Label-pTQ3x"><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="prc-Button-Visual-2epfX prc-Button-VisualWrap-Db-eB"><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="prc-Button-ButtonBase-c50BI" data-loading="false" data-size="medium" data-variant="default" aria-describedby=":R1crab:-loading-announcement" id=":R1crab:"><span data-component="buttonContent" data-align="center" class="prc-Button-ButtonContent-HKbr-"><span data-component="text" class="prc-Button-Label-pTQ3x"><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="prc-Button-Visual-2epfX prc-Button-VisualWrap-Db-eB"><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="prc-Button-ButtonBase-c50BI" data-loading="false" data-size="medium" data-variant="default" aria-describedby=":Rlsrab:-loading-announcement"><span data-component="buttonContent" data-align="center" class="prc-Button-ButtonContent-HKbr-"><span data-component="leadingVisual" class="prc-Button-Visual-2epfX prc-Button-VisualWrap-Db-eB"><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" class="prc-Button-Label-pTQ3x">All time</span><span data-component="trailingVisual" class="prc-Button-Visual-2epfX prc-Button-VisualWrap-Db-eB"><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__ToggleTimeline-sc-1nkzbnu-0 eSFHqT"><div style="display:contents"><div class="Timeline__ToggleTimelineItem-sc-1nkzbnu-1 fhQhVG 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rt5rab:" data-testid="commit-group-title">Commits on Dec 20, 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=":Ragt5rab:-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=":Ragt5rab:-list-view-node-:Rfqgt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/5030b56631e7f293417b0bb47afe5551e8d494af"><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.4.0 to 2.5.0 in the rubygems group (#706)

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


Updates `tilt` from 2.4.0 to 2.5.0
- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)
- [Commits](https://github.com/jeremyevans/tilt/compare/v2.4.0...v2.5.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/5030b56631e7f293417b0bb47afe5551e8d494af">chore(deps): bump tilt from 2.4.0 to 2.5.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2753575199" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/706" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/706/hovercard" href="https://github.com/html2rss/html2rss-web/pull/706">#706</a><a data-pjax="true" title="chore(deps): bump tilt from 2.4.0 to 2.5.0 in the rubygems group (#706)

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


Updates `tilt` from 2.4.0 to 2.5.0
- [Changelog](https://github.com/jeremyevans/tilt/blob/master/CHANGELOG.md)
- [Commits](https://github.com/jeremyevans/tilt/compare/v2.4.0...v2.5.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/5030b56631e7f293417b0bb47afe5551e8d494af">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqgt5rab:-loading-announcement show-description-5030b56" aria-labelledby="show-description-5030b56"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 5030b56" role="tooltip" aria-hidden="true" id="show-description-5030b56">Show description for 5030b56</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqgt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/5030b56631e7f293417b0bb47afe5551e8d494af" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">5030b56</span></span></a></span><div><div aria-describedby=":Rjnfqgt5rab:"><button aria-label="Copy full SHA for 5030b56" 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-5030b56" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-5030b56" href="/html2rss/html2rss-web/tree/5030b56631e7f293417b0bb47afe5551e8d494af" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R1d5rab:" data-testid="commit-group-title">Commits on Dec 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=":Rahd5rab:-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=":Rahd5rab:-list-view-node-:Rfqhd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/e6282bfd205e908bfda6c8ffb77b03bcd00952db"><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.13.0 to 1.13.1 in the rubygems group (#705)

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


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

---
updated-dependencies:
- dependency-name: erubi
  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/e6282bfd205e908bfda6c8ffb77b03bcd00952db">chore(deps): bump erubi from 1.13.0 to 1.13.1 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2751554814" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/705" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/705/hovercard" href="https://github.com/html2rss/html2rss-web/pull/705">#705</a><a data-pjax="true" title="chore(deps): bump erubi from 1.13.0 to 1.13.1 in the rubygems group (#705)

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


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

---
updated-dependencies:
- dependency-name: erubi
  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/e6282bfd205e908bfda6c8ffb77b03bcd00952db">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqhd5rab:-loading-announcement show-description-e6282bf" aria-labelledby="show-description-e6282bf"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for e6282bf" role="tooltip" aria-hidden="true" id="show-description-e6282bf">Show description for e6282bf</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqhd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/e6282bfd205e908bfda6c8ffb77b03bcd00952db" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">e6282bf</span></span></a></span><div><div aria-describedby=":Rjnfqhd5rab:"><button aria-label="Copy full SHA for e6282bf" 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-e6282bf" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-e6282bf" href="/html2rss/html2rss-web/tree/e6282bfd205e908bfda6c8ffb77b03bcd00952db" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R1t5rab:" data-testid="commit-group-title">Commits on Dec 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=":Raht5rab:-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=":Raht5rab:-list-view-node-:Rfqht5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/0c3540f087c223102a3ae4c24249ca993dba341d"><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.86.0 to 3.87.0 in the rubygems group (#704)

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


Updates `roda` from 3.86.0 to 3.87.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.86.0...3.87.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/0c3540f087c223102a3ae4c24249ca993dba341d">chore(deps): bump roda from 3.86.0 to 3.87.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2746267762" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/704" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/704/hovercard" href="https://github.com/html2rss/html2rss-web/pull/704">#704</a><a data-pjax="true" title="chore(deps): bump roda from 3.86.0 to 3.87.0 in the rubygems group (#704)

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


Updates `roda` from 3.86.0 to 3.87.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.86.0...3.87.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/0c3540f087c223102a3ae4c24249ca993dba341d">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqht5rab:-loading-announcement show-description-0c3540f" aria-labelledby="show-description-0c3540f"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 0c3540f" role="tooltip" aria-hidden="true" id="show-description-0c3540f">Show description for 0c3540f</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqht5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/0c3540f087c223102a3ae4c24249ca993dba341d" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">0c3540f</span></span></a></span><div><div aria-describedby=":Rjnfqht5rab:"><button aria-label="Copy full SHA for 0c3540f" 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-0c3540f" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-0c3540f" href="/html2rss/html2rss-web/tree/0c3540f087c223102a3ae4c24249ca993dba341d" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R2d5rab:" data-testid="commit-group-title">Commits on Nov 25, 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=":Raid5rab:-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=":Raid5rab:-list-view-node-:Rfqid5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/769dd7964c3411d7f368883ba50451b8362db658"><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 (#703)

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


Updates `html2rss-configs` from `905ca2a` to `9aa87f0`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/905ca2a7da7d5cbf63d5265f8b70c64563957252...9aa87f0d713f5caebaab148c3922698655556a33)

Updates `puma` from 6.4.3 to 6.5.0
- [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.3...v6.5.0)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: puma
  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/769dd7964c3411d7f368883ba50451b8362db658">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="2692016591" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/703" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/703/hovercard" href="https://github.com/html2rss/html2rss-web/pull/703">#703</a><a data-pjax="true" title="chore(deps): bump the rubygems group with 2 updates (#703)

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


Updates `html2rss-configs` from `905ca2a` to `9aa87f0`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/905ca2a7da7d5cbf63d5265f8b70c64563957252...9aa87f0d713f5caebaab148c3922698655556a33)

Updates `puma` from 6.4.3 to 6.5.0
- [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.3...v6.5.0)

---
updated-dependencies:
- dependency-name: html2rss-configs
  dependency-type: direct:production
  dependency-group: rubygems
- dependency-name: puma
  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/769dd7964c3411d7f368883ba50451b8362db658">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqid5rab:-loading-announcement show-description-769dd79" aria-labelledby="show-description-769dd79"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 769dd79" role="tooltip" aria-hidden="true" id="show-description-769dd79">Show description for 769dd79</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqid5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/769dd7964c3411d7f368883ba50451b8362db658" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">769dd79</span></span></a></span><div><div aria-describedby=":Rjnfqid5rab:"><button aria-label="Copy full SHA for 769dd79" 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-769dd79" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-769dd79" href="/html2rss/html2rss-web/tree/769dd7964c3411d7f368883ba50451b8362db658" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R2t5rab:" data-testid="commit-group-title">Commits on Nov 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=":Rait5rab:-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=":Rait5rab:-list-view-node-:Rnqit5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/7808bf7445f3b2eca6fb17cdd4d748d742cdb580"><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 (#702)

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


Updates `html2rss-configs` from `f63f74f` to `905ca2a`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/f63f74f8805177d0237a04f64235785906fa54ba...905ca2a7da7d5cbf63d5265f8b70c64563957252)

---
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/7808bf7445f3b2eca6fb17cdd4d748d742cdb580">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="2684847025" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/702" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/702/hovercard" href="https://github.com/html2rss/html2rss-web/pull/702">#702</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#702)

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


Updates `html2rss-configs` from `f63f74f` to `905ca2a`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/f63f74f8805177d0237a04f64235785906fa54ba...905ca2a7da7d5cbf63d5265f8b70c64563957252)

---
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/7808bf7445f3b2eca6fb17cdd4d748d742cdb580">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6nqit5rab:-loading-announcement show-description-7808bf7" aria-labelledby="show-description-7808bf7"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 7808bf7" role="tooltip" aria-hidden="true" id="show-description-7808bf7">Show description for 7808bf7</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnenqit5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/7808bf7445f3b2eca6fb17cdd4d748d742cdb580" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">7808bf7</span></span></a></span><div><div aria-describedby=":R17enqit5rab:"><button aria-label="Copy full SHA for 7808bf7" 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-7808bf7" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-7808bf7" href="/html2rss/html2rss-web/tree/7808bf7445f3b2eca6fb17cdd4d748d742cdb580" 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=":Rait5rab:-list-view-node-:Rrqit5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8"><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="ci(mergify): upgrade configuration to current format (#701)

Co-authored-by: Mergify &lt;37929162+mergify[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8">ci(mergify): upgrade configuration to current format (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2682648852" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/701" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/701/hovercard" href="https://github.com/html2rss/html2rss-web/pull/701">#701</a><a data-pjax="true" title="ci(mergify): upgrade configuration to current format (#701)

Co-authored-by: Mergify &lt;37929162+mergify[bot]@users.noreply.github.com&gt;" class="color-fg-default" href="/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6rqit5rab:-loading-announcement show-description-e48211b" aria-labelledby="show-description-e48211b"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for e48211b" role="tooltip" aria-hidden="true" id="show-description-e48211b">Show description for e48211b</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="prc-Link-Link-85e08" href="/apps/mergify" data-testid="avatar-icon-link" data-hovercard-url="/users/mergify%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="mergify[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/10562?v=4&amp;size=32" data-testid="github-avatar" aria-label="mergify[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" muted="" href="/html2rss/html2rss-web/commits?author=mergify%5Bbot%5D" aria-label="commits by mergify[bot]" data-hovercard-url="/users/mergify%5Bbot%5D/hovercard">mergify[bot]</a></div><span class="pl-1">authored</span><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnerqit5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">e48211b</span></span></a></span><div><div aria-describedby=":R17erqit5rab:"><button aria-label="Copy full SHA for e48211b" 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-e48211b" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-e48211b" href="/html2rss/html2rss-web/tree/e48211b64cc6a2fd34648d7c7f0c1f7c9ce27ef8" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R3d5rab:" data-testid="commit-group-title">Commits on Nov 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=":Rajd5rab:-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=":Rajd5rab:-list-view-node-:Rfqjd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/462c942c89136223eadb97b32e2d17f095456fe0"><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.85.0 to 3.86.0 in the rubygems group (#699)

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


Updates `roda` from 3.85.0 to 3.86.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.85.0...3.86.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/462c942c89136223eadb97b32e2d17f095456fe0">chore(deps): bump roda from 3.85.0 to 3.86.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2653546861" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/699" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/699/hovercard" href="https://github.com/html2rss/html2rss-web/pull/699">#699</a><a data-pjax="true" title="chore(deps): bump roda from 3.85.0 to 3.86.0 in the rubygems group (#699)

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


Updates `roda` from 3.85.0 to 3.86.0
- [Changelog](https://github.com/jeremyevans/roda/blob/master/CHANGELOG)
- [Commits](https://github.com/jeremyevans/roda/compare/3.85.0...3.86.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/462c942c89136223eadb97b32e2d17f095456fe0">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqjd5rab:-loading-announcement show-description-462c942" aria-labelledby="show-description-462c942"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 462c942" role="tooltip" aria-hidden="true" id="show-description-462c942">Show description for 462c942</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqjd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/462c942c89136223eadb97b32e2d17f095456fe0" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">462c942</span></span></a></span><div><div aria-describedby=":Rjnfqjd5rab:"><button aria-label="Copy full SHA for 462c942" 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-462c942" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-462c942" href="/html2rss/html2rss-web/tree/462c942c89136223eadb97b32e2d17f095456fe0" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R3t5rab:" data-testid="commit-group-title">Commits on Nov 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=":Rajt5rab:-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=":Rajt5rab:-list-view-node-:Rfqjt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/69db1a8bf7a8823d08b8cb35a51bda263c0beac6"><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 ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (#698)

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


Updates `ssrf_filter` from 1.1.2 to 1.2.0
- [Release notes](https://github.com/arkadiyt/ssrf_filter/releases)
- [Changelog](https://github.com/arkadiyt/ssrf_filter/blob/main/CHANGELOG.md)
- [Commits](https://github.com/arkadiyt/ssrf_filter/compare/1.1.2...1.2.0)

---
updated-dependencies:
- dependency-name: ssrf_filter
  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/69db1a8bf7a8823d08b8cb35a51bda263c0beac6">chore(deps): bump ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2645264898" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/698" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/698/hovercard" href="https://github.com/html2rss/html2rss-web/pull/698">#698</a><a data-pjax="true" title="chore(deps): bump ssrf_filter from 1.1.2 to 1.2.0 in the rubygems group (#698)

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


Updates `ssrf_filter` from 1.1.2 to 1.2.0
- [Release notes](https://github.com/arkadiyt/ssrf_filter/releases)
- [Changelog](https://github.com/arkadiyt/ssrf_filter/blob/main/CHANGELOG.md)
- [Commits](https://github.com/arkadiyt/ssrf_filter/compare/1.1.2...1.2.0)

---
updated-dependencies:
- dependency-name: ssrf_filter
  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/69db1a8bf7a8823d08b8cb35a51bda263c0beac6">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqjt5rab:-loading-announcement show-description-69db1a8" aria-labelledby="show-description-69db1a8"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 69db1a8" role="tooltip" aria-hidden="true" id="show-description-69db1a8">Show description for 69db1a8</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqjt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/69db1a8bf7a8823d08b8cb35a51bda263c0beac6" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">69db1a8</span></span></a></span><div><div aria-describedby=":Rjnfqjt5rab:"><button aria-label="Copy full SHA for 69db1a8" 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-69db1a8" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-69db1a8" href="/html2rss/html2rss-web/tree/69db1a8bf7a8823d08b8cb35a51bda263c0beac6" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R4d5rab:" data-testid="commit-group-title">Commits on Nov 6, 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=":Rakd5rab:-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=":Rakd5rab:-list-view-node-:Rfqkd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/34bed7bcab753a523360f6da9200749255121509"><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.5-alpine3.20 to 3.3.6-alpine3.20 (#697)

Bumps ruby from 3.3.5-alpine3.20 to 3.3.6-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/34bed7bcab753a523360f6da9200749255121509">chore(deps): bump ruby from 3.3.5-alpine3.20 to 3.3.6-alpine3.20 (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2637516983" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/697" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/697/hovercard" href="https://github.com/html2rss/html2rss-web/pull/697">#697</a><a data-pjax="true" title="chore(deps): bump ruby from 3.3.5-alpine3.20 to 3.3.6-alpine3.20 (#697)

Bumps ruby from 3.3.5-alpine3.20 to 3.3.6-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/34bed7bcab753a523360f6da9200749255121509">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqkd5rab:-loading-announcement show-description-34bed7b" aria-labelledby="show-description-34bed7b"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 34bed7b" role="tooltip" aria-hidden="true" id="show-description-34bed7b">Show description for 34bed7b</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqkd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/34bed7bcab753a523360f6da9200749255121509" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">34bed7b</span></span></a></span><div><div aria-describedby=":Rjnfqkd5rab:"><button aria-label="Copy full SHA for 34bed7b" 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-34bed7b" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-34bed7b" href="/html2rss/html2rss-web/tree/34bed7bcab753a523360f6da9200749255121509" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R4t5rab:" data-testid="commit-group-title">Commits on Nov 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=":Rakt5rab:-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=":Rakt5rab:-list-view-node-:Rfqkt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4"><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: optionally allow APM using Sentry via env variable (#696)" class="color-fg-default" href="/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4">feat: optionally allow APM using Sentry via env variable (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2630513713" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/696" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/696/hovercard" href="https://github.com/html2rss/html2rss-web/pull/696">#696</a><a data-pjax="true" title="feat: optionally allow APM using Sentry via env variable (#696)" class="color-fg-default" href="/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4">)</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqkt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/94477d50b178cf519d1e56f82f31e27cacc223c4" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">94477d5</span></span></a></span><div><div aria-describedby=":Rjnfqkt5rab:"><button aria-label="Copy full SHA for 94477d5" 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-94477d5" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-94477d5" href="/html2rss/html2rss-web/tree/94477d50b178cf519d1e56f82f31e27cacc223c4" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R5d5rab:" data-testid="commit-group-title">Commits on Oct 31, 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=":Rald5rab:-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=":Rald5rab:-list-view-node-:Rfqld5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/59aea1416f3d0157d5e7a1027f927548fe38f6c0"><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 (#695)

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


Updates `html2rss-configs` from `d226b29` to `f63f74f`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/d226b299376893fb5863322b95bdfa6e16d78dd5...f63f74f8805177d0237a04f64235785906fa54ba)

---
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/59aea1416f3d0157d5e7a1027f927548fe38f6c0">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="2627934488" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/695" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/695/hovercard" href="https://github.com/html2rss/html2rss-web/pull/695">#695</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#695)

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


Updates `html2rss-configs` from `d226b29` to `f63f74f`
- [Commits](https://github.com/html2rss/html2rss-configs/compare/d226b299376893fb5863322b95bdfa6e16d78dd5...f63f74f8805177d0237a04f64235785906fa54ba)

---
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/59aea1416f3d0157d5e7a1027f927548fe38f6c0">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqld5rab:-loading-announcement show-description-59aea14" aria-labelledby="show-description-59aea14"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 59aea14" role="tooltip" aria-hidden="true" id="show-description-59aea14">Show description for 59aea14</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqld5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/59aea1416f3d0157d5e7a1027f927548fe38f6c0" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">59aea14</span></span></a></span><div><div aria-describedby=":Rjnfqld5rab:"><button aria-label="Copy full SHA for 59aea14" 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-59aea14" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-59aea14" href="/html2rss/html2rss-web/tree/59aea1416f3d0157d5e7a1027f927548fe38f6c0" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R5t5rab:" data-testid="commit-group-title">Commits on Oct 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=":Ralt5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R5t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Ralt5rab:-list-view-node-:Rfqlt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8"><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.14.0 to 0.15.0 in the rubygems group (#694)

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


Updates `html2rss` from 0.14.0 to 0.15.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.14.0...v0.15.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/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8">chore(deps): bump html2rss from 0.14.0 to 0.15.0 in the rubygems group (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2624857597" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/694" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/694/hovercard" href="https://github.com/html2rss/html2rss-web/pull/694">#694</a><a data-pjax="true" title="chore(deps): bump html2rss from 0.14.0 to 0.15.0 in the rubygems group (#694)

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


Updates `html2rss` from 0.14.0 to 0.15.0
- [Release notes](https://github.com/gildesmarais/html2rss/releases)
- [Commits](https://github.com/gildesmarais/html2rss/compare/v0.14.0...v0.15.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/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqlt5rab:-loading-announcement show-description-1d30aad" aria-labelledby="show-description-1d30aad"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 1d30aad" role="tooltip" aria-hidden="true" id="show-description-1d30aad">Show description for 1d30aad</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqlt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">1d30aad</span></span></a></span><div><div aria-describedby=":Rjnfqlt5rab:"><button aria-label="Copy full SHA for 1d30aad" 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-1d30aad" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-1d30aad" href="/html2rss/html2rss-web/tree/1d30aad32136b2abc6d7b3a2a9a59bd620c4e6e8" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R6d5rab:" data-testid="commit-group-title">Commits on Oct 28, 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=":Ramd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R6d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Ramd5rab:-list-view-node-:Rnqmd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/591746729f722272cbb803cc4a73d43038c598f8"><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 (#693)

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


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

---
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/591746729f722272cbb803cc4a73d43038c598f8">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="2619735864" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/693" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/693/hovercard" href="https://github.com/html2rss/html2rss-web/pull/693">#693</a><a data-pjax="true" title="chore(deps): bump html2rss-configs in the rubygems group (#693)

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


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

---
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/591746729f722272cbb803cc4a73d43038c598f8">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6nqmd5rab:-loading-announcement show-description-5917467" aria-labelledby="show-description-5917467"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 5917467" role="tooltip" aria-hidden="true" id="show-description-5917467">Show description for 5917467</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnenqmd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/591746729f722272cbb803cc4a73d43038c598f8" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">5917467</span></span></a></span><div><div aria-describedby=":R17enqmd5rab:"><button aria-label="Copy full SHA for 5917467" 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-5917467" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-5917467" href="/html2rss/html2rss-web/tree/591746729f722272cbb803cc4a73d43038c598f8" 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=":Ramd5rab:-list-view-node-:Rrqmd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/8123508b9f07ed42ae61e807ba7903526595f817"><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.8 to 3.3.9 (#692)

Bumps [rexml](https://github.com/ruby/rexml) from 3.3.8 to 3.3.9.
- [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.8...v3.3.9)

---
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/8123508b9f07ed42ae61e807ba7903526595f817">chore(deps): bump rexml from 3.3.8 to 3.3.9 (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2619292681" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/692" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/692/hovercard" href="https://github.com/html2rss/html2rss-web/pull/692">#692</a><a data-pjax="true" title="chore(deps): bump rexml from 3.3.8 to 3.3.9 (#692)

Bumps [rexml](https://github.com/ruby/rexml) from 3.3.8 to 3.3.9.
- [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.8...v3.3.9)

---
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/8123508b9f07ed42ae61e807ba7903526595f817">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6rqmd5rab:-loading-announcement show-description-8123508" aria-labelledby="show-description-8123508"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 8123508" role="tooltip" aria-hidden="true" id="show-description-8123508">Show description for 8123508</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnerqmd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/8123508b9f07ed42ae61e807ba7903526595f817" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">8123508</span></span></a></span><div><div aria-describedby=":R17erqmd5rab:"><button aria-label="Copy full SHA for 8123508" 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-8123508" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-8123508" href="/html2rss/html2rss-web/tree/8123508b9f07ed42ae61e807ba7903526595f817" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R6t5rab:" data-testid="commit-group-title">Commits on Oct 25, 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=":Ramt5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R6t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Ramt5rab:-list-view-node-:Rfqmt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f"><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(auto_source): respect headers from global config (#691)" class="color-fg-default" href="/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f">fix(auto_source): respect headers from global config (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2614338089" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/691" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/691/hovercard" href="https://github.com/html2rss/html2rss-web/pull/691">#691</a><a data-pjax="true" title="fix(auto_source): respect headers from global config (#691)" class="color-fg-default" href="/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f">)</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqmt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">3e9ba91</span></span></a></span><div><div aria-describedby=":Rjnfqmt5rab:"><button aria-label="Copy full SHA for 3e9ba91" 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-3e9ba91" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-3e9ba91" href="/html2rss/html2rss-web/tree/3e9ba91db0cc60d2e5b2312c06ca4be238cbef7f" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R7d5rab:" data-testid="commit-group-title">Commits on Oct 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=":Rand5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R7d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rand5rab:-list-view-node-:R17qnd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687"><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="dev: update readme and test-suite configuration (#690)

This pull request includes updates to the `README.md` file and
improvements to the test suite, particularly focusing on the use of
`ClimateControl` for environment variable management and some general
cleanup.

Updates to documentation:

*
[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52):
Clarified and corrected the usage of environment variables, ensuring
they are correctly quoted and formatted.
[[1]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52)
[[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L86-R87)
[[3]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L96-R97)
[[4]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L155-R157)
*
[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R9):
Added a new feature description for providing stable URLs for feeds
generated by automatic sourcing.

Improvements to test suite:

*
[`spec/html2rss/web/app_spec.rb`](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4):
Introduced `ClimateControl` to manage environment variables during
tests, replacing direct `ENV` manipulation.
[[1]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4)
[[2]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R43-R54)
*
[`spec/html2rss/web/helpers/auto_source_spec.rb`](diffhunk://#diff-1c878bb09df33c5882ccb5908063682ecd481c30c7a5d0bf97a8be65cb698548L4-R11):
Added `ClimateControl` and corrected the RSpec description format.
*
[`spec/routes/auto_source_spec.rb`](diffhunk://#diff-c88fcacaf08dea9f6768c205b268876e4b05dc517724faacbc6215eafe37f543L7-R7):
Updated to use `RSpec.describe` for consistency.

General cleanup:

*
[`spec/spec_helper.rb`](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15):
Removed the `EnvHelper` module and associated `ClimateControl` support
file, as they are no longer needed.
[[1]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15)
[[2]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L121-L122)
[[3]](diffhunk://#diff-77b0d409fb1eaea240996a5f235354d577c0624382f9e7c19fdd075636bfd2a9L1-L9)" class="color-fg-default" href="/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687">dev: update readme and test-suite configuration (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2605923029" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/690" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/690/hovercard" href="https://github.com/html2rss/html2rss-web/pull/690">#690</a><a data-pjax="true" title="dev: update readme and test-suite configuration (#690)

This pull request includes updates to the `README.md` file and
improvements to the test suite, particularly focusing on the use of
`ClimateControl` for environment variable management and some general
cleanup.

Updates to documentation:

*
[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52):
Clarified and corrected the usage of environment variables, ensuring
they are correctly quoted and formatted.
[[1]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L51-R52)
[[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L86-R87)
[[3]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L96-R97)
[[4]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L155-R157)
*
[`README.md`](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R9):
Added a new feature description for providing stable URLs for feeds
generated by automatic sourcing.

Improvements to test suite:

*
[`spec/html2rss/web/app_spec.rb`](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4):
Introduced `ClimateControl` to manage environment variables during
tests, replacing direct `ENV` manipulation.
[[1]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R4)
[[2]](diffhunk://#diff-090562f30c41a91ba9b59502563d84d791cfb29c288708bd2acc51e7c33e8f10R43-R54)
*
[`spec/html2rss/web/helpers/auto_source_spec.rb`](diffhunk://#diff-1c878bb09df33c5882ccb5908063682ecd481c30c7a5d0bf97a8be65cb698548L4-R11):
Added `ClimateControl` and corrected the RSpec description format.
*
[`spec/routes/auto_source_spec.rb`](diffhunk://#diff-c88fcacaf08dea9f6768c205b268876e4b05dc517724faacbc6215eafe37f543L7-R7):
Updated to use `RSpec.describe` for consistency.

General cleanup:

*
[`spec/spec_helper.rb`](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15):
Removed the `EnvHelper` module and associated `ClimateControl` support
file, as they are no longer needed.
[[1]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L14-L15)
[[2]](diffhunk://#diff-89eebfcbc0f14b6d989517837ca1e94fce4e2ce9a03233641cd936f2b8d2ed94L121-L122)
[[3]](diffhunk://#diff-77b0d409fb1eaea240996a5f235354d577c0624382f9e7c19fdd075636bfd2a9L1-L9)" class="color-fg-default" href="/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687">)</a></span></h4><span class="Title-module__trailingBadgesContainer--XGsbF"></span><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R72d7qnd5rab:-loading-announcement show-description-d4e4d91" aria-labelledby="show-description-d4e4d91"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for d4e4d91" role="tooltip" aria-hidden="true" id="show-description-d4e4d91">Show description for d4e4d91</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":R1et7qnd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/d4e4d913062ee91236c610c7889368202f4ae687" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">d4e4d91</span></span></a></span><div><div aria-describedby=":R2et7qnd5rab:"><button aria-label="Copy full SHA for d4e4d91" 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-d4e4d91" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-d4e4d91" href="/html2rss/html2rss-web/tree/d4e4d913062ee91236c610c7889368202f4ae687" 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=":Rand5rab:-list-view-node-:R1bqnd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/d0d9e6651e13b1b7557ec13627e142ee6aa84d3f"><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="docs(readme): promote auto_source feature &amp; fix yaml parsing in examples" class="color-fg-default" href="/html2rss/html2rss-web/commit/d0d9e6651e13b1b7557ec13627e142ee6aa84d3f">docs(readme): promote auto_source feature &amp; fix yaml parsing in examples</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":R1etbqnd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/d0d9e6651e13b1b7557ec13627e142ee6aa84d3f" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">d0d9e66</span></span></a></span><div><div aria-describedby=":R2etbqnd5rab:"><button aria-label="Copy full SHA for d0d9e66" 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-d0d9e66" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-d0d9e66" href="/html2rss/html2rss-web/tree/d0d9e6651e13b1b7557ec13627e142ee6aa84d3f" 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=":Rand5rab:-list-view-node-:R1fqnd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74"><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="dev(test): disable rspec&#39;s monkey patching" class="color-fg-default" href="/html2rss/html2rss-web/commit/e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74">dev(test): disable rspec's monkey patching</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":R1etfqnd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">e94c28e</span></span></a></span><div><div aria-describedby=":R2etfqnd5rab:"><button aria-label="Copy full SHA for e94c28e" 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-e94c28e" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-e94c28e" href="/html2rss/html2rss-web/tree/e94c28e1a99ca95b9bbf54e0ab89d4a68cb9db74" 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=":Rand5rab:-list-view-node-:R1jqnd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/08db4d8bc1581670b4ac031dc2b72972740d8b7c"><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="dev(test): keep track of failed examples" class="color-fg-default" href="/html2rss/html2rss-web/commit/08db4d8bc1581670b4ac031dc2b72972740d8b7c">dev(test): keep track of failed examples</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":R1etjqnd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/08db4d8bc1581670b4ac031dc2b72972740d8b7c" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">08db4d8</span></span></a></span><div><div aria-describedby=":R2etjqnd5rab:"><button aria-label="Copy full SHA for 08db4d8" 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-08db4d8" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-08db4d8" href="/html2rss/html2rss-web/tree/08db4d8bc1581670b4ac031dc2b72972740d8b7c" 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=":Rand5rab:-list-view-node-:R1nqnd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/1efab5ddb930d847c3896c37b043ef7ce43ac009"><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="dev(test): use climate control without helper indirection" class="color-fg-default" href="/html2rss/html2rss-web/commit/1efab5ddb930d847c3896c37b043ef7ce43ac009">dev(test): use climate control without helper indirection</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":R1etnqnd5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/1efab5ddb930d847c3896c37b043ef7ce43ac009" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">1efab5d</span></span></a></span><div><div aria-describedby=":R2etnqnd5rab:"><button aria-label="Copy full SHA for 1efab5d" 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-1efab5d" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-1efab5d" href="/html2rss/html2rss-web/tree/1efab5ddb930d847c3896c37b043ef7ce43ac009" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R7t5rab:" data-testid="commit-group-title">Commits on Oct 21, 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=":Rant5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R7t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rant5rab:-list-view-node-:Rfqnt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e"><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(auto_source): add support for `auto_source` feature (#676)" class="color-fg-default" href="/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e">feat(auto_source): add support for</a> <code><a data-pjax="true" title="feat(auto_source): add support for `auto_source` feature (#676)" class="color-fg-default" href="/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e">auto_source</a></code> <a data-pjax="true" title="feat(auto_source): add support for `auto_source` feature (#676)" class="color-fg-default" href="/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e">feature (</a><a class="issue-link js-issue-link" data-error-text="Failed to load title" data-id="2471560586" data-permission-text="Title is private" data-url="https://github.com/html2rss/html2rss-web/issues/676" data-hovercard-type="pull_request" data-hovercard-url="/html2rss/html2rss-web/pull/676/hovercard" href="https://github.com/html2rss/html2rss-web/pull/676">#676</a><a data-pjax="true" title="feat(auto_source): add support for `auto_source` feature (#676)" class="color-fg-default" href="/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e">)</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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqnt5rab:" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-s"><a class="Button--invisible Button--small Button text-mono" href="/html2rss/html2rss-web/commit/531dced02ecd53f9594670b56699ea5d2ab6842e" variant="invisible" sx="[object Object]"><span class="Button-content"><span class="Button-label color-fg-muted">531dced</span></span></a></span><div><div aria-describedby=":Rjnfqnt5rab:"><button aria-label="Copy full SHA for 531dced" 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-531dced" class="Tooltip__TooltipBase-sc-17tf59c-0 hWlpPn tooltipped-sw"><a aria-labelledby="browse-repo-531dced" href="/html2rss/html2rss-web/tree/531dced02ecd53f9594670b56699ea5d2ab6842e" 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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R8d5rab:" 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=":Raod5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R8d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Raod5rab:-list-view-node-:Rfqod5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/8eeb9e69a1c57f3c61ca00469083604e25066859"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqod5rab:-loading-announcement show-description-8eeb9e6" aria-labelledby="show-description-8eeb9e6"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 8eeb9e6" role="tooltip" aria-hidden="true" id="show-description-8eeb9e6">Show description for 8eeb9e6</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqod5rab:" 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=":Rjnfqod5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R8t5rab:" 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=":Raot5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R8t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Raot5rab:-list-view-node-:Rfqot5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/65964787b26ab6406ca1e9f1f64de67adb66b49e"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqot5rab:-loading-announcement show-description-6596478" aria-labelledby="show-description-6596478"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 6596478" role="tooltip" aria-hidden="true" id="show-description-6596478">Show description for 6596478</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqot5rab:" 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=":Rjnfqot5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R9d5rab:" 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=":Rapd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R9d5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rapd5rab:-list-view-node-:Rfqpd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/9ff3cc1a706ebdea7b75e560ea263caab79ce68f"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqpd5rab:-loading-announcement show-description-9ff3cc1" aria-labelledby="show-description-9ff3cc1"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 9ff3cc1" role="tooltip" aria-hidden="true" id="show-description-9ff3cc1">Show description for 9ff3cc1</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqpd5rab:" 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=":Rjnfqpd5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":R9t5rab:" 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=":Rapt5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":R9t5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rapt5rab:-list-view-node-:Rfqpt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/9d81615cc9c178127b86c45fa108bc3bf92ba163"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqpt5rab:-loading-announcement show-description-9d81615" aria-labelledby="show-description-9d81615"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 9d81615" role="tooltip" aria-hidden="true" id="show-description-9d81615">Show description for 9d81615</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqpt5rab:" 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=":Rjnfqpt5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rad5rab:" 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=":Raqd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rad5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Raqd5rab:-list-view-node-:Rfqqd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/2d1b2506699897694d47244748fd6ece6dedbd4e"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqqd5rab:-loading-announcement show-description-2d1b250" aria-labelledby="show-description-2d1b250"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 2d1b250" role="tooltip" aria-hidden="true" id="show-description-2d1b250">Show description for 2d1b250</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqqd5rab:" 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=":Rjnfqqd5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rat5rab:" 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=":Raqt5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rat5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Raqt5rab:-list-view-node-:Rfqqt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/ac21f2efb1bac21cbb0b1ece1d9a59e8eba45989"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqqt5rab:-loading-announcement show-description-ac21f2e" aria-labelledby="show-description-ac21f2e"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for ac21f2e" role="tooltip" aria-hidden="true" id="show-description-ac21f2e">Show description for ac21f2e</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqqt5rab:" 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=":Rjnfqqt5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rbd5rab:" 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=":Rard5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rbd5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rard5rab:-list-view-node-:Rnqrd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/b45763778438aa153e7cd3d18a8b84e521624874"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6nqrd5rab:-loading-announcement show-description-b457637" aria-labelledby="show-description-b457637"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for b457637" role="tooltip" aria-hidden="true" id="show-description-b457637">Show description for b457637</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnenqrd5rab:" 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=":R17enqrd5rab:"><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=":Rard5rab:-list-view-node-:Rrqrd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/dca827891199a7a8b6979ccd4e36487d1798ed0d"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6rqrd5rab:-loading-announcement show-description-dca8278" aria-labelledby="show-description-dca8278"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for dca8278" role="tooltip" aria-hidden="true" id="show-description-dca8278">Show description for dca8278</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnerqrd5rab:" 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=":R17erqrd5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rbt5rab:" 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=":Rart5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rbt5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rart5rab:-list-view-node-:Rfqrt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/5ebc9ec5de9799d9da28b93275cfbdc775240f0c"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqrt5rab:-loading-announcement show-description-5ebc9ec" aria-labelledby="show-description-5ebc9ec"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 5ebc9ec" role="tooltip" aria-hidden="true" id="show-description-5ebc9ec">Show description for 5ebc9ec</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqrt5rab:" 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=":Rjnfqrt5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rcd5rab:" 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=":Rasd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rcd5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rasd5rab:-list-view-node-:Rfqsd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/929ae671dade0457a5af781982d3db5a39c8676a"><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="prc-Link-Link-85e08" href="/gildesmarais" data-testid="avatar-icon-link" data-hovercard-url="/users/gildesmarais/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="github-avatar" aria-label="gildesmarais"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqsd5rab:" 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=":Rjnfqsd5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rct5rab:" 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=":Rast5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rct5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Rast5rab:-list-view-node-:Rnqst5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/59831cddd1ed24f722ac60c388141a5b65d8e269"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6nqst5rab:-loading-announcement show-description-59831cd" aria-labelledby="show-description-59831cd"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 59831cd" role="tooltip" aria-hidden="true" id="show-description-59831cd">Show description for 59831cd</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 hzFJAq pc-AvatarStack--three"><div class="Box-sc-g0xbh4-0 pc-AvatarStackBody" tabindex="0"> <img data-component="Avatar" class="pc-AvatarItem prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" 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"/><img data-component="Avatar" class="pc-AvatarItem prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="commit-stack-avatar" data-hovercard-url="/users/gildesmarais/hovercard"/></div></span><div data-testid="author-link" class="Box-sc-g0xbh4-0 iCHGgS"><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnenqst5rab:" 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=":R17enqst5rab:"><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=":Rast5rab:-list-view-node-:Rrqst5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/83772a132ca489c0b58d8becc716710896d348e4"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R3h6rqst5rab:-loading-announcement show-description-83772a1" aria-labelledby="show-description-83772a1"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 83772a1" role="tooltip" aria-hidden="true" id="show-description-83772a1">Show description for 83772a1</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rnerqst5rab:" 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=":R17erqst5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rdd5rab:" 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=":Ratd5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rdd5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Ratd5rab:-list-view-node-:Rfqtd5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/1f466065612bd289933b28747e7e6f76a628bc31"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqtd5rab:-loading-announcement show-description-1f46606" aria-labelledby="show-description-1f46606"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 1f46606" role="tooltip" aria-hidden="true" id="show-description-1f46606">Show description for 1f46606</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="prc-Link-Link-85e08" href="/apps/dependabot" data-testid="avatar-icon-link" data-hovercard-url="/users/dependabot%5Bbot%5D/hovercard"><img data-component="Avatar" class="Box-sc-g0xbh4-0 bbHsCC prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/in/29110?v=4&amp;size=32" data-testid="github-avatar" aria-label="dependabot[bot]"/></a><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqtd5rab:" 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=":Rjnfqtd5rab:"><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__ToggleTimelineItem-sc-1nkzbnu-1 eHtUWW 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__ToggleTimelineBody-sc-1nkzbnu-2 jdZjlQ mt-0"><h3 class="text-normal f5 py-1 prc-Heading-Heading-6CmGO" id=":Rdt5rab:" 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=":Ratt5rab:-list-view-container" class="ListView-module__container--zF6wW"><ul class="Box-sc-g0xbh4-0 ListView-module__ul--vMLEZ" aria-labelledby=":Rdt5rab:" tabindex="-1" role="list" data-listview-component="items-list" data-testid="list-view-items"><li id=":Ratt5rab:-list-view-node-:Rfqtt5rab:" 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" data-commit-link="/html2rss/html2rss-web/commit/6ae606229ae48d9c1cd3c7d0339172eb244ce8eb"><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><button data-component="IconButton" type="button" data-testid="commit-row-show-description-button" aria-pressed="false" aria-expanded="false" class="prc-Button-ButtonBase-c50BI Button Button--iconOnly Button--invisible Button--small ml-1 prc-Button-IconButton-szpyj" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="default" aria-describedby=":R1ojfqtt5rab:-loading-announcement show-description-6ae6062" aria-labelledby="show-description-6ae6062"><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 class="Tooltip__StyledTooltip-sc-e45c7z-0 jOyaRH" data-direction="s" aria-label="Show description for 6ae6062" role="tooltip" aria-hidden="true" id="show-description-6ae6062">Show description for 6ae6062</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 hzFJAq pc-AvatarStack--three"><div class="Box-sc-g0xbh4-0 pc-AvatarStackBody" tabindex="0"> <img data-component="Avatar" class="pc-AvatarItem prc-Avatar-Avatar-ZRS-m" alt="dependabot[bot]" data-square="" width="16" height="16" style="--avatarSize-regular:16px" 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"/><img data-component="Avatar" class="pc-AvatarItem prc-Avatar-Avatar-ZRS-m" alt="gildesmarais" width="16" height="16" style="--avatarSize-regular:16px" src="https://avatars.githubusercontent.com/u/350021?v=4&amp;size=32" data-testid="commit-stack-avatar" data-hovercard-url="/users/gildesmarais/hovercard"/></div></span><div data-testid="author-link" class="Box-sc-g0xbh4-0 iCHGgS"><a class="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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="Box-sc-g0xbh4-0 jRhDJg prc-Link-Link-85e08" data-muted="true" 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><div class="Box-sc-g0xbh4-0 LoadingSkeleton-sc-695d630a-0 irPhWZ irithh d-none d-sm-flex ml-1" width="60px"></div><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=":Rbnfqtt5rab:" 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=":Rjnfqtt5rab:"><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></ul></div></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="Box-sc-g0xbh4-0 cQAMJB prc-Button-ButtonBase-c50BI fgColor-accent text-normal" data-loading="false" data-no-visuals="true" data-size="medium" data-variant="invisible" aria-describedby=":R39rab:-loading-announcement" href="/html2rss/html2rss-web/commits/master?before=5030b56631e7f293417b0bb47afe5551e8d494af+0"><span data-component="buttonContent" class="Box-sc-g0xbh4-0 gUkoLg prc-Button-ButtonContent-HKbr-"><span data-component="text" class="prc-Button-Label-pTQ3x">Previous</span></span></a><a type="button" tabindex="0" data-testid="pagination-next-button" class="prc-Button-ButtonBase-c50BI fgColor-accent text-normal" data-loading="false" data-size="medium" data-variant="invisible" aria-describedby=":R59rab:-loading-announcement" href="/html2rss/html2rss-web/commits/master?after=5030b56631e7f293417b0bb47afe5551e8d494af+34"><span data-component="buttonContent" data-align="center" class="prc-Button-ButtonContent-HKbr-"><span data-component="text" class="prc-Button-Label-pTQ3x">Next</span><span data-component="trailingVisual" class="prc-Button-Visual-2epfX prc-Button-VisualWrap-Db-eB"><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="mx-2" >
  <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="mx-2">
  <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: Mon, 23 Dec 2024 15:50:56 GMT +recorded_with: VCR 6.3.1 diff --git a/spec/html2rss/web/app/ssrf_filter_strategy_spec.rb b/spec/html2rss/web/app/ssrf_filter_strategy_spec.rb new file mode 100644 index 00000000..94a3492c --- /dev/null +++ b/spec/html2rss/web/app/ssrf_filter_strategy_spec.rb @@ -0,0 +1,29 @@ +# frozen_string_literal: true + +require 'spec_helper' +require_relative '../../../../app/ssrf_filter_strategy' + +RSpec.describe Html2rss::Web::SsrfFilterStrategy do + subject(:instance) { described_class.new(ctx) } + + let(:url) { 'http://example.com' } + let(:headers) { { 'User-Agent': 'Mozilla/5.0' } } + let(:ctx) { instance_double(Html2rss::RequestService::Context, url:, headers:) } + + describe '#execute' do + before do + allow(SsrfFilter).to receive(:get).with(url, headers:).and_return( + instance_double(Net::HTTPResponse, body: 'body', to_hash: { 'Content-Type' => ['text/html'] }) + ) + end + + it 'returns a response', :aggregate_failures do + response = instance.execute + + expect(SsrfFilter).to have_received(:get).with(url, headers:) + expect(response).to be_a(Html2rss::RequestService::Response) + expect(response.body).to eq('body') + expect(response.headers).to eq('Content-Type' => 'text/html') + end + end +end diff --git a/spec/html2rss/web/helpers/auto_source_spec.rb b/spec/html2rss/web/helpers/auto_source_spec.rb index e9e6b2df..dd285f1a 100644 --- a/spec/html2rss/web/helpers/auto_source_spec.rb +++ b/spec/html2rss/web/helpers/auto_source_spec.rb @@ -149,31 +149,4 @@ 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 - - before do - allow(SsrfFilter).to receive(:get).with(any_args).and_call_original - end - - let(:url) { 'https://github.com/html2rss/html2rss-web/commits/master' } - let(:encoded_url) { Base64.urlsafe_encode64(url) } - - it 'returns an RSS::Rss object' do - expect(feed).to be_a(RSS::Rss) - end - - it 'sets headers in the http request' do - feed - expect(SsrfFilter).to have_received(:get).with(Addressable::URI.parse(url), - headers: { - 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36' # rubocop:disable Layout/LineLength - }) - end - end end diff --git a/spec/routes/auto_source_spec.rb b/spec/routes/auto_source_spec.rb index c3a6c49c..378fad83 100644 --- a/spec/routes/auto_source_spec.rb +++ b/spec/routes/auto_source_spec.rb @@ -3,6 +3,7 @@ require 'spec_helper' require 'rss' require_relative '../../app' +require 'html2rss' RSpec.describe Html2rss::Web::App do # rubocop:disable RSpec/SpecFilePathFormat include Rack::Test::Methods @@ -11,6 +12,7 @@ def app = described_class let(:request_headers) do { 'HTTP_HOST' => 'localhost' } end + let(:encoded_url) { Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web/commits/master') } let(:username) { 'username' } let(:password) { 'password' } @@ -27,8 +29,7 @@ def app = described_class allow(Html2rss::Web::AutoSource).to receive_messages(enabled?: true, username:, password:, - allowed_origins: Set['localhost'], - build_auto_source_from_encoded_url: feed) + allowed_origins: Set['localhost']) end describe "GET '/auto_source/'" do @@ -66,18 +67,35 @@ def app = described_class describe "GET '/auto_source/:encoded_url'" do context 'with provided basic auth' do subject(:response) do - get "/auto_source/#{Base64.urlsafe_encode64('https://github.com/html2rss/html2rss-web')}", - {}, - request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password)) + VCR.use_cassette('auto_source-github-h2r-web') do + get "/auto_source/#{encoded_url}?strategy", + {}, + 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 '' - expect(response.get_header('cache-control')).to eq 'must-revalidate, private, max-age=3600' + 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 + + context 'when strategy is not registered' do + subject(:response) do + VCR.use_cassette('auto_source-github-h2r-web', match_requests_on: [:path]) do + get "/auto_source/#{encoded_url}?strategy=nope", + {}, + request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password)) + end + end + + it 'responds with Error', :aggregate_failures do + expect(response.status).to eq 422 + expect(response.body).to match(/UnknownStrategy/) + end + end end context 'when auto_source feature is disabled' do @@ -96,7 +114,7 @@ def app = described_class 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')}", + get "/auto_source/#{encoded_url}", {}, request_headers.merge('HTTP_AUTHORIZATION' => basic_authorize(username, password)) From fa12ab87e826ee8cc7bcece35fa2f7412b8a91fb Mon Sep 17 00:00:00 2001 From: Gil Desmarais Date: Mon, 23 Dec 2024 18:01:53 +0100 Subject: [PATCH 2/4] feat: add strategy selection to form --- public/auto_source.css | 14 ++++++++++++++ public/auto_source.js | 15 ++++++++++++--- views/auto_source/index.erb | 21 ++++++++++++++++++--- 3 files changed, 44 insertions(+), 6 deletions(-) diff --git a/public/auto_source.css b/public/auto_source.css index 00e6ae2a..beea8f5e 100644 --- a/public/auto_source.css +++ b/public/auto_source.css @@ -19,6 +19,20 @@ margin-right: 0; } +.auto_source > form label { + display: flex; + justify-content: center; + align-items: center; +} + +.auto_source > form label > span { + flex: 1; +} + +.auto_source > form label > input { + flex: 0; +} + .auto_source > nav { display: flex; flex-direction: column; diff --git a/public/auto_source.js b/public/auto_source.js index d4c1c06d..5eca7e93 100644 --- a/public/auto_source.js +++ b/public/auto_source.js @@ -93,7 +93,13 @@ const autoSource = (function () { if (this.isValidUrl(url)) { const encodedUrl = this.encodeUrl(url); - const autoSourceUrl = this.generateAutoSourceUrl(encodedUrl); + const params = {}; + const strategy = this.form?.querySelector('input[name="strategy"]:checked')?.value; + if (strategy) { + params["strategy"] = strategy; + } + + const autoSourceUrl = this.generateAutoSourceUrl(encodedUrl, params); this.rssUrlInput.value = autoSourceUrl; this.rssUrlInput.select(); @@ -132,9 +138,12 @@ const autoSource = (function () { * @param {string} encodedUrl - The base64 encoded URL. * @returns {string} The generated auto-source URL. */ - generateAutoSourceUrl(encodedUrl) { + generateAutoSourceUrl(encodedUrl, params = {}) { const baseUrl = new URL(window.location.origin); - return `${baseUrl}${BASE_PATH}/${encodedUrl}`; + + const url = new URL(`${baseUrl}${BASE_PATH}/${encodedUrl}`); + url.search = new URLSearchParams(params).toString(); + return url.toString(); } /** diff --git a/views/auto_source/index.erb b/views/auto_source/index.erb index 3bc2955a..04118b47 100644 --- a/views/auto_source/index.erb +++ b/views/auto_source/index.erb @@ -21,14 +21,29 @@ autocomplete="on" token-list="url" autofocus - required> + required + > + + <%- default_strategy_name = Html2rss::RequestService.default_strategy_name %> +
+ Strategy + <% Html2rss::RequestService.strategy_names.each do |strategy| %> + + <% end %> +