lightningcss 0.2.0-x86_64-linux-gnu → 1.33.0.1-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60b9bf5ff6f7226f2deb903411280800ba1bb5e4d270fd32cc7c28ae23f82e54
-  data.tar.gz: 3199cdeaca6c86296bd0d05c7350d450694e00c71d26a72a9cfe70acbc71e249
+  metadata.gz: 1485fc29582d87b66d75264e0b773efe97357d3fdd8a63a57004b062d5d94b9a
+  data.tar.gz: 68231e8729126e916fc40002a6ec6ea9993e444a3552217152b1c2f22b903ada
 SHA512:
-  metadata.gz: 562c17a0bedbc7c0c971b20df9da6352b108b1607321f9ada7021c6d696515e8a371003a78ed90b4bd69fd60c01b6027016414f834cb5d5e27206a5e6b4c57e3
-  data.tar.gz: e0b92d822c7244d589aa00c021338c27455cbaf845494eeac942a01a29e8c346b47141d7a87c752337d2a52152a51a5332fbcf1277deabc7873492b4da211e3f
+  metadata.gz: 0ee7d7471fa4cdbcb3bf81a834d1bfa819c889bf584fa10e590b0357d43aca02ba746cdf663c51a3f2adec303921702aae5faf4e22e88b58f0918565cbb5f527
+  data.tar.gz: d7152c918ccf343be32fb4cd52e3aed525f36e5d02016522403390f696935ecbf2f47a4be61499cc34d07897981c54529caa69c56506afa976a9a6180fb11021

data/README.md

@@ -27,6 +27,16 @@ bundle add lightningcss
 
 Precompiled gems are published for Linux (gnu and musl) and macOS, on x86_64, aarch64, and arm. On those platforms nothing is compiled at install time. Anywhere else the gem builds from source and needs the [Rust toolchain](https://rustup.rs).
 
+### Versioning
+
+The gem carries the version of the Lightning CSS release it packages. Gem v1.33.0 bundles [Lightning CSS v1.33.0](https://github.com/parcel-bundler/lightningcss/releases/tag/v1.33.0).
+
+Lightning CSS publishes its Rust crate under a different number than it releases under: v1.33.0 ships the crate as `1.0.0-alpha.72`. The gem follows the release, since that is the version everything else calls it. `LightningCSS.lightningcss_version` reports the crate version a given build was compiled against.
+
+So the version tracks Lightning CSS, not the Ruby API here. A minor bump is a minor Lightning CSS release, and says nothing about whether this gem's own API moved. Pin on the Lightning CSS version you want.
+
+If the gem needs releasing again for the same Lightning CSS version, that release adds a fourth digit, as in v1.33.0.1.
+
 ### Usage
 
 #### Transforming
@@ -131,6 +141,113 @@ LightningCSS.transform_style_attribute("color: #ff0000; border: none", minify: t
 
 Having no selectors and no names, it takes neither `scope` nor `css_modules`, and says so when given one.
 
+#### Parsing
+
+`parse` answers what Lightning CSS read a stylesheet as, without printing anything. It takes `filename` and `error_recovery`, the two options that change how a stylesheet is read.
+
+```ruby
+parsed = LightningCSS.parse(".card .title:hover { color: #f00 }")
+
+parsed.stylesheet   #=> the AST exactly as Lightning CSS serializes it
+parsed.warnings     #=> []
+parsed.source       #=> ".card .title:hover { color: #f00 }"
+```
+
+The AST is Lightning CSS's own, so its shapes are the ones its [JavaScript visitors](https://lightningcss.dev/transforms.html) see and [`lightningcss/node/ast.d.ts`](https://github.com/parcel-bundler/lightningcss/blob/master/node/ast.d.ts) describes. It is what Lightning CSS understood, not what was written: `#f00` reads as an `rgb` with `r` of `255.0`, and a `0` margin reads as `0px`.
+
+#### Walking the AST
+
+`root` answers the stylesheet as a `LightningCSS::Node`, which walks, reads its fields by name, and knows what it sits inside.
+
+```ruby
+root = LightningCSS.parse(source).root
+
+root.type                   #=> "stylesheet"
+root.keys                   #=> the fields this node carries
+root.fields                 #=> those fields and their values, without its type and location
+root.child_nodes            #=> the nodes directly under it
+root.every("declaration")   #=> every declaration in the stylesheet
+root.each                   #=> an Enumerator over every node
+```
+
+Every object in the tree is a node, so reads chain all the way down.
+
+```ruby
+rule = root.rules.first
+
+rule.type                                  #=> "style"
+rule.value.selectors.first.map(&:type)     #=> ["class", "combinator", "class", "pseudo-class"]
+rule.value.declarations.declarations.first.value.r
+#=> 255.0
+```
+
+Most objects say what they are with their own `type`. The stylesheet, a declaration block, and a declaration do not, so a node names those `"stylesheet"`, `"declaration-block"`, and `"declaration"` from where it sits. Anything else without a `type`, like the `value` a rule wraps, answers `nil`.
+
+Inspecting a node shows every field it carries.
+
+```
+#<LightningCSS::Node style value=#<LightningCSS::Node>>
+#<LightningCSS::Node location=0:1 selectors=[... 1 item] declarations=#<LightningCSS::Node declaration-block> rules=[]>
+#<LightningCSS::Node declaration property="color" value=#<LightningCSS::Node rgb>>
+```
+
+Lightning CSS names its fields in camelCase, and a field answers to its snake_case name too.
+
+```ruby
+block.important_declarations   # the same field as block.importantDeclarations
+query.media_queries            # mediaQueries
+```
+
+Lightning CSS records where each rule starts and nothing else, so `location` is a rule's line, counted from 0, and its column, counted from 1 in UTF-16 code units. There are no end positions, so a node has no `slice` and there is no `at(offset)`.
+
+```ruby
+rule.value.location
+#=> {"source_index" => 0, "line" => 0, "column" => 1}
+```
+
+`ancestors` answers what a node sits inside, and `rule?` says whether it is a rule.
+
+```ruby
+declaration = root.every("declaration").first
+declaration.ancestors.find(&:rule?).type
+#=> "style"
+```
+
+Nodes pattern match, and nest, since a field holding an object comes back as a node. Patterns take snake_case names, and a node's `type` matches even when Lightning CSS gave it none.
+
+```ruby
+declaration => { type: "declaration", property:, value: { type: "rgb", r: } }
+property   #=> "color"
+r          #=> 255.0
+```
+
+`to_h` and `to_json` answer the AST the node wraps.
+
+```ruby
+declaration.value.to_h
+#=> {"type" => "rgb", "r" => 255.0, "g" => 0.0, "b" => 0.0, "alpha" => 1.0}
+```
+
+`LightningCSS::Visitor` answers a node with the method named after its type, and walks through anything nothing answers.
+
+```ruby
+class Colors < LightningCSS::Visitor
+  def visit_style_rule(node)
+    puts node.value.location["line"]
+
+    visit_children(node)
+  end
+
+  def visit_declaration(node)
+    puts node.property
+  end
+end
+
+Colors.new.visit(LightningCSS.parse(source))
+```
+
+A rule is answered as one, as in `visit_style_rule`, `visit_media_rule`, or `visit_namespace_rule`. Lightning CSS calls the rule `style`, but `namespace` and `nesting` are also parts of a selector, so `visit_namespace` answers `svg|rect` and `visit_namespace_rule` answers `@namespace`. Hyphens become underscores, so a `pseudo-class` is answered by `visit_pseudo_class`.
+
 #### Reusing options
 
 `LightningCSS::Transformer` holds a set of options to use across many stylesheets. Options given to a call are merged over the ones it was built with.
@@ -145,6 +262,8 @@ transformer.with(scope: "[s]")
 
 It answers `call` as well, so it can be handed to anything expecting something callable.
 
+`transformer.parse` reads with the `filename` and `error_recovery` it holds and leaves the rest, which only matter to printing.
+
 ### Options
 
 | Option           | Type           | Description                                                                            |

data/ext/lightningcss/include/lightningcss.h

@@ -23,6 +23,8 @@ typedef struct LightningCssResult {
 
 struct LightningCssResult lightningcss_transform(const char *code, const char *options_json);
 
+struct LightningCssResult lightningcss_parse(const char *code, const char *options_json);
+
 struct LightningCssResult lightningcss_transform_style_attribute(const char *code,
                                                                  const char *options_json);
 

data/ext/lightningcss/lightningcss.c

@@ -90,6 +90,12 @@ static VALUE rb_transform(VALUE self, VALUE code, VALUE options) {
   return call(lightningcss_transform, code, options);
 }
 
+static VALUE rb_parse(VALUE self, VALUE code, VALUE options) {
+  (void) self;
+
+  return call(lightningcss_parse, code, options);
+}
+
 static VALUE rb_transform_style_attribute(VALUE self, VALUE code, VALUE options) {
   (void) self;
 
@@ -123,6 +129,7 @@ void Init_lightningcss(void) {
   rb_eOptionError = rb_define_class_under(rb_mLightningCSS, "OptionError", rb_eError);
   rb_eBundleError = rb_define_class_under(rb_mLightningCSS, "BundleError", rb_eError);
 
+  rb_define_singleton_method(rb_mBackend, "parse", rb_parse, 2);
   rb_define_singleton_method(rb_mBackend, "transform", rb_transform, 2);
   rb_define_singleton_method(rb_mBackend, "transform_style_attribute", rb_transform_style_attribute, 2);
   rb_define_singleton_method(rb_mBackend, "bundle", rb_bundle, 2);

data/lib/lightningcss/backend.rb

@@ -8,6 +8,11 @@ module LightningCSS
         unavailable(__method__)
       end
 
+      #: (String, String) -> String
+      def parse(_code, _options_json)
+        unavailable(__method__)
+      end
+
       #: (String, String) -> String
       def transform_style_attribute(_code, _options_json)
         unavailable(__method__)

data/lib/lightningcss/node.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module LightningCSS
+  # One object in the AST Lightning CSS parsed a stylesheet to.
+  #
+  #     root = LightningCSS.parse(".a { color: red }").root
+  #
+  #     root.type                        #=> "stylesheet"
+  #     root.every("declaration")        #=> every declaration in the stylesheet
+  #     root.rules.first.value.location  #=> {"source_index" => 0, "line" => 0, "column" => 1}
+  #
+  # Every object in the tree is a node, so reads chain all the way down. Most say what they are
+  # with their own `type`. The stylesheet, a declaration block, and a declaration do not, so a node
+  # names those from where it sits.
+  #
+  class Node
+    include Enumerable #[LightningCSS::Node]
+
+    POSITION = ["type", "loc"].freeze #: Array[String]
+    DECLARATIONS = ["declarations", "importantDeclarations"].freeze #: Array[String]
+
+    attr_reader :parent #: LightningCSS::Node?
+    attr_reader :field #: String?
+
+    #: (Hash[String, untyped], ?LightningCSS::Node?, ?String?) -> void
+    def initialize(attributes, parent = nil, field = nil)
+      @attributes = attributes
+      @parent = parent
+      @field = field
+    end
+
+    #: () -> String?
+    def type
+      attributes.fetch("type") { inferred_type }
+    end
+
+    #: () -> String?
+    def underscored_type
+      return nil unless (name = type)
+
+      name = name.tr("-", "_").downcase
+
+      rule? ? "#{name}_rule" : name
+    end
+
+    #: () -> bool
+    def rule?
+      field == "rules" && attributes.key?("type")
+    end
+
+    #: () -> Hash[String, Integer]?
+    def location
+      attributes["loc"]
+    end
+
+    #: (String) -> untyped
+    def [](key)
+      attributes[key]
+    end
+
+    #: () -> Array[String]
+    def keys
+      attributes.keys
+    end
+
+    #: () -> Hash[String, untyped]
+    def to_h
+      attributes
+    end
+
+    #: (?untyped) -> String
+    def to_json(state = nil)
+      state ? attributes.to_json(state) : attributes.to_json
+    end
+
+    #: (Array[Symbol]?) -> Hash[Symbol, untyped]
+    def deconstruct_keys(keys)
+      found = {} #: Hash[Symbol, untyped]
+
+      if keys
+        keys.each do |name|
+          key = field_for(name.to_s)
+
+          if key
+            found[name] = wrap(attributes[key], key)
+          elsif name == :type && type
+            found[name] = type
+          end
+        end
+      else
+        found[:type] = type if type
+        attributes.each_key { |key| found[key.to_sym] = wrap(attributes[key], key) }
+      end
+
+      found
+    end
+
+    #: () -> Array[LightningCSS::Node]
+    def child_nodes
+      @child_nodes ||= attributes.flat_map { |key, value| key == "loc" ? [] : nodes_in(value, key) }.freeze
+    end
+
+    #: () { (LightningCSS::Node) -> void } -> void
+    #: () -> Enumerator[LightningCSS::Node, void]
+    def each(&)
+      return enum_for(:each) unless block_given?
+
+      yield self
+
+      child_nodes.each { |child| child.each(&) }
+    end
+
+    #: () -> Array[LightningCSS::Node]
+    def ancestors
+      parent ? [parent, *parent.ancestors] : []
+    end
+
+    #: (String) -> Array[LightningCSS::Node]
+    def every(type)
+      each.select { |node| node.type == type || node.underscored_type == type }
+    end
+
+    #: () -> Hash[String, untyped]
+    def fields
+      attributes.except(*POSITION)
+    end
+
+    #: () -> String
+    def inspect
+      described = fields.map { |key, value| described_field(key, value) }
+      position = location
+      described.unshift("location=#{position["line"]}:#{position["column"]}") if position
+
+      "#<#{self.class.name}#{" #{type}" if type}#{" #{described.join(" ")}" unless described.empty?}>"
+    end
+
+    #: (Symbol, *untyped) -> untyped
+    def method_missing(name, *arguments)
+      key = field_for(name.to_s)
+
+      return super unless key
+
+      wrap(attributes[key], key)
+    end
+
+    #: (Symbol, ?bool) -> bool
+    def respond_to_missing?(name, include_private = false)
+      !field_for(name.to_s).nil? || super
+    end
+
+    protected
+
+    attr_reader :attributes #: Hash[String, untyped]
+
+    private
+
+    #: () -> String?
+    def inferred_type
+      if parent.nil? && attributes.key?("rules") && attributes.key?("sources")
+        "stylesheet"
+      elsif attributes.key?("importantDeclarations")
+        "declaration-block"
+      elsif DECLARATIONS.include?(field) && attributes.key?("property")
+        "declaration"
+      end
+    end
+
+    #: (untyped, String) -> Array[LightningCSS::Node]
+    def nodes_in(value, key)
+      case value
+      when Hash
+        [Node.new(value, self, key)]
+      when Array
+        value.flat_map { |item| nodes_in(item, key) }
+      else
+        []
+      end
+    end
+
+    #: (String, untyped) -> String
+    def described_field(key, value)
+      case value
+      when Array
+        "#{key}=#{value.empty? ? "[]" : "[... #{counted(value)}]"}"
+      when Hash
+        type = Node.new(value, self, key).type
+
+        "#{key}=#<#{self.class.name}#{" #{type}" if type}>"
+      else
+        "#{key}=#{value.inspect}"
+      end
+    end
+
+    #: (Array[untyped]) -> String
+    def counted(items)
+      "#{items.length} #{items.length == 1 ? "item" : "items"}"
+    end
+
+    #: (String) -> String?
+    def field_for(name)
+      return name if attributes.key?(name)
+
+      camelized = name.gsub(/_([a-z\d])/) { Regexp.last_match(1).to_s.upcase }
+
+      camelized if attributes.key?(camelized)
+    end
+
+    #: (untyped, String) -> untyped
+    def wrap(value, key)
+      case value
+      when Hash
+        key == "loc" ? value : Node.new(value, self, key)
+      when Array
+        value.map { |item| wrap(item, key) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/lightningcss/options.rb

@@ -26,6 +26,11 @@ module LightningCSS
       :targets
     ].freeze #: Array[Symbol]
 
+    PARSE = [
+      :filename,
+      :error_recovery
+    ].freeze #: Array[Symbol]
+
     BUNDLE = [
       :minify,
       :error_recovery,

data/lib/lightningcss/parse_result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module LightningCSS
+  # What a stylesheet parsed to.
+  #
+  # `stylesheet` is the AST exactly as Lightning CSS serializes it, and `root` is the same tree as a
+  # `LightningCSS::Node` to walk. `warnings` are the ones a transform would have reported.
+  #
+  class ParseResult
+    attr_reader :source #: String?
+    attr_reader :stylesheet #: Hash[String, untyped]
+    attr_reader :warnings #: Array[String]
+
+    #: (String, ?String?) -> LightningCSS::ParseResult
+    def self.from_json(payload, source = nil)
+      parsed = JSON.parse(payload)
+
+      new(
+        source: source,
+        stylesheet: parsed.fetch("stylesheet"),
+        warnings: parsed.fetch("warnings")
+      )
+    end
+
+    #: (stylesheet: Hash[String, untyped], warnings: Array[String], ?source: String?) -> void
+    def initialize(stylesheet:, warnings:, source: nil)
+      @source = source
+      @stylesheet = stylesheet.freeze
+      @warnings = warnings.freeze
+
+      freeze
+    end
+
+    #: () -> LightningCSS::Node
+    def root
+      Node.new(stylesheet)
+    end
+
+    #: () -> bool
+    def warnings?
+      !warnings.empty?
+    end
+
+    #: () -> String
+    def inspect
+      parts = ["rules=#{stylesheet.fetch("rules").length}"]
+      parts << "warnings=#{warnings.inspect}" if warnings?
+
+      "#<#{self.class.name} #{parts.join(" ")}>"
+    end
+  end
+end

data/lib/lightningcss/transformer.rb

@@ -28,6 +28,11 @@ module LightningCSS
 
     alias call transform
 
+    #: (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+    def parse(code, **overrides)
+      LightningCSS.parse(code, **options.slice(*Options::PARSE), **overrides)
+    end
+
     #: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
     def bundle(path, **overrides)
       LightningCSS.bundle(path, **options, **overrides)

data/lib/lightningcss/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LightningCSS
-  VERSION = "0.2.0"
+  VERSION = "1.33.0.1"
 end

data/lib/lightningcss/visitor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LightningCSS
+  # Walks an AST, answering each node with the method named after it and walking through anything
+  # nothing answers.
+  #
+  #     class Colors < LightningCSS::Visitor
+  #       def visit_declaration(node)
+  #         puts node.value.type if node.property == "color"
+  #       end
+  #     end
+  #
+  #     Colors.new.visit(LightningCSS.parse(".a { color: red }"))
+  #
+  # A rule is answered as one, as in `visit_style_rule` or `visit_media_rule`, since `style`,
+  # `nesting`, and `namespace` are also what a selector is made of.
+  #
+  class Visitor
+    #: (LightningCSS::Node | LightningCSS::ParseResult) -> void
+    def visit(node)
+      node = node.root if node.is_a?(ParseResult)
+
+      method_name = "visit_#{node.underscored_type}" if node.underscored_type
+
+      method_name && respond_to?(method_name) ? public_send(method_name, node) : visit_children(node)
+
+      nil
+    end
+
+    #: (LightningCSS::Node) -> void
+    def visit_children(node)
+      node.child_nodes.each { |child| visit(child) }
+
+      nil
+    end
+  end
+end

data/lib/lightningcss.rb

@@ -15,6 +15,9 @@ end
 
 require_relative "lightningcss/options"
 require_relative "lightningcss/result"
+require_relative "lightningcss/node"
+require_relative "lightningcss/parse_result"
+require_relative "lightningcss/visitor"
 require_relative "lightningcss/transformer"
 
 # Ruby bindings for Lightning CSS.
@@ -28,14 +31,27 @@ require_relative "lightningcss/transformer"
 #     LightningCSS.transform(".title { color: red }", scope: "[data-scope-abc]").code
 #     #=> ".title[data-scope-abc]{color:red}"
 #
+# `parse` returns the AST instead, to walk with `LightningCSS::Node` and `LightningCSS::Visitor`:
+#
+#     LightningCSS.parse(".a { color: red }").root.every("declaration").first.property
+#     #=> "color"
+#
 # `LightningCSS::Options` is what the options are read by, and `LightningCSS::Transformer` holds a
 # set of them to reuse across many stylesheets.
+#
 module LightningCSS
   #: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.transform(code, **options)
     Result.from_json(Backend.transform(code.to_s, Options.serialize(options)))
   end
 
+  #: (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+  def self.parse(code, **options)
+    serialized = Options.serialize(options, Options::PARSE, "a parse")
+
+    ParseResult.from_json(Backend.parse(code.to_s, serialized), code.to_s)
+  end
+
   #: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.bundle(path, **options)
     serialized = Options.serialize(options, Options::BUNDLE, "a bundle")

data/rust/Cargo.lock

@@ -90,6 +90,9 @@ name = "bitflags"
 version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "bitvec"
@@ -139,9 +142,9 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "cbindgen"
-version = "0.28.0"
+version = "0.29.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadd868a2ce9ca38de7eeafdcec9c7065ef89b42b32f0839278d55f35c54d1ff"
+checksum = "2ecb53484c9c167ba674026b656d8a27d7657a58e6066aa902bfb1a4aa00ae20"
 dependencies = [
  "clap",
  "heck",
@@ -245,6 +248,7 @@ dependencies = [
  "dtoa-short",
  "itoa",
  "phf 0.13.1",
+ "serde",
  "smallvec",
 ]
 
@@ -425,9 +429,9 @@ checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 
 [[package]]
 name = "heck"
-version = "0.4.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "indexmap"
@@ -511,6 +515,7 @@ dependencies = [
  "serde",
  "serde-content",
  "smallvec",
+ "static-self",
 ]
 
 [[package]]
@@ -527,7 +532,7 @@ dependencies = [
 
 [[package]]
 name = "lightningcss-ffi"
-version = "0.2.0"
+version = "0.0.0"
 dependencies = [
  "cbindgen",
  "lightningcss",
@@ -599,7 +604,9 @@ dependencies = [
  "phf_codegen",
  "precomputed-hash",
  "rustc-hash",
+ "serde",
  "smallvec",
+ "static-self",
 ]
 
 [[package]]
@@ -963,11 +970,11 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.9"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -1002,6 +1009,31 @@ name = "smallvec"
 version = "1.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "static-self"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6635404b73efc136af3a7956e53c53d4f34b2f16c95a15c438929add0f69412"
+dependencies = [
+ "indexmap",
+ "smallvec",
+ "static-self-derive",
+]
+
+[[package]]
+name = "static-self-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5268c96d4b907c558a9a52d8492522d6c7b559651a5e1d8f2d551e461b9425d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
 
 [[package]]
 name = "strsim"
@@ -1078,44 +1110,42 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "toml"
-version = "0.8.23"
+version = "0.9.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
 dependencies = [
- "serde",
+ "indexmap",
+ "serde_core",
  "serde_spanned",
  "toml_datetime",
- "toml_edit",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.15",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.11"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.22.27"
+name = "toml_parser"
+version = "1.1.3+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56"
 dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_write",
- "winnow",
+ "winnow 1.0.4",
 ]
 
 [[package]]
-name = "toml_write"
-version = "0.1.2"
+name = "toml_writer"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+checksum = "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2"
 
 [[package]]
 name = "unicode-ident"
@@ -1237,9 +1267,12 @@ name = "winnow"
 version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
-dependencies = [
- "memchr",
-]
+
+[[package]]
+name = "winnow"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"
 
 [[package]]
 name = "wit-bindgen"

data/rust/Cargo.toml

@@ -2,7 +2,6 @@
 
 [package]
 name = "lightningcss-ffi"
-version = "0.2.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "C FFI bindings for Lightning CSS, used by the lightningcss gem"
@@ -16,9 +15,9 @@ path = "src/lib.rs"
 crate-type = ["cdylib", "staticlib", "rlib"]
 
 [dependencies]
-lightningcss = { version = "1.0.0-alpha.68", features = ["visitor"] }
+lightningcss = { version = "=1.0.0-alpha.72", features = ["visitor", "serde"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 
 [build-dependencies]
-cbindgen = "0.28"
+cbindgen = "0.29"

data/rust/build.rs

@@ -28,10 +28,32 @@ fn main() {
     PathBuf::from(&crate_dir).join("cbindgen.toml").display()
   );
 
+  let version_rb_path = PathBuf::from(&crate_dir).join("../lib/lightningcss/version.rb");
+
+  println!("cargo:rerun-if-changed={}", version_rb_path.display());
+
   println!(
     "cargo:rustc-env=LIGHTNINGCSS_VERSION={}",
     locked_version(&lock_path, "lightningcss")
   );
+
+  println!("cargo:rustc-env=GEM_VERSION={}", gem_version(&version_rb_path));
+}
+
+fn gem_version(version_rb_path: &PathBuf) -> String {
+  let Ok(source) = fs::read_to_string(version_rb_path) else {
+    return "unknown".to_string();
+  };
+
+  for line in source.lines() {
+    let Some(rest) = line.trim().strip_prefix("VERSION = ") else {
+      continue;
+    };
+
+    return rest.trim().trim_matches('"').to_string();
+  }
+
+  "unknown".to_string()
 }
 
 fn locked_version(lock_path: &PathBuf, package: &str) -> String {

data/rust/src/lib.rs

@@ -21,10 +21,10 @@ use lightningcss::bundler::{BundleErrorKind, Bundler, FileProvider};
 use lightningcss::stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleAttribute, StyleSheet};
 use lightningcss::visitor::Visit;
 
-use crate::options::{TransformOptions, TransformResult};
+use crate::options::{ParseResult, TransformOptions, TransformResult};
 use crate::scope::Scoper;
 
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const VERSION: &str = env!("GEM_VERSION");
 pub const LIGHTNINGCSS_VERSION: &str = env!("LIGHTNINGCSS_VERSION");
 
 #[repr(C)]
@@ -125,6 +125,26 @@ unsafe fn borrow_options(pointer: *const c_char) -> Result<TransformOptions, Fai
   serde_json::from_str(json).map_err(|error| Failure::option(format!("Invalid options: {error}")))
 }
 
+fn parse_source<'i>(code: &'i str, options: &TransformOptions) -> Result<ParseResult<StyleSheet<'i>>, Failure> {
+  let collected = Arc::new(RwLock::new(Vec::new()));
+
+  let parser_options = ParserOptions {
+    filename: options.filename.clone().unwrap_or_default(),
+    error_recovery: options.error_recovery,
+    warnings: Some(collected.clone()),
+    ..ParserOptions::default()
+  };
+
+  let stylesheet = StyleSheet::parse(code, parser_options).map_err(|error| Failure::parse(error.to_string()))?;
+
+  let warnings = collected
+    .read()
+    .map(|warnings| warnings.iter().map(|warning| warning.to_string()).collect())
+    .unwrap_or_default();
+
+  Ok(ParseResult { stylesheet, warnings })
+}
+
 fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformResult, Failure> {
   let filename = options.filename.clone().unwrap_or_default();
   let css_modules = match &options.css_modules {
@@ -295,7 +315,7 @@ fn transform_attribute(code: &str, options: &TransformOptions) -> Result<Transfo
   })
 }
 
-fn to_result(outcome: Result<TransformResult, Failure>) -> LightningCssResult {
+fn to_result(outcome: Result<impl serde::Serialize, Failure>) -> LightningCssResult {
   match outcome {
     Ok(result) => match serde_json::to_string(&result) {
       Ok(json) => LightningCssResult::ok(json),
@@ -323,6 +343,21 @@ pub unsafe extern "C" fn lightningcss_transform(
   to_result(transform_source(code, &options))
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_parse(code: *const c_char, options_json: *const c_char) -> LightningCssResult {
+  let code = match borrow_str(code, "code") {
+    Ok(code) => code,
+    Err(failure) => return LightningCssResult::err(failure),
+  };
+
+  let options = match borrow_options(options_json) {
+    Ok(options) => options,
+    Err(failure) => return LightningCssResult::err(failure),
+  };
+
+  to_result(parse_source(code, &options))
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn lightningcss_transform_style_attribute(
   code: *const c_char,

data/rust/src/options.rs

@@ -89,6 +89,12 @@ impl TransformOptions {
   }
 }
 
+#[derive(Debug, Serialize)]
+pub struct ParseResult<T> {
+  pub stylesheet: T,
+  pub warnings: Vec<String>,
+}
+
 #[derive(Debug, Serialize)]
 pub struct TransformResult {
   pub code: String,

data/sig/lightningcss/backend.rbs

@@ -6,6 +6,9 @@ module LightningCSS
       # : (String, String) -> String
       def transform: (String, String) -> String
 
+      # : (String, String) -> String
+      def parse: (String, String) -> String
+
       # : (String, String) -> String
       def transform_style_attribute: (String, String) -> String
 

data/sig/lightningcss/node.rbs

@@ -0,0 +1,104 @@
+# Generated from lib/lightningcss/node.rb with RBS::Inline
+
+module LightningCSS
+  # One object in the AST Lightning CSS parsed a stylesheet to.
+  #
+  #     root = LightningCSS.parse(".a { color: red }").root
+  #
+  #     root.type                        #=> "stylesheet"
+  #     root.every("declaration")        #=> every declaration in the stylesheet
+  #     root.rules.first.value.location  #=> {"source_index" => 0, "line" => 0, "column" => 1}
+  #
+  # Every object in the tree is a node, so reads chain all the way down. Most say what they are
+  # with their own `type`. The stylesheet, a declaration block, and a declaration do not, so a node
+  # names those from where it sits.
+  class Node
+    include Enumerable[LightningCSS::Node]
+
+    POSITION: Array[String]
+
+    DECLARATIONS: Array[String]
+
+    attr_reader parent: LightningCSS::Node?
+
+    attr_reader field: String?
+
+    # : (Hash[String, untyped], ?LightningCSS::Node?, ?String?) -> void
+    def initialize: (Hash[String, untyped], ?LightningCSS::Node?, ?String?) -> void
+
+    # : () -> String?
+    def type: () -> String?
+
+    # : () -> String?
+    def underscored_type: () -> String?
+
+    # : () -> bool
+    def rule?: () -> bool
+
+    # : () -> Hash[String, Integer]?
+    def location: () -> Hash[String, Integer]?
+
+    # : (String) -> untyped
+    def []: (String) -> untyped
+
+    # : () -> Array[String]
+    def keys: () -> Array[String]
+
+    # : () -> Hash[String, untyped]
+    def to_h: () -> Hash[String, untyped]
+
+    # : (?untyped) -> String
+    def to_json: (?untyped) -> String
+
+    # : (Array[Symbol]?) -> Hash[Symbol, untyped]
+    def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, untyped]
+
+    # : () -> Array[LightningCSS::Node]
+    def child_nodes: () -> Array[LightningCSS::Node]
+
+    # : () { (LightningCSS::Node) -> void } -> void
+    # : () -> Enumerator[LightningCSS::Node, void]
+    def each: () { (LightningCSS::Node) -> void } -> void
+            | () -> Enumerator[LightningCSS::Node, void]
+
+    # : () -> Array[LightningCSS::Node]
+    def ancestors: () -> Array[LightningCSS::Node]
+
+    # : (String) -> Array[LightningCSS::Node]
+    def every: (String) -> Array[LightningCSS::Node]
+
+    # : () -> Hash[String, untyped]
+    def fields: () -> Hash[String, untyped]
+
+    # : () -> String
+    def inspect: () -> String
+
+    # : (Symbol, *untyped) -> untyped
+    def method_missing: (Symbol, *untyped) -> untyped
+
+    # : (Symbol, ?bool) -> bool
+    def respond_to_missing?: (Symbol, ?bool) -> bool
+
+    attr_reader attributes: Hash[String, untyped]
+
+    private
+
+    # : () -> String?
+    def inferred_type: () -> String?
+
+    # : (untyped, String) -> Array[LightningCSS::Node]
+    def nodes_in: (untyped, String) -> Array[LightningCSS::Node]
+
+    # : (String, untyped) -> String
+    def described_field: (String, untyped) -> String
+
+    # : (Array[untyped]) -> String
+    def counted: (Array[untyped]) -> String
+
+    # : (String) -> String?
+    def field_for: (String) -> String?
+
+    # : (untyped, String) -> untyped
+    def wrap: (untyped, String) -> untyped
+  end
+end

data/sig/lightningcss/options.rbs

@@ -13,6 +13,8 @@ module LightningCSS
 
     STYLE_ATTRIBUTE: Array[Symbol]
 
+    PARSE: Array[Symbol]
+
     BUNDLE: Array[Symbol]
 
     attr_reader to_h: Hash[Symbol, untyped]

data/sig/lightningcss/parse_result.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/lightningcss/parse_result.rb with RBS::Inline
+
+module LightningCSS
+  # What a stylesheet parsed to.
+  #
+  # `stylesheet` is the AST exactly as Lightning CSS serializes it, and `root` is the same tree as a
+  # `LightningCSS::Node` to walk. `warnings` are the ones a transform would have reported.
+  class ParseResult
+    attr_reader source: String?
+
+    attr_reader stylesheet: Hash[String, untyped]
+
+    attr_reader warnings: Array[String]
+
+    # : (String, ?String?) -> LightningCSS::ParseResult
+    def self.from_json: (String, ?String?) -> LightningCSS::ParseResult
+
+    # : (stylesheet: Hash[String, untyped], warnings: Array[String], ?source: String?) -> void
+    def initialize: (stylesheet: Hash[String, untyped], warnings: Array[String], ?source: String?) -> void
+
+    # : () -> LightningCSS::Node
+    def root: () -> LightningCSS::Node
+
+    # : () -> bool
+    def warnings?: () -> bool
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/lightningcss/transformer.rbs

@@ -21,6 +21,9 @@ module LightningCSS
 
     alias call transform
 
+    # : (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+    def parse: (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+
     # : (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
     def bundle: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
 

data/sig/lightningcss/visitor.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/lightningcss/visitor.rb with RBS::Inline
+
+module LightningCSS
+  # Walks an AST, answering each node with the method named after it and walking through anything
+  # nothing answers.
+  #
+  #     class Colors < LightningCSS::Visitor
+  #       def visit_declaration(node)
+  #         puts node.value.type if node.property == "color"
+  #       end
+  #     end
+  #
+  #     Colors.new.visit(LightningCSS.parse(".a { color: red }"))
+  #
+  # A rule is answered as one, as in `visit_style_rule` or `visit_media_rule`, since `style`,
+  # `nesting`, and `namespace` are also what a selector is made of.
+  class Visitor
+    # : (LightningCSS::Node | LightningCSS::ParseResult) -> void
+    def visit: (LightningCSS::Node | LightningCSS::ParseResult) -> void
+
+    # : (LightningCSS::Node) -> void
+    def visit_children: (LightningCSS::Node) -> void
+  end
+end

data/sig/lightningcss.rbs

@@ -11,12 +11,20 @@
 #     LightningCSS.transform(".title { color: red }", scope: "[data-scope-abc]").code
 #     #=> ".title[data-scope-abc]{color:red}"
 #
+# `parse` returns the AST instead, to walk with `LightningCSS::Node` and `LightningCSS::Visitor`:
+#
+#     LightningCSS.parse(".a { color: red }").root.every("declaration").first.property
+#     #=> "color"
+#
 # `LightningCSS::Options` is what the options are read by, and `LightningCSS::Transformer` holds a
 # set of them to reuse across many stylesheets.
 module LightningCSS
   # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.transform: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
 
+  # : (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+  def self.parse: (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+
   # : (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.bundle: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightningcss
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.33.0.1
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-30 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings for Lightning CSS, an extremely fast CSS parser, transformer,
   bundler, and minifier.
@@ -30,10 +30,13 @@ files:
 - lib/lightningcss/4.0/lightningcss.so
 - lib/lightningcss/backend.rb
 - lib/lightningcss/errors.rb
+- lib/lightningcss/node.rb
 - lib/lightningcss/options.rb
+- lib/lightningcss/parse_result.rb
 - lib/lightningcss/result.rb
 - lib/lightningcss/transformer.rb
 - lib/lightningcss/version.rb
+- lib/lightningcss/visitor.rb
 - licenses/README.md
 - licenses/lightningcss-MPL-2.0.txt
 - lightningcss.gemspec
@@ -48,11 +51,14 @@ files:
 - sig/lightningcss.rbs
 - sig/lightningcss/backend.rbs
 - sig/lightningcss/errors.rbs
+- sig/lightningcss/node.rbs
 - sig/lightningcss/options.rbs
+- sig/lightningcss/parse_result.rbs
 - sig/lightningcss/result.rbs
 - sig/lightningcss/transformer.rbs
 - sig/lightningcss/types.rbs
 - sig/lightningcss/version.rbs
+- sig/lightningcss/visitor.rbs
 homepage: https://github.com/marcoroth/lightningcss-ruby
 licenses:
 - MIT