lightningcss 1.33.0-x86_64-linux-gnu → 1.33.0.2-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a034ecd57effe657dddf772892d2f0afa74cd6358f0120bd75c6850e936ea8b
-  data.tar.gz: 9cca0736400fb61fb3a1fc4a37e6b30a5c7b260acb7cd9135deae714d7cbf17a
+  metadata.gz: 87a5af79c2ae53a0dda0b24238474c04534cedca9a4c7250161012d27f91e0e1
+  data.tar.gz: 33620cc2e235bb293882979804587b4310f63543eed5c76aeb680e5afff12545
 SHA512:
-  metadata.gz: a22044c7bdd58290d675281f4359fe5a2b5240b3767210c14fc1d54fd9f4be88366e8089558655e6deb628770c6682e41ac5dd33b8db632d8089dd947c152da0
-  data.tar.gz: 033f6788c9b199d0e0444e82b53370781a193e252b3fabaab643c20b76185479b290be2dff3397fb286abfbbb5f6a1c02c0bf99ea453155d213fd43da905bfe1
+  metadata.gz: 558056ca4e596e12e1a559d0e91d4aa5696f56800fed1f0500684e9e6bd86403555158cfe56f899cb577483f76ca11f599bee26b669db7773815f098c1d050d1
+  data.tar.gz: 87180611a1a270ff150c2575d42672b03a0c414d54f893aa547991d9f3b27a63cf6f3fde498368e77a9326e805f2e6fa80e1f721c91fd2ed16f5b3080742d440

data/README.md

@@ -57,13 +57,25 @@ LightningCSS.minify(".a { color: #ff0000 }")
 
 #### Targeting browsers
 
-Give the browsers you support, each as its major version. Anything they cannot read is lowered, with the original kept after it so that a browser which understands it still wins.
+Give the browsers you support, each with the oldest version you support. Anything they cannot read is lowered, with the original kept after it so that a browser which understands it still wins.
 
 ```ruby
 LightningCSS.transform(".a { color: lab(50% 40 59) }", targets: { chrome: 80 }, minify: true).code
 #=> ".a{color:#bf5702;color:lab(50% 40 59)}"
 ```
 
+A version is an `Integer` for a major version, or a `Float` or `String` for a minor or patch release. Several features first shipped in a minor Safari release, so the minor version can change the output.
+
+```ruby
+LightningCSS.transform(".a { color: oklch(60% .2 30) }", targets: { safari: 15 }, minify: true).code
+#=> ".a{color:lab(51.6908% 61.9679 48.0969)}"
+
+LightningCSS.transform(".a { color: oklch(60% .2 30) }", targets: { safari: "15.4" }, minify: true).code
+#=> ".a{color:oklch(60% .2 30)}"
+```
+
+Prefer a `String` for a minor version above 9, since `16.10` as a `Float` is `16.1`.
+
 #### Bundling
 
 `bundle` resolves the `@import` statements a stylesheet was written with by reading the files they name, so it takes a path on disk to the entry stylesheet.
@@ -83,7 +95,7 @@ result.exports
 #=> {"application" => "_8Z4fiW_application"}
 
 result.warnings.first
-#=> "'deep' is not recognized as a valid pseudo-class. ... at app/assets/stylesheets/layout.css:0:9"
+#=> "'deep' is not recognized as a valid pseudo-class. ... at app/assets/stylesheets/layout.css:1:9"
 ```
 
 #### CSS modules
@@ -141,6 +153,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.
@@ -155,6 +274,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                                                                            |
@@ -162,7 +283,7 @@ It answers `call` as well, so it can be handed to anything expecting something c
 | `filename`       | `String`       | The name to use in errors and warnings.                                                |
 | `minify`         | `bool`         | Whether to print the result as small as it goes.                                       |
 | `error_recovery` | `bool`         | Whether to carry on past a rule it cannot read. Off by default, so such a rule raises. |
-| `targets`        | `Hash`         | The browsers being compiled for, each as its major version.                            |
+| `targets`        | `Hash`         | The browsers being compiled for, each with the oldest version supported.               |
 | `css_modules`    | `bool`, `Hash` | Whether to compile as a CSS module, and how.                                           |
 | `scope`          | `String`       | A selector fragment to narrow every rule by.                                           |
 
@@ -216,13 +337,40 @@ result = LightningCSS.transform(".a:deep(.b) { color: red }", minify: true)
 result.warnings?
 #=> true
 
-result.warnings.first
-#=> "'deep' is not recognized as a valid pseudo-class. Did you mean '::deep' (pseudo-element) or is this a typo? at :0:9"
+result.warnings.first.to_s
+#=> "'deep' is not recognized as a valid pseudo-class. Did you mean '::deep' (pseudo-element) or is this a typo? at :1:9"
 
 result.code
 #=> ".a:deep(.b){color:red}"
 ```
 
+### Locations
+
+A warning is a `LightningCSS::Warning` with a `message`, a `type`, and a `location`, the same as a diagnostic in Prism or Herb. A `LightningCSS::Error` carries the same `type` and `location`, and keeps the location in its message.
+
+A `LightningCSS::Location` counts lines from 1 and columns from 0, the same as Prism, Herb, and Yerba, and prints the way an editor reads it:
+
+```ruby
+css = ".a { color: red; }\n.b, { color: blue; }\n"
+
+begin
+  LightningCSS.transform(css, filename: "main.css")
+rescue LightningCSS::ParseError => error
+  error.message  #=> "Invalid empty selector at main.css:2:5"
+  error.type     #=> "SelectorError"
+  error.location #=> #<data LightningCSS::Location filename="main.css", line=2, column=4>
+end
+
+warning = LightningCSS.transform(css, filename: "main.css", error_recovery: true).warnings.first
+
+warning.message       #=> "Invalid empty selector"
+warning.type          #=> "SelectorError"
+warning.location.line #=> 2
+warning.to_s          #=> "Invalid empty selector at main.css:2:5"
+```
+
+A warning converts to the string it always was wherever a `String` is expected and is equal to it, so `warnings.include?("...")` still works. An error without a location, such as an `OptionError`, has `nil` for `type` and `location`.
+
 ### Development
 
 The gem is a C extension over a Rust crate. `rust/` builds a static library and generates the C header with [cbindgen](https://github.com/mozilla/cbindgen), `ext/lightningcss/` wraps it, and `lib/` is the Ruby API over that.

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

@@ -43,12 +43,12 @@ static VALUE error_class_for(enum LightningCssErrorCode code) {
 
 static VALUE unwrap(struct LightningCssResult result) {
   if (result.error) {
-    VALUE message = make_utf8_string(result.error);
+    VALUE payload = make_utf8_string(result.error);
     VALUE error_class = error_class_for(result.code);
 
     lightningcss_result_free(result);
 
-    rb_raise(error_class, "%s", StringValueCStr(message));
+    rb_exc_raise(rb_funcall(error_class, rb_intern("from_json"), 1, payload));
   }
 
   if (!result.value) {
@@ -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/errors.rb

@@ -1,7 +1,28 @@
 # frozen_string_literal: true
 
 module LightningCSS
-  class Error < StandardError; end
+  class Error < StandardError
+    attr_reader :type #: String?
+    attr_reader :location #: LightningCSS::Location?
+
+    #: (String) -> instance
+    def self.from_json(payload)
+      parsed = JSON.parse(payload)
+      location = parsed["location"] && Location.from_hash(parsed["location"])
+      message = parsed.fetch("message")
+
+      new(location ? "#{message} at #{location}" : message, type: parsed["type"], location: location)
+    end
+
+    #: (?String?, ?type: String?, ?location: LightningCSS::Location?) -> void
+    def initialize(message = nil, type: nil, location: nil)
+      super(message)
+
+      @type = type
+      @location = location
+    end
+  end
+
   class ParseError < Error; end
   class OptionError < Error; end
   class BundleError < Error; end

data/lib/lightningcss/location.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LightningCSS
+  Location = Data.define(
+    :filename, #: String?
+    :line, #: Integer
+    :column #: Integer
+  )
+
+  class Location
+    #: (Hash[String, untyped]) -> LightningCSS::Location
+    def self.from_hash(hash)
+      new(filename: hash["filename"], line: hash.fetch("line"), column: hash.fetch("column"))
+    end
+
+    #: () -> String
+    def to_s
+      "#{filename}:#{line}:#{column + 1}"
+    end
+  end
+end

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[LightningCSS::Warning]
+
+    #: (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").map { |warning| Warning.from_hash(warning) }
+      )
+    end
+
+    #: (stylesheet: Hash[String, untyped], warnings: Array[LightningCSS::Warning], ?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.map(&:to_s).inspect}" if warnings?
+
+      "#<#{self.class.name} #{parts.join(" ")}>"
+    end
+  end
+end

data/lib/lightningcss/result.rb

@@ -13,7 +13,7 @@ module LightningCSS
   class Result
     attr_reader :code #: String
     attr_reader :exports #: Hash[String, String]?
-    attr_reader :warnings #: Array[String]
+    attr_reader :warnings #: Array[LightningCSS::Warning]
 
     #: (String) -> LightningCSS::Result
     def self.from_json(payload)
@@ -22,11 +22,11 @@ module LightningCSS
       new(
         code: parsed.fetch("code"),
         exports: parsed["exports"],
-        warnings: parsed.fetch("warnings")
+        warnings: parsed.fetch("warnings").map { |warning| Warning.from_hash(warning) }
       )
     end
 
-    #: (code: String, warnings: Array[String], ?exports: Hash[String, String]?) -> void
+    #: (code: String, warnings: Array[LightningCSS::Warning], ?exports: Hash[String, String]?) -> void
     def initialize(code:, warnings:, exports: nil)
       @code = code
       @exports = exports
@@ -49,7 +49,7 @@ module LightningCSS
     def inspect
       parts = ["code=#{code.inspect}"]
       parts << "exports=#{exports.inspect}" if exports
-      parts << "warnings=#{warnings.inspect}" if warnings?
+      parts << "warnings=#{warnings.map(&:to_s).inspect}" if warnings?
 
       "#<#{self.class.name} #{parts.join(" ")}>"
     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 = "1.33.0"
+  VERSION = "1.33.0.2"
 end