p_css 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e5c2f5073fa34e7847e6ce57005acbd33a912c544b6ea6971f8c50fc6f9f416
-  data.tar.gz: 4b6de8fb7d7919fafdc4e4ba249024d022c628675c0ecc66d65cba85f6132b51
+  metadata.gz: df1cd693075fe04da6a0c9ce4c65c9c4ef5f85c5b84bb82bd0136cf62fe52552
+  data.tar.gz: 9a9fc875c3872c49396c5b6c753a099ba3cc344efa7aa97745958d277630c7cb
 SHA512:
-  metadata.gz: ee478932c614e644236fe532663bf781c72397795db988ea34c92ff02a7659da0e076a2f547397f94b6500168b4fafa9071b728d0dd38b05075dfcf5589201fa
-  data.tar.gz: 9b87600e33a0500fd61c0b919e4709795a0cea47755eded8f343adb5341ee4c47a49b5197429cd443102adc88b0ebbcfdb2ee26a7e2a3133387c3650daae44fe
+  metadata.gz: 28c76784dac592aa39cfaa5100b69e4765861ec2ab1ed536fb95dfb963481de2bd64d6b6b954f71b14b17ea4a328cc65af6f7a63df662f2083c2ef5ec623e892
+  data.tar.gz: 291d12b999205c032e7cebaa5da4b69aff717cb9f7b9743c3c54ce99539b59ec49612b87e9bcf105d374cc79871d8955fc57f18200b8ba76c396894db14f349f

data/lib/css/cascade.rb

@@ -115,9 +115,8 @@ module CSS
     # Index
     # ----------------------------------------------------------------
 
-    Index = Data.define(:by_id, :by_class, :by_tag, :universal)
-
-    EMPTY_INDEXES = [].freeze
+    Index     = Data.define(:by_id, :by_class, :by_tag, :universal)
+    AnchorKey = Data.define(:kind, :name)
 
     def build_index(entries)
       by_id     = {}
@@ -126,19 +125,19 @@ module CSS
       universal = []
 
       entries.each_with_index do |entry, idx|
-        keys = Set.new
+        seen = Set.new
 
         entry.selector_pairs.each do |sel, _spec|
           key = anchor_key(sel)
 
-          next if keys.include?(key)
+          next if seen.include?(key)
 
-          keys << key
+          seen << key
 
-          case key.first
-          when :id        then (by_id[key.last]    ||= []) << idx
-          when :class     then (by_class[key.last] ||= []) << idx
-          when :tag       then (by_tag[key.last]   ||= []) << idx
+          case key.kind
+          when :id        then (by_id[key.name]    ||= []) << idx
+          when :class     then (by_class[key.name] ||= []) << idx
+          when :tag       then (by_tag[key.name]   ||= []) << idx
           when :universal then universal                   << idx
           end
         end
@@ -158,44 +157,51 @@ module CSS
     # they will be tested against every element, but real-world
     # stylesheets rarely have many such rules.
     def anchor_key(complex_selector)
-      compound = complex_selector.compounds.last
-
-      compound.components.each do |c|
-        return [:id, c.name] if c.is_a?(Selectors::IdSelector)
-      end
-      compound.components.each do |c|
-        return [:class, c.name] if c.is_a?(Selectors::ClassSelector)
-      end
-      compound.components.each do |c|
-        return [:tag, c.name.downcase] if c.is_a?(Selectors::TypeSelector)
+      class_name = nil
+      tag_name   = nil
+
+      complex_selector.compounds.last.components.each do |c|
+        case c
+        when Selectors::IdSelector    then return AnchorKey.new(kind: :id, name: c.name)
+        when Selectors::ClassSelector then class_name ||= c.name
+        when Selectors::TypeSelector  then tag_name   ||= c.name.downcase
+        end
       end
 
-      [:universal]
+      return AnchorKey.new(kind: :class, name: class_name) if class_name
+      return AnchorKey.new(kind: :tag,   name: tag_name)   if tag_name
+
+      AnchorKey.new(kind: :universal, name: nil)
     end
 
     # Resolve helpers
     # ----------------------------------------------------------------
 
+    # Buckets are appended in source-order at compile time, so each is
+    # already sorted ascending and unique. Concatenating them and using
+    # `sort! + uniq!` is cheaper than going through a `Set`: integers
+    # sort in C, and `uniq!` on a sorted array only removes adjacent
+    # duplicates.
     def collect_candidate_indexes(element, cache)
-      seen = Set.new
+      out = []
 
-      el_id = Selectors::Matcher.id_of(element, cache)
+      el_id  = Selectors::Matcher.id_of(element, cache)
+      bucket = @index.by_id[el_id] if el_id
 
-      if el_id && (bucket = @index.by_id[el_id])
-        seen.merge(bucket)
-      end
+      out.concat(bucket) if bucket
 
       Selectors::Matcher.classes_of(element, cache).each do |cls|
         bucket = @index.by_class[cls]
-        seen.merge(bucket) if bucket
+        out.concat(bucket) if bucket
       end
 
-      tag_bucket = @index.by_tag[Selectors::Matcher.tag_of(element, cache)]
-      seen.merge(tag_bucket) if tag_bucket
+      bucket = @index.by_tag[Selectors::Matcher.tag_of(element, cache)]
+      out.concat(bucket) if bucket
 
-      seen.merge(@index.universal)
-
-      seen.to_a.sort!
+      out.concat(@index.universal)
+      out.sort!
+      out.uniq!
+      out
     end
 
     def best_matching_specificity(element, selector_pairs, cache)

data/lib/css/selectors/matcher.rb

@@ -30,7 +30,7 @@ module CSS
       # for every selector in a hot loop (e.g. `Cascade#resolve` against
       # hundreds of rules). Keyed by `Object#object_id`; only valid for
       # the duration of a single matcher invocation.
-      Context = Struct.new(:tag, :id, :classes, keyword_init: true)
+      Context = Data.define(:tag, :id, :classes)
 
       EMPTY_CLASS_SET = Set.new.freeze
 
@@ -425,10 +425,6 @@ module CSS
         element[lower]
       end
 
-      def class_list(element)
-        attr(element, 'class').to_s.split(/\s+/)
-      end
-
       def parent_element(element)
         p = element.respond_to?(:parent) ? element.parent : nil
 

data/lib/css/tokenizer.rb

@@ -1,6 +1,10 @@
 module CSS
   # Tokenizer based on CSS Syntax Module Level 3/4 §4.
   # https://www.w3.org/TR/css-syntax-3/#tokenization
+  #
+  # Not thread-safe: an instance carries mutable cursors (`@pos`,
+  # `@newline_cursor`) that advance over the input. Allocate one
+  # tokenizer per thread.
   class Tokenizer
     include CodePoints
 
@@ -21,9 +25,10 @@ module CSS
     PREPROCESS_RE = /\r\n?|\f|\0/.freeze
 
     def initialize(input, preserve_comments: false)
-      @input             = preprocess(input)
+      @chars             = preprocess(input)
       @pos               = 0
-      @newlines          = collect_newline_offsets(@input)
+      @newlines          = collect_newline_offsets(@chars)
+      @newline_cursor    = 0
       @preserve_comments = preserve_comments
     end
 
@@ -43,7 +48,7 @@ module CSS
     def next_token
       consume_comments unless @preserve_comments
 
-      return Token.new(:eof) if @pos >= @input.length
+      return Token.new(:eof) if @pos >= @chars.length
 
       start_offset = @pos
       tok          = consume_one_token
@@ -127,18 +132,25 @@ module CSS
       end
     end
 
+    # Random access on a non-ascii-only UTF-8 String is O(distance from
+    # the cached character index), and the peek-ahead pattern (`peek`,
+    # `peek(1)`, `peek(2)`) defeats the cache — empirically ~200× slower
+    # than indexing a flat Array. Splitting into `chars` once amortizes
+    # the UTF-8 walk and gives us O(1) random access for the rest of
+    # tokenization.
     def preprocess(input)
-      input.encode('UTF-8').gsub(PREPROCESS_RE) {
-        $~[0] == "\0" ? CodePoints::REPLACEMENT : "\n"
-      }
+      input
+        .encode('UTF-8')
+        .gsub(PREPROCESS_RE) { $~[0] == "\0" ? CodePoints::REPLACEMENT : "\n" }
+        .chars
     end
 
     def peek(offset = 0)
-      @input[@pos + offset]
+      @chars[@pos + offset]
     end
 
     def consume
-      c = @input[@pos]
+      c = @chars[@pos]
       return nil if c.nil?
 
       @pos += 1
@@ -149,21 +161,34 @@ module CSS
       @pos -= 1
     end
 
-    def collect_newline_offsets(input)
+    def collect_newline_offsets(chars)
       offsets = []
-      i       = -1
+      i       = 0
+      n       = chars.length
+
+      while i < n
+        offsets << i if chars[i] == "\n"
+        i += 1
+      end
 
-      offsets << i while (i = input.index("\n", i + 1))
       offsets
     end
 
-    # Newline characters themselves are reported as belonging to the line
-    # they terminate (col = offset + 1 on line 1, etc).
+    # Newline characters themselves are reported as belonging to the
+    # line they terminate (col = offset + 1 on line 1, etc).
+    #
+    # Tokens are emitted in order, so the offsets passed in are
+    # monotonically non-decreasing. We keep a running cursor into
+    # `@newlines` and advance linearly — amortized O(1) per call,
+    # vs. O(log n) per call with a fresh `bsearch`.
     def line_column_at(offset)
-      idx     = @newlines.bsearch_index { it >= offset } || @newlines.size
-      prev_nl = idx.zero? ? -1 : @newlines[idx - 1]
+      while @newline_cursor < @newlines.size && @newlines[@newline_cursor] < offset
+        @newline_cursor += 1
+      end
+
+      prev_nl = @newline_cursor.zero? ? -1 : @newlines[@newline_cursor - 1]
 
-      [idx + 1, offset - prev_nl]
+      [@newline_cursor + 1, offset - prev_nl]
     end
 
     def whitespace?(c)
@@ -242,7 +267,7 @@ module CSS
     end
 
     def eof?
-      @pos >= @input.length
+      @pos >= @chars.length
     end
 
     def consume_whitespace

data/lib/css/version.rb

@@ -1,3 +1,3 @@
 module CSS
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/sig/css/cascade.rbs

@@ -0,0 +1,22 @@
+module CSS
+  # See `CSS.cascade` for the typical entry point.
+  class Cascade
+    type inline_style = String | Nodes::Block | Array[Nodes::Declaration]
+
+    class Match < Data
+      attr_reader declaration: Nodes::Declaration
+      attr_reader specificity: Selectors::Specificity
+      attr_reader inline: bool
+      attr_reader order: Integer
+
+      def self.new: (declaration: Nodes::Declaration, specificity: Selectors::Specificity, inline: bool, order: Integer) -> Match
+    end
+
+    def initialize: (Nodes::Stylesheet stylesheet, ?context: MediaQueries::Context) -> void
+
+    # 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]
+  end
+end

data/sig/css/media_queries.rbs

@@ -0,0 +1,107 @@
+module CSS
+  module MediaQueries
+    module Node
+    end
+
+    type modifier = :not | :only
+
+    type comparison_op = :eq | :lt | :le | :gt | :ge
+
+    type media_condition = MediaNot | MediaAnd | MediaOr | MediaFeature | GeneralEnclosed
+
+    type feature_value = Token | Ratio
+
+    class MediaQueryList < Data
+      include Node
+
+      attr_reader queries: Array[MediaQuery]
+
+      def self.new: (queries: Array[MediaQuery]) -> MediaQueryList
+    end
+
+    class MediaQuery < Data
+      include Node
+
+      attr_reader modifier: modifier?
+      attr_reader type: String?
+      attr_reader condition: media_condition?
+
+      def self.new: (modifier: modifier?, type: String?, condition: media_condition?) -> MediaQuery
+    end
+
+    class MediaNot < Data
+      include Node
+
+      attr_reader operand: media_condition
+
+      def self.new: (operand: media_condition) -> MediaNot
+    end
+
+    class MediaAnd < Data
+      include Node
+
+      attr_reader operands: Array[media_condition]
+
+      def self.new: (operands: Array[media_condition]) -> MediaAnd
+    end
+
+    class MediaOr < Data
+      include Node
+
+      attr_reader operands: Array[media_condition]
+
+      def self.new: (operands: Array[media_condition]) -> MediaOr
+    end
+
+    # `op` is `nil` for boolean form (`(color)`), `:eq` for plain
+    # (`(min-width: 600px)`) and explicit `=`, otherwise a comparison.
+    # `value` mirrors that — `nil` for boolean form.
+    class MediaFeature < Data
+      include Node
+
+      attr_reader name: String
+      attr_reader op: comparison_op?
+      attr_reader value: feature_value?
+
+      def self.new: (name: String, op: comparison_op?, value: feature_value?) -> MediaFeature
+    end
+
+    class GeneralEnclosed < Data
+      include Node
+
+      attr_reader tokens: Array[component_value]
+
+      def self.new: (tokens: Array[component_value]) -> GeneralEnclosed
+    end
+
+    class Ratio < Data
+      include Node
+
+      attr_reader numerator: Numeric
+      attr_reader denominator: Numeric
+
+      def self.new: (numerator: Numeric, denominator: Numeric) -> Ratio
+
+      def to_f: () -> Float
+    end
+
+    # User-agent context against which a `MediaQueryList` is evaluated.
+    # `features` is keyed by feature name (no `min-`/`max-` prefix);
+    # values follow Media Queries 4 conventions (lengths in CSS px,
+    # resolution in `dppx`, identifiers as Strings, booleans as 1/0).
+    class Context < Data
+      DEFAULTS: Hash[String, untyped]
+
+      attr_reader features: Hash[String, untyped]
+
+      def self.new: (features: Hash[String, untyped]) -> Context
+
+      # `Context.default('width' => 1200, 'prefers-color-scheme' => 'dark')`
+      def self.default: (**untyped overrides) -> Context
+
+      def []: ((String | Symbol) name) -> untyped
+      def media_type: () -> String
+      def with: (**untyped overrides) -> Context
+    end
+  end
+end

data/sig/css/nodes.rbs

@@ -0,0 +1,76 @@
+module CSS
+  module Nodes
+    # `Token` here covers preserved comments when the stylesheet was
+    # parsed with `preserve_comments: true`.
+    type rule = AtRule | QualifiedRule | Token
+
+    type block_item = Declaration | QualifiedRule | AtRule | Token
+
+    class Stylesheet < Data
+      attr_reader rules: Array[rule]
+
+      def self.new: (rules: Array[rule]) -> Stylesheet
+    end
+
+    # `prelude` is the list of component values before `{` or `;`;
+    # `block` is `nil` for at-rules ending with `;` (e.g. `@charset "UTF-8";`).
+    class AtRule < Data
+      attr_reader name: String
+      attr_reader prelude: Array[component_value]
+      attr_reader block: Block?
+
+      def self.new: (name: String, prelude: Array[component_value], block: Block?) -> AtRule
+    end
+
+    class QualifiedRule < Data
+      attr_reader prelude: Array[component_value]
+      attr_reader block: Block
+
+      def self.new: (prelude: Array[component_value], block: Block) -> QualifiedRule
+    end
+
+    class Block < Data
+      attr_reader items: Array[block_item]
+
+      def self.new: (items: Array[block_item]) -> Block
+    end
+
+    class Declaration < Data
+      attr_reader name: String
+      attr_reader value: Array[component_value]
+      attr_reader important: bool
+
+      def self.new: (name: String, value: Array[component_value], important: bool) -> Declaration
+    end
+
+    class Function < Data
+      attr_reader name: String
+      attr_reader value: Array[component_value]
+
+      def self.new: (name: String, value: Array[component_value]) -> Function
+    end
+
+    # `open` is one of `(`, `[`, `{`.
+    class SimpleBlock < Data
+      attr_reader open: String
+      attr_reader value: Array[component_value]
+
+      def self.new: (open: String, value: Array[component_value]) -> SimpleBlock
+
+      def braced?: () -> bool
+      def bracketed?: () -> bool
+      def parenthesized?: () -> bool
+    end
+
+    # Inclusive code-point range produced by `CSS.parse_urange`.
+    class UnicodeRange < Data
+      attr_reader first: Integer
+      attr_reader last: Integer
+
+      def self.new: (first: Integer, last: Integer) -> UnicodeRange
+
+      def cover?: (Integer cp) -> bool
+      def to_s: () -> String
+    end
+  end
+end

data/sig/css/selectors.rbs

@@ -0,0 +1,161 @@
+module CSS
+  module Selectors
+    # Marker module included by every Selector AST node so callers can
+    # discriminate `Selectors::Node` from raw component values.
+    module Node
+    end
+
+    type combinator = :descendant | :child | :next_sibling | :subsequent_sibling
+
+    type simple_selector =
+      TypeSelector | UniversalSelector | NestingSelector
+      | IdSelector | ClassSelector | AttributeSelector
+      | PseudoClass | PseudoElement
+
+    type attribute_matcher = :exact | :includes | :dash | :prefix | :suffix | :substring
+
+    type case_flag = :i | :s
+
+    # `argument` is `nil` for plain `:hover` etc., a `SelectorList` for
+    # `:not / :is / :where / :matches`, an `AnB` for `:nth-*`, or an
+    # opaque component-value array for unrecognized functional pseudos
+    # (including `:has`, which is intentionally not parsed as a selector
+    # list yet).
+    type pseudo_argument = nil | SelectorList | AnB | Array[component_value]
+
+    class SelectorList < Data
+      include Node
+
+      attr_reader selectors: Array[ComplexSelector]
+
+      def self.new: (selectors: Array[ComplexSelector]) -> SelectorList
+
+      def to_s: () -> String
+    end
+
+    # `compounds.size == combinators.size + 1`. `combinators[i]` joins
+    # `compounds[i]` to `compounds[i + 1]`.
+    class ComplexSelector < Data
+      include Node
+
+      attr_reader compounds: Array[CompoundSelector]
+      attr_reader combinators: Array[combinator]
+
+      def self.new: (compounds: Array[CompoundSelector], combinators: Array[combinator]) -> ComplexSelector
+
+      def to_s: () -> String
+    end
+
+    class CompoundSelector < Data
+      include Node
+
+      attr_reader components: Array[simple_selector]
+
+      def self.new: (components: Array[simple_selector]) -> CompoundSelector
+
+      def to_s: () -> String
+    end
+
+    class TypeSelector < Data
+      include Node
+
+      attr_reader name: String
+
+      def self.new: (name: String) -> TypeSelector
+    end
+
+    class UniversalSelector < Data
+      include Node
+
+      def self.new: () -> UniversalSelector
+    end
+
+    class NestingSelector < Data
+      include Node
+
+      def self.new: () -> NestingSelector
+    end
+
+    class IdSelector < Data
+      include Node
+
+      attr_reader name: String
+
+      def self.new: (name: String) -> IdSelector
+    end
+
+    class ClassSelector < Data
+      include Node
+
+      attr_reader name: String
+
+      def self.new: (name: String) -> ClassSelector
+    end
+
+    class AttributeSelector < Data
+      include Node
+
+      attr_reader name: String
+      attr_reader matcher: attribute_matcher?
+      attr_reader value: String?
+      attr_reader case_flag: case_flag?
+
+      def self.new: (name: String, matcher: attribute_matcher?, value: String?, case_flag: case_flag?) -> AttributeSelector
+    end
+
+    class PseudoClass < Data
+      include Node
+
+      attr_reader name: String
+      attr_reader argument: pseudo_argument
+
+      def self.new: (name: String, argument: pseudo_argument) -> PseudoClass
+    end
+
+    class PseudoElement < Data
+      include Node
+
+      attr_reader name: String
+      attr_reader argument: pseudo_argument
+
+      def self.new: (name: String, argument: pseudo_argument) -> PseudoElement
+    end
+
+    class AnB < Data
+      include Node
+
+      attr_reader step: Integer
+      attr_reader offset: Integer
+
+      def self.new: (step: Integer, offset: Integer) -> AnB
+
+      def to_s: () -> String
+    end
+
+    # Selectors §16 specificity tuple `(a, b, c)` — id / class+attr+pseudo /
+    # type+pseudo-element counts.
+    class Specificity < Data
+      include Comparable
+
+      ZERO: Specificity
+
+      attr_reader a: Integer
+      attr_reader b: Integer
+      attr_reader c: Integer
+
+      def self.new: (a: Integer, b: Integer, c: Integer) -> Specificity
+
+      def <=>: (untyped other) -> Integer?
+      def +: (Specificity other) -> Specificity
+      def to_s: () -> String
+    end
+
+    module Matcher
+      def self.matches?: (untyped element, untyped selector, ?cache: Hash[Integer, untyped]) -> bool
+
+      def self.tag_of: (untyped element, ?Hash[Integer, untyped]?) -> String
+      def self.id_of: (untyped element, ?Hash[Integer, untyped]?) -> String?
+      def self.classes_of: (untyped element, ?Hash[Integer, untyped]?) -> Set[String]
+    end
+  end
+end

data/sig/css/token.rbs

@@ -0,0 +1,33 @@
+module CSS
+  class Token
+    TYPES: Array[Symbol]
+
+    type token_type =
+      :ident | :function | :at_keyword | :hash | :string | :bad_string
+      | :url | :bad_url | :delim | :number | :percentage | :dimension
+      | :whitespace | :cdo | :cdc | :comment
+      | :colon | :semicolon | :comma
+      | :lbracket | :rbracket | :lparen | :rparen | :lbrace | :rbrace
+      | :eof
+
+    attr_reader type: token_type
+    attr_reader value: untyped
+    attr_reader flag: Symbol?
+    attr_reader unit: String?
+    attr_reader position: Position?
+
+    def initialize: (token_type type, ?untyped value, ?flag: Symbol?, ?unit: String?, ?position: Position?) -> void
+
+    def whitespace?: () -> bool
+    def comment?: () -> bool
+    def trivia?: () -> bool
+
+    def assign_position!: (Position pos) -> self
+
+    def ==: (untyped other) -> bool
+    def eql?: (untyped other) -> bool
+    def hash: () -> Integer
+
+    def inspect: () -> String
+  end
+end

data/sig/css.rbs

@@ -0,0 +1,94 @@
+# CSS Syntax Level 4 toolkit — top-level entry points and shared types.
+#
+# Public API surface lives directly on `CSS`; AST nodes live under
+# `CSS::Nodes`, `CSS::Selectors`, and `CSS::MediaQueries`. Per-token
+# source positions are `CSS::Position`.
+module CSS
+  # Inputs that carry CSS source. `String` is tokenized internally; an
+  # array of component values (as produced by `CSS.parse_component_values`
+  # or by reading a rule's `prelude`) is consumed structurally.
+  type input = String | Array[component_value]
+
+  # The output of `CSS.parse_component_value` and the element type of a
+  # rule's `prelude` / declaration's `value`.
+  type component_value = Token | Nodes::Function | Nodes::SimpleBlock
+
+  # Bracket-pair information used by both the parser (open token type →
+  # open char, close token type) and the serializer.
+  BRACKET_OPEN_CHAR: Hash[Symbol, String]
+  BRACKET_CLOSE_TYPE: Hash[Symbol, Symbol]
+  BRACKET_PAIRS: Hash[String, String]
+
+  class ParseError < StandardError
+    attr_reader position: Position?
+
+    def initialize: (String message, ?position: Position?) -> void
+  end
+
+  # 1-based line / column with 0-based character offsets into the
+  # preprocessed input.
+  class Position < Data
+    attr_reader line: Integer
+    attr_reader column: Integer
+    attr_reader offset: Integer
+    attr_reader end_offset: Integer
+
+    def self.new: (line: Integer, column: Integer, offset: Integer, end_offset: Integer) -> Position
+
+    def to_s: () -> String
+  end
+
+  # Tokenization (Syntax 4 §4)
+  # ---------------------------------------------------------------
+
+  def self.tokenize: (String input, ?preserve_comments: bool) -> Array[Token]
+
+  # Parsing (Syntax 4 §5.3)
+  # ---------------------------------------------------------------
+
+  def self.parse_stylesheet: (input input, ?preserve_comments: bool) -> Nodes::Stylesheet
+  def self.parse: (input input, ?preserve_comments: bool) -> Nodes::Stylesheet
+
+  def self.parse_rule: (input input, ?preserve_comments: bool) -> (Nodes::AtRule | Nodes::QualifiedRule)
+  def self.parse_declaration: (input input, ?preserve_comments: bool) -> Nodes::Declaration
+  def self.parse_block_contents: (input input, ?preserve_comments: bool) -> Nodes::Block
+
+  def self.parse_component_value: (input input, ?preserve_comments: bool) -> component_value
+  def self.parse_component_values: (input input, ?preserve_comments: bool) -> Array[component_value]
+  def self.parse_comma_separated_values: (input input, ?preserve_comments: bool) -> Array[Array[component_value]]
+
+  # Selectors (Selectors 4)
+  # ---------------------------------------------------------------
+
+  def self.parse_selector_list: (String | Array[component_value] input) -> Selectors::SelectorList
+  def self.parse_selector: (String | Array[component_value] input) -> Selectors::ComplexSelector
+  def self.parse_anb: (String | Array[Token] input) -> Selectors::AnB
+
+  def self.specificity: (Selectors::Node selector) -> Selectors::Specificity
+
+  type selector = Selectors::SelectorList | Selectors::ComplexSelector | Selectors::CompoundSelector
+
+  def self.matches?: (untyped element, String | selector selector, ?cache: Hash[Integer, untyped]) -> bool
+
+  # Media queries (Media Queries 4)
+  # ---------------------------------------------------------------
+
+  def self.parse_media_query_list: (String | Array[component_value] input) -> MediaQueries::MediaQueryList
+
+  type media_context_input = MediaQueries::Context | Hash[String, untyped]
+
+  def self.media_matches?: (String | MediaQueries::MediaQueryList query_list, media_context_input context) -> bool
+
+  # Other transformations
+  # ---------------------------------------------------------------
+
+  def self.parse_urange: (_ToS input) -> Nodes::UnicodeRange
+
+  def self.desugar: (Nodes::Stylesheet stylesheet) -> Nodes::Stylesheet
+
+  def self.cascade: (Nodes::Stylesheet stylesheet, ?context: MediaQueries::Context) -> Cascade
+
+  def self.serialize: (untyped node) -> String
+
+  VERSION: String
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p_css
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Keita Urashima
@@ -45,6 +45,12 @@ files:
 - lib/css/urange.rb
 - lib/css/version.rb
 - lib/p_css.rb
+- sig/css.rbs
+- sig/css/cascade.rbs
+- sig/css/media_queries.rbs
+- sig/css/nodes.rbs
+- sig/css/selectors.rbs
+- sig/css/token.rbs
 homepage: https://github.com/ursm/p_css
 licenses:
 - MIT