p_css 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20afa2206ed855fdd796f19179d06a8dc8b76231c223560d59e664cb43ddf897
-  data.tar.gz: e951f89d04ff6db6f68151ad05a414e4f0f7d05f2dfc48580b22ef31b6f949de
+  metadata.gz: c46687ed2138f367e3d83b51065e7faaeea99190ba035f47f0a9ad9ae7fabcbb
+  data.tar.gz: 773fb3861bb5f5c18bf5027327592477349747d7dde550d93b640add292c5b4b
 SHA512:
-  metadata.gz: dc533dd2a146654d7a622b3206568168bea1e404b163ef6b24ae1c841ef4cd5ff3a4621bc6794f64178ffd5c87a0c4e6a46f70fd6c7999a52539091849ae2941
-  data.tar.gz: 67d08837559466bc5713aa6a40d8e67030ff9389228527b4ed8b4bb5e1121965fa90a31e6cf5aae40167151e535ae83b9f6073068e72d495a5098559b331698d
+  metadata.gz: 161f1b01423d7389446bbc32bc2df68812f35423c2e8c4ab8b94493a02e2b7e1b032c2b94c6c60c1e0b11411117326ad68dda66d2ebe1c88a6ab0a13fe1aa30a
+  data.tar.gz: 71e99867725196832e2598d4b3e0ffb8e40f5aef62b36ce95fd2785a3eacf114113253206db2731764450d8e6fde5f3940bbef01b74286429e58da26d0fa6e73

data/README.md

@@ -185,8 +185,9 @@ CSS.matches?(active, 'ul > li:not(:first-child)')        # => true
 ```
 
 Stateful pseudo-classes (`:hover`, `:focus`, `:visited`, validity API states,
-etc.) deliberately return `false` — this matcher is intended for stateless
-analysis. `:has()` is not yet implemented (its argument is kept as opaque
+etc.) return `false` by default — there's no UA in the loop. Pass a `state:`
+Hash to opt in; see [Stateful pseudo-classes](#stateful-pseudo-classes)
+below. `:has()` is not yet implemented (its argument is kept as opaque
 component values).
 
 ### Nesting de-sugar
@@ -270,6 +271,60 @@ source order. Cascade layers, `@scope` proximity, and Shadow DOM
 encapsulation are not modeled — `@layer` / `@supports` / `@scope` /
 `@container` / `@starting-style` blocks are descended into unconditionally.
 
+### Stateful pseudo-classes
+
+`:hover`, `:focus`, `:focus-within`, `:focus-visible`, `:active`, `:visited`,
+and `:target` return `false` from the matcher by default. Pass a `state:`
+Hash to override:
+
+```ruby
+state = {
+  hover:           Set[hovered_element],   # match these and their ancestors
+  focus:           Set[focused_element],   # match only this element
+  'focus-within' => Set[el],               # propagates to ancestors
+  active:          true                    # match every element
+}
+
+CSS.matches?(element, ':hover', state: state)
+cascade.resolve(element, state: state)
+```
+
+Values:
+
+- `Set` or `Array` of elements — matches those elements (and, for
+  `:hover`, `:active`, `:focus-within`, their ancestors per Selectors §10)
+- `true` — matches every element
+- falsy / missing — default behavior; never matches
+
+Symbol and String keys are both accepted. Hyphenated names (`focus-within`,
+`focus-visible`) read more naturally as String keys.
+
+#### Limits of stateful matching
+
+The API gives you the primitives but not a policy. Two patterns are
+inherently hard:
+
+- **`hover: true` over-reveals.** Every `:hover`-gated rule matches every
+  element, so multiple dropdowns / popovers / menus all become "visible"
+  simultaneously. Useful for "is this element *potentially* visible
+  somehow?" but not for unique-match queries.
+
+- **Peer-row reveal patterns are unsolvable without mouse position.**
+  Stylesheets like `.row:hover .icon-copy { display: block }` reveal one
+  icon per row when its row is hovered. Per-candidate evaluation (giving
+  each candidate its own ancestor chain in the hover Set) doesn't break
+  the symmetry — every candidate sees its own `.row` ancestor as hovered
+  and reports itself visible. Real browsers disambiguate via the actual
+  mouse position; a headless analyzer can't reproduce that without the
+  test explicitly recording which element it treats as hovered (e.g. via
+  Capybara's `element.hover`).
+
+The recommendation for tools layered on top of p CSS: track explicit hover
+actions and pass the corresponding Set; for queries that depend on
+hover-based uniqueness without an explicit hover, treat them as fragile
+and disambiguate by `text:` / `id:` / data attributes instead of relying
+on stateful CSS.
+
 ### `urange`
 
 ```ruby

data/lib/css/cascade.rb

@@ -31,7 +31,11 @@ module CSS
     end
 
     # Returns Hash<String, Declaration> of winning declarations.
-    def resolve(element, inline_style: nil)
+    #
+    # `state:` opts into stateful-pseudo matching — see
+    # `Selectors::Matcher#matches?` for the shape. Defaults to the
+    # stateless behavior (`:hover`, `:focus`, etc. never match).
+    def resolve(element, inline_style: nil, state: nil)
       cache       = {}
       candidates  = collect_candidate_indexes(element, cache)
       order       = 0
@@ -39,7 +43,7 @@ module CSS
 
       candidates.each do |idx|
         entry = @entries[idx]
-        spec  = best_matching_specificity(element, entry.selector_pairs, cache)
+        spec  = best_matching_specificity(element, entry.selector_pairs, cache, state)
 
         next if spec.nil?
 
@@ -85,11 +89,11 @@ module CSS
     end
 
     def register_qualified_rule(rule, media_chain, out)
-      return unless media_chain.all? { MediaQueries::Evaluator.evaluate(it, @context) }
+      return unless media_chain.all? { MediaQueries::Evaluator.evaluate(_1, @context) }
 
       sl    = Selectors::Parser.parse_selector_list(rule.prelude)
-      pairs = sl.selectors.map { [it, Selectors::SpecificityCalculator.calculate(it)] }
-      decls = rule.block.items.select { it.is_a?(Nodes::Declaration) }
+      pairs = sl.selectors.map { [_1, Selectors::SpecificityCalculator.calculate(_1)] }
+      decls = rule.block.items.select { _1.is_a?(Nodes::Declaration) }
 
       out << RuleEntry.new(selector_pairs: pairs, declarations: decls)
     rescue ParseError
@@ -204,11 +208,11 @@ module CSS
       out
     end
 
-    def best_matching_specificity(element, selector_pairs, cache)
+    def best_matching_specificity(element, selector_pairs, cache, state)
       best = nil
 
       selector_pairs.each do |sel, spec|
-        next unless Selectors::Matcher.matches?(element, sel, cache: cache)
+        next unless Selectors::Matcher.matches?(element, sel, cache: cache, state: state)
 
         best = spec if best.nil? || spec > best
       end
@@ -255,9 +259,9 @@ module CSS
 
     def inline_declarations(style)
       case style
-      when String       then CSS.parse_block_contents(style).items.select { it.is_a?(Nodes::Declaration) }
-      when Nodes::Block then style.items.select { it.is_a?(Nodes::Declaration) }
-      when Array        then style.select        { it.is_a?(Nodes::Declaration) }
+      when String       then CSS.parse_block_contents(style).items.select { _1.is_a?(Nodes::Declaration) }
+      when Nodes::Block then style.items.select { _1.is_a?(Nodes::Declaration) }
+      when Array        then style.select        { _1.is_a?(Nodes::Declaration) }
       else
         raise ArgumentError, "cannot derive inline declarations from #{style.class}"
       end

data/lib/css/code_points.rb

@@ -14,7 +14,7 @@ module CSS
     def self.build_table(*ranges_or_ints)
       Array.new(128, false).tap {|a|
         ranges_or_ints.each {|r|
-          if r.is_a?(Range) then r.each { a[it] = true }
+          if r.is_a?(Range) then r.each { a[_1] = true }
           else                   a[r] = true
           end
         }

data/lib/css/media_queries/evaluator.rb

@@ -38,7 +38,7 @@ module CSS
       PREFIX_OP = {min: :ge, max: :le}.freeze
 
       def evaluate(query_list, context)
-        query_list.queries.any? { evaluate_query(it, context) }
+        query_list.queries.any? { evaluate_query(_1, context) }
       end
 
       private
@@ -65,8 +65,8 @@ module CSS
       def evaluate_condition(node, context)
         case node
         when MediaNot       then !evaluate_condition(node.operand, context)
-        when MediaAnd       then node.operands.all? { evaluate_condition(it, context) }
-        when MediaOr        then node.operands.any? { evaluate_condition(it, context) }
+        when MediaAnd       then node.operands.all? { evaluate_condition(_1, context) }
+        when MediaOr        then node.operands.any? { evaluate_condition(_1, context) }
         when MediaFeature   then evaluate_feature(node, context)
         when GeneralEnclosed then false
         else                      false

data/lib/css/nesting.rb

@@ -12,7 +12,7 @@ module CSS
     extend self
 
     def desugar(stylesheet)
-      Nodes::Stylesheet.new(rules: stylesheet.rules.flat_map { desugar_top_level(it) })
+      Nodes::Stylesheet.new(rules: stylesheet.rules.flat_map { desugar_top_level(_1) })
     end
 
     private
@@ -135,7 +135,7 @@ module CSS
 
     def contains_nesting?(complex_selector)
       complex_selector.compounds.any? {|c|
-        c.components.any? { it.is_a?(Selectors::NestingSelector) }
+        c.components.any? { _1.is_a?(Selectors::NestingSelector) }
       }
     end
 
@@ -159,7 +159,7 @@ module CSS
       replacement = Selectors::PseudoClass.new(name: 'is', argument: parent_list)
 
       Selectors::ComplexSelector.new(
-        compounds:   own_complex.compounds.map { swap_components_in_compound(it, replacement) },
+        compounds:   own_complex.compounds.map { swap_components_in_compound(_1, replacement) },
         combinators: own_complex.combinators
       )
     end

data/lib/css/parser.rb

@@ -321,7 +321,7 @@ module CSS
         end
       end
 
-      if value.any? { it.is_a?(SimpleBlock) && it.braced? }
+      if value.any? { _1.is_a?(SimpleBlock) && _1.braced? }
         @pos = saved
         return nil
       end

data/lib/css/selectors/matcher.rb

@@ -16,8 +16,9 @@ module CSS
     # protocol out of the box.
     #
     # Pseudo-classes that depend on user-agent state (`:hover`, `:focus`,
-    # `:visited`, validity-API states, `:fullscreen`, etc.) always return
-    # false; this matcher is intended for stateless analysis.
+    # `:visited`, etc.) return false by default; pass an explicit `state:`
+    # mapping to opt into stateful matching. Validity-API and viewport-
+    # only states (`:fullscreen`, `:valid`, …) are not exposed.
     module Matcher
       extend self
 
@@ -26,6 +27,16 @@ module CSS
       LINK_TAGS        = %w[a area link].freeze
       RO_INPUT_TYPES   = %w[hidden range color checkbox radio file submit image reset button].freeze
 
+      # User-agent state pseudos. The matcher returns `false` for these
+      # unless the caller passes a `state:` Hash describing which
+      # elements (or "all") should match.
+      STATEFUL_PSEUDOS = %w[hover focus focus-within focus-visible active visited target].to_set.freeze
+
+      # Per spec these states propagate up the ancestor chain — if a
+      # descendant is hovered/active/contains-focus, the ancestors
+      # share the state for selector-matching purposes.
+      PROPAGATING_STATEFUL_PSEUDOS = %w[hover active focus-within].to_set.freeze
+
       # Per-element cache used to avoid recomputing tag / id / class set
       # for every selector in a hot loop (e.g. `Cascade#resolve` against
       # hundreds of rules). Keyed by `Object#object_id`; only valid for
@@ -34,16 +45,16 @@ module CSS
 
       EMPTY_CLASS_SET = Set.new.freeze
 
-      def matches?(element, selector, cache: nil)
+      def matches?(element, selector, cache: nil, state: nil)
         sel = selector.is_a?(String) ? Parser.parse_selector_list(selector) : selector
 
         case sel
         when SelectorList
-          sel.selectors.any? { match_complex(element, it, cache) }
+          sel.selectors.any? { match_complex(element, _1, cache, state) }
         when ComplexSelector
-          match_complex(element, sel, cache)
+          match_complex(element, sel, cache, state)
         when CompoundSelector
-          match_compound(element, sel, cache)
+          match_compound(element, sel, cache, state)
         else
           raise ArgumentError, "expected a selector node or string, got #{sel.class}"
         end
@@ -54,32 +65,32 @@ module CSS
       # Walks the complex selector right-to-left starting at the rightmost
       # compound. Each combinator either succeeds against ancestors /
       # siblings of the current candidate or fails the whole match.
-      def match_complex(element, complex, cache)
-        match_at(element, complex, complex.compounds.size - 1, cache)
+      def match_complex(element, complex, cache, state)
+        match_at(element, complex, complex.compounds.size - 1, cache, state)
       end
 
-      def match_at(element, complex, index, cache)
+      def match_at(element, complex, index, cache, state)
         return false if element.nil?
-        return false unless match_compound(element, complex.compounds[index], cache)
+        return false unless match_compound(element, complex.compounds[index], cache, state)
         return true  if index.zero?
 
         prev = index - 1
 
         case complex.combinators[prev]
-        when :descendant         then walk_until_match(element, complex, prev, :parent_element, cache)
-        when :child              then match_at(parent_element(element), complex, prev, cache)
-        when :next_sibling       then match_at(previous_element(element), complex, prev, cache)
-        when :subsequent_sibling then walk_until_match(element, complex, prev, :previous_element, cache)
+        when :descendant         then walk_until_match(element, complex, prev, :parent_element,   cache, state)
+        when :child              then match_at(parent_element(element), complex, prev, cache, state)
+        when :next_sibling       then match_at(previous_element(element), complex, prev, cache, state)
+        when :subsequent_sibling then walk_until_match(element, complex, prev, :previous_element, cache, state)
         end
       end
 
       # Steps along the DOM via `direction` until a candidate matches the
       # remaining complex selector or the chain runs out.
-      def walk_until_match(element, complex, index, direction, cache)
+      def walk_until_match(element, complex, index, direction, cache, state)
         candidate = send(direction, element)
 
         while candidate
-          return true if match_at(candidate, complex, index, cache)
+          return true if match_at(candidate, complex, index, cache, state)
 
           candidate = send(direction, candidate)
         end
@@ -87,18 +98,18 @@ module CSS
         false
       end
 
-      def match_compound(element, compound, cache)
-        compound.components.all? { match_simple(element, it, cache) }
+      def match_compound(element, compound, cache, state)
+        compound.components.all? { match_simple(element, _1, cache, state) }
       end
 
-      def match_simple(element, simple, cache)
+      def match_simple(element, simple, cache, state)
         case simple
         when TypeSelector      then tag_of(element, cache).casecmp?(simple.name)
         when UniversalSelector then true
         when IdSelector        then id_of(element, cache) == simple.name
         when ClassSelector     then classes_of(element, cache).include?(simple.name)
         when AttributeSelector then match_attribute(element, simple)
-        when PseudoClass       then match_pseudo_class(element, simple, cache)
+        when PseudoClass       then match_pseudo_class(element, simple, cache, state)
         when PseudoElement     then false
         when NestingSelector   then false
         else                        false
@@ -172,10 +183,14 @@ module CSS
 
       # Pseudo-class matching -------------------------------------------
 
-      def match_pseudo_class(element, pc, cache)
-        case pc.name.downcase
-        when 'is', 'where', 'matches'   then match_selector_list_arg(element, pc.argument, cache)
-        when 'not'                       then negate_selector_list_arg(element, pc.argument, cache)
+      def match_pseudo_class(element, pc, cache, state)
+        name = pc.name.downcase
+
+        return match_stateful_pseudo?(name, element, state) if STATEFUL_PSEUDOS.include?(name)
+
+        case name
+        when 'is', 'where', 'matches'   then match_selector_list_arg(element, pc.argument, cache, state)
+        when 'not'                       then negate_selector_list_arg(element, pc.argument, cache, state)
         when 'has'                       then false
         when 'root'                      then parent_element(element).nil?
         when 'scope'                     then parent_element(element).nil?
@@ -206,12 +221,40 @@ module CSS
         end
       end
 
-      def match_selector_list_arg(element, arg, cache)
-        arg.is_a?(SelectorList) && matches?(element, arg, cache: cache)
+      # `:hover` / `:active` / `:focus-within` propagate up the ancestor
+      # chain per Selectors §10 — the Set members are the *source* nodes
+      # (e.g. the deepest hovered element) and any of their ancestors
+      # also matches. Other stateful pseudos match only the explicit
+      # elements in the Set.
+      def match_stateful_pseudo?(name, element, state)
+        return false if state.nil?
+
+        value = state[name.to_sym] || state[name]
+
+        return false   if value.nil? || value == false
+        return true    if value == true
+
+        return value.include?(element) unless PROPAGATING_STATEFUL_PSEUDOS.include?(name)
+
+        value.each do |source|
+          cur = source
+
+          while cur
+            return true if cur == element
+
+            cur = parent_element(cur)
+          end
+        end
+
+        false
+      end
+
+      def match_selector_list_arg(element, arg, cache, state)
+        arg.is_a?(SelectorList) && matches?(element, arg, cache: cache, state: state)
       end
 
-      def negate_selector_list_arg(element, arg, cache)
-        arg.is_a?(SelectorList) && !matches?(element, arg, cache: cache)
+      def negate_selector_list_arg(element, arg, cache, state)
+        arg.is_a?(SelectorList) && !matches?(element, arg, cache: cache, state: state)
       end
 
       def match_nth(element, anb, of_type:, from_end:)
@@ -238,10 +281,10 @@ module CSS
         return nil if p.nil?
 
         siblings = element_children(p)
-        siblings = siblings.select { tag(it).casecmp?(tag(element)) } if of_type
+        siblings = siblings.select { tag(_1).casecmp?(tag(element)) } if of_type
         siblings = siblings.reverse if from_end
 
-        idx = siblings.index { same_node?(it, element) }
+        idx = siblings.index { same_node?(_1, element) }
         idx && idx + 1
       end
 
@@ -273,7 +316,7 @@ module CSS
       end
 
       def inside_first_legend?(element, fieldset)
-        first_legend = element_children(fieldset).find { tag(it) == 'legend' }
+        first_legend = element_children(fieldset).find { tag(_1) == 'legend' }
 
         return false if first_legend.nil?
 
@@ -384,7 +427,7 @@ module CSS
       def ident_argument(argument)
         return nil unless argument.is_a?(Array)
 
-        token = argument.find { it.is_a?(Token) && (it.type == :ident || it.type == :string) }
+        token = argument.find { _1.is_a?(Token) && (_1.type == :ident || _1.type == :string) }
         token&.value
       end
 

data/lib/css/selectors/serializer.rb

@@ -21,9 +21,9 @@ module CSS
 
       def serialize(node)
         case node
-        when SelectorList      then node.selectors.map { serialize(it) }.join(', ')
+        when SelectorList      then node.selectors.map { serialize(_1) }.join(', ')
         when ComplexSelector   then serialize_complex(node)
-        when CompoundSelector  then node.components.map { serialize(it) }.join
+        when CompoundSelector  then node.components.map { serialize(_1) }.join
         when TypeSelector      then Escape.ident(node.name)
         when UniversalSelector then '*'
         when NestingSelector   then '&'

data/lib/css/selectors/specificity.rb

@@ -41,7 +41,7 @@ module CSS
 
       def calculate(node)
         case node
-        when SelectorList     then node.selectors.map { calculate(it) }.max || Specificity::ZERO
+        when SelectorList     then node.selectors.map { calculate(_1) }.max || Specificity::ZERO
         when ComplexSelector  then sum(node.compounds)
         when CompoundSelector then sum(node.components)
         when IdSelector       then Specificity.new(a: 1, b: 0, c: 0)
@@ -59,7 +59,7 @@ module CSS
       private
 
       def sum(items)
-        items.map { calculate(it) }.reduce(Specificity::ZERO, :+)
+        items.map { calculate(_1) }.reduce(Specificity::ZERO, :+)
       end
 
       def specificity_of_pseudo_class(node)

data/lib/css/serializer.rb

@@ -21,7 +21,7 @@ module CSS
       when Nodes::SimpleBlock   then serialize_simple_block(node)
       when Token                then serialize_token(node)
       when Selectors::Node      then Selectors::Serializer.serialize(node)
-      when Array                then node.map { serialize(it) }.join
+      when Array                then node.map { serialize(_1) }.join
       else
         raise ArgumentError, "cannot serialize #{node.class}"
       end
@@ -30,7 +30,7 @@ module CSS
     private
 
     def serialize_stylesheet(ss)
-      ss.rules.map { serialize(it) }.join("\n")
+      ss.rules.map { serialize(_1) }.join("\n")
     end
 
     def serialize_at_rule(rule)
@@ -49,7 +49,7 @@ module CSS
     def serialize_block(block)
       return '{}' if block.items.empty?
 
-      inner = block.items.map { serialize(it) }.join("\n")
+      inner = block.items.map { serialize(_1) }.join("\n")
       "{\n#{indent(inner)}\n}"
     end
 
@@ -159,8 +159,8 @@ module CSS
     def serialize_string(s) = Escape.string(s)
 
     def indent(str)
-      str.lines.map { "#{INDENT}#{it}" }.join.then {
-        it.end_with?("\n") ? it.chomp : it
+      str.lines.map { "#{INDENT}#{_1}" }.join.then {
+        _1.end_with?("\n") ? _1.chomp : _1
       }
     end
   end

data/lib/css/token.rb

@@ -93,7 +93,7 @@ module CSS
     private
 
     def compute_position
-      idx     = @newlines.bsearch_index { it >= @start_offset } || @newlines.size
+      idx     = @newlines.bsearch_index { _1 >= @start_offset } || @newlines.size
       prev_nl = idx.zero? ? -1 : @newlines[idx - 1]
 
       Position.new(

data/lib/css/version.rb

@@ -1,3 +1,3 @@
 module CSS
-  VERSION = '0.1.4'
+  VERSION = '0.1.6'
 end

data/lib/css.rb

@@ -50,7 +50,7 @@ module CSS
 
     def specificity(selector) = Selectors::SpecificityCalculator.calculate(selector)
 
-    def matches?(element, selector) = Selectors::Matcher.matches?(element, selector)
+    def matches?(element, selector, state: nil) = Selectors::Matcher.matches?(element, selector, state: state)
 
     def parse_media_query_list(input) = MediaQueries::Parser.parse(input)
 

data/sig/css/cascade.rbs

@@ -17,6 +17,6 @@ module CSS
     # Returns Hash<String, Declaration> of winning declarations after
     # !important > inline > stylesheet > specificity > source-order
     # sorting.
-    def resolve: (untyped element, ?inline_style: inline_style?) -> Hash[String, Nodes::Declaration]
+    def resolve: (untyped element, ?inline_style: inline_style?, ?state: matcher_state?) -> Hash[String, Nodes::Declaration]
   end
 end

data/sig/css/selectors.rbs

@@ -151,7 +151,10 @@ module CSS
     end
 
     module Matcher
-      def self.matches?: (untyped element, untyped selector, ?cache: Hash[Integer, untyped]) -> bool
+      STATEFUL_PSEUDOS: Set[String]
+      PROPAGATING_STATEFUL_PSEUDOS: Set[String]
+
+      def self.matches?: (untyped element, untyped selector, ?cache: Hash[Integer, untyped], ?state: matcher_state?) -> bool
 
       def self.tag_of: (untyped element, ?Hash[Integer, untyped]?) -> String
       def self.id_of: (untyped element, ?Hash[Integer, untyped]?) -> String?

data/sig/css.rbs

@@ -68,7 +68,12 @@ module CSS
 
   type selector = Selectors::SelectorList | Selectors::ComplexSelector | Selectors::CompoundSelector
 
-  def self.matches?: (untyped element, String | selector selector, ?cache: Hash[Integer, untyped]) -> bool
+  # Per-pseudo state. Keys are pseudo-class names (Symbol or String);
+  # values are `true` (match every element), a `Set` / `Array` of the
+  # specific elements in that state, or falsy (no match).
+  type matcher_state = Hash[Symbol | String, bool | Set[untyped] | Array[untyped]]
+
+  def self.matches?: (untyped element, String | selector selector, ?cache: Hash[Integer, untyped], ?state: matcher_state?) -> bool
 
   # Media queries (Media Queries 4)
   # ---------------------------------------------------------------

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p_css
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Keita Urashima
@@ -66,7 +66,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.4'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="