clsx-ruby 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 043652e6d2bc00c77d0409b45cb15f361cd1fb417af14db62892be42ed2a1815
-  data.tar.gz: dbacda2ec82ed045800345914fec73339d1dfee64df87e33305a5a8b5cf7c118
+  metadata.gz: 7af7dbc1bf63dae86a10afc293087f0528b82d479e0f4cc2e82a6944c79c8ed4
+  data.tar.gz: 2ed149e30e3da918e403697ea511ca597c6bece1bbb2965ae6dd02e0d054a4b8
 SHA512:
-  metadata.gz: 26c9443192380c6b8415923df85df04d78add5cead6a676d78739410261cbeb277f8e6c4856b15761355dd61becfc09ad6aec7870d530f78bb5d3fcfbd358893
-  data.tar.gz: 919462b5126de045d8a2b1d63ef5e3da4fb04156ef62c9c3e4985922d05dd041997fcbc473f1aab7495d61914e87b09cdf88b2f1448f0fb80b8c3c3006115763
+  metadata.gz: 37be556d78cb762df769303b6143e7872fd0bc67f26110720e31cf34238d3c657cab2f09b39f899163babcd7086c044d281d157261cb73736e7fcf4fe81d6b05
+  data.tar.gz: 6c5af47dba54f7d17fa5ba00a8f9bd2e96f34581cdd3f3544702b93699ec9bb0f5068147e294b5cff976341f64aa56353f2713b90929dbdfd443a5d83a62560e

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## v1.1.3
+
+### Fixed
+
+- Normalize whitespace in class strings: tabs, newlines, leading/trailing spaces, and consecutive spaces are collapsed to single spaces (e.g., `clsx("foo\tbar")` returns `"foo bar"`)
+- Whitespace-only strings now correctly return `nil` (e.g., `clsx("   ")` returns `nil`)
+- Deduplicate class names across multi-token strings (e.g., `clsx("foo bar", "foo")` now returns `"foo bar"`)
+
+## v1.1.2
+
+### Changed
+
+- Improved gemspec description and README marketing copy
+- Switched gemspec to whitelist approach for included files
+
 ## v1.1.1
 
 ### Added

data/README.md

@@ -1,8 +1,9 @@
 # clsx-ruby [![Gem Version](https://img.shields.io/gem/v/clsx-ruby)](https://rubygems.org/gems/clsx-ruby) [![Codecov](https://img.shields.io/codecov/c/github/svyatov/clsx-ruby)](https://app.codecov.io/gh/svyatov/clsx-ruby) [![CI](https://github.com/svyatov/clsx-ruby/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/svyatov/clsx-ruby/actions?query=workflow%3ACI) [![GitHub License](https://img.shields.io/github/license/svyatov/clsx-ruby)](LICENSE.txt)
 
-> The fastest Ruby utility for constructing CSS class strings conditionally. Perfect for Tailwind CSS utility classes. Zero dependencies.
+> The fastest, framework-agnostic conditional CSS class builder for Ruby.  
+> Perfect for ViewComponent, Phlex, Tailwind CSS or just standalone.
 
-Ruby port of the JavaScript [clsx](https://github.com/lukeed/clsx) package — a faster, smarter alternative to Rails `class_names`. Works with Rails, Sinatra, Hanami, or plain Ruby.
+Inspired by the JavaScript [clsx](https://github.com/lukeed/clsx) package. Works with any Ruby codebase.
 
 ## Quick Start
 
@@ -25,20 +26,24 @@ Clsx['btn', 'btn-primary', active: is_active, disabled: is_disabled]
 # => "btn btn-primary active" (when is_active is truthy, is_disabled is falsy)
 ```
 
+## Rails Integration
+
+For Rails integration (adds `clsx` and `cn` helpers to all views), see [clsx-rails](https://github.com/svyatov/clsx-rails).
+
 ## Why clsx-ruby?
 
 ### Blazing fast
 
-**3–8x faster** than Rails `class_names` across every scenario:
+**2-3x faster** than Rails `class_names` across every scenario:
 
 | Scenario | clsx-ruby | Rails `class_names` | Speedup |
 |---|---|---|---|
-| Single string | 7.6M i/s | 911K i/s | **8.5x** |
-| String + hash | 2.4M i/s | 580K i/s | **4.1x** |
-| String array | 1.4M i/s | 357K i/s | **4.0x** |
-| Multiple strings | 1.5M i/s | 414K i/s | **3.7x** |
-| Hash | 2.2M i/s | 670K i/s | **3.3x** |
-| Mixed types | 852K i/s | 367K i/s | **2.3x** |
+| String array | 1.3M i/s | 369K i/s | **3.4x** |
+| Multiple strings | 1.3M i/s | 408K i/s | **3.3x** |
+| Single string | 2.4M i/s | 893K i/s | **2.7x** |
+| Mixed types | 912K i/s | 358K i/s | **2.5x** |
+| Hash | 1.7M i/s | 672K i/s | **2.5x** |
+| String + hash | 1.2M i/s | 565K i/s | **2.1x** |
 
 <sup>Ruby 4.0.1, Apple M1 Pro. Reproduce: `bundle exec ruby benchmark/run.rb`</sup>
 
@@ -48,7 +53,7 @@ Clsx['btn', 'btn-primary', active: is_active, disabled: is_disabled]
 |---|---|---|
 | Conditional classes | ✅ | ✅ |
 | Auto-deduplication | ✅ | ✅ |
-| 3–8× faster | ✅ | ❌ |
+| 2–3× faster | ✅ | ❌ |
 | Returns `nil` when empty | ✅ | ❌ (returns `""`) |
 | Complex hash keys | ✅ | ❌ |
 | Framework-agnostic | ✅ | ❌ |
@@ -223,9 +228,10 @@ end
    Clsx[nil, false] # => nil
    ```
 
-2. **Deduplication** — Duplicate classes are automatically removed:
+2. **Deduplication** — Duplicate classes are automatically removed, even across multi-token strings:
    ```ruby
-   Clsx['foo', 'foo'] # => 'foo'
+   Clsx['foo', 'foo']      # => 'foo'
+   Clsx['foo bar', 'foo']  # => 'foo bar'
    ```
 
 3. **Falsy values** — In Ruby only `false` and `nil` are falsy, so `0`, `''`, `[]`, `{}` are all truthy:
@@ -243,10 +249,6 @@ end
    Clsx['', proc {}, -> {}, nil, false, true] # => nil
    ```
 
-## Rails Integration
-
-For automatic Rails view helper integration (adds `clsx` and `cn` helpers to all views), see [clsx-rails](https://github.com/svyatov/clsx-rails).
-
 ## Development
 
 ```bash

data/lib/clsx/helper.rb

@@ -26,12 +26,18 @@ module Clsx
     #   clsx(%w[foo bar], hidden: true)         # => "foo bar hidden"
     def clsx(*args)
       return nil if args.empty?
-      return clsx_single(args[0]) if args.size == 1
-      return clsx_string_hash(args[0], args[1]) if args.size == 2 && args[0].is_a?(String) && args[1].is_a?(Hash)
+      return clsx_one(args[0]) if args.size == 1
+
+      if args.size == 2 && args[0].is_a?(String) && args[1].is_a?(Hash)
+        str = args[0]
+        return clsx_hash(args[1]) if str.empty?
+        return clsx_str_hash_full(str, args[1]) if str.include?(' ') || str.include?("\t") || str.include?("\n") # rubocop:disable Layout/EmptyLineAfterGuardClause
+        return clsx_str_hash(str, args[1])
+      end
 
       seen = {}
-      clsx_process(args, seen)
-      seen.empty? ? nil : seen.keys.join(' ')
+      clsx_walk(args, seen)
+      clsx_join(seen)
     end
 
     # (see #clsx)
@@ -39,131 +45,283 @@ module Clsx
 
     private
 
-    # Single-argument fast path — dispatches by type to avoid allocating
-    # a +seen+ hash when possible.
+    # Single-argument fast path — dispatches by type, handles multi-token
+    # string dedup without allocating a walker Hash for simple cases.
     #
-    # @param arg [String, Symbol, Hash, Array] single class descriptor
-    # @return [String] resolved class string
-    # @return [nil] when the argument produces no classes
-    def clsx_single(arg)
-      return (arg.empty? ? nil : arg) if arg.is_a?(String)
-      return arg.name if arg.is_a?(Symbol)
-      return clsx_simple_hash(arg) if arg.is_a?(Hash)
+    # @param arg [Object] single class descriptor
+    # @return [String, nil]
+    def clsx_one(arg)
+      if arg.is_a?(String)
+        return nil if arg.empty?
+        return arg unless arg.include?(' ') || arg.include?("\t") || arg.include?("\n")
+
+        parts = arg.split
+        return nil if parts.empty?
+        return parts[0] if parts.length == 1
+        return arg if !parts.uniq! && parts.length == arg.count(' ') + 1 # rubocop:disable Layout/EmptyLineAfterGuardClause
+        return parts.join(' ')
+      end
+
+      if arg.is_a?(Symbol)
+        s = arg.name
+        return s unless s.include?(' ') || s.include?("\t") || s.include?("\n") # rubocop:disable Layout/EmptyLineAfterGuardClause
+        return clsx_dedup_str(s)
+      end
+
+      return clsx_hash(arg) if arg.is_a?(Hash)
 
       if arg.is_a?(Array)
         return nil if arg.empty?
 
-        if arg.all?(String)
-          seen = {}
-          arg.each { |s| seen[s] = true unless s.empty? }
-          return seen.empty? ? nil : seen.keys.join(' ')
-        end
-
         seen = {}
-        clsx_process(arg, seen)
-        return seen.empty? ? nil : seen.keys.join(' ')
+        clsx_walk(arg, seen)
+        return clsx_join(seen)
       end
 
-      return arg.to_s if arg.is_a?(Numeric)
       return nil if !arg || arg == true || arg.is_a?(Proc)
 
-      str = arg.to_s
-      str.empty? ? nil : str
+      s = arg.to_s
+      s.empty? ? nil : s
     end
 
-    # Hash-only fast path — no dedup needed since hash keys are unique.
-    # Falls back to {#clsx_process} on non-String/Symbol keys.
+    # Dedup and normalize a multi-token string. Handles whitespace-only
+    # input, leading/trailing whitespace, tabs, newlines, and duplicates.
     #
-    # @param hash [Hash{String, Symbol => Boolean}] class-name => condition pairs
-    # @return [String] resolved class string
-    # @return [nil] when no hash values are truthy
-    def clsx_simple_hash(hash)
+    # @param str [String] space-separated class string
+    # @return [String, nil]
+    def clsx_dedup_str(str)
+      parts = str.split
+      return nil if parts.empty?
+      return parts[0] if parts.length == 1
+      return str if !parts.uniq! && parts.length == str.count(' ') + 1
+
+      parts.join(' ')
+    end
+
+    # Hash-only fast path using string buffer. Falls back to Hash dedup
+    # on mixed key types, multi-token keys, or complex keys.
+    #
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_hash(hash)
       return nil if hash.empty?
 
       buf = nil
+      key_type = nil
+
       hash.each do |key, value|
         next unless value
 
         if key.is_a?(Symbol)
-          str = key.name
-          buf ? (buf << ' ' << str) : (buf = str.dup)
+          return clsx_hash_full(hash) if key_type == :string
+
+          key_type = :symbol
+          s = key.name
+          return clsx_hash_full(hash) if s.include?(' ')
+
+          buf ? (buf << ' ' << s) : (buf = s.dup)
         elsif key.is_a?(String)
           next if key.empty?
 
+          return clsx_hash_full(hash) if key_type == :symbol
+          return clsx_hash_full(hash) if key.include?(' ')
+
+          key_type = :string
           buf ? (buf << ' ' << key) : (buf = key.dup)
         else
-          seen = {}
-          clsx_process([hash], seen)
-          return seen.empty? ? nil : seen.keys.join(' ')
+          return clsx_hash_full(hash)
         end
       end
+
+      return nil unless buf
+      return clsx_dedup_str(buf) if buf.include?("\t") || buf.include?("\n")
+
       buf
     end
 
-    # Fast path for +clsx('base', active: cond)+ — deduplicates only against
-    # the base string. Falls back to {#clsx_process} on non-String/Symbol keys.
+    # Hash fallback with full dedup via walker.
     #
-    # @param str [String] base class name
-    # @param hash [Hash{String, Symbol => Boolean}] class-name => condition pairs
-    # @return [String] resolved class string
-    # @return [nil] when no classes apply
-    def clsx_string_hash(str, hash)
-      return clsx_simple_hash(hash) if str.empty?
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_hash_full(hash)
+      seen = {}
+      clsx_walk_hash(hash, seen)
+      clsx_join(seen)
+    end
 
+    # Fast path for +clsx('base', active: cond)+ pattern where base is a
+    # single token. Deduplicates via direct string comparison.
+    #
+    # @param str [String] base class name
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_str_hash(str, hash)
       buf = str.dup
+      key_type = nil
+
+      hash.each do |key, value|
+        next unless value
+
+        if key.is_a?(Symbol)
+          return clsx_str_hash_full(str, hash) if key_type == :string
+
+          key_type = :symbol
+          s = key.name
+          return clsx_str_hash_full(str, hash) if s.include?(' ')
+
+          next if s == str
+
+          buf << ' ' << s
+        elsif key.is_a?(String)
+          return clsx_str_hash_full(str, hash) if key_type == :symbol
+
+          key_type = :string
+          next if key.empty?
+
+          return clsx_str_hash_full(str, hash) if key.include?(' ')
+
+          next if key == str
+
+          buf << ' ' << key
+        else
+          return clsx_str_hash_full(str, hash)
+        end
+      end
+
+      return clsx_dedup_str(buf) if buf.include?("\t") || buf.include?("\n")
+
+      buf
+    end
+
+    # Full str+hash dedup using array lookup. Splits the base string once,
+    # then checks hash keys against the parts array via linear search.
+    # Falls back to Hash dedup on mixed key types or complex keys.
+    #
+    # @param str [String] base class name (contains spaces)
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_str_hash_full(str, hash)
+      parts = str.split
+      return clsx_hash(hash) if parts.empty?
+      return clsx_str_hash_full_walk(parts, hash) if parts.length == 1
+
+      buf = if parts.uniq! || parts.length != str.count(' ') + 1
+              parts.join(' ')
+            else
+              str.dup
+            end
+
+      key_type = nil
+
       hash.each do |key, value|
         next unless value
 
         if key.is_a?(Symbol)
+          return clsx_str_hash_full_walk(parts, hash) if key_type == :string
+
+          key_type = :symbol
           s = key.name
-          buf << ' ' << s unless s == str
+          return clsx_str_hash_full_walk(parts, hash) if s.include?(' ') || s.include?("\t") || s.include?("\n")
+
+          next if parts.include?(s)
+
+          buf << ' ' << s
         elsif key.is_a?(String)
-          buf << ' ' << key unless key.empty? || key == str
+          return clsx_str_hash_full_walk(parts, hash) if key_type == :symbol
+
+          key_type = :string
+          next if key.empty?
+          return clsx_str_hash_full_walk(parts, hash) if key.include?(' ') || key.include?("\t") || key.include?("\n")
+
+          next if parts.include?(key)
+
+          buf << ' ' << key
         else
-          seen = { str => true }
-          clsx_process([hash], seen)
-          return seen.size == 1 ? str : seen.keys.join(' ')
+          return clsx_str_hash_full_walk(parts, hash)
         end
       end
+
       buf
     end
 
-    # General-purpose recursive walker. Processes hash keys inline for simple
-    # types (String/Symbol) to avoid deferred-array allocation. Only complex
-    # keys (Array, nested Hash) recurse.
+    # Hash-based fallback for str+hash when array lookup can't handle it.
+    #
+    # @param parts [Array<String>] pre-split base tokens
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_str_hash_full_walk(parts, hash)
+      seen = {}
+      parts.each { |s| seen[s] = true }
+      clsx_walk_hash(hash, seen)
+      clsx_join(seen)
+    end
+
+    # General-purpose recursive walker. Stores strings as-is; normalization
+    # and dedup are handled by {#clsx_join} after walking.
     #
-    # @param args [Array<String, Symbol, Hash, Array, Numeric, nil, false>] nested arguments
+    # @param args [Array] nested arguments to walk
     # @param seen [Hash{String => true}] accumulator for deduplication
     # @return [void]
-    def clsx_process(args, seen)
+    def clsx_walk(args, seen)
       args.each do |arg|
         if arg.is_a?(String)
           seen[arg] = true unless arg.empty?
         elsif arg.is_a?(Symbol)
           seen[arg.name] = true
         elsif arg.is_a?(Array)
-          clsx_process(arg, seen)
+          clsx_walk(arg, seen)
         elsif arg.is_a?(Hash)
-          arg.each do |key, value|
-            next unless value
-
-            if key.is_a?(Symbol)
-              seen[key.name] = true
-            elsif key.is_a?(String)
-              seen[key] = true unless key.empty?
-            else
-              clsx_process([key], seen)
-            end
-          end
-        elsif arg.is_a?(Numeric)
-          seen[arg.to_s] = true
+          clsx_walk_hash(arg, seen)
         elsif !arg || arg == true || arg.is_a?(Proc)
           next
         else
-          str = arg.to_s
-          seen[str] = true unless str.empty?
+          s = arg.to_s
+          seen[s] = true unless s.empty?
+        end
+      end
+    end
+
+    # Hash-specific walker — avoids wrapping hash in an array for recursion.
+    #
+    # @param hash [Hash] hash to walk
+    # @param seen [Hash{String => true}] accumulator
+    # @return [void]
+    def clsx_walk_hash(hash, seen)
+      return if hash.empty?
+
+      hash.each do |key, value|
+        next unless value
+
+        if key.is_a?(Symbol)
+          seen[key.name] = true
+        elsif key.is_a?(String)
+          seen[key] = true unless key.empty?
+        elsif key.is_a?(Array)
+          clsx_walk(key, seen)
+        elsif key.is_a?(Hash)
+          clsx_walk_hash(key, seen)
+        elsif !key || key == true || key.is_a?(Proc)
+          next
+        else
+          s = key.to_s
+          seen[s] = true unless s.empty?
         end
       end
     end
+
+    # Post-join dedup and normalization: detects multi-token entries via
+    # space count mismatch or tab/newline presence, then splits and rebuilds.
+    #
+    # @param seen [Hash{String => true}] token accumulator
+    # @return [String, nil] space-joined class string
+    def clsx_join(seen)
+      return nil if seen.empty?
+
+      result = seen.keys.join(' ')
+      return result if result.count(' ') + 1 == seen.size && !result.include?("\t") && !result.include?("\n")
+
+      normalized = result.split.uniq.join(' ')
+      normalized.empty? ? nil : normalized
+    end
   end
 end

data/lib/clsx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clsx
-  VERSION = '1.1.1'
+  VERSION = '1.1.3'
 end

metadata

@@ -1,15 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: clsx-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Leonid Svyatov
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: A tiny utility for constructing CSS class strings conditionally
+description: Build CSS class strings from conditional expressions, hashes, arrays,
+  or nested structures. Framework-agnostic. Perfect for ViewComponent, Phlex, and
+  Tailwind CSS. Works with any Ruby codebase.
 email:
 - leonid@svyatov.com
 executables: []
@@ -17,7 +19,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CLAUDE.md
 - LICENSE.txt
 - README.md
 - lib/clsx.rb
@@ -46,5 +47,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
-summary: clsx / classnames for Ruby
+summary: The fastest conditional CSS class builder for Ruby
 test_files: []

data/CLAUDE.md

@@ -1,138 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-clsx-ruby is a Ruby gem that provides a utility (`clsx`/`cn`) for constructing CSS class strings conditionally. It's a Ruby port of the JavaScript [clsx](https://github.com/lukeed/clsx) package, adapted for Ruby conventions. Framework-agnostic — works with Rails, Sinatra, Hanami, or plain Ruby.
-
-## Common Commands
-
-```bash
-# Run all tests and linting (default rake task)
-bundle exec rake
-
-# Run tests only
-bundle exec rake test
-
-# Run a single test file
-bundle exec ruby -Itest test/clsx/helper_test.rb
-
-# Run a specific test method
-bundle exec ruby -Itest test/clsx/helper_test.rb -n test_with_strings
-
-# Run linter
-bundle exec rake rubocop
-
-# Run benchmark
-bundle exec ruby benchmark/run.rb
-
-# Install dependencies
-bin/setup
-
-# Release a new version (update version.rb first)
-# Builds gem, creates git tag, pushes to rubygems.org
-# OTP is fetched automatically from 1Password
-bundle exec rake release
-```
-
-## Architecture
-
-The gem has a minimal structure:
-
-- `lib/clsx.rb` - Entry point; extends `Clsx` with `Helper`, defines `Clsx[]` and `Cn[]` shortcuts
-- `lib/clsx/helper.rb` - Core implementation with `clsx` method and `cn` alias
-- `lib/clsx/version.rb` - Version constant
-
-### API
-
-- **`Clsx['foo', bar: true]`** — primary bracket API via `self.[]`
-- **`Cn['foo', bar: true]`** — short alias (defined only if `Cn` constant is not taken)
-- **`Clsx.clsx(...)`** / **`Clsx.cn(...)`** — module methods
-- **`include Clsx::Helper`** — mixin giving `clsx()` and `cn()` instance methods
-
-The helper uses an optimized algorithm with fast-paths for common cases (single string, string array, simple hash) and Hash-based deduplication for complex inputs.
-
-## Key Behaviors
-
-- Returns `nil` (not empty string) when no classes apply — prevents rendering empty `class=""` attributes
-- Eliminates duplicate classes automatically
-- Ruby falsy values are only `false` and `nil` (unlike JS, `0`, `''`, `[]`, `{}` are truthy)
-- Ignores `Proc`/lambda objects and boolean `true` values
-- Supports complex hash keys like `{ %w[foo bar] => true }` which resolve recursively
-
-## Benchmarking
-
-`benchmark/original.rb` contains the **previous version** of the algorithm for comparison. It must always reflect the last committed version from the main branch — not some ancient baseline.
-
-**Rule:** Before making any algorithm or performance change to `lib/clsx/helper.rb`, copy the current main-branch implementation into `benchmark/original.rb` (wrapping in `module ClsxOriginal` — method names stay the same, no renaming needed). This ensures `bundle exec ruby benchmark/run.rb` compares the new code against its immediate predecessor, giving meaningful before/after numbers.
-
-## Commit Convention
-
-This project follows [Conventional Commits v1.0.0](https://www.conventionalcommits.org/en/v1.0.0/).
-
-Format: `<type>[optional scope]: <description>`
-
-### Types
-
-| Type | Description | Version bump |
-|------|-------------|--------------|
-| `feat` | New feature | MINOR |
-| `fix` | Bug fix | PATCH |
-| `docs` | Documentation only | — |
-| `style` | Formatting, whitespace | — |
-| `refactor` | Code change (no feature/fix) | — |
-| `perf` | Performance improvement | — |
-| `test` | Adding/fixing tests | — |
-| `build` | Build system or dependencies | — |
-| `ci` | CI configuration | — |
-| `chore` | Maintenance tasks | — |
-
-### Breaking Changes
-
-Use `!` after type or add `BREAKING CHANGE:` footer. Breaking changes trigger a MAJOR version bump.
-
-## Changelog Format
-
-This project follows [Keep a Changelog v1.1.0](https://keepachangelog.com/en/1.1.0/).
-
-Allowed categories in **required order**:
-
-1. **Added** — new features
-2. **Changed** — changes to existing functionality
-3. **Deprecated** — soon-to-be removed features
-4. **Removed** — removed features
-5. **Fixed** — bug fixes
-6. **Security** — vulnerability fixes
-
-Rules:
-- Categories must appear in the order listed above within each release section
-- Each category must appear **at most once** per release section — always append to an existing category rather than creating a duplicate
-- Do NOT use non-standard categories like "Updated", "Internal", or "Breaking changes"
-- Breaking changes should be prefixed with **BREAKING:** within the relevant category (typically Changed or Removed)
-
-`CHANGELOG.md` must stay current on every feature branch. After each commit, ensure the `## Unreleased` section at the top accurately reflects all user-facing changes on the branch. Add the section if it doesn't exist. Keep entries concise — one bullet per logical change. On release, the `## Unreleased` heading gets replaced with the version number.
-
-The unreleased section describes the **net result** compared to the last release, not a history of intermediate steps. When a later change supersedes an earlier one, update or remove the stale bullet — don't accumulate entries that no longer reflect reality.
-
-## Documentation Style
-
-All classes and methods must have YARD documentation. Follow these conventions:
-
-- Always leave a **blank line** between the main description and `@` attributes (params, return, etc.)
-- Document all public methods with description, params, and return types
-- Document all private methods with params and return types, add description for complex logic
-- Include `@example` blocks for non-obvious usage patterns
-- **Omit descriptions that just repeat the code** — if the method name and signature make it obvious, only include `@param`, `@return` tags without a description
-
-## Releasing a New Version
-
-This project follows [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html):
-- **MAJOR** — breaking changes (incompatible API changes)
-- **MINOR** — new features (backwards-compatible)
-- **PATCH** — bug fixes (backwards-compatible)
-
-1. Update `lib/clsx/version.rb` with the new version number
-2. Update `CHANGELOG.md`: change `## Unreleased` to `## vX.Y.Z` and add new empty `## Unreleased` section
-3. Commit changes: `chore: bump version to X.Y.Z`
-4. Release: `bundle exec rake release`