p_css 0.2.0.beta1-aarch64-linux

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,164 @@
+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
+      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?
+      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_source!: (Integer start_offset, Integer end_offset, Array[Integer] newlines) -> 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,99 @@
+# 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
+
+  # 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)
+  # ---------------------------------------------------------------
+
+  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

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: p_css
+version: !ruby/object:Gem::Version
+  version: 0.2.0.beta1
+platform: aarch64-linux
+authors:
+- Keita Urashima
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: p_css is a Ruby implementation of the CSS Syntax Level 4 tokenizer and
+  parser, including support for CSS nesting.
+email:
+- ursm@ursm.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- ext/css_native/Cargo.toml
+- ext/css_native/extconf.rb
+- ext/css_native/src/lib.rs
+- ext/css_native/src/matcher.rs
+- ext/css_native/src/selectors.rs
+- ext/css_native/src/snapshot.rs
+- ext/css_native/src/state.rs
+- ext/css_native/src/tokenizer.rs
+- lib/css.rb
+- lib/css/3.3/css_native.so
+- lib/css/3.4/css_native.so
+- lib/css/4.0/css_native.so
+- lib/css/cascade.rb
+- lib/css/code_points.rb
+- lib/css/escape.rb
+- lib/css/media_queries.rb
+- lib/css/media_queries/context.rb
+- lib/css/media_queries/evaluator.rb
+- lib/css/media_queries/nodes.rb
+- lib/css/media_queries/parser.rb
+- lib/css/native.rb
+- lib/css/nesting.rb
+- lib/css/nodes.rb
+- lib/css/parser.rb
+- lib/css/selectors.rb
+- lib/css/selectors/anb_parser.rb
+- lib/css/selectors/matcher.rb
+- lib/css/selectors/nodes.rb
+- lib/css/selectors/parser.rb
+- lib/css/selectors/serializer.rb
+- lib/css/selectors/specificity.rb
+- lib/css/serializer.rb
+- lib/css/token.rb
+- lib/css/token_cursor.rb
+- lib/css/tokenizer.rb
+- 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
+metadata:
+  bug_tracker_uri: https://github.com/ursm/p_css/issues
+  changelog_uri: https://github.com/ursm/p_css/releases
+  source_code_uri: https://github.com/ursm/p_css
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key: 
+specification_version: 4
+summary: A CSS Syntax Level 4 parser for Ruby, with nesting support.
+test_files: []