tint_me 1.0.0 → 1.1.0

data/benchmark/2025-09-08-style-caching-optimization/03_prefix_only_caching_results.txt

@@ -1,107 +0,0 @@
-============================================================
-TIntMe Style Performance Benchmark
-============================================================
-
-Memory Usage Analysis:
-----------------------------------------
-Calculating -------------------------------------
- Create simple style     6.048k memsize (     0.000  retained)
-                        58.000  objects (     0.000  retained)
-                         2.000  strings (     0.000  retained)
-Create complex style     7.744k memsize (     0.000  retained)
-                        79.000  objects (     0.000  retained)
-                         9.000  strings (     0.000  retained)
-Apply simple style (short text)
-                       616.000  memsize (     0.000  retained)
-                         4.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-Apply complex style (short text)
-                       264.000  memsize (     0.000  retained)
-                         2.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-
-Comparison:
-Apply complex style (short text):        264 allocated
-Apply simple style (short text):        616 allocated - 2.33x more
- Create simple style:       6048 allocated - 22.91x more
-Create complex style:       7744 allocated - 29.33x more
-
-Performance Benchmark (operations per second):
-----------------------------------------
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
- Create simple style     2.927k i/100ms
-Create complex style     2.413k i/100ms
-Apply simple style (short)
-                       443.590k i/100ms
-Apply simple style (medium)
-                       395.847k i/100ms
-Apply simple style (long)
-                       378.681k i/100ms
-Apply complex style (short)
-                       321.759k i/100ms
-Apply complex style (medium)
-                       382.195k i/100ms
-Apply complex style (long)
-                       356.585k i/100ms
-Apply hex style (short)
-                       373.664k i/100ms
-Calculating -------------------------------------
- Create simple style     29.037k (± 3.1%) i/s   (34.44 μs/i) -    146.350k in   5.045026s
-Create complex style     24.894k (± 1.7%) i/s   (40.17 μs/i) -    125.476k in   5.042000s
-Apply simple style (short)
-                          4.428M (± 0.8%) i/s  (225.85 ns/i) -     22.180M in   5.009439s
-Apply simple style (medium)
-                          3.847M (± 1.4%) i/s  (259.95 ns/i) -     19.397M in   5.043123s
-Apply simple style (long)
-                          3.764M (± 1.6%) i/s  (265.69 ns/i) -     18.934M in   5.031865s
-Apply complex style (short)
-                          3.275M (± 1.0%) i/s  (305.32 ns/i) -     16.410M in   5.010664s
-Apply complex style (medium)
-                          3.748M (± 4.8%) i/s  (266.82 ns/i) -     18.728M in   5.012920s
-Apply complex style (long)
-                          3.469M (± 5.5%) i/s  (288.30 ns/i) -     17.473M in   5.056096s
-Apply hex style (short)
-                          3.747M (± 3.1%) i/s  (266.90 ns/i) -     19.057M in   5.092324s
-
-Comparison:
-Apply simple style (short):  4427800.1 i/s
-Apply simple style (medium):  3846907.6 i/s - 1.15x  slower
-Apply simple style (long):  3763792.3 i/s - 1.18x  slower
-Apply complex style (medium):  3747858.3 i/s - 1.18x  slower
-Apply hex style (short):  3746719.7 i/s - 1.18x  slower
-Apply complex style (long):  3468603.6 i/s - 1.28x  slower
-Apply complex style (short):  3275289.7 i/s - 1.35x  slower
- Create simple style:    29037.4 i/s - 152.49x  slower
-Create complex style:    24894.1 i/s - 177.87x  slower
-
-
-Repeated Application Benchmark:
-----------------------------------------
-Applying the same style 1000 times to measure caching benefit...
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
-  1000x simple style   497.000 i/100ms
- 1000x complex style   357.000 i/100ms
-     1000x hex style   426.000 i/100ms
-Calculating -------------------------------------
-  1000x simple style      4.961k (± 0.9%) i/s  (201.59 μs/i) -     24.850k in   5.009943s
- 1000x complex style      3.553k (± 3.4%) i/s  (281.45 μs/i) -     17.850k in   5.031381s
-     1000x hex style      4.171k (± 5.0%) i/s  (239.76 μs/i) -     20.874k in   5.019703s
-
-Comparison:
-  1000x simple style:     4960.5 i/s
-     1000x hex style:     4170.9 i/s - 1.19x  slower
- 1000x complex style:     3553.0 i/s - 1.40x  slower
-
-
-Object Allocation Analysis:
-----------------------------------------
-Create simple style: 117 objects allocated
-Create complex style: 136 objects allocated
-Apply simple style 100x: 104 objects allocated
-Apply complex style 100x: 104 objects allocated
-
-============================================================
-Benchmark complete!
-============================================================

data/benchmark/2025-09-08-style-caching-optimization/04_baseline_vs_optimized_analysis.txt

@@ -1,65 +0,0 @@
-PERFORMANCE COMPARISON ANALYSIS
-===============================
-
-## Before vs After Optimization Summary
-
-### Style Application Performance (ops/second)
-| Style Type | Before    | After     | Improvement |
-|------------|-----------|-----------|-------------|
-| Simple     | 766,000   | 5,444,000 | 7.1x faster |
-| Complex    | 437,000   | 3,834,000 | 8.8x faster |
-| Hex Color  | 266,000   | 4,656,000 | 17.5x faster|
-
-### Repeated Application (1000x, ops/second)
-| Style Type | Before | After | Improvement |
-|------------|--------|-------|-------------|
-| Simple     | 781    | 6,383 | 8.2x faster |
-| Complex    | 433    | 4,294 | 9.9x faster |
-| Hex        | 265    | 5,343 | 20.2x faster|
-
-### Object Allocations (100 applications)
-| Style Type | Before | After | Reduction |
-|------------|--------|-------|-----------|
-| Simple     | 703    | 104   | 85% less  |
-| Complex    | 1,203  | 104   | 91% less  |
-
-### Memory Usage Per Style Creation
-| Style Type | Before        | After         | Increase |
-|------------|---------------|---------------|----------|
-| Simple     | 5.8KB, 52 obj| 6.1KB, 58 obj | +6%      |
-| Complex    | 6.6KB, 66 obj| 7.8KB, 79 obj | +18%     |
-
-## Key Insights
-
-### Performance Gains
-1. **Hex colors see biggest improvement**: 17.5-20x faster
-   - RGB conversion now happens once at creation instead of every call
-   
-2. **Complex styles benefit most**: 8.8-9.9x faster
-   - Multiple SGR parameters cached as single string
-   
-3. **Simple styles still significant**: 7.1-8.2x faster
-   - Even basic styles benefit from eliminating repeated calculation
-
-### Memory Trade-offs
-1. **Creation cost acceptable**: 6-18% increase in creation memory
-   - Small price for immutable objects that may be called many times
-   
-2. **Runtime memory much better**: Massive reduction in per-call allocations
-   - 85-91% fewer objects created during style application
-   
-3. **Net positive for typical usage**: Any style called >2-3 times benefits
-
-### Algorithm Complexity Improvements
-1. **Before**: O(n) per call where n = number of style attributes
-2. **After**: O(1) per call - just string concatenation
-3. **One-time cost**: SGR sequence building moved to initialization
-
-## Recommendation
-The optimization is highly successful with minimal downsides:
-- Dramatic performance improvements across all scenarios
-- Acceptable memory trade-off for creation
-- Maintains identical API and behavior
-- Especially beneficial for repeated use (the common case)
-
-This change transforms Style from a computation-heavy operation to a simple string concatenation, making it suitable for high-frequency styling operations.

data/benchmark/2025-09-08-style-caching-optimization/05_caching_approaches_comparison.txt

@@ -1,59 +0,0 @@
-CACHING APPROACH COMPARISON
-===========================
-Date: 2025-09-08
-
-## Memory Usage Comparison (Style Creation)
-
-### With reset_code caching:
-- Simple style: 6.1KB, 58 objects
-- Complex style: 7.8KB, 79 objects
-
-### Without reset_code caching:
-- Simple style: 6.0KB, 58 objects (-8 bytes)
-- Complex style: 7.7KB, 79 objects (-8 bytes)
-
-**Memory savings: ~8 bytes per Style instance (negligible)**
-
-## Performance Comparison (ops/second)
-
-### Style Application Performance:
-| Style Type | With reset_code cache | Without reset_code cache | Difference |
-|------------|----------------------|---------------------------|------------|
-| Simple     | 5.44M                | 4.43M                     | 18% slower |
-| Complex    | 3.83M                | 3.28M                     | 14% slower |
-| Hex        | 4.66M                | 3.75M                     | 20% slower |
-
-### Repeated Application (1000x):
-| Style Type | With cache | Without cache | Difference |
-|------------|------------|---------------|------------|
-| Simple     | 6,383      | 4,961         | 22% slower |
-| Complex    | 4,294      | 3,553         | 17% slower |
-| Hex        | 5,343      | 4,171         | 22% slower |
-
-### Memory Usage Per Application:
-| Style Type | With cache | Without cache | Difference |
-|------------|------------|---------------|------------|
-| Simple     | 424 bytes  | 616 bytes     | +45% more |
-| Complex    | 264 bytes  | 264 bytes     | same      |
-
-## Analysis
-
-### Performance Impact:
-- **14-22% performance decrease** without reset_code caching
-- Simple styles show highest impact (22% slower)
-- Memory allocation per call increases for simple styles
-
-### Memory Trade-off:
-- **Minimal creation savings**: Only 8 bytes per Style instance
-- **Higher runtime cost**: Simple styles use 45% more memory per call
-- **Net negative**: More allocations during frequent usage
-
-### Recommendations:
-
-**Keep reset_code caching** because:
-1. Negligible memory savings (8 bytes) when removed
-2. Significant performance cost (14-22% slower)
-3. Increased runtime memory allocations
-4. Reset code is a constant string ("\e[0m") - perfect for caching
-
-The reset_code caching provides substantial performance benefits with minimal memory overhead, making it an optimal trade-off for the typical use case of applying styles multiple times.

data/benchmark/2025-09-08-style-caching-optimization/06_append_operator_results.txt

@@ -1,107 +0,0 @@
-============================================================
-TIntMe Style Performance Benchmark
-============================================================
-
-Memory Usage Analysis:
-----------------------------------------
-Calculating -------------------------------------
- Create simple style     6.056k memsize (     0.000  retained)
-                        58.000  objects (     0.000  retained)
-                         2.000  strings (     0.000  retained)
-Create complex style     7.752k memsize (     0.000  retained)
-                        79.000  objects (     0.000  retained)
-                         9.000  strings (     0.000  retained)
-Apply simple style (short text)
-                       424.000  memsize (     0.000  retained)
-                         3.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-Apply complex style (short text)
-                       264.000  memsize (     0.000  retained)
-                         2.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-
-Comparison:
-Apply complex style (short text):        264 allocated
-Apply simple style (short text):        424 allocated - 1.61x more
- Create simple style:       6056 allocated - 22.94x more
-Create complex style:       7752 allocated - 29.36x more
-
-Performance Benchmark (operations per second):
-----------------------------------------
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
- Create simple style     2.537k i/100ms
-Create complex style     2.341k i/100ms
-Apply simple style (short)
-                       466.725k i/100ms
-Apply simple style (medium)
-                       341.328k i/100ms
-Apply simple style (long)
-                       287.127k i/100ms
-Apply complex style (short)
-                       323.061k i/100ms
-Apply complex style (medium)
-                       336.757k i/100ms
-Apply complex style (long)
-                       303.412k i/100ms
-Apply hex style (short)
-                       237.369k i/100ms
-Calculating -------------------------------------
- Create simple style     28.350k (± 3.5%) i/s   (35.27 μs/i) -    142.072k in   5.018115s
-Create complex style     22.956k (± 8.6%) i/s   (43.56 μs/i) -    114.709k in   5.048226s
-Apply simple style (short)
-                          4.604M (± 1.7%) i/s  (217.20 ns/i) -     23.336M in   5.069941s
-Apply simple style (medium)
-                          3.365M (± 3.7%) i/s  (297.21 ns/i) -     17.066M in   5.080576s
-Apply simple style (long)
-                          3.071M (± 4.5%) i/s  (325.67 ns/i) -     15.505M in   5.059977s
-Apply complex style (short)
-                          3.362M (± 4.0%) i/s  (297.41 ns/i) -     16.799M in   5.006339s
-Apply complex style (medium)
-                          3.337M (± 1.8%) i/s  (299.70 ns/i) -     16.838M in   5.047809s
-Apply complex style (long)
-                          3.027M (± 6.1%) i/s  (330.32 ns/i) -     15.171M in   5.032030s
-Apply hex style (short)
-                          2.473M (± 1.8%) i/s  (404.40 ns/i) -     12.581M in   5.089276s
-
-Comparison:
-Apply simple style (short):  4604142.2 i/s
-Apply simple style (medium):  3364580.5 i/s - 1.37x  slower
-Apply complex style (short):  3362358.4 i/s - 1.37x  slower
-Apply complex style (medium):  3336720.3 i/s - 1.38x  slower
-Apply simple style (long):  3070605.6 i/s - 1.50x  slower
-Apply complex style (long):  3027356.7 i/s - 1.52x  slower
-Apply hex style (short):  2472779.1 i/s - 1.86x  slower
- Create simple style:    28349.6 i/s - 162.41x  slower
-Create complex style:    22956.2 i/s - 200.56x  slower
-
-
-Repeated Application Benchmark:
-----------------------------------------
-Applying the same style 1000 times to measure caching benefit...
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
-  1000x simple style   528.000 i/100ms
- 1000x complex style   362.000 i/100ms
-     1000x hex style   238.000 i/100ms
-Calculating -------------------------------------
-  1000x simple style      5.013k (± 7.6%) i/s  (199.47 μs/i) -     25.344k in   5.092091s
- 1000x complex style      3.694k (± 2.3%) i/s  (270.71 μs/i) -     18.462k in   5.000406s
-     1000x hex style      2.608k (± 5.6%) i/s  (383.40 μs/i) -     13.090k in   5.040010s
-
-Comparison:
-  1000x simple style:     5013.4 i/s
- 1000x complex style:     3694.0 i/s - 1.36x  slower
-     1000x hex style:     2608.3 i/s - 1.92x  slower
-
-
-Object Allocation Analysis:
-----------------------------------------
-Create simple style: 117 objects allocated
-Create complex style: 136 objects allocated
-Apply simple style 100x: 104 objects allocated
-Apply complex style 100x: 104 objects allocated
-
-============================================================
-Benchmark complete!
-============================================================

data/benchmark/2025-09-08-style-caching-optimization/07_string_concatenation_comparison.txt

@@ -1,66 +0,0 @@
-STRING CONCATENATION METHOD COMPARISON
-======================================
-Date: 2025-09-08
-
-## Performance Comparison: String Interpolation vs << Operator
-
-### Method Implementations
-
-#### String Interpolation (Original)
-```ruby
-def call(text)
-  return text if @prefix.empty?
-  "#{@prefix}#{text}#{@reset_code}"
-end
-```
-
-#### << Operator (Experimental) 
-```ruby
-def call(text)
-  return text if @prefix.empty?
-  @prefix.dup << text << @reset_code
-end
-```
-
-### Performance Results (ops/second)
-
-| Style Type | String Interpolation | << Operator | Performance Loss |
-|------------|---------------------|-------------|------------------|
-| Simple     | 5.44M/s             | 4.55M/s     | **16% slower**   |
-| Complex    | 3.83M/s             | 3.35M/s     | **13% slower**   |
-| Hex Color  | 4.66M/s             | 2.45M/s     | **47% slower**   |
-
-### Memory Usage (per application)
-
-| Implementation | Simple Style | Complex Style |
-|----------------|-------------|---------------|
-| String Interpolation | 424 bytes, 3 objects | 264 bytes, 2 objects |
-| << Operator          | 424 bytes, 3 objects | 264 bytes, 2 objects |
-
-*Memory usage appears identical*
-
-### Analysis
-
-#### Why << Operator is Slower:
-
-1. **Extra Copy Cost**: `@prefix.dup` creates unnecessary string copy
-2. **Multiple Operations**: Three separate `<<` calls vs single interpolation
-3. **Ruby Optimization**: String interpolation is highly optimized in Ruby
-4. **Hex Colors Impact**: Most significant performance hit (47% slower)
-
-#### Performance Loss Breakdown:
-
-- **Simple styles**: 16% slower due to dup + concatenation overhead
-- **Complex styles**: 13% slower, similar pattern
-- **Hex colors**: 47% slower, suggests interpolation especially optimized for longer strings
-
-### Conclusion
-
-**String interpolation (`"#{a}#{b}#{c}"`) is definitively superior** for this use case:
-
-- Consistently faster across all style types
-- No additional memory allocation overhead  
-- Leverages Ruby's built-in string interpolation optimizations
-- Simpler, more readable code
-
-The experiment confirms that the original implementation choice was optimal. Ruby's string interpolation is highly optimized and should be preferred over manual concatenation methods for performance-critical string building operations.

data/benchmark/2025-09-08-style-caching-optimization/08_with_freeze_optimization_results.txt

@@ -1,107 +0,0 @@
-============================================================
-TIntMe Style Performance Benchmark
-============================================================
-
-Memory Usage Analysis:
-----------------------------------------
-Calculating -------------------------------------
- Create simple style     6.056k memsize (     0.000  retained)
-                        58.000  objects (     0.000  retained)
-                         2.000  strings (     0.000  retained)
-Create complex style     7.752k memsize (     0.000  retained)
-                        79.000  objects (     0.000  retained)
-                         9.000  strings (     0.000  retained)
-Apply simple style (short text)
-                       424.000  memsize (     0.000  retained)
-                         3.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-Apply complex style (short text)
-                       264.000  memsize (     0.000  retained)
-                         2.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-
-Comparison:
-Apply complex style (short text):        264 allocated
-Apply simple style (short text):        424 allocated - 1.61x more
- Create simple style:       6056 allocated - 22.94x more
-Create complex style:       7752 allocated - 29.36x more
-
-Performance Benchmark (operations per second):
-----------------------------------------
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
- Create simple style     2.829k i/100ms
-Create complex style     2.405k i/100ms
-Apply simple style (short)
-                       551.851k i/100ms
-Apply simple style (medium)
-                       476.907k i/100ms
-Apply simple style (long)
-                       482.203k i/100ms
-Apply complex style (short)
-                       381.682k i/100ms
-Apply complex style (medium)
-                       455.559k i/100ms
-Apply complex style (long)
-                       417.965k i/100ms
-Apply hex style (short)
-                       470.351k i/100ms
-Calculating -------------------------------------
- Create simple style     27.161k (± 6.4%) i/s   (36.82 μs/i) -    135.792k in   5.024378s
-Create complex style     23.009k (± 4.3%) i/s   (43.46 μs/i) -    115.440k in   5.027763s
-Apply simple style (short)
-                          5.264M (± 3.8%) i/s  (189.96 ns/i) -     26.489M in   5.039995s
-Apply simple style (medium)
-                          4.621M (± 3.1%) i/s  (216.40 ns/i) -     23.368M in   5.061823s
-Apply simple style (long)
-                          4.478M (± 4.8%) i/s  (223.34 ns/i) -     22.664M in   5.074611s
-Apply complex style (short)
-                          3.685M (± 2.4%) i/s  (271.36 ns/i) -     18.702M in   5.078168s
-Apply complex style (medium)
-                          4.536M (± 4.8%) i/s  (220.45 ns/i) -     22.778M in   5.036293s
-Apply complex style (long)
-                          4.271M (± 7.5%) i/s  (234.13 ns/i) -     21.316M in   5.031500s
-Apply hex style (short)
-                          4.558M (± 3.7%) i/s  (219.39 ns/i) -     23.047M in   5.063931s
-
-Comparison:
-Apply simple style (short):  5264329.5 i/s
-Apply simple style (medium):  4621101.0 i/s - 1.14x  slower
-Apply hex style (short):  4558064.1 i/s - 1.15x  slower
-Apply complex style (medium):  4536089.7 i/s - 1.16x  slower
-Apply simple style (long):  4477533.0 i/s - 1.18x  slower
-Apply complex style (long):  4271132.9 i/s - 1.23x  slower
-Apply complex style (short):  3685074.9 i/s - 1.43x  slower
- Create simple style:    27161.3 i/s - 193.82x  slower
-Create complex style:    23008.5 i/s - 228.80x  slower
-
-
-Repeated Application Benchmark:
-----------------------------------------
-Applying the same style 1000 times to measure caching benefit...
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
-  1000x simple style   631.000 i/100ms
- 1000x complex style   412.000 i/100ms
-     1000x hex style   540.000 i/100ms
-Calculating -------------------------------------
-  1000x simple style      6.203k (± 2.1%) i/s  (161.20 μs/i) -     31.550k in   5.088346s
- 1000x complex style      4.119k (± 5.2%) i/s  (242.77 μs/i) -     20.600k in   5.018834s
-     1000x hex style      5.267k (± 2.8%) i/s  (189.85 μs/i) -     26.460k in   5.027249s
-
-Comparison:
-  1000x simple style:     6203.3 i/s
-     1000x hex style:     5267.4 i/s - 1.18x  slower
- 1000x complex style:     4119.1 i/s - 1.51x  slower
-
-
-Object Allocation Analysis:
-----------------------------------------
-Create simple style: 117 objects allocated
-Create complex style: 136 objects allocated
-Apply simple style 100x: 103 objects allocated
-Apply complex style 100x: 103 objects allocated
-
-============================================================
-Benchmark complete!
-============================================================

data/benchmark/2025-09-08-style-caching-optimization/09_freeze_optimization_analysis.txt

@@ -1,49 +0,0 @@
-FREEZE OPTIMIZATION ANALYSIS
-=============================
-Date: 2025-09-08
-
-## Implementation Change
-
-Added `.freeze` to the cached prefix string:
-
-```ruby
-# Before
-@prefix = sgr_builder.prefix_codes(...) 
-
-# After  
-@prefix = sgr_builder.prefix_codes(...).freeze
-```
-
-## Performance Comparison
-
-| Style Type | Without freeze | With freeze | Difference |
-|------------|----------------|-------------|------------|
-| Simple     | 5.44M/s        | 5.26M/s     | **3% slower** |
-| Complex    | 3.83M/s        | 3.69M/s     | **4% slower** |  
-| Hex Color  | 4.66M/s        | 4.56M/s     | **2% slower** |
-
-## Analysis
-
-### Why freeze didn't help (and slightly hurt):
-
-1. **String interpolation doesn't modify strings**: The operation `"#{@prefix}#{text}#{@reset_code}"` creates a new string without modifying the original strings, so freeze protection isn't needed.
-
-2. **Freeze call overhead**: The `.freeze` method call during initialization adds slight overhead without providing benefits for this use case.
-
-3. **Data.define already provides immutability**: The Style instance itself is frozen after `super`, providing sufficient protection.
-
-4. **Memory allocation patterns unchanged**: Freeze doesn't affect how string interpolation allocates memory.
-
-### When freeze would be beneficial:
-
-- If we were doing destructive operations like `@prefix << something`
-- If the strings were being passed to untrusted code
-- If we needed to prevent accidental modification in other parts of the codebase
-
-## Conclusion
-
-**Remove the freeze optimization** - it provides no performance benefit and adds unnecessary overhead.
-
-The original implementation without explicit freezing is optimal for this use case. Ruby's string interpolation is already highly optimized and doesn't require the strings to be frozen for maximum performance.
-
-**Recommendation**: Revert to the non-frozen version for best performance.

data/benchmark/2025-09-08-style-caching-optimization/10_constant_access_results.txt

@@ -1,107 +0,0 @@
-============================================================
-TIntMe Style Performance Benchmark
-============================================================
-
-Memory Usage Analysis:
-----------------------------------------
-Calculating -------------------------------------
- Create simple style     6.048k memsize (     0.000  retained)
-                        58.000  objects (     0.000  retained)
-                         2.000  strings (     0.000  retained)
-Create complex style     7.744k memsize (     0.000  retained)
-                        79.000  objects (     0.000  retained)
-                         9.000  strings (     0.000  retained)
-Apply simple style (short text)
-                       616.000  memsize (     0.000  retained)
-                         4.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-Apply complex style (short text)
-                       264.000  memsize (     0.000  retained)
-                         2.000  objects (     0.000  retained)
-                         1.000  strings (     0.000  retained)
-
-Comparison:
-Apply complex style (short text):        264 allocated
-Apply simple style (short text):        616 allocated - 2.33x more
- Create simple style:       6048 allocated - 22.91x more
-Create complex style:       7744 allocated - 29.33x more
-
-Performance Benchmark (operations per second):
-----------------------------------------
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
- Create simple style     2.828k i/100ms
-Create complex style     2.434k i/100ms
-Apply simple style (short)
-                       566.692k i/100ms
-Apply simple style (medium)
-                       492.842k i/100ms
-Apply simple style (long)
-                       493.077k i/100ms
-Apply complex style (short)
-                       388.767k i/100ms
-Apply complex style (medium)
-                       465.948k i/100ms
-Apply complex style (long)
-                       405.436k i/100ms
-Apply hex style (short)
-                       454.188k i/100ms
-Calculating -------------------------------------
- Create simple style     26.982k (± 6.8%) i/s   (37.06 μs/i) -    135.744k in   5.055760s
-Create complex style     22.324k (± 7.6%) i/s   (44.80 μs/i) -    111.964k in   5.048157s
-Apply simple style (short)
-                          5.383M (± 4.2%) i/s  (185.78 ns/i) -     27.201M in   5.062923s
-Apply simple style (medium)
-                          4.710M (± 5.8%) i/s  (212.30 ns/i) -     23.656M in   5.043190s
-Apply simple style (long)
-                          4.582M (± 3.1%) i/s  (218.23 ns/i) -     23.175M in   5.062439s
-Apply complex style (short)
-                          3.777M (± 3.0%) i/s  (264.78 ns/i) -     19.050M in   5.048997s
-Apply complex style (medium)
-                          4.664M (± 2.6%) i/s  (214.42 ns/i) -     23.763M in   5.099101s
-Apply complex style (long)
-                          4.359M (± 5.2%) i/s  (229.40 ns/i) -     21.894M in   5.038110s
-Apply hex style (short)
-                          4.689M (± 3.3%) i/s  (213.25 ns/i) -     23.618M in   5.042292s
-
-Comparison:
-Apply simple style (short):  5382832.4 i/s
-Apply simple style (medium):  4710226.6 i/s - 1.14x  slower
-Apply hex style (short):  4689404.2 i/s - 1.15x  slower
-Apply complex style (medium):  4663664.1 i/s - 1.15x  slower
-Apply simple style (long):  4582346.7 i/s - 1.17x  slower
-Apply complex style (long):  4359256.4 i/s - 1.23x  slower
-Apply complex style (short):  3776649.2 i/s - 1.43x  slower
- Create simple style:    26982.3 i/s - 199.50x  slower
-Create complex style:    22323.7 i/s - 241.13x  slower
-
-
-Repeated Application Benchmark:
-----------------------------------------
-Applying the same style 1000 times to measure caching benefit...
-ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
-Warming up --------------------------------------
-  1000x simple style   654.000 i/100ms
- 1000x complex style   379.000 i/100ms
-     1000x hex style   546.000 i/100ms
-Calculating -------------------------------------
-  1000x simple style      6.440k (± 1.6%) i/s  (155.28 μs/i) -     32.700k in   5.079043s
- 1000x complex style      4.218k (± 4.5%) i/s  (237.07 μs/i) -     21.224k in   5.044673s
-     1000x hex style      5.513k (± 2.2%) i/s  (181.39 μs/i) -     27.846k in   5.053459s
-
-Comparison:
-  1000x simple style:     6439.9 i/s
-     1000x hex style:     5513.1 i/s - 1.17x  slower
- 1000x complex style:     4218.1 i/s - 1.53x  slower
-
-
-Object Allocation Analysis:
-----------------------------------------
-Create simple style: 117 objects allocated
-Create complex style: 136 objects allocated
-Apply simple style 100x: 104 objects allocated
-Apply complex style 100x: 104 objects allocated
-
-============================================================
-Benchmark complete!
-============================================================