diff --git a/Cargo.toml b/Cargo.toml
index 1ede2d39..b44f5a59 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,6 +39,10 @@ criterion = { version = "0.7", features = ["html_reports"] }
 name = "basic"
 harness = false
 
+[[bench]]
+name = "style"
+harness = false
+
 # Example that requires the `picture` feature.
 [[example]]
 name = "read_picture_data"
diff --git a/benches/style.rs b/benches/style.rs
new file mode 100644
index 00000000..523c616a
--- /dev/null
+++ b/benches/style.rs
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright 2016-2025, Johann Tuffe.
+
+//! Benchmarks for style parsing and extraction features.
+//!
+//! Uses `tests/styles_1M.xlsx` (1M styled cells) for realistic performance
+//! measurement.
+//!
+//! ## Run benchmarks
+//!
+//! ```bash
+//! cargo bench --bench style
+//! ```
+//!
+//! ## Profiling (identify bottlenecks)
+//!
+//! Install samply (cross-platform, works on macOS and Linux):
+//! ```bash
+//! cargo install samply
+//! ```
+//!
+//! Profile a specific benchmark:
+//! ```bash
+//! samply record cargo bench --bench style -- "style/worksheet_style" --profile-time 5
+//! ```
+//!
+//! This opens Firefox Profiler with an interactive flamegraph showing where time is spent.
+
+use calamine::{open_workbook, Reader, Xlsx};
+use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};
+use std::fs::File;
+use std::hint::black_box;
+use std::io::BufReader;
+use std::time::Duration;
+
+const LARGE_FILE: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/styles_1M.xlsx");
+
+fn configure(c: &mut Criterion) -> criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> {
+    let mut group = c.benchmark_group("style");
+    group.sample_size(10);
+    group.warm_up_time(Duration::from_millis(100));
+    group.measurement_time(Duration::from_secs(15)); // Accommodate slowest benchmark (~1.2s × 10)
+    group.sampling_mode(SamplingMode::Flat); // 1 iteration per sample for slow benchmarks
+    group
+}
+
+fn bench_style_parsing(c: &mut Criterion) {
+    if !std::path::Path::new(LARGE_FILE).exists() {
+        eprintln!("ERROR: tests/styles_1M.xlsx not found.");
+        return;
+    }
+
+    let mut group = configure(c);
+
+    // Core style parsing
+    group.bench_function("worksheet_style", |b| {
+        b.iter(|| {
+            let mut excel: Xlsx<BufReader<File>> =
+                open_workbook(LARGE_FILE).expect("cannot open file");
+            black_box(excel.worksheet_style("Sheet 1").unwrap())
+        })
+    });
+
+    // Layout parsing (column widths, row heights)
+    group.bench_function("worksheet_layout", |b| {
+        b.iter(|| {
+            let mut excel: Xlsx<BufReader<File>> =
+                open_workbook(LARGE_FILE).expect("cannot open file");
+            black_box(excel.worksheet_layout("Sheet 1").unwrap())
+        })
+    });
+
+    // Range parsing (cell values only, no styles)
+    group.bench_function("worksheet_range", |b| {
+        b.iter(|| {
+            let mut excel: Xlsx<BufReader<File>> =
+                open_workbook(LARGE_FILE).expect("cannot open file");
+            black_box(excel.worksheet_range("Sheet 1").unwrap())
+        })
+    });
+
+    // Combined range + style (common real-world usage)
+    group.bench_function("range_and_style", |b| {
+        b.iter(|| {
+            let mut excel: Xlsx<BufReader<File>> =
+                open_workbook(LARGE_FILE).expect("cannot open file");
+            let range = excel.worksheet_range("Sheet 1").unwrap();
+            let style = excel.worksheet_style("Sheet 1").unwrap();
+            black_box((range.cells().count(), style.cells().count()))
+        })
+    });
+
+    // Cell-by-cell iteration via cells_reader
+    group.bench_function("cells_reader", |b| {
+        b.iter(|| {
+            let mut excel: Xlsx<BufReader<File>> =
+                open_workbook(LARGE_FILE).expect("cannot open file");
+            let mut reader = excel.worksheet_cells_reader("Sheet 1").unwrap();
+            let mut count = 0usize;
+            while let Ok(Some(_)) = reader.next_cell() {
+                count += 1;
+            }
+            black_box(count)
+        })
+    });
+
+    // Iterate and access ALL style properties
+    group.bench_function("iterate_all_properties", |b| {
+        b.iter(|| {
+            let mut excel: Xlsx<BufReader<File>> =
+                open_workbook(LARGE_FILE).expect("cannot open file");
+            let styles = excel.worksheet_style("Sheet 1").unwrap();
+            let mut count = 0usize;
+            for (_, _, style) in styles.cells() {
+                if style.get_font().is_some() {
+                    count += 1;
+                }
+                if style.get_fill().is_some() {
+                    count += 1;
+                }
+                if style.borders.is_some() {
+                    count += 1;
+                }
+                if style.get_alignment().is_some() {
+                    count += 1;
+                }
+                if style.get_number_format().is_some() {
+                    count += 1;
+                }
+            }
+            black_box(count)
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_style_parsing);
+criterion_main!(benches);
diff --git a/examples/README.md b/examples/README.md
index 89b109f8..844b292c 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -16,6 +16,8 @@ This directory contains some example of Calamine usage.
 - `read_hyperlinks.rs`: Reads the hyperlinks defined in an XLSX worksheet,
   either by sheet name or by sheet index.
 - `read_picture_data.rs`: Reads pictures and their metadata from an XLSX file.
+- `read_row_and_column_dimensions.rs`: Reads the column widths and row heights
+  (the worksheet layout) from an XLSX file.
 
 ### Serialization examples
 
diff --git a/examples/excel_to_csv.rs b/examples/excel_to_csv.rs
index b2d41f49..96f4897a 100644
--- a/examples/excel_to_csv.rs
+++ b/examples/excel_to_csv.rs
@@ -68,6 +68,7 @@ fn write_to_csv<W: Write>(output_file: &mut W, range: &Range<Data>) -> std::io::
                 Data::String(s) | Data::DateTimeIso(s) | Data::DurationIso(s) => {
                     write!(output_file, "{s}")
                 }
+                Data::RichText(r) => write!(output_file, "{}", r.plain_text()),
             }?;
 
             // Write the field separator except for the last column.
diff --git a/examples/read_row_and_column_dimensions.rs b/examples/read_row_and_column_dimensions.rs
new file mode 100644
index 00000000..73dce696
--- /dev/null
+++ b/examples/read_row_and_column_dimensions.rs
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright 2016-2025, Johann Tuffe.
+
+use calamine::{open_workbook, Reader, Xlsx};
+
+/// Example demonstrating how to capture column widths and row heights from Excel files
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Open an Excel file
+    let path = "tests/styles.xlsx";
+    let mut workbook: Xlsx<_> = open_workbook(path)?;
+
+    // Get the first sheet name
+    let sheet_names = workbook.sheet_names();
+    if let Some(sheet_name) = sheet_names.first() {
+        println!("Getting layout information for sheet: {}", sheet_name);
+
+        // Get the worksheet layout information (column widths and row heights)
+        let layout = workbook.worksheet_layout(sheet_name)?;
+
+        // Display default dimensions
+        if let Some(default_col_width) = layout.default_column_width {
+            println!("Default column width: {} characters", default_col_width);
+        }
+        if let Some(default_row_height) = layout.default_row_height {
+            println!("Default row height: {} points", default_row_height);
+        }
+
+        // Display custom column widths
+        if !layout.column_widths.is_empty() {
+            println!("\nCustom column widths:");
+            for col_width in layout.column_widths.values() {
+                println!(
+                    "  Column {}: {} characters (custom: {}, hidden: {}, best_fit: {})",
+                    col_width.column,
+                    col_width.width,
+                    col_width.custom_width,
+                    col_width.hidden,
+                    col_width.best_fit
+                );
+            }
+        }
+
+        // Display custom row heights
+        if !layout.row_heights.is_empty() {
+            println!("\nCustom row heights:");
+            for row_height in layout.row_heights.values() {
+                println!(
+                    "  Row {}: {} points (custom: {}, hidden: {})",
+                    row_height.row, row_height.height, row_height.custom_height, row_height.hidden
+                );
+            }
+        }
+
+        // Example of using the helper methods
+        println!("\nExample queries:");
+        let effective_width_0 = layout.get_effective_column_width(0);
+        let effective_height_0 = layout.get_effective_row_height(0);
+        println!(
+            "Effective width of column 0: {} characters",
+            effective_width_0
+        );
+        println!("Effective height of row 0: {} points", effective_height_0);
+
+        // Check if a specific column has custom width
+        if let Some(col_width) = layout.get_column_width(0) {
+            println!("Column 0 has custom width: {}", col_width.width);
+        } else {
+            println!("Column 0 uses default width");
+        }
+
+        // Check if layout has any custom dimensions
+        if layout.has_custom_dimensions() {
+            println!("This worksheet has custom column widths or row heights");
+        } else {
+            println!("This worksheet uses all default dimensions");
+        }
+    }
+
+    Ok(())
+}
diff --git a/examples/style.rs b/examples/style.rs
new file mode 100644
index 00000000..3615128c
--- /dev/null
+++ b/examples/style.rs
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright 2016-2025, Johann Tuffe.
+
+use calamine::{Cell, Color, Data, Font, FontWeight, Style};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Example of creating a cell with style
+    let style = Style::new().with_font(
+        Font::new()
+            .with_name("Arial".to_string())
+            .with_size(12.0)
+            .with_weight(FontWeight::Bold)
+            .with_color(Color::rgb(255, 0, 0)),
+    );
+
+    let cell = Cell::with_style((0, 0), Data::String("Hello World".to_string()), style);
+
+    println!("Created cell with style:");
+    if let Some(cell_style) = cell.get_style() {
+        if let Some(font) = cell_style.get_font() {
+            println!(
+                "  Font: {} (size: {})",
+                font.name.as_deref().unwrap_or("Unknown"),
+                font.size.unwrap_or(0.0)
+            );
+            println!("  Bold: {}", font.is_bold());
+            if let Some(color) = font.color {
+                println!("  Color: {}", color);
+            }
+        }
+    }
+
+    // Example of creating CellData with style
+    use calamine::CellData;
+
+    let cell_data = CellData::with_style(
+        Data::Int(42),
+        Style::new().with_font(Font::new().with_weight(FontWeight::Bold)),
+    );
+
+    println!("\nCreated CellData with style:");
+    if cell_data.has_style() {
+        if let Some(style) = cell_data.get_style() {
+            if let Some(font) = style.get_font() {
+                println!("  Bold: {}", font.is_bold());
+            }
+        }
+    }
+
+    // Example of creating a more complex style
+    let complex_style = Style::new()
+        .with_font(
+            Font::new()
+                .with_name("Times New Roman".to_string())
+                .with_size(14.0)
+                .with_weight(FontWeight::Bold)
+                .with_color(Color::rgb(0, 0, 255)),
+        )
+        .with_fill(calamine::Fill::solid(Color::rgb(255, 255, 0)))
+        .with_borders(calamine::Borders::new());
+
+    let styled_cell = Cell::with_style((1, 1), Data::Float(42.0), complex_style);
+
+    println!("\nCreated cell with complex style:");
+    if let Some(style) = styled_cell.get_style() {
+        if let Some(font) = style.get_font() {
+            println!(
+                "  Font: {} (size: {})",
+                font.name.as_deref().unwrap_or("Unknown"),
+                font.size.unwrap_or(0.0)
+            );
+            println!("  Bold: {}", font.is_bold());
+            if let Some(color) = font.color {
+                println!("  Font color: {}", color);
+            }
+        }
+
+        if let Some(fill) = style.get_fill() {
+            if fill.is_visible() {
+                println!("  Has fill");
+                if let Some(color) = fill.get_color() {
+                    println!("  Fill color: {}", color);
+                }
+            }
+        }
+    }
+
+    println!("\nStyle system is working correctly!");
+
+    Ok(())
+}
diff --git a/src/auto.rs b/src/auto.rs
index a380b26f..b8a8594c 100644
--- a/src/auto.rs
+++ b/src/auto.rs
@@ -10,7 +10,7 @@ use crate::vba::VbaProject;
 use crate::Picture;
 use crate::{
     open_workbook, open_workbook_from_rs, Data, DataRef, HeaderRow, Metadata, Ods, Range, Reader,
-    ReaderRef, Xls, Xlsb, Xlsx,
+    ReaderRef, StyleRange, WorksheetLayout, Xls, Xlsb, Xlsx,
 };
 
 use std::fs::File;
@@ -147,6 +147,24 @@ where
         }
     }
 
+    fn worksheet_style(&mut self, name: &str) -> Result<StyleRange, Self::Error> {
+        match self {
+            Sheets::Xls(ref mut e) => e.worksheet_style(name).map_err(Error::Xls),
+            Sheets::Xlsx(ref mut e) => e.worksheet_style(name).map_err(Error::Xlsx),
+            Sheets::Xlsb(ref mut e) => e.worksheet_style(name).map_err(Error::Xlsb),
+            Sheets::Ods(ref mut e) => e.worksheet_style(name).map_err(Error::Ods),
+        }
+    }
+
+    fn worksheet_layout(&mut self, name: &str) -> Result<WorksheetLayout, Self::Error> {
+        match self {
+            Sheets::Xls(ref mut e) => e.worksheet_layout(name).map_err(Error::Xls),
+            Sheets::Xlsx(ref mut e) => e.worksheet_layout(name).map_err(Error::Xlsx),
+            Sheets::Xlsb(ref mut e) => e.worksheet_layout(name).map_err(Error::Xlsb),
+            Sheets::Ods(ref mut e) => e.worksheet_layout(name).map_err(Error::Ods),
+        }
+    }
+
     fn worksheets(&mut self) -> Vec<(String, Range<Data>)> {
         match self {
             Sheets::Xls(e) => e.worksheets(),
diff --git a/src/datatype.rs b/src/datatype.rs
index 567b951d..f7f24ea9 100644
--- a/src/datatype.rs
+++ b/src/datatype.rs
@@ -10,6 +10,8 @@ use serde::de::Visitor;
 use serde::Deserialize;
 
 use super::CellErrorType;
+use super::RichText;
+use super::Style;
 
 // Constants used in Excel date calculations.
 const DAY_SECONDS: f64 = 24.0 * 60.0 * 60.;
@@ -30,8 +32,59 @@ const EXCEL_1900_1904_DIFF: f64 = 1462.;
 #[cfg(feature = "chrono")]
 const MS_MULTIPLIER: f64 = 24f64 * 60f64 * 60f64 * 1e+3f64;
 
+/// A struct that combines cell value and style information.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct CellData {
+    /// The cell value
+    pub value: Data,
+    /// The cell style
+    pub style: Option<Style>,
+}
+
+impl CellData {
+    /// Create a new CellData with just a value.
+    pub fn new(value: Data) -> Self {
+        Self { value, style: None }
+    }
+
+    /// Create a new CellData with value and style.
+    pub fn with_style(value: Data, style: Style) -> Self {
+        Self {
+            value,
+            style: Some(style),
+        }
+    }
+
+    /// Get the cell value.
+    pub fn get_value(&self) -> &Data {
+        &self.value
+    }
+
+    /// Get the cell style.
+    pub fn get_style(&self) -> Option<&Style> {
+        self.style.as_ref()
+    }
+
+    /// Check if the cell has style information.
+    pub fn has_style(&self) -> bool {
+        self.style.is_some()
+    }
+}
+
+impl From<Data> for CellData {
+    fn from(value: Data) -> Self {
+        Self::new(value)
+    }
+}
+
+impl From<CellData> for Data {
+    fn from(cell_data: CellData) -> Self {
+        cell_data.value
+    }
+}
+
 /// An enum to represent all different data types that can appear as
-/// a value in a worksheet cell
+/// a value in a worksheet cell.
 #[derive(Debug, Clone, PartialEq, Default)]
 pub enum Data {
     /// Signed integer
@@ -40,13 +93,15 @@ pub enum Data {
     Float(f64),
     /// String
     String(String),
+    /// Rich text with multiple formatted runs.
+    RichText(RichText),
     /// Boolean
     Bool(bool),
     /// Date or Time
     DateTime(ExcelDateTime),
-    /// Date, Time or Date/Time in ISO 8601
+    /// Date, Time or Date/Time in ISO 8601.
     DateTimeIso(String),
-    /// Duration in ISO 8601
+    /// Duration in ISO 8601.
     DurationIso(String),
     /// Error
     Error(CellErrorType),
@@ -56,7 +111,7 @@ pub enum Data {
 }
 
 /// An enum to represent all different data types that can appear as
-/// a value in a worksheet cell
+/// a value in a worksheet cell.
 impl DataType for Data {
     fn is_empty(&self) -> bool {
         *self == Data::Empty
@@ -71,7 +126,11 @@ impl DataType for Data {
         matches!(*self, Data::Bool(_))
     }
     fn is_string(&self) -> bool {
-        matches!(*self, Data::String(_))
+        matches!(*self, Data::String(_) | Data::RichText(_))
+    }
+
+    fn is_rich_text(&self) -> bool {
+        matches!(*self, Data::RichText(_))
     }
 
     fn is_duration_iso(&self) -> bool {
@@ -119,6 +178,14 @@ impl DataType for Data {
         }
     }
 
+    fn get_rich_text(&self) -> Option<&RichText> {
+        if let Data::RichText(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
     fn get_datetime(&self) -> Option<ExcelDateTime> {
         match self {
             Data::DateTime(v) => Some(*v),
@@ -152,6 +219,7 @@ impl DataType for Data {
             Data::Float(v) => Some(v.to_string()),
             Data::Int(v) => Some(v.to_string()),
             Data::String(v) => Some(v.clone()),
+            Data::RichText(v) => Some(v.plain_text()),
             _ => None,
         }
     }
@@ -213,6 +281,7 @@ impl fmt::Display for Data {
             Data::Int(e) => write!(f, "{e}"),
             Data::Float(e) => write!(f, "{e}"),
             Data::String(e) => write!(f, "{e}"),
+            Data::RichText(e) => write!(f, "{e}"),
             Data::Bool(e) => write!(f, "{e}"),
             Data::DateTime(e) => write!(f, "{e}"),
             Data::DateTimeIso(e) => write!(f, "{e}"),
@@ -307,6 +376,7 @@ macro_rules! define_from {
 define_from!(Data::Int, i64);
 define_from!(Data::Float, f64);
 define_from!(Data::String, String);
+define_from!(Data::RichText, RichText);
 define_from!(Data::Bool, bool);
 define_from!(Data::Error, CellErrorType);
 
@@ -335,7 +405,7 @@ where
 }
 
 /// An enum to represent all different data types that can appear as
-/// a value in a worksheet cell
+/// a value in a worksheet cell.
 #[derive(Debug, Clone, PartialEq, Default)]
 pub enum DataRef<'a> {
     /// Signed integer
@@ -346,13 +416,15 @@ pub enum DataRef<'a> {
     String(String),
     /// Shared String
     SharedString(&'a str),
+    /// Shared Rich Text (reference to rich text in shared strings table)
+    SharedRichText(&'a RichText),
     /// Boolean
     Bool(bool),
     /// Date or Time
     DateTime(ExcelDateTime),
-    /// Date, Time or Date/Time in ISO 8601
+    /// Date, Time or Date/Time in ISO 8601.
     DateTimeIso(String),
-    /// Duration in ISO 8601
+    /// Duration in ISO 8601.
     DurationIso(String),
     /// Error
     Error(CellErrorType),
@@ -379,7 +451,14 @@ impl DataType for DataRef<'_> {
     }
 
     fn is_string(&self) -> bool {
-        matches!(*self, DataRef::String(_) | DataRef::SharedString(_))
+        matches!(
+            *self,
+            DataRef::String(_) | DataRef::SharedString(_) | DataRef::SharedRichText(_)
+        )
+    }
+
+    fn is_rich_text(&self) -> bool {
+        matches!(*self, DataRef::SharedRichText(_))
     }
 
     fn is_duration_iso(&self) -> bool {
@@ -430,6 +509,13 @@ impl DataType for DataRef<'_> {
         }
     }
 
+    fn get_rich_text(&self) -> Option<&RichText> {
+        match self {
+            DataRef::SharedRichText(rt) => Some(rt),
+            _ => None,
+        }
+    }
+
     fn get_datetime(&self) -> Option<ExcelDateTime> {
         match self {
             DataRef::DateTime(v) => Some(*v),
@@ -464,6 +550,7 @@ impl DataType for DataRef<'_> {
             DataRef::Int(v) => Some(v.to_string()),
             DataRef::String(v) => Some(v.clone()),
             DataRef::SharedString(v) => Some(v.to_string()),
+            DataRef::SharedRichText(v) => Some(v.plain_text()),
             _ => None,
         }
     }
@@ -522,69 +609,75 @@ impl PartialEq<i64> for DataRef<'_> {
 }
 
 /// A trait to represent all different data types that can appear as
-/// a value in a worksheet cell
+/// a value in a worksheet cell.
 pub trait DataType {
-    /// Assess if datatype is empty
+    /// Assess if datatype is empty.
     fn is_empty(&self) -> bool;
 
-    /// Assess if datatype is a int
+    /// Assess if datatype is a int.
     fn is_int(&self) -> bool;
 
-    /// Assess if datatype is a float
+    /// Assess if datatype is a float.
     fn is_float(&self) -> bool;
 
-    /// Assess if datatype is a bool
+    /// Assess if datatype is a bool.
     fn is_bool(&self) -> bool;
 
-    /// Assess if datatype is a string
+    /// Assess if datatype is a string (includes rich text)
     fn is_string(&self) -> bool;
 
+    /// Assess if datatype is rich text (string with formatting)
+    fn is_rich_text(&self) -> bool;
+
     /// Assess if datatype is a `CellErrorType`
     fn is_error(&self) -> bool;
 
-    /// Assess if datatype is an ISO8601 duration
+    /// Assess if datatype is an ISO8601 duration.
     fn is_duration_iso(&self) -> bool;
 
-    /// Assess if datatype is a datetime
+    /// Assess if datatype is a datetime.
     fn is_datetime(&self) -> bool;
 
-    /// Assess if datatype is an ISO8601 datetime
+    /// Assess if datatype is an ISO8601 datetime.
     fn is_datetime_iso(&self) -> bool;
 
-    /// Try getting int value
+    /// Try getting int value.
     fn get_int(&self) -> Option<i64>;
 
-    /// Try getting float value
+    /// Try getting float value.
     fn get_float(&self) -> Option<f64>;
 
-    /// Try getting bool value
+    /// Try getting bool value.
     fn get_bool(&self) -> Option<bool>;
 
-    /// Try getting string value
+    /// Try getting string value (plain string only, not rich text)
     fn get_string(&self) -> Option<&str>;
 
-    /// Try getting datetime value
+    /// Try getting rich text value.
+    fn get_rich_text(&self) -> Option<&RichText>;
+
+    /// Try getting datetime value.
     fn get_datetime(&self) -> Option<ExcelDateTime>;
 
-    /// Try getting datetime ISO8601 value
+    /// Try getting datetime ISO8601 value.
     fn get_datetime_iso(&self) -> Option<&str>;
 
-    /// Try getting duration ISO8601 value
+    /// Try getting duration ISO8601 value.
     fn get_duration_iso(&self) -> Option<&str>;
 
-    /// Try getting Error value
+    /// Try getting Error value.
     fn get_error(&self) -> Option<&CellErrorType>;
 
-    /// Try converting data type into a string
+    /// Try converting data type into a string (includes rich text as plain text)
     fn as_string(&self) -> Option<String>;
 
-    /// Try converting data type into an int
+    /// Try converting data type into an int.
     fn as_i64(&self) -> Option<i64>;
 
-    /// Try converting data type into a float
+    /// Try converting data type into a float.
     fn as_f64(&self) -> Option<f64>;
 
-    /// Try converting data type into a date
+    /// Try converting data type into a date.
     #[cfg(feature = "chrono")]
     #[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
     fn as_date(&self) -> Option<chrono::NaiveDate> {
@@ -599,7 +692,7 @@ pub trait DataType {
         }
     }
 
-    /// Try converting data type into a time
+    /// Try converting data type into a time.
     #[cfg(feature = "chrono")]
     #[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
     fn as_time(&self) -> Option<chrono::NaiveTime> {
@@ -617,7 +710,7 @@ pub trait DataType {
         }
     }
 
-    /// Try converting data type into a duration
+    /// Try converting data type into a duration.
     #[cfg(feature = "chrono")]
     #[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
     fn as_duration(&self) -> Option<chrono::Duration> {
@@ -665,6 +758,7 @@ impl<'a> From<DataRef<'a>> for Data {
             DataRef::Float(v) => Data::Float(v),
             DataRef::String(v) => Data::String(v),
             DataRef::SharedString(v) => Data::String(v.into()),
+            DataRef::SharedRichText(v) => Data::RichText(v.clone()),
             DataRef::Bool(v) => Data::Bool(v),
             DataRef::DateTime(v) => Data::DateTime(v),
             DataRef::DateTimeIso(v) => Data::DateTimeIso(v),
@@ -722,28 +816,28 @@ impl ExcelDateTime {
         matches!(self.datetime_type, ExcelDateTimeType::DateTime)
     }
 
-    /// Converting data type into a float
+    /// Converting data type into a float.
     pub fn as_f64(&self) -> f64 {
         self.value
     }
 
     /// Convert an Excel serial datetime to standard date components.
     ///
-    /// Datetimes in Excel are serial dates with days counted from an epoch
-    /// (usually 1900-01-01) and where the time is a percentage/decimal of the
-    /// milliseconds in the day. Both the date and time are stored in the same
+    /// Datetimes in Excel are serial dates with days counted from an epoch.
+    /// (usually 1900-01-01) and where the time is a percentage/decimal of the.
+    /// milliseconds in the day. Both the date and time are stored in the same.
     /// f64 value. For example, 2025/10/13 12:00:00 is stored as 45943.5.
     ///
-    /// This function returns a tuple of (year, month, day, hour, minutes,
-    /// seconds, milliseconds). It works for serial dates in both the 1900 and
+    /// This function returns a tuple of (year, month, day, hour, minutes,.
+    /// seconds, milliseconds). It works for serial dates in both the 1900 and.
     /// 1904 epochs.
     ///
-    /// This function always returns a date, even if the serial value is outside
-    /// of Excel's range of `0.0 <= datetime < 10000.0`. It also returns, as
-    /// Excel does, the invalid date 1900/02/29 due to the [Excel 1900 leap year
+    /// This function always returns a date, even if the serial value is outside.
+    /// of Excel's range of `0.0 <= datetime < 10000.0`. It also returns, as.
+    /// Excel does, the invalid date 1900/02/29 due to the [Excel 1900 leap year.
     /// bug](https://en.wikipedia.org/wiki/Leap_year_problem#Occurrences).
     ///
-    /// Excel only supports millisecond precision and it also doesn't use or
+    /// Excel only supports millisecond precision and it also doesn't use or.
     /// encode timezone information in any way.
     ///
     /// # Examples
@@ -758,10 +852,10 @@ impl ExcelDateTime {
     /// let excel_datetime = ExcelDateTime::new(
     ///     45943.541,
     ///     ExcelDateTimeType::DateTime,
-    ///     false, // Using 1900 epoch (not 1904).
+    ///     false, // Using 1900 epoch (not 1904)
     /// );
     ///
-    /// // Convert to standard date/time components.
+    /// // Convert to standard date/time components
     /// let (year, month, day, hour, min, sec, milli) = excel_datetime.to_ymd_hms_milli();
     ///
     /// assert_eq!(year, 2025);
@@ -1069,6 +1163,91 @@ mod date_tests {
     }
 }
 
+/// An enum to represent all different data types that can appear as
+/// a value in a worksheet cell.
+impl DataType for CellData {
+    fn is_empty(&self) -> bool {
+        self.value.is_empty()
+    }
+    fn is_int(&self) -> bool {
+        self.value.is_int()
+    }
+    fn is_float(&self) -> bool {
+        self.value.is_float()
+    }
+    fn is_bool(&self) -> bool {
+        self.value.is_bool()
+    }
+    fn is_string(&self) -> bool {
+        self.value.is_string()
+    }
+
+    fn is_rich_text(&self) -> bool {
+        self.value.is_rich_text()
+    }
+
+    fn is_duration_iso(&self) -> bool {
+        self.value.is_duration_iso()
+    }
+
+    fn is_datetime(&self) -> bool {
+        self.value.is_datetime()
+    }
+
+    fn is_datetime_iso(&self) -> bool {
+        self.value.is_datetime_iso()
+    }
+
+    fn is_error(&self) -> bool {
+        self.value.is_error()
+    }
+
+    fn get_int(&self) -> Option<i64> {
+        self.value.get_int()
+    }
+    fn get_float(&self) -> Option<f64> {
+        self.value.get_float()
+    }
+    fn get_bool(&self) -> Option<bool> {
+        self.value.get_bool()
+    }
+    fn get_string(&self) -> Option<&str> {
+        self.value.get_string()
+    }
+
+    fn get_rich_text(&self) -> Option<&RichText> {
+        self.value.get_rich_text()
+    }
+
+    fn get_datetime(&self) -> Option<ExcelDateTime> {
+        self.value.get_datetime()
+    }
+
+    fn get_datetime_iso(&self) -> Option<&str> {
+        self.value.get_datetime_iso()
+    }
+
+    fn get_duration_iso(&self) -> Option<&str> {
+        self.value.get_duration_iso()
+    }
+
+    fn get_error(&self) -> Option<&CellErrorType> {
+        self.value.get_error()
+    }
+
+    fn as_string(&self) -> Option<String> {
+        self.value.as_string()
+    }
+
+    fn as_i64(&self) -> Option<i64> {
+        self.value.as_i64()
+    }
+
+    fn as_f64(&self) -> Option<f64> {
+        self.value.as_f64()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/de.rs b/src/de.rs
index 94bfd55a..160e1eff 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -655,6 +655,7 @@ impl<'a, 'de> serde::Deserializer<'de> for DataDeserializer<'a> {
     {
         match self.data_type {
             Data::String(v) => visitor.visit_str(v),
+            Data::RichText(v) => visitor.visit_str(&v.plain_text()),
             Data::Float(v) => visitor.visit_f64(*v),
             Data::Bool(v) => visitor.visit_bool(*v),
             Data::Int(v) => visitor.visit_i64(*v),
@@ -675,6 +676,7 @@ impl<'a, 'de> serde::Deserializer<'de> for DataDeserializer<'a> {
     {
         match self.data_type {
             Data::String(v) => visitor.visit_str(v),
+            Data::RichText(v) => visitor.visit_str(&v.plain_text()),
             Data::Empty => visitor.visit_str(""),
             Data::Float(v) => visitor.visit_str(&v.to_string()),
             Data::Int(v) => visitor.visit_str(&v.to_string()),
@@ -729,6 +731,14 @@ impl<'a, 'de> serde::Deserializer<'de> for DataDeserializer<'a> {
                 "FALSE" | "false" | "False" => visitor.visit_bool(false),
                 d => Err(DeError::Custom(format!("Expecting bool, got '{d}'"))),
             },
+            Data::RichText(v) => {
+                let text = v.plain_text();
+                match text.as_str() {
+                    "TRUE" | "true" | "True" => visitor.visit_bool(true),
+                    "FALSE" | "false" | "False" => visitor.visit_bool(false),
+                    d => Err(DeError::Custom(format!("Expecting bool, got '{d}'"))),
+                }
+            }
             Data::Empty => visitor.visit_bool(false),
             Data::Float(v) => visitor.visit_bool(*v != 0.),
             Data::Int(v) => visitor.visit_bool(*v != 0),
diff --git a/src/lib.rs b/src/lib.rs
index e869c490..004cb0f5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -86,6 +86,7 @@ mod cfb;
 mod datatype;
 mod formats;
 mod ods;
+mod style;
 mod xls;
 mod xlsb;
 mod xlsx;
@@ -105,12 +106,17 @@ use std::ops::{Index, IndexMut};
 use std::path::Path;
 
 pub use crate::auto::{open_workbook_auto, open_workbook_auto_from_rs, Sheets};
-pub use crate::datatype::{Data, DataRef, DataType, ExcelDateTime, ExcelDateTimeType};
+pub use crate::datatype::{CellData, Data, DataRef, DataType, ExcelDateTime, ExcelDateTimeType};
 pub use crate::de::{
     DeError, RangeDeserializer, RangeDeserializerBuilder, RowDeserializer, ToCellDeserializer,
 };
 pub use crate::errors::Error;
 pub use crate::ods::{Ods, OdsError};
+pub use crate::style::{
+    Alignment, Border, BorderStyle, Borders, Color, ColumnWidth, Fill, FillPattern, Font,
+    FontStyle, FontWeight, HorizontalAlignment, NumberFormat, Protection, RichText, RowHeight,
+    Style, StyleRange, TextRotation, TextRun, UnderlineStyle, VerticalAlignment, WorksheetLayout,
+};
 pub use crate::xls::{Xls, XlsError, XlsOptions};
 pub use crate::xlsb::{Xlsb, XlsbError};
 pub use crate::xlsx::{
@@ -337,6 +343,16 @@ where
     /// Read worksheet formula in corresponding worksheet path
     fn worksheet_formula(&mut self, _: &str) -> Result<Range<String>, Self::Error>;
 
+    /// Read worksheet styles as an RLE-compressed StyleRange.
+    ///
+    /// Returns a [`StyleRange`] containing styles for all cells with explicit
+    /// formatting. The styles are stored in run-length encoded format for
+    /// memory efficiency.
+    fn worksheet_style(&mut self, name: &str) -> Result<StyleRange, Self::Error>;
+
+    /// Read worksheet layout information (column widths and row heights).
+    fn worksheet_layout(&mut self, name: &str) -> Result<WorksheetLayout, Self::Error>;
+
     /// Get all sheet names of this workbook, in workbook order
     ///
     /// # Examples
@@ -515,6 +531,8 @@ impl CellType for Data {}
 impl<'a> CellType for DataRef<'a> {}
 impl CellType for String {}
 impl CellType for usize {} // for tests
+impl CellType for CellData {}
+impl CellType for Style {}
 
 // -----------------------------------------------------------------------
 // The `Cell` struct.
@@ -566,6 +584,9 @@ pub struct Cell<T: CellType> {
 
     // The [`CellType`] value of the cell.
     val: T,
+
+    // The style information for the cell.
+    style: Option<Style>,
 }
 
 impl<T: CellType> Cell<T> {
@@ -594,6 +615,39 @@ impl<T: CellType> Cell<T> {
         Cell {
             pos: position,
             val: value,
+            style: None,
+        }
+    }
+
+    /// Creates a new `Cell` instance with style information.
+    ///
+    /// # Parameters
+    ///
+    /// - `position`: A tuple representing the cell's position in the form of
+    ///   `(row, column)`.
+    /// - `value`: The value of the cell, which must implement the [`CellType`]
+    ///   trait.
+    /// - `style`: The style information for the cell.
+    ///
+    /// # Examples
+    ///
+    /// An example of creating a new `Cell` instance with style.
+    ///
+    /// ```
+    /// use calamine::{Cell, Data, Style, Font, FontWeight};
+    ///
+    /// let style = Style::new().with_font(Font::new().with_weight(FontWeight::Bold));
+    /// let cell = Cell::with_style((1, 2), Data::Int(42), style);
+    ///
+    /// assert_eq!(&Data::Int(42), cell.get_value());
+    /// assert!(cell.get_style().is_some());
+    /// ```
+    ///
+    pub fn with_style(position: (u32, u32), value: T, style: Style) -> Cell<T> {
+        Cell {
+            pos: position,
+            val: value,
+            style: Some(style),
         }
     }
 
@@ -632,6 +686,46 @@ impl<T: CellType> Cell<T> {
     pub fn get_value(&self) -> &T {
         &self.val
     }
+
+    /// Gets `Cell` style.
+    ///
+    /// # Examples
+    ///
+    /// An example of getting a `Cell` style.
+    ///
+    /// ```
+    /// use calamine::{Cell, Data, Style, Font, FontWeight};
+    ///
+    /// let style = Style::new().with_font(Font::new().with_weight(FontWeight::Bold));
+    /// let cell = Cell::with_style((1, 2), Data::Int(42), style);
+    ///
+    /// assert!(cell.get_style().is_some());
+    /// ```
+    ///
+    pub fn get_style(&self) -> Option<&Style> {
+        self.style.as_ref()
+    }
+
+    /// Checks if the cell has any style information.
+    ///
+    /// # Examples
+    ///
+    /// An example of checking if a `Cell` has style.
+    ///
+    /// ```
+    /// use calamine::{Cell, Data, Style, Font, FontWeight};
+    ///
+    /// let cell = Cell::new((1, 2), Data::Int(42));
+    /// assert!(!cell.has_style());
+    ///
+    /// let style = Style::new().with_font(Font::new().with_weight(FontWeight::Bold));
+    /// let cell_with_style = Cell::with_style((1, 2), Data::Int(42), style);
+    /// assert!(cell_with_style.has_style());
+    /// ```
+    ///
+    pub fn has_style(&self) -> bool {
+        self.style.is_some()
+    }
 }
 
 // -----------------------------------------------------------------------
@@ -1135,8 +1229,8 @@ impl<T: CellType> Range<T> {
     ///
     pub fn get(&self, relative_position: (usize, usize)) -> Option<&T> {
         let (row, col) = relative_position;
-        let (height, width) = self.get_size();
-        if col >= width || row >= height {
+        let width = self.width();
+        if row >= self.height() || col >= width {
             None
         } else {
             self.inner.get(row * width + col)
@@ -1168,7 +1262,6 @@ impl<T: CellType> Range<T> {
     ///         println!("({row_num}, {col_num}): {data}");
     ///     }
     /// }
-    ///
     /// ```
     ///
     /// Output in relative coordinates:
diff --git a/src/ods.rs b/src/ods.rs
index 05a23041..15eff153 100644
--- a/src/ods.rs
+++ b/src/ods.rs
@@ -23,7 +23,10 @@ use zip::result::ZipError;
 use crate::attrs::{decode_attr, RawAttributes};
 use crate::utils::unescape_entity_to_buffer;
 use crate::vba::VbaProject;
-use crate::{Data, DataType, HeaderRow, Metadata, Range, Reader, Sheet, SheetType, SheetVisible};
+use crate::{
+    Data, DataType, HeaderRow, Metadata, Range, Reader, Sheet, SheetType, SheetVisible, StyleRange,
+    WorksheetLayout,
+};
 use std::marker::PhantomData;
 
 const MIMETYPE: &[u8] = b"application/vnd.oasis.opendocument.spreadsheet";
@@ -270,6 +273,16 @@ where
             .map(|r| r.1.to_owned())
     }
 
+    fn worksheet_style(&mut self, _name: &str) -> Result<StyleRange, OdsError> {
+        // TODO: Implement ODS style parsing
+        Ok(StyleRange::empty())
+    }
+
+    fn worksheet_layout(&mut self, _name: &str) -> Result<WorksheetLayout, OdsError> {
+        // ODS doesn't support column width/row height information in the same way as XLSX
+        Ok(WorksheetLayout::new())
+    }
+
     #[cfg(feature = "picture")]
     fn pictures(&self) -> Option<Vec<(String, Vec<u8>)>> {
         self.pictures.to_owned()
diff --git a/src/style.rs b/src/style.rs
new file mode 100644
index 00000000..21fa9122
--- /dev/null
+++ b/src/style.rs
@@ -0,0 +1,1482 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright 2016-2025, Johann Tuffe.
+
+use std::collections::BTreeMap;
+use std::fmt;
+
+/// Represents a color in ARGB format.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Color {
+    /// Alpha channel (0-255)
+    pub alpha: u8,
+    /// Red channel (0-255)
+    pub red: u8,
+    /// Green channel (0-255)
+    pub green: u8,
+    /// Blue channel (0-255)
+    pub blue: u8,
+}
+
+impl Color {
+    /// Create a new color from ARGB values.
+    pub fn new(alpha: u8, red: u8, green: u8, blue: u8) -> Self {
+        Self {
+            alpha,
+            red,
+            green,
+            blue,
+        }
+    }
+
+    /// Create a color from RGB values (alpha = 255).
+    pub fn rgb(red: u8, green: u8, blue: u8) -> Self {
+        Self::new(255, red, green, blue)
+    }
+
+    /// Create a color from ARGB integer.
+    pub fn from_argb(argb: u32) -> Self {
+        Self {
+            alpha: ((argb >> 24) & 0xFF) as u8,
+            red: ((argb >> 16) & 0xFF) as u8,
+            green: ((argb >> 8) & 0xFF) as u8,
+            blue: (argb & 0xFF) as u8,
+        }
+    }
+
+    /// Convert to ARGB integer.
+    pub fn to_argb(&self) -> u32 {
+        ((self.alpha as u32) << 24)
+            | ((self.red as u32) << 16)
+            | ((self.green as u32) << 8)
+            | (self.blue as u32)
+    }
+
+    /// Check if the color is black.
+    pub fn is_black(&self) -> bool {
+        self.red == 0 && self.green == 0 && self.blue == 0
+    }
+
+    /// Check if the color is white.
+    pub fn is_white(&self) -> bool {
+        self.red == 255 && self.green == 255 && self.blue == 255
+    }
+}
+
+impl fmt::Display for Color {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "#{:02X}{:02X}{:02X}", self.red, self.green, self.blue)
+    }
+}
+
+/// Border style enumeration
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum BorderStyle {
+    /// No border
+    #[default]
+    None,
+    /// Thin border
+    Thin,
+    /// Medium border
+    Medium,
+    /// Thick border
+    Thick,
+    /// Double border
+    Double,
+    /// Hair border
+    Hair,
+    /// Dashed border
+    Dashed,
+    /// Dotted border
+    Dotted,
+    /// Medium dashed border
+    MediumDashed,
+    /// Dash dot border
+    DashDot,
+    /// Dash dot dot border.
+    DashDotDot,
+    /// Slant dash dot border.
+    SlantDashDot,
+}
+
+/// Border side
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Border {
+    /// Border style
+    pub style: BorderStyle,
+    /// Border color
+    pub color: Option<Color>,
+}
+
+impl Border {
+    /// Create a new border with style.
+    pub fn new(style: BorderStyle) -> Self {
+        Self { style, color: None }
+    }
+
+    /// Create a new border with style and color.
+    pub fn with_color(style: BorderStyle, color: Color) -> Self {
+        Self {
+            style,
+            color: Some(color),
+        }
+    }
+
+    /// Check if border is visible.
+    pub fn is_visible(&self) -> bool {
+        self.style != BorderStyle::None
+    }
+}
+
+/// All borders for a cell.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Borders {
+    /// Left border
+    pub left: Border,
+    /// Right border
+    pub right: Border,
+    /// Top border
+    pub top: Border,
+    /// Bottom border
+    pub bottom: Border,
+    /// Diagonal down border
+    pub diagonal_down: Border,
+    /// Diagonal up border
+    pub diagonal_up: Border,
+}
+
+impl Borders {
+    /// Create new borders.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Check if any border is visible.
+    pub fn has_visible_borders(&self) -> bool {
+        self.left.is_visible()
+            || self.right.is_visible()
+            || self.top.is_visible()
+            || self.bottom.is_visible()
+            || self.diagonal_down.is_visible()
+            || self.diagonal_up.is_visible()
+    }
+}
+
+/// Font weight
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum FontWeight {
+    /// Normal weight
+    #[default]
+    Normal,
+    /// Bold weight
+    Bold,
+}
+
+/// Font style
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum FontStyle {
+    /// Normal style
+    #[default]
+    Normal,
+    /// Italic style
+    Italic,
+}
+
+/// Underline style
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum UnderlineStyle {
+    /// No underline
+    #[default]
+    None,
+    /// Single underline
+    Single,
+    /// Double underline
+    Double,
+    /// Single accounting underline
+    SingleAccounting,
+    /// Double accounting underline
+    DoubleAccounting,
+}
+
+/// Font properties
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Font {
+    /// Font name
+    pub name: Option<String>,
+    /// Font size in points.
+    pub size: Option<f64>,
+    /// Font weight
+    pub weight: FontWeight,
+    /// Font style
+    pub style: FontStyle,
+    /// Underline style
+    pub underline: UnderlineStyle,
+    /// Strikethrough
+    pub strikethrough: bool,
+    /// Font color
+    pub color: Option<Color>,
+    /// Font family
+    pub family: Option<String>,
+}
+
+impl Font {
+    /// Create a new font.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set font name.
+    pub fn with_name(mut self, name: String) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    /// Set font size.
+    pub fn with_size(mut self, size: f64) -> Self {
+        self.size = Some(size);
+        self
+    }
+
+    /// Set font weight.
+    pub fn with_weight(mut self, weight: FontWeight) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    /// Set font style.
+    pub fn with_style(mut self, style: FontStyle) -> Self {
+        self.style = style;
+        self
+    }
+
+    /// Set underline.
+    pub fn with_underline(mut self, underline: UnderlineStyle) -> Self {
+        self.underline = underline;
+        self
+    }
+
+    /// Set strikethrough.
+    pub fn with_strikethrough(mut self, strikethrough: bool) -> Self {
+        self.strikethrough = strikethrough;
+        self
+    }
+
+    /// Set font color.
+    pub fn with_color(mut self, color: Color) -> Self {
+        self.color = Some(color);
+        self
+    }
+
+    /// Set font family.
+    pub fn with_family(mut self, family: String) -> Self {
+        self.family = Some(family);
+        self
+    }
+
+    /// Check if font is bold.
+    pub fn is_bold(&self) -> bool {
+        self.weight == FontWeight::Bold
+    }
+
+    /// Check if font is italic.
+    pub fn is_italic(&self) -> bool {
+        self.style == FontStyle::Italic
+    }
+
+    /// Check if font has underline.
+    pub fn has_underline(&self) -> bool {
+        self.underline != UnderlineStyle::None
+    }
+
+    /// Check if font has strikethrough.
+    pub fn has_strikethrough(&self) -> bool {
+        self.strikethrough
+    }
+}
+
+/// A run of text with its own formatting within a rich text cell.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct TextRun {
+    /// The text content of this run.
+    pub text: String,
+    /// Font properties for this run (None means inherit cell default)
+    pub font: Option<Font>,
+}
+
+impl TextRun {
+    /// Create a new text run with just text (no formatting).
+    pub fn new(text: String) -> Self {
+        Self { text, font: None }
+    }
+
+    /// Create a new text run with text and font.
+    pub fn with_font(text: String, font: Font) -> Self {
+        Self {
+            text,
+            font: Some(font),
+        }
+    }
+
+    /// Check if this run has any formatting.
+    pub fn has_formatting(&self) -> bool {
+        self.font.is_some()
+    }
+}
+
+/// Rich text content with multiple formatted runs.
+///
+/// Rich text allows different parts of a cell's text to have different
+/// formatting (bold, italic, colors, etc.). This is common in spreadsheets
+/// where users want to emphasize certain words within a cell.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct RichText {
+    /// The text runs in order.
+    pub runs: Vec<TextRun>,
+}
+
+impl RichText {
+    /// Create a new empty rich text.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create rich text from a vector of runs.
+    pub fn from_runs(runs: Vec<TextRun>) -> Self {
+        Self { runs }
+    }
+
+    /// Add a text run.
+    pub fn push(&mut self, run: TextRun) {
+        self.runs.push(run);
+    }
+
+    /// Add a plain text run (no formatting).
+    pub fn push_text(&mut self, text: String) {
+        self.runs.push(TextRun::new(text));
+    }
+
+    /// Add a formatted text run.
+    pub fn push_formatted(&mut self, text: String, font: Font) {
+        self.runs.push(TextRun::with_font(text, font));
+    }
+
+    /// Get the plain text content (all runs concatenated)
+    pub fn plain_text(&self) -> String {
+        self.runs.iter().map(|r| r.text.as_str()).collect()
+    }
+
+    /// Check if the rich text is empty.
+    pub fn is_empty(&self) -> bool {
+        self.runs.is_empty() || self.runs.iter().all(|r| r.text.is_empty())
+    }
+
+    /// Get the number of runs.
+    pub fn len(&self) -> usize {
+        self.runs.len()
+    }
+
+    /// Check if any run has formatting.
+    pub fn has_formatting(&self) -> bool {
+        self.runs.iter().any(|r| r.has_formatting())
+    }
+
+    /// Iterate over the runs.
+    pub fn iter(&self) -> impl Iterator<Item = &TextRun> {
+        self.runs.iter()
+    }
+}
+
+impl std::fmt::Display for RichText {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.plain_text())
+    }
+}
+
+/// Horizontal alignment
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum HorizontalAlignment {
+    /// Left alignment
+    Left,
+    /// Center alignment
+    Center,
+    /// Right alignment
+    Right,
+    /// Justify alignment
+    Justify,
+    /// Distributed alignment
+    Distributed,
+    /// Fill alignment
+    Fill,
+    /// General alignment (default)
+    #[default]
+    General,
+}
+
+/// Vertical alignment
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum VerticalAlignment {
+    /// Top alignment
+    Top,
+    /// Center alignment
+    Center,
+    /// Bottom alignment
+    #[default]
+    Bottom,
+    /// Justify alignment
+    Justify,
+    /// Distributed alignment
+    Distributed,
+}
+
+/// Text rotation in degrees.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum TextRotation {
+    /// No rotation
+    #[default]
+    None,
+    /// Rotated by degrees (0-180)
+    Degrees(u16),
+    /// Stacked text
+    Stacked,
+}
+
+/// Cell alignment properties
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Alignment {
+    /// Horizontal alignment
+    pub horizontal: HorizontalAlignment,
+    /// Vertical alignment
+    pub vertical: VerticalAlignment,
+    /// Text rotation
+    pub text_rotation: TextRotation,
+    /// Wrap text
+    pub wrap_text: bool,
+    /// Indent level
+    pub indent: Option<u8>,
+    /// Shrink to fit
+    pub shrink_to_fit: bool,
+}
+
+impl Alignment {
+    /// Create new alignment.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set horizontal alignment.
+    pub fn with_horizontal(mut self, horizontal: HorizontalAlignment) -> Self {
+        self.horizontal = horizontal;
+        self
+    }
+
+    /// Set vertical alignment.
+    pub fn with_vertical(mut self, vertical: VerticalAlignment) -> Self {
+        self.vertical = vertical;
+        self
+    }
+
+    /// Set text rotation.
+    pub fn with_text_rotation(mut self, rotation: TextRotation) -> Self {
+        self.text_rotation = rotation;
+        self
+    }
+
+    /// Set wrap text.
+    pub fn with_wrap_text(mut self, wrap: bool) -> Self {
+        self.wrap_text = wrap;
+        self
+    }
+
+    /// Set indent level.
+    pub fn with_indent(mut self, indent: u8) -> Self {
+        self.indent = Some(indent);
+        self
+    }
+
+    /// Set shrink to fit.
+    pub fn with_shrink_to_fit(mut self, shrink: bool) -> Self {
+        self.shrink_to_fit = shrink;
+        self
+    }
+}
+
+/// Fill pattern type
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum FillPattern {
+    /// No fill
+    #[default]
+    None,
+    /// Solid fill
+    Solid,
+    /// Dark gray pattern
+    DarkGray,
+    /// Medium gray pattern
+    MediumGray,
+    /// Light gray pattern
+    LightGray,
+    /// Gray 125 pattern
+    Gray125,
+    /// Gray 0625 pattern
+    Gray0625,
+    /// Dark horizontal pattern
+    DarkHorizontal,
+    /// Dark vertical pattern
+    DarkVertical,
+    /// Dark down pattern
+    DarkDown,
+    /// Dark up pattern
+    DarkUp,
+    /// Dark grid pattern
+    DarkGrid,
+    /// Dark trellis pattern
+    DarkTrellis,
+    /// Light horizontal pattern
+    LightHorizontal,
+    /// Light vertical pattern
+    LightVertical,
+    /// Light down pattern
+    LightDown,
+    /// Light up pattern
+    LightUp,
+    /// Light grid pattern
+    LightGrid,
+    /// Light trellis pattern
+    LightTrellis,
+}
+
+/// Fill properties
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Fill {
+    /// Fill pattern
+    pub pattern: FillPattern,
+    /// Foreground color
+    pub foreground_color: Option<Color>,
+    /// Background color
+    pub background_color: Option<Color>,
+}
+
+impl Fill {
+    /// Create new fill.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create solid fill with color.
+    pub fn solid(color: Color) -> Self {
+        Self {
+            pattern: FillPattern::Solid,
+            foreground_color: Some(color),
+            background_color: None,
+        }
+    }
+
+    /// Set pattern.
+    pub fn with_pattern(mut self, pattern: FillPattern) -> Self {
+        self.pattern = pattern;
+        self
+    }
+
+    /// Set foreground color.
+    pub fn with_foreground_color(mut self, color: Color) -> Self {
+        self.foreground_color = Some(color);
+        self
+    }
+
+    /// Set background color.
+    pub fn with_background_color(mut self, color: Color) -> Self {
+        self.background_color = Some(color);
+        self
+    }
+
+    /// Check if fill is visible.
+    pub fn is_visible(&self) -> bool {
+        self.pattern != FillPattern::None
+    }
+
+    /// Get the main fill color (foreground if available, otherwise background)
+    pub fn get_color(&self) -> Option<Color> {
+        self.foreground_color.or(self.background_color)
+    }
+}
+
+/// Number format
+#[derive(Debug, Clone, PartialEq)]
+pub struct NumberFormat {
+    /// Format code
+    pub format_code: String,
+    /// Format ID
+    pub format_id: Option<u32>,
+}
+
+impl NumberFormat {
+    /// Create new number format.
+    pub fn new(format_code: String) -> Self {
+        Self {
+            format_code,
+            format_id: None,
+        }
+    }
+
+    /// Create with format ID.
+    pub fn with_id(mut self, format_id: u32) -> Self {
+        self.format_id = Some(format_id);
+        self
+    }
+}
+
+impl Default for NumberFormat {
+    fn default() -> Self {
+        Self {
+            format_code: "General".to_string(),
+            format_id: None,
+        }
+    }
+}
+
+/// Cell protection properties
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Protection {
+    /// Cell is locked
+    pub locked: bool,
+    /// Cell is hidden
+    pub hidden: bool,
+}
+
+impl Protection {
+    /// Create new protection.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set locked.
+    pub fn with_locked(mut self, locked: bool) -> Self {
+        self.locked = locked;
+        self
+    }
+
+    /// Set hidden.
+    pub fn with_hidden(mut self, hidden: bool) -> Self {
+        self.hidden = hidden;
+        self
+    }
+}
+
+/// Column width information
+#[derive(Debug, Clone, PartialEq)]
+pub struct ColumnWidth {
+    /// Column index (0-based)
+    pub column: u32,
+    /// Width in Excel units (characters)
+    pub width: f64,
+    /// Whether the width is custom (manually set)
+    pub custom_width: bool,
+    /// Whether the column is hidden.
+    pub hidden: bool,
+    /// Best fit width
+    pub best_fit: bool,
+}
+
+impl ColumnWidth {
+    /// Create a new column width.
+    pub fn new(column: u32, width: f64) -> Self {
+        Self {
+            column,
+            width,
+            custom_width: false,
+            hidden: false,
+            best_fit: false,
+        }
+    }
+
+    /// Set custom width flag.
+    pub fn with_custom_width(mut self, custom: bool) -> Self {
+        self.custom_width = custom;
+        self
+    }
+
+    /// Set hidden flag.
+    pub fn with_hidden(mut self, hidden: bool) -> Self {
+        self.hidden = hidden;
+        self
+    }
+
+    /// Set best fit flag.
+    pub fn with_best_fit(mut self, best_fit: bool) -> Self {
+        self.best_fit = best_fit;
+        self
+    }
+
+    /// Check if column is visible.
+    pub fn is_visible(&self) -> bool {
+        !self.hidden
+    }
+}
+
+/// Row height information
+#[derive(Debug, Clone, PartialEq)]
+pub struct RowHeight {
+    /// Row index (0-based)
+    pub row: u32,
+    /// Height in points
+    pub height: f64,
+    /// Whether the height is custom (manually set)
+    pub custom_height: bool,
+    /// Whether the row is hidden.
+    pub hidden: bool,
+    /// Thick top border
+    pub thick_top: bool,
+    /// Thick bottom border
+    pub thick_bottom: bool,
+}
+
+impl RowHeight {
+    /// Create a new row height.
+    pub fn new(row: u32, height: f64) -> Self {
+        Self {
+            row,
+            height,
+            custom_height: false,
+            hidden: false,
+            thick_top: false,
+            thick_bottom: false,
+        }
+    }
+
+    /// Set custom height flag.
+    pub fn with_custom_height(mut self, custom: bool) -> Self {
+        self.custom_height = custom;
+        self
+    }
+
+    /// Set hidden flag.
+    pub fn with_hidden(mut self, hidden: bool) -> Self {
+        self.hidden = hidden;
+        self
+    }
+
+    /// Set thick top border.
+    pub fn with_thick_top(mut self, thick_top: bool) -> Self {
+        self.thick_top = thick_top;
+        self
+    }
+
+    /// Set thick bottom border.
+    pub fn with_thick_bottom(mut self, thick_bottom: bool) -> Self {
+        self.thick_bottom = thick_bottom;
+        self
+    }
+
+    /// Check if row is visible.
+    pub fn is_visible(&self) -> bool {
+        !self.hidden
+    }
+}
+
+/// Worksheet layout information
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct WorksheetLayout {
+    /// Column widths (keyed by column index)
+    pub column_widths: BTreeMap<u32, ColumnWidth>,
+    /// Row heights (keyed by row index)
+    pub row_heights: BTreeMap<u32, RowHeight>,
+    /// Default column width
+    pub default_column_width: Option<f64>,
+    /// Default row height
+    pub default_row_height: Option<f64>,
+}
+
+impl WorksheetLayout {
+    /// Create a new worksheet layout.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add a column width.
+    pub fn add_column_width(mut self, column_width: ColumnWidth) -> Self {
+        self.column_widths.insert(column_width.column, column_width);
+        self
+    }
+
+    /// Add a row height.
+    pub fn add_row_height(mut self, row_height: RowHeight) -> Self {
+        self.row_heights.insert(row_height.row, row_height);
+        self
+    }
+
+    /// Set default column width.
+    pub fn with_default_column_width(mut self, width: f64) -> Self {
+        self.default_column_width = Some(width);
+        self
+    }
+
+    /// Set default row height.
+    pub fn with_default_row_height(mut self, height: f64) -> Self {
+        self.default_row_height = Some(height);
+        self
+    }
+
+    /// Get column width for a specific column (O(log n) lookup)
+    pub fn get_column_width(&self, column: u32) -> Option<&ColumnWidth> {
+        self.column_widths.get(&column)
+    }
+
+    /// Get row height for a specific row (O(log n) lookup)
+    pub fn get_row_height(&self, row: u32) -> Option<&RowHeight> {
+        self.row_heights.get(&row)
+    }
+
+    /// Get effective column width (custom or default).
+    ///
+    /// Returns the column width in Excel's character-based units. If no custom.
+    /// width is set, returns the worksheet's default column width, or 8.43 if.
+    /// no default is specified.
+    ///
+    /// **Note:** Excel column widths are stored in character units relative to.
+    /// the workbook's default font, not pixels. Converting to pixels requires.
+    /// font metrics and is font-dependent. The value 8.43 is Excel's standard.
+    /// default for Calibri 11pt.
+    pub fn get_effective_column_width(&self, column: u32) -> f64 {
+        self.get_column_width(column)
+            .map(|cw| cw.width)
+            .or(self.default_column_width)
+            .unwrap_or(8.43)
+    }
+
+    /// Get effective row height (custom or default).
+    ///
+    /// Returns the row height in points. If no custom height is set, returns.
+    /// the worksheet's default row height, or 15.0 if no default is specified.
+    ///
+    /// **Note:** Row heights in Excel are stored in points (1/72 inch), but.
+    /// the actual displayed height may vary slightly depending on the default.
+    /// font. The value 15.0 is Excel's standard default for Calibri 11pt.
+    pub fn get_effective_row_height(&self, row: u32) -> f64 {
+        self.get_row_height(row)
+            .map(|rh| rh.height)
+            .or(self.default_row_height)
+            .unwrap_or(15.0)
+    }
+
+    /// Check if layout has any custom dimensions.
+    pub fn has_custom_dimensions(&self) -> bool {
+        !self.column_widths.is_empty()
+            || !self.row_heights.is_empty()
+            || self.default_column_width.is_some()
+            || self.default_row_height.is_some()
+    }
+}
+
+/// Complete cell style
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Style {
+    /// Font properties
+    pub font: Option<Font>,
+    /// Fill properties
+    pub fill: Option<Fill>,
+    /// Border properties
+    pub borders: Option<Borders>,
+    /// Alignment properties
+    pub alignment: Option<Alignment>,
+    /// Number format
+    pub number_format: Option<NumberFormat>,
+    /// Protection properties
+    pub protection: Option<Protection>,
+    /// Style ID (for internal use)
+    pub style_id: Option<u32>,
+}
+
+impl Style {
+    /// Create new style.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set font.
+    pub fn with_font(mut self, font: Font) -> Self {
+        self.font = Some(font);
+        self
+    }
+
+    /// Set fill.
+    pub fn with_fill(mut self, fill: Fill) -> Self {
+        self.fill = Some(fill);
+        self
+    }
+
+    /// Set borders.
+    pub fn with_borders(mut self, borders: Borders) -> Self {
+        self.borders = Some(borders);
+        self
+    }
+
+    /// Set alignment.
+    pub fn with_alignment(mut self, alignment: Alignment) -> Self {
+        self.alignment = Some(alignment);
+        self
+    }
+
+    /// Set number format.
+    pub fn with_number_format(mut self, number_format: NumberFormat) -> Self {
+        self.number_format = Some(number_format);
+        self
+    }
+
+    /// Set protection.
+    pub fn with_protection(mut self, protection: Protection) -> Self {
+        self.protection = Some(protection);
+        self
+    }
+
+    /// Set style ID.
+    pub fn with_style_id(mut self, style_id: u32) -> Self {
+        self.style_id = Some(style_id);
+        self
+    }
+
+    /// Get font.
+    pub fn get_font(&self) -> Option<&Font> {
+        self.font.as_ref()
+    }
+
+    /// Get fill.
+    pub fn get_fill(&self) -> Option<&Fill> {
+        self.fill.as_ref()
+    }
+
+    /// Get borders.
+    pub fn get_borders(&self) -> Option<&Borders> {
+        self.borders.as_ref()
+    }
+
+    /// Get alignment.
+    pub fn get_alignment(&self) -> Option<&Alignment> {
+        self.alignment.as_ref()
+    }
+
+    /// Get number format.
+    pub fn get_number_format(&self) -> Option<&NumberFormat> {
+        self.number_format.as_ref()
+    }
+
+    /// Get protection.
+    pub fn get_protection(&self) -> Option<&Protection> {
+        self.protection.as_ref()
+    }
+
+    /// Check if style is empty (no properties set).
+    pub fn is_empty(&self) -> bool {
+        self.font.is_none()
+            && self.fill.is_none()
+            && self.borders.is_none()
+            && self.alignment.is_none()
+            && self.number_format.is_none()
+            && self.protection.is_none()
+    }
+
+    /// Check if style has any visible properties.
+    pub fn has_visible_properties(&self) -> bool {
+        (self
+            .font
+            .as_ref()
+            .is_some_and(|f| f.color.is_some() || f.is_bold() || f.is_italic()))
+            || (self.fill.as_ref().is_some_and(|f| f.is_visible()))
+            || (self
+                .borders
+                .as_ref()
+                .is_some_and(|b| b.has_visible_borders()))
+            || (self.alignment.as_ref().is_some_and(|a| {
+                a.horizontal != HorizontalAlignment::General
+                    || a.vertical != VerticalAlignment::Bottom
+                    || a.text_rotation != TextRotation::None
+                    || a.wrap_text
+                    || a.indent.is_some()
+                    || a.shrink_to_fit
+            }))
+    }
+}
+
+/// A run of consecutive cells with the same style (row-major order).
+#[derive(Debug, Clone)]
+struct StyleRun {
+    /// Index into the palette (0 = no style/default)
+    style_id: u16,
+    /// Number of consecutive cells with this style.
+    count: u32,
+}
+
+/// RLE-compressed style storage for a worksheet range.
+///
+/// Instead of storing one Style per cell (which wastes memory when many cells
+/// share the same style), this stores:
+/// - A palette of unique styles
+/// - Runs of consecutive cells (row-major) that share the same style
+///
+/// This dramatically reduces memory usage and clone overhead for large worksheets.
+#[derive(Debug, Clone, Default)]
+pub struct StyleRange {
+    start: (u32, u32),
+    end: (u32, u32),
+    /// Palette of unique styles. Index 0 is reserved for "no style" (empty).
+    palette: Vec<Style>,
+    /// RLE-encoded runs in row-major order.
+    runs: Vec<StyleRun>,
+    /// Total cell count (for validation)
+    total_cells: u64,
+}
+
+impl StyleRange {
+    /// Create an empty StyleRange.
+    pub fn empty() -> Self {
+        Self::default()
+    }
+
+    /// Create a StyleRange from style IDs and a palette (zero-copy).
+    ///
+    /// This is more efficient than `from_sparse` as it avoids cloning styles.
+    ///
+    /// - `cells`: Vec of (row, col, style_id) where style_id indexes into palette
+    /// - `palette`: The shared palette of unique styles (taken ownership)
+    pub fn from_style_ids(cells: Vec<(u32, u32, usize)>, palette: Vec<Style>) -> Self {
+        if cells.is_empty() {
+            return Self::empty();
+        }
+
+        // Find bounds
+        let mut row_start = u32::MAX;
+        let mut row_end = 0;
+        let mut col_start = u32::MAX;
+        let mut col_end = 0;
+        for (r, c, _) in &cells {
+            row_start = row_start.min(*r);
+            row_end = row_end.max(*r);
+            col_start = col_start.min(*c);
+            col_end = col_end.max(*c);
+        }
+
+        let width = (col_end - col_start + 1) as usize;
+        let height = (row_end - row_start + 1) as usize;
+        let total_cells = (width * height) as u64;
+
+        // Create dense style ID array (temporary)
+        let mut style_ids = vec![0u16; width * height];
+
+        for (r, c, style_id) in cells {
+            let row = (r - row_start) as usize;
+            let col = (c - col_start) as usize;
+            let idx = row * width + col;
+            if let Some(slot) = style_ids.get_mut(idx) {
+                *slot = style_id.min(u16::MAX as usize) as u16;
+            }
+        }
+
+        // Compress into RLE runs
+        let mut runs = Vec::new();
+        if !style_ids.is_empty() {
+            let mut current_style = style_ids[0];
+            let mut count = 1u32;
+
+            for &style_id in &style_ids[1..] {
+                if style_id == current_style {
+                    count += 1;
+                } else {
+                    runs.push(StyleRun {
+                        style_id: current_style,
+                        count,
+                    });
+                    current_style = style_id;
+                    count = 1;
+                }
+            }
+            runs.push(StyleRun {
+                style_id: current_style,
+                count,
+            });
+        }
+
+        runs.shrink_to_fit();
+
+        StyleRange {
+            start: (row_start, col_start),
+            end: (row_end, col_end),
+            palette,
+            runs,
+            total_cells,
+        }
+    }
+
+    /// Create a StyleRange from sparse cell data.
+    ///
+    /// Takes cells with positions and styles, compresses into RLE format.
+    pub fn from_sparse(cells: Vec<(u32, u32, Style)>) -> Self {
+        if cells.is_empty() {
+            return Self::empty();
+        }
+
+        // Find bounds
+        let mut row_start = u32::MAX;
+        let mut row_end = 0;
+        let mut col_start = u32::MAX;
+        let mut col_end = 0;
+        for (r, c, _) in &cells {
+            row_start = row_start.min(*r);
+            row_end = row_end.max(*r);
+            col_start = col_start.min(*c);
+            col_end = col_end.max(*c);
+        }
+
+        let width = (col_end - col_start + 1) as usize;
+        let height = (row_end - row_start + 1) as usize;
+        let total_cells = (width * height) as u64;
+
+        // Build palette and map styles to IDs
+        // Use style_id from Excel if available, otherwise assign sequential IDs
+        let mut palette: Vec<Style> = vec![Style::default()]; // Index 0 = empty/default
+        let mut style_to_id: std::collections::HashMap<u32, u16> = std::collections::HashMap::new();
+
+        // Create dense style ID array (temporary)
+        let mut style_ids = vec![0u16; width * height];
+
+        for (r, c, style) in cells {
+            let row = (r - row_start) as usize;
+            let col = (c - col_start) as usize;
+            let idx = row * width + col;
+
+            if style.is_empty() {
+                continue; // Leave as 0
+            }
+
+            // Use Excel's style_id if available for deduplication.
+            // This groups cells with the same formatting together.
+            // Fallback to palette length as unique ID (no dedup for these).
+            let excel_style_id = style.style_id.unwrap_or(palette.len() as u32);
+
+            let style_id = if let Some(&id) = style_to_id.get(&excel_style_id) {
+                id
+            } else {
+                let id = palette.len() as u16;
+                palette.push(style);
+                style_to_id.insert(excel_style_id, id);
+                id
+            };
+
+            if let Some(slot) = style_ids.get_mut(idx) {
+                *slot = style_id;
+            }
+        }
+
+        // Compress into RLE runs
+        let mut runs = Vec::new();
+        if !style_ids.is_empty() {
+            let mut current_style = style_ids[0];
+            let mut count = 1u32;
+
+            for &style_id in &style_ids[1..] {
+                if style_id == current_style {
+                    count += 1;
+                } else {
+                    runs.push(StyleRun {
+                        style_id: current_style,
+                        count,
+                    });
+                    current_style = style_id;
+                    count = 1;
+                }
+            }
+            // Push final run
+            runs.push(StyleRun {
+                style_id: current_style,
+                count,
+            });
+        }
+
+        runs.shrink_to_fit();
+        palette.shrink_to_fit();
+
+        StyleRange {
+            start: (row_start, col_start),
+            end: (row_end, col_end),
+            palette,
+            runs,
+            total_cells,
+        }
+    }
+
+    /// Get the start position of the range.
+    pub fn start(&self) -> Option<(u32, u32)> {
+        if self.is_empty() {
+            None
+        } else {
+            Some(self.start)
+        }
+    }
+
+    /// Get the end position of the range.
+    pub fn end(&self) -> Option<(u32, u32)> {
+        if self.is_empty() {
+            None
+        } else {
+            Some(self.end)
+        }
+    }
+
+    /// Check if the range is empty.
+    pub fn is_empty(&self) -> bool {
+        self.runs.is_empty()
+    }
+
+    /// Get width of the range.
+    pub fn width(&self) -> usize {
+        if self.is_empty() {
+            0
+        } else {
+            (self.end.1 - self.start.1 + 1) as usize
+        }
+    }
+
+    /// Get height of the range.
+    pub fn height(&self) -> usize {
+        if self.is_empty() {
+            0
+        } else {
+            (self.end.0 - self.start.0 + 1) as usize
+        }
+    }
+
+    /// Get style at a position (relative to range start)
+    ///
+    /// Returns None if position is out of bounds, or reference to style.
+    pub fn get(&self, pos: (usize, usize)) -> Option<&Style> {
+        let width = self.width();
+        let height = self.height();
+
+        if pos.0 >= height || pos.1 >= width {
+            return None;
+        }
+
+        let linear_idx = pos.0 * width + pos.1;
+        let style_id = self.style_id_at(linear_idx)?;
+        self.palette.get(style_id as usize)
+    }
+
+    /// Get style ID at a linear index using binary search on runs.
+    fn style_id_at(&self, linear_idx: usize) -> Option<u16> {
+        let mut offset = 0usize;
+        for run in &self.runs {
+            let run_end = offset + run.count as usize;
+            if linear_idx < run_end {
+                return Some(run.style_id);
+            }
+            offset = run_end;
+        }
+        None
+    }
+
+    /// Iterate over all cells with their positions and styles.
+    pub fn cells(&self) -> StyleRangeCells<'_> {
+        StyleRangeCells {
+            range: self,
+            run_idx: 0,
+            run_offset: 0,
+            linear_idx: 0,
+        }
+    }
+
+    /// Get number of unique styles (excluding empty).
+    pub fn unique_style_count(&self) -> usize {
+        self.palette.len().saturating_sub(1)
+    }
+
+    /// Get number of RLE runs (for diagnostics)
+    pub fn run_count(&self) -> usize {
+        self.runs.len()
+    }
+
+    /// Get compression ratio (cells / runs)
+    pub fn compression_ratio(&self) -> f64 {
+        if self.runs.is_empty() {
+            0.0
+        } else {
+            self.total_cells as f64 / self.runs.len() as f64
+        }
+    }
+}
+
+/// Iterator over cells in a StyleRange.
+pub struct StyleRangeCells<'a> {
+    range: &'a StyleRange,
+    run_idx: usize,
+    run_offset: u32,
+    linear_idx: u64,
+}
+
+impl<'a> Iterator for StyleRangeCells<'a> {
+    type Item = (usize, usize, &'a Style);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.run_idx >= self.range.runs.len() {
+            return None;
+        }
+
+        let width = self.range.width();
+        if width == 0 {
+            return None;
+        }
+
+        let row = (self.linear_idx / width as u64) as usize;
+        let col = (self.linear_idx % width as u64) as usize;
+
+        let run = &self.range.runs[self.run_idx];
+        let style = self.range.palette.get(run.style_id as usize)?;
+
+        self.linear_idx += 1;
+        self.run_offset += 1;
+
+        if self.run_offset >= run.count {
+            self.run_idx += 1;
+            self.run_offset = 0;
+        }
+
+        Some((row, col, style))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_color() {
+        let color = Color::rgb(255, 0, 128);
+        assert_eq!(color.red, 255);
+        assert_eq!(color.green, 0);
+        assert_eq!(color.blue, 128);
+        assert_eq!(color.alpha, 255);
+        assert_eq!(color.to_string(), "#FF0080");
+    }
+
+    #[test]
+    fn test_font() {
+        let font = Font::new()
+            .with_name("Arial".to_string())
+            .with_size(12.0)
+            .with_weight(FontWeight::Bold)
+            .with_color(Color::rgb(255, 0, 0));
+
+        assert_eq!(font.name, Some("Arial".to_string()));
+        assert_eq!(font.size, Some(12.0));
+        assert!(font.is_bold());
+        assert_eq!(font.color, Some(Color::rgb(255, 0, 0)));
+    }
+
+    #[test]
+    fn test_style() {
+        let style = Style::new()
+            .with_font(Font::new().with_name("Arial".to_string()))
+            .with_fill(Fill::solid(Color::rgb(255, 255, 0)));
+
+        assert!(!style.is_empty());
+        assert!(style.get_font().is_some());
+        assert!(style.get_fill().is_some());
+    }
+
+    #[test]
+    fn test_border_with_color() {
+        let border = Border::with_color(BorderStyle::Thin, Color::rgb(255, 0, 0));
+        assert_eq!(border.style, BorderStyle::Thin);
+        assert_eq!(border.color, Some(Color::rgb(255, 0, 0)));
+        assert!(border.is_visible());
+    }
+
+    #[test]
+    fn test_border_without_color() {
+        let border = Border::new(BorderStyle::Medium);
+        assert_eq!(border.style, BorderStyle::Medium);
+        assert_eq!(border.color, None);
+        assert!(border.is_visible());
+    }
+
+    #[test]
+    fn test_borders_with_mixed_colors() {
+        let mut borders = Borders::new();
+        borders.left = Border::with_color(BorderStyle::Thin, Color::rgb(255, 0, 0));
+        borders.right = Border::new(BorderStyle::Medium);
+        borders.top = Border::with_color(BorderStyle::Thick, Color::rgb(0, 255, 0));
+
+        assert_eq!(borders.left.color, Some(Color::rgb(255, 0, 0)));
+        assert_eq!(borders.right.color, None);
+        assert_eq!(borders.top.color, Some(Color::rgb(0, 255, 0)));
+        assert!(borders.has_visible_borders());
+    }
+
+    #[test]
+    fn test_column_width() {
+        let column_width = ColumnWidth::new(5, 12.5)
+            .with_custom_width(true)
+            .with_hidden(false)
+            .with_best_fit(true);
+
+        assert_eq!(column_width.column, 5);
+        assert_eq!(column_width.width, 12.5);
+        assert!(column_width.custom_width);
+        assert!(!column_width.hidden);
+        assert!(column_width.best_fit);
+        assert!(column_width.is_visible());
+    }
+
+    #[test]
+    fn test_row_height() {
+        let row_height = RowHeight::new(10, 20.0)
+            .with_custom_height(true)
+            .with_hidden(false)
+            .with_thick_top(true)
+            .with_thick_bottom(false);
+
+        assert_eq!(row_height.row, 10);
+        assert_eq!(row_height.height, 20.0);
+        assert!(row_height.custom_height);
+        assert!(!row_height.hidden);
+        assert!(row_height.thick_top);
+        assert!(!row_height.thick_bottom);
+        assert!(row_height.is_visible());
+    }
+
+    #[test]
+    fn test_worksheet_layout() {
+        let layout = WorksheetLayout::new()
+            .add_column_width(ColumnWidth::new(0, 10.0))
+            .add_column_width(ColumnWidth::new(1, 15.0))
+            .add_row_height(RowHeight::new(0, 18.0))
+            .add_row_height(RowHeight::new(1, 22.0))
+            .with_default_column_width(8.43)
+            .with_default_row_height(15.0);
+
+        assert_eq!(layout.column_widths.len(), 2);
+        assert_eq!(layout.row_heights.len(), 2);
+        assert_eq!(layout.default_column_width, Some(8.43));
+        assert_eq!(layout.default_row_height, Some(15.0));
+        assert!(layout.has_custom_dimensions());
+
+        // Test getting specific column width
+        let col_width = layout.get_column_width(0).unwrap();
+        assert_eq!(col_width.width, 10.0);
+
+        // Test getting specific row height
+        let row_height = layout.get_row_height(1).unwrap();
+        assert_eq!(row_height.height, 22.0);
+
+        // Test effective widths/heights
+        assert_eq!(layout.get_effective_column_width(0), 10.0); // Custom width
+        assert_eq!(layout.get_effective_column_width(5), 8.43); // Default width
+        assert_eq!(layout.get_effective_row_height(0), 18.0); // Custom height
+        assert_eq!(layout.get_effective_row_height(5), 15.0); // Default height
+    }
+
+    #[test]
+    fn test_worksheet_layout_defaults() {
+        let layout = WorksheetLayout::new();
+
+        assert!(!layout.has_custom_dimensions());
+        assert_eq!(layout.get_effective_column_width(0), 8.43); // Excel default
+        assert_eq!(layout.get_effective_row_height(0), 15.0); // Excel default
+    }
+}
diff --git a/src/xls.rs b/src/xls.rs
index 27ca729f..01c0c688 100644
--- a/src/xls.rs
+++ b/src/xls.rs
@@ -20,7 +20,7 @@ use crate::utils::{push_column, read_f64, read_i16, read_i32, read_u16, read_u32
 use crate::vba::VbaProject;
 use crate::{
     Cell, CellErrorType, Data, Dimensions, HeaderRow, Metadata, Range, Reader, Sheet, SheetType,
-    SheetVisible,
+    SheetVisible, StyleRange, WorksheetLayout,
 };
 
 #[derive(Debug)]
@@ -440,6 +440,16 @@ impl<RS: Read + Seek> Reader<RS> for Xls<RS> {
         }
     }
 
+    fn worksheet_style(&mut self, _name: &str) -> Result<StyleRange, XlsError> {
+        // TODO: Implement XLS style parsing
+        Ok(StyleRange::empty())
+    }
+
+    fn worksheet_layout(&mut self, _name: &str) -> Result<WorksheetLayout, XlsError> {
+        // XLS doesn't support column width/row height information in the same way as XLSX
+        Ok(WorksheetLayout::new())
+    }
+
     fn worksheets(&mut self) -> Vec<(String, Range<Data>)> {
         self.sheets
             .iter()
diff --git a/src/xlsb/mod.rs b/src/xlsb/mod.rs
index d5d93a59..87a45cd4 100644
--- a/src/xlsb/mod.rs
+++ b/src/xlsb/mod.rs
@@ -29,6 +29,7 @@ use crate::utils::{
 use crate::vba::VbaProject;
 use crate::{
     Cell, Data, HeaderRow, Metadata, Range, Reader, ReaderRef, Sheet, SheetType, SheetVisible,
+    StyleRange, WorksheetLayout,
 };
 
 /// A Xlsb specific error
@@ -535,6 +536,16 @@ impl<RS: Read + Seek> Reader<RS> for Xlsb<RS> {
         Ok(Range::from_sparse(cells))
     }
 
+    fn worksheet_style(&mut self, _name: &str) -> Result<StyleRange, XlsbError> {
+        // TODO: Implement XLSB style parsing
+        Ok(StyleRange::empty())
+    }
+
+    fn worksheet_layout(&mut self, _name: &str) -> Result<WorksheetLayout, XlsbError> {
+        // XLSB doesn't support column width/row height information in the same way as XLSX yet
+        Ok(WorksheetLayout::new())
+    }
+
     /// MS-XLSB 2.1.7.62
     fn worksheets(&mut self) -> Vec<(String, Range<Data>)> {
         let sheets = self
@@ -611,6 +622,7 @@ impl<RS: Read + Seek> ReaderRef<RS> for Xlsb<RS> {
                                 cells.first().expect("cells should not be empty").pos.1,
                             ),
                             val: DataRef::Empty,
+                            style: None,
                         },
                     );
                 }
diff --git a/src/xlsx/cells_reader.rs b/src/xlsx/cells_reader.rs
index 8336acba..5b5e6d46 100644
--- a/src/xlsx/cells_reader.rs
+++ b/src/xlsx/cells_reader.rs
@@ -14,7 +14,7 @@ use crate::{
     datatype::DataRef,
     formats::{format_excel_f64_ref, CellFormat},
     utils::unescape_entity_to_buffer,
-    Cell, XlsxError,
+    Cell, Data, Style, XlsxError,
 };
 
 #[derive(Clone, Debug)]
@@ -25,7 +25,7 @@ struct SharedFormula {
 
 /// Workbook-level context used when reading cell values.
 struct WorkbookContext<'a> {
-    strings: &'a [String],
+    strings: &'a [Data],
     formats: &'a [CellFormat],
     is_1904: bool,
 }
@@ -178,8 +178,9 @@ where
     RS: Read + Seek,
 {
     xml: XlReader<'a, RS>,
-    strings: &'a [String],
+    strings: &'a [Data],
     formats: &'a [CellFormat],
+    styles: &'a [Style],
     is_1904: bool,
     dimensions: Dimensions,
     row_index: u32,
@@ -197,8 +198,9 @@ where
     /// Create a new XLSX cell reader over a worksheet XML stream.
     pub fn new(
         mut xml: XlReader<'a, RS>,
-        strings: &'a [String],
+        strings: &'a [Data],
         formats: &'a [CellFormat],
+        styles: &'a [Style],
         is_1904: bool,
     ) -> Result<Self, XlsxError> {
         let mut buf = Vec::with_capacity(1024);
@@ -226,7 +228,7 @@ where
                     if let Some(typ) = sh_type {
                         return Err(XlsxError::NotAWorksheet(typ));
                     } else {
-                        return Err(XlsxError::XmlEof("worksheet"));
+                        return Err(XlsxError::XmlEof("sheetData"));
                     }
                 }
                 _ => (),
@@ -236,6 +238,7 @@ where
             xml,
             strings,
             formats,
+            styles,
             is_1904,
             dimensions,
             row_index: 0,
@@ -277,6 +280,18 @@ where
                         (self.row_index, self.col_index)
                     };
                     let mut value = DataRef::Empty;
+                    let mut style = None;
+
+                    let style_id = style_attr
+                        .and_then(|s| atoi_simd::parse::<usize, true, false>(s).ok())
+                        .unwrap_or(0);
+
+                    if style_id < self.styles.len() {
+                        let mut s = self.styles[style_id].clone();
+                        s.style_id = Some(style_id as u32);
+                        style = Some(s);
+                    }
+
                     loop {
                         self.cell_buf.clear();
                         match self.xml.read_event_into(&mut self.cell_buf) {
@@ -302,7 +317,12 @@ where
                         }
                     }
                     self.col_index += 1;
-                    return Ok(Some(Cell::new(pos, value)));
+
+                    if let Some(cell_style) = style {
+                        return Ok(Some(Cell::with_style(pos, value, cell_style)));
+                    } else {
+                        return Ok(Some(Cell::new(pos, value)));
+                    }
                 }
                 Ok(Event::End(e)) if e.local_name().as_ref() == b"sheetData" => {
                     return Ok(None);
@@ -512,6 +532,19 @@ where
                         (self.row_index, self.col_index)
                     };
                     let mut value = None;
+                    let mut style = None;
+
+                    let style_id = c_element
+                        .raw_attr(b"s")?
+                        .map(|v| atoi_simd::parse::<usize, true, false>(v).unwrap_or(0))
+                        .unwrap_or(0);
+
+                    if style_id < self.styles.len() {
+                        let mut s = self.styles[style_id].clone();
+                        s.style_id = Some(style_id as u32);
+                        style = Some(s);
+                    }
+
                     loop {
                         self.cell_buf.clear();
                         match self.xml.read_event_into(&mut self.cell_buf) {
@@ -536,7 +569,150 @@ where
                         }
                     }
                     self.col_index += 1;
-                    return Ok(Some(Cell::new(pos, value.unwrap_or_default())));
+
+                    if let Some(cell_style) = style {
+                        return Ok(Some(Cell::with_style(
+                            pos,
+                            value.unwrap_or_default(),
+                            cell_style,
+                        )));
+                    } else {
+                        return Ok(Some(Cell::new(pos, value.unwrap_or_default())));
+                    }
+                }
+                Ok(Event::End(e)) if e.local_name().as_ref() == b"sheetData" => {
+                    return Ok(None);
+                }
+                Ok(Event::Eof) => return Err(XlsxError::XmlEof("sheetData")),
+                Err(e) => return Err(XlsxError::Xml(e)),
+                _ => (),
+            }
+        }
+    }
+
+    /// Return the next cell's resolved [`Style`] in XML stream order.
+    pub fn next_style(&mut self) -> Result<Option<Cell<Style>>, XlsxError> {
+        loop {
+            self.buf.clear();
+            match self.xml.read_event_into(&mut self.buf) {
+                Ok(Event::Start(ref row_element))
+                    if row_element.local_name().as_ref() == b"row" =>
+                {
+                    let attribute = row_element.raw_attr(b"r")?;
+                    if let Some(range) = attribute {
+                        let row = get_row(range)?;
+                        self.row_index = row;
+                    }
+                }
+                Ok(Event::End(ref row_element)) if row_element.local_name().as_ref() == b"row" => {
+                    self.row_index += 1;
+                    self.col_index = 0;
+                }
+                Ok(Event::Start(ref c_element)) if c_element.local_name().as_ref() == b"c" => {
+                    let attribute = c_element.raw_attr(b"r")?;
+                    let pos = if let Some(range) = attribute {
+                        let (row, col) = get_row_column(range)?;
+                        self.col_index = col;
+                        (row, col)
+                    } else {
+                        (self.row_index, self.col_index)
+                    };
+
+                    // Extract style ID if present
+                    let style = if let Ok(Some(style_id_str)) = c_element.raw_attr(b"s") {
+                        if let Ok(style_id) = atoi_simd::parse::<usize, true, false>(style_id_str) {
+                            if style_id < self.styles.len() {
+                                let mut s = self.styles[style_id].clone();
+                                s.style_id = Some(style_id as u32);
+                                s
+                            } else {
+                                Style::new()
+                            }
+                        } else {
+                            Style::new()
+                        }
+                    } else {
+                        Style::new()
+                    };
+
+                    // Skip the cell content since we only care about the style
+                    loop {
+                        self.cell_buf.clear();
+                        match self.xml.read_event_into(&mut self.cell_buf) {
+                            Ok(Event::End(ref e)) if e.local_name().as_ref() == b"c" => break,
+                            Ok(Event::Eof) => return Err(XlsxError::XmlEof("c")),
+                            Err(e) => return Err(XlsxError::Xml(e)),
+                            _ => (),
+                        }
+                    }
+                    self.col_index += 1;
+                    return Ok(Some(Cell::new(pos, style)));
+                }
+                Ok(Event::End(ref e)) if e.local_name().as_ref() == b"sheetData" => {
+                    return Ok(None);
+                }
+                Ok(Event::Eof) => return Err(XlsxError::XmlEof("sheetData")),
+                Err(e) => return Err(XlsxError::Xml(e)),
+                _ => (),
+            }
+        }
+    }
+
+    /// Iterate over cells, returning just position and style_id (no clone).
+    ///
+    /// Returns `(row, col, style_id)` where `style_id` is an index into the styles palette.
+    /// This is more efficient than `next_style()` when building compressed style storage.
+    pub fn next_style_id(&mut self) -> Result<Option<(u32, u32, usize)>, XlsxError> {
+        loop {
+            self.buf.clear();
+            match self.xml.read_event_into(&mut self.buf) {
+                Ok(Event::Start(ref row_element))
+                    if row_element.local_name().as_ref() == b"row" =>
+                {
+                    if let Some(row_index) = row_element.raw_attr(b"r")? {
+                        self.row_index = atoi_simd::parse::<u32, true, false>(row_index)
+                            .unwrap_or(1)
+                            .saturating_sub(1);
+                    }
+                }
+                Ok(Event::End(ref row_element)) if row_element.local_name().as_ref() == b"row" => {
+                    self.row_index += 1;
+                    self.col_index = 0;
+                }
+                Ok(Event::Start(ref c_element)) if c_element.local_name().as_ref() == b"c" => {
+                    let attribute = c_element.raw_attr(b"r")?;
+                    let pos = if let Some(range) = attribute {
+                        let (row, col) = get_row_column(range)?;
+                        self.col_index = col;
+                        (row, col)
+                    } else {
+                        (self.row_index, self.col_index)
+                    };
+
+                    // Extract style ID if present (no clone needed!)
+                    let style_id = if let Ok(Some(style_id_str)) = c_element.raw_attr(b"s") {
+                        atoi_simd::parse::<usize, true, false>(style_id_str).unwrap_or(0)
+                    } else {
+                        0
+                    };
+
+                    // Skip the cell content since we only care about the style ID
+                    loop {
+                        self.cell_buf.clear();
+                        match self.xml.read_event_into(&mut self.cell_buf) {
+                            Ok(Event::End(ref e)) if e.local_name().as_ref() == b"c" => break,
+                            Ok(Event::Eof) => return Err(XlsxError::XmlEof("c")),
+                            Err(e) => return Err(XlsxError::Xml(e)),
+                            _ => (),
+                        }
+                    }
+                    self.col_index += 1;
+
+                    // Only return cells with actual styles
+                    if style_id > 0 && style_id < self.styles.len() {
+                        return Ok(Some((pos.0, pos.1, style_id)));
+                    }
+                    // Continue to next cell if no style
                 }
                 Ok(Event::End(e)) if e.local_name().as_ref() == b"sheetData" => {
                     return Ok(None);
@@ -547,9 +723,14 @@ where
             }
         }
     }
+
+    /// Get the styles palette (reference to avoid clones)
+    pub fn styles(&self) -> &[Style] {
+        self.styles
+    }
 }
 
-/// Reads a cell value using pre-extracted `s` and `t` attributes
+/// Reads a cell value using pre-extracted `s` and `t` attributes.
 /// (avoids repeating attribute iteration on the `<c>` element).
 fn read_value<'s, RS>(
     ctx: &WorkbookContext<'s>,
@@ -640,13 +821,18 @@ fn read_v<'s>(
             if v.is_empty() {
                 return Ok(DataRef::Empty);
             }
+            // Cell value is an index into the shared string table.
             let idx = atoi_simd::parse::<usize, true, false>(v).unwrap_or(0);
-            ctx.strings
-                .get(idx)
-                .map(|s| DataRef::SharedString(s))
-                .ok_or(XlsxError::Unexpected(
+            match ctx.strings.get(idx) {
+                Some(Data::String(s)) => Ok(DataRef::SharedString(s)),
+                Some(Data::RichText(rt)) => Ok(DataRef::SharedRichText(rt)),
+                Some(_) => Err(XlsxError::Unexpected(
+                    "Unexpected data type in shared strings table",
+                )),
+                None => Err(XlsxError::Unexpected(
                     "Cell string index not found in shared strings table",
-                ))
+                )),
+            }
         }
         Some(b"b") => Ok(DataRef::Bool(v != b"0")),
         Some(b"d") => Ok(DataRef::DateTimeIso(v_as_str(v)?.to_string())),
diff --git a/src/xlsx/mod.rs b/src/xlsx/mod.rs
index d68a5d3c..961a4671 100644
--- a/src/xlsx/mod.rs
+++ b/src/xlsx/mod.rs
@@ -5,8 +5,9 @@
 #![warn(missing_docs)]
 
 mod cells_reader;
+mod style_parser;
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 #[cfg(feature = "picture")]
 use std::collections::HashSet;
 use std::io::BufReader;
@@ -14,6 +15,7 @@ use std::io::{Read, Seek};
 use std::str::FromStr;
 
 use log::warn;
+use quick_xml::events::attributes::Attribute;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::name::QName;
 use quick_xml::Decoder;
@@ -24,6 +26,10 @@ use zip::result::ZipError;
 use crate::attrs::{decode_attr, local_name_matches, RawAttributes};
 use crate::datatype::DataRef;
 use crate::formats::{builtin_format_by_id, detect_custom_number_format, CellFormat};
+use crate::style::{
+    Color, ColumnWidth, Font, FontStyle, FontWeight, RichText, RowHeight, StyleRange, TextRun,
+    UnderlineStyle, WorksheetLayout,
+};
 use crate::utils::{
     build_zip_path_cache, cached_zip_path, unescape_entity_to_buffer, unescape_xml,
 };
@@ -32,7 +38,7 @@ use crate::vba::VbaProject;
 use crate::Picture;
 use crate::{
     Cell, CellErrorType, Data, Dimensions, HeaderRow, Metadata, Range, Reader, ReaderRef, Sheet,
-    SheetType, SheetVisible, Table,
+    SheetType, SheetVisible, Style, Table,
 };
 pub use cells_reader::{
     XlsxCellFormula, XlsxCellFormulaMetadataRecord, XlsxCellReader, XlsxFormulaMetadata,
@@ -253,14 +259,16 @@ pub struct Xlsx<RS> {
     zip: ZipArchive<RS>,
     /// Path to directory containing workbook.xml within zip archive (commonly "xl/")
     xl_path: String,
-    /// Shared strings
-    strings: Vec<String>,
+    /// Shared strings (can be plain strings or rich text)
+    strings: Vec<Data>,
     /// Sheets paths
     sheets: Vec<(String, String)>,
     /// Tables: Name, Sheet, Columns, Data dimensions
     tables: Tables,
     /// Cell (number) formats
     formats: Vec<CellFormat>,
+    /// Cell styles
+    pub styles: Vec<Style>,
     /// 1904 datetime system
     is_1904: bool,
     /// Metadata
@@ -359,16 +367,12 @@ impl<RS: Read + Seek> Xlsx<RS> {
             }
         }
 
-        let mut str_buf = Vec::with_capacity(1024);
-        let mut str_val_buf = Vec::with_capacity(1024);
         loop {
             buf.clear();
             match xml.read_event_into(&mut buf) {
                 Ok(Event::Start(e)) if e.local_name().as_ref() == b"si" => {
-                    if let Some(s) =
-                        read_string_with_bufs(&mut xml, e.name(), &mut str_buf, &mut str_val_buf)?
-                    {
-                        self.strings.push(s);
+                    if let Some(data) = read_rich_string(&mut xml, e.name())? {
+                        self.strings.push(data);
                     }
                 }
                 Ok(Event::End(e)) if e.local_name().as_ref() == b"sst" => break,
@@ -380,14 +384,26 @@ impl<RS: Read + Seek> Xlsx<RS> {
         Ok(())
     }
 
+    fn read_theme_colors(&mut self) -> Vec<Color> {
+        match xml_reader(&mut self.zip, "xl/theme/theme1.xml", &self.zip_path_cache) {
+            Some(Ok(mut xml)) => style_parser::read_theme_colors(&mut xml),
+            _ => style_parser::default_theme_colors(),
+        }
+    }
+
     fn read_styles(&mut self) -> Result<(), XlsxError> {
+        let theme_colors = self.read_theme_colors();
+
         let path = format!("{}styles.xml", self.xl_path);
         let mut xml = match xml_reader(&mut self.zip, path.as_ref(), &self.zip_path_cache) {
             None => return Ok(()),
             Some(x) => x?,
         };
 
-        let mut number_formats = HashMap::new();
+        let mut number_formats = BTreeMap::new();
+        let mut fonts = Vec::new();
+        let mut fills = Vec::new();
+        let mut borders = Vec::new();
 
         let mut buf = Vec::with_capacity(1024);
         let mut inner_buf = Vec::with_capacity(1024);
@@ -398,11 +414,44 @@ impl<RS: Read + Seek> Xlsx<RS> {
                     inner_buf.clear();
                     match xml.read_event_into(&mut inner_buf) {
                         Ok(Event::Start(e)) if e.local_name().as_ref() == b"numFmt" => {
-                            let (id, format_code) =
-                                get_attrs!(e, b"numFmtId" => id, b"formatCode" => fmt)?;
-                            if let (Some(id), Some(fc)) = (id, format_code) {
-                                let format = decode_attr(&xml.decoder(), fc)?;
-                                number_formats.insert(id.to_vec(), format);
+                            let mut id = Vec::new();
+                            let mut format = String::new();
+                            for a in e.attributes() {
+                                let a = a?;
+                                match a {
+                                    Attribute {
+                                        key: QName(b"numFmtId"),
+                                        value: v,
+                                    } => id.extend_from_slice(&v),
+                                    Attribute {
+                                        key: QName(b"formatCode"),
+                                        value: v,
+                                    } => {
+                                        let format_code = decode_attr(&xml.decoder(), &v)?;
+                                        // Excel format codes use backslashes to escape special characters
+                                        // Remove escape backslashes (backslash followed by any character becomes just the character)
+                                        let mut unescaped = String::new();
+                                        let mut chars = format_code.chars().peekable();
+                                        while let Some(ch) = chars.next() {
+                                            if ch == '\\' {
+                                                // If there's a next character, use it without the backslash
+                                                if let Some(next_ch) = chars.next() {
+                                                    unescaped.push(next_ch);
+                                                } else {
+                                                    // Trailing backslash, keep it
+                                                    unescaped.push(ch);
+                                                }
+                                            } else {
+                                                unescaped.push(ch);
+                                            }
+                                        }
+                                        format = unescaped;
+                                    }
+                                    _ => (),
+                                }
+                            }
+                            if !format.is_empty() {
+                                number_formats.insert(id, format);
                             }
                         }
                         Ok(Event::End(e)) if e.local_name().as_ref() == b"numFmts" => break,
@@ -411,17 +460,185 @@ impl<RS: Read + Seek> Xlsx<RS> {
                         _ => (),
                     }
                 },
-                Ok(Event::Start(e)) if e.local_name().as_ref() == b"cellXfs" => loop {
+                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"fonts" => loop {
                     inner_buf.clear();
                     match xml.read_event_into(&mut inner_buf) {
-                        Ok(Event::Start(e)) if e.local_name().as_ref() == b"xf" => {
-                            self.formats.push(e.raw_attr(b"numFmtId")?.map_or(
-                                CellFormat::Other,
-                                |val| match number_formats.get(val) {
+                        Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"font" => {
+                            let font = style_parser::parse_font(&mut xml, e, &theme_colors)?;
+                            fonts.push(font);
+                        }
+                        Ok(Event::End(ref e)) if e.local_name().as_ref() == b"fonts" => break,
+                        Ok(Event::Eof) => return Err(XlsxError::XmlEof("fonts")),
+                        Err(e) => return Err(XlsxError::Xml(e)),
+                        _ => (),
+                    }
+                },
+                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"fills" => loop {
+                    inner_buf.clear();
+                    match xml.read_event_into(&mut inner_buf) {
+                        Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"fill" => {
+                            let fill = style_parser::parse_fill(&mut xml, e, &theme_colors)?;
+                            fills.push(fill);
+                        }
+                        Ok(Event::End(ref e)) if e.local_name().as_ref() == b"fills" => break,
+                        Ok(Event::Eof) => return Err(XlsxError::XmlEof("fills")),
+                        Err(e) => return Err(XlsxError::Xml(e)),
+                        _ => (),
+                    }
+                },
+                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"borders" => loop {
+                    inner_buf.clear();
+                    match xml.read_event_into(&mut inner_buf) {
+                        Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"border" => {
+                            let border = style_parser::parse_border(&mut xml, e, &theme_colors)?;
+                            borders.push(border);
+                        }
+                        Ok(Event::End(ref e)) if e.local_name().as_ref() == b"borders" => break,
+                        Ok(Event::Eof) => return Err(XlsxError::XmlEof("borders")),
+                        Err(e) => return Err(XlsxError::Xml(e)),
+                        _ => (),
+                    }
+                },
+                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"cellXfs" => loop {
+                    inner_buf.clear();
+                    match xml.read_event_into(&mut inner_buf) {
+                        Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"xf" => {
+                            let mut style = Style::new();
+                            let mut fmt_id_bytes_for_format: Option<Vec<u8>> = None;
+
+                            for a in e.attributes() {
+                                let a = a.map_err(XlsxError::XmlAttr)?;
+                                match a.key.as_ref() {
+                                    b"fontId" => {
+                                        if let Ok(font_id) =
+                                            xml.decoder().decode(&a.value)?.parse::<usize>()
+                                        {
+                                            if let Some(font) = fonts.get(font_id) {
+                                                style = style.with_font(font.clone());
+                                            }
+                                        }
+                                    }
+                                    b"fillId" => {
+                                        if let Ok(fill_id) =
+                                            xml.decoder().decode(&a.value)?.parse::<usize>()
+                                        {
+                                            if let Some(fill) = fills.get(fill_id) {
+                                                style = style.with_fill(fill.clone());
+                                            }
+                                        }
+                                    }
+                                    b"borderId" => {
+                                        if let Ok(border_id) =
+                                            xml.decoder().decode(&a.value)?.parse::<usize>()
+                                        {
+                                            if let Some(border) = borders.get(border_id) {
+                                                style = style.with_borders(border.clone());
+                                            }
+                                        }
+                                    }
+                                    b"numFmtId" => {
+                                        if let Ok(num_fmt_id) =
+                                            xml.decoder().decode(&a.value)?.parse::<u32>()
+                                        {
+                                            let id_bytes: &[u8] = &a.value;
+                                            fmt_id_bytes_for_format = Some(id_bytes.to_vec());
+                                            let format_code = match number_formats
+                                                .get(id_bytes)
+                                            {
+                                                Some(fmt) => fmt.clone(),
+                                                None => {
+                                                    match num_fmt_id {
+                                                        0 => "General".to_string(),
+                                                        1 => "0".to_string(),
+                                                        2 => "0.00".to_string(),
+                                                        3 => "#,##0".to_string(),
+                                                        4 => "#,##0.00".to_string(),
+                                                        9 => "0%".to_string(),
+                                                        10 => "0.00%".to_string(),
+                                                        11 => "0.00E+00".to_string(),
+                                                        12 => "# ?/?".to_string(),
+                                                        13 => "# ??/??".to_string(),
+                                                        14 => "mm-dd-yy".to_string(),
+                                                        15 => "d-mmm-yy".to_string(),
+                                                        16 => "d-mmm".to_string(),
+                                                        17 => "mmm-yy".to_string(),
+                                                        18 => "h:mm AM/PM".to_string(),
+                                                        19 => "h:mm:ss AM/PM".to_string(),
+                                                        20 => "h:mm".to_string(),
+                                                        21 => "h:mm:ss".to_string(),
+                                                        22 => "m/d/yy h:mm".to_string(),
+                                                        37 => "#,##0 ;(#,##0)".to_string(),
+                                                        38 => "#,##0 ;[Red](#,##0)".to_string(),
+                                                        39 => "#,##0.00;(#,##0.00)".to_string(),
+                                                        40 => "#,##0.00;[Red](#,##0.00)".to_string(),
+                                                        41 => "_(* #,##0_);_(* (#,##0);_(* \"-\"_);_(@_)".to_string(),
+                                                        42 => "_($* #,##0_);_($* (#,##0);_($* \"-\"_);_(@_)".to_string(),
+                                                        43 => "_(* #,##0.00_);_(* (#,##0.00);_(* \"-\"??_);_(@_)".to_string(),
+                                                        44 => "_($* #,##0.00_);_($* (#,##0.00);_($* \"-\"??_);_(@_)".to_string(),
+                                                        45 => "mm:ss".to_string(),
+                                                        46 => "[h]:mm:ss".to_string(),
+                                                        47 => "mmss.0".to_string(),
+                                                        48 => "##0.0E+0".to_string(),
+                                                        49 => "@".to_string(),
+                                                        _ => "General".to_string(),
+                                                    }
+                                                }
+                                            };
+
+                                            use crate::style::NumberFormat;
+                                            let number_format =
+                                                NumberFormat::new(format_code).with_id(num_fmt_id);
+                                            style = style.with_number_format(number_format);
+                                        }
+                                    }
+                                    _ => {}
+                                }
+                            }
+
+                            // Resolve the CellFormat from the numFmtId we already
+                            // parsed above, before the nested loop overwrites buffers.
+                            let cell_format = fmt_id_bytes_for_format
+                                .as_ref()
+                                .map(|id_bytes| match number_formats.get(id_bytes.as_slice()) {
                                     Some(fmt) => detect_custom_number_format(fmt),
-                                    None => builtin_format_by_id(val),
-                                },
-                            ));
+                                    None => builtin_format_by_id(id_bytes),
+                                })
+                                .unwrap_or(CellFormat::Other);
+
+                            let mut nested_buf = Vec::with_capacity(512);
+                            loop {
+                                nested_buf.clear();
+                                match xml.read_event_into(&mut nested_buf) {
+                                    Ok(Event::Start(ref nested_e) | Event::Empty(ref nested_e)) => {
+                                        match nested_e.local_name().as_ref() {
+                                            b"alignment" => {
+                                                let alignment = style_parser::parse_alignment(
+                                                    &mut xml, nested_e,
+                                                )?;
+                                                style = style.with_alignment(alignment);
+                                            }
+                                            b"protection" => {
+                                                let protection = style_parser::parse_protection(
+                                                    &mut xml, nested_e,
+                                                )?;
+                                                style = style.with_protection(protection);
+                                            }
+                                            _ => {}
+                                        }
+                                    }
+                                    Ok(Event::End(ref end_e))
+                                        if end_e.local_name().as_ref() == b"xf" =>
+                                    {
+                                        break
+                                    }
+                                    Ok(Event::Eof) => return Err(XlsxError::XmlEof("xf")),
+                                    Err(e) => return Err(XlsxError::Xml(e)),
+                                    _ => {}
+                                }
+                            }
+
+                            self.styles.push(style);
+                            self.formats.push(cell_format);
                         }
                         Ok(Event::End(e)) if e.local_name().as_ref() == b"cellXfs" => break,
                         Ok(Event::Eof) => return Err(XlsxError::XmlEof("cellXfs")),
@@ -2265,6 +2482,260 @@ impl<RS: Read + Seek> Xlsx<RS> {
 
         self.hyperlinks_by_sheet_name(&name)
     }
+
+    /// Get the styles for a worksheet.
+    ///
+    /// Get worksheet styles as an RLE-compressed [`StyleRange`].
+    ///
+    /// This function returns styles for all cells with explicit formatting,
+    /// stored in run-length encoded format for memory efficiency.
+    ///
+    /// # Parameters
+    ///
+    /// - `name`: The name of the worksheet to get the styles for.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// let styles = xlsx.worksheet_style("Sheet1")?;
+    /// println!("Unique styles: {}", styles.unique_style_count());
+    /// println!("Compression ratio: {:.1}x", styles.compression_ratio());
+    /// for (row, col, style) in styles.cells() {
+    ///     // process style
+    /// }
+    /// ```
+    pub fn worksheet_style(&mut self, name: &str) -> Result<StyleRange, XlsxError> {
+        let mut cell_reader = match self.worksheet_cells_reader(name) {
+            Ok(reader) => reader,
+            Err(XlsxError::NotAWorksheet(typ)) => {
+                warn!("'{typ}' not a worksheet");
+                return Ok(StyleRange::empty());
+            }
+            Err(e) => return Err(e),
+        };
+
+        let len = cell_reader.dimensions().len();
+        let mut cells = Vec::new();
+        if len < 100_000 {
+            cells.reserve(len as usize);
+        }
+
+        // Use zero-copy path: collect (row, col, style_id) without cloning styles
+        while let Some((row, col, style_id)) = cell_reader.next_style_id()? {
+            cells.push((row, col, style_id));
+        }
+
+        // Get the palette from the cell_reader (clone once, not per cell)
+        let palette = cell_reader.styles().to_vec();
+
+        Ok(StyleRange::from_style_ids(cells, palette))
+    }
+
+    /// Get the layout for a worksheet.
+    ///
+    /// This function returns a [`WorksheetLayout`] for the specified worksheet.
+    /// The layout contains the column widths and row heights for the cells in the worksheet.
+    ///
+    /// # Parameters
+    ///
+    /// - `name`: The name of the worksheet to get the layout for.
+    ///
+    pub fn worksheet_layout(&mut self, name: &str) -> Result<WorksheetLayout, XlsxError> {
+        let (_, path) = self
+            .sheets
+            .iter()
+            .find(|&(n, _)| n == name)
+            .ok_or_else(|| XlsxError::WorksheetNotFound(name.into()))?;
+
+        let mut xml = xml_reader(&mut self.zip, path, &self.zip_path_cache)
+            .ok_or_else(|| XlsxError::WorksheetNotFound(name.into()))??;
+
+        let mut layout = WorksheetLayout::new();
+        let mut buf = Vec::with_capacity(1024);
+
+        loop {
+            buf.clear();
+            match xml.read_event_into(&mut buf) {
+                Ok(Event::Start(ref e) | Event::Empty(ref e))
+                    if e.local_name().as_ref() == b"sheetFormatPr" =>
+                {
+                    for attr in e.attributes() {
+                        let attr = attr.map_err(XlsxError::XmlAttr)?;
+                        match attr.key.as_ref() {
+                            b"defaultColWidth" => {
+                                if let Ok(width_str) = xml.decoder().decode(&attr.value) {
+                                    if let Ok(width) = width_str.parse::<f64>() {
+                                        layout = layout.with_default_column_width(width);
+                                    }
+                                }
+                            }
+                            b"defaultRowHeight" => {
+                                if let Ok(height_str) = xml.decoder().decode(&attr.value) {
+                                    if let Ok(height) = height_str.parse::<f64>() {
+                                        layout = layout.with_default_row_height(height);
+                                    }
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"cols" => loop {
+                    buf.clear();
+                    match xml.read_event_into(&mut buf) {
+                        Ok(Event::Start(ref col_e) | Event::Empty(ref col_e))
+                            if col_e.local_name().as_ref() == b"col" =>
+                        {
+                            let mut col_min = None;
+                            let mut col_max = None;
+                            let mut width = 0.0;
+                            let mut custom_width = false;
+                            let mut hidden = false;
+                            let mut best_fit = false;
+
+                            for attr in col_e.attributes() {
+                                let attr = attr.map_err(XlsxError::XmlAttr)?;
+                                match attr.key.as_ref() {
+                                    b"min" => {
+                                        if let Ok(min_str) = xml.decoder().decode(&attr.value) {
+                                            if let Ok(min_col) = min_str.parse::<u32>() {
+                                                col_min = Some(min_col.saturating_sub(1));
+                                            }
+                                        }
+                                    }
+                                    b"max" => {
+                                        if let Ok(max_str) = xml.decoder().decode(&attr.value) {
+                                            if let Ok(max_col) = max_str.parse::<u32>() {
+                                                col_max = Some(max_col.saturating_sub(1));
+                                            }
+                                        }
+                                    }
+                                    b"width" => {
+                                        if let Ok(width_str) = xml.decoder().decode(&attr.value) {
+                                            if let Ok(w) = width_str.parse::<f64>() {
+                                                width = w;
+                                            }
+                                        }
+                                    }
+                                    b"customWidth" => {
+                                        custom_width = &*attr.value != b"0";
+                                    }
+                                    b"hidden" => {
+                                        hidden = &*attr.value != b"0";
+                                    }
+                                    b"bestFit" => {
+                                        best_fit = &*attr.value != b"0";
+                                    }
+                                    _ => {}
+                                }
+                            }
+
+                            if let Some(min_col) = col_min {
+                                let max_col = col_max.unwrap_or(min_col);
+                                for col in min_col..=max_col {
+                                    let column_width = ColumnWidth::new(col, width)
+                                        .with_custom_width(custom_width)
+                                        .with_hidden(hidden)
+                                        .with_best_fit(best_fit);
+                                    layout = layout.add_column_width(column_width);
+                                }
+                            }
+                        }
+                        Ok(Event::End(ref end_e)) if end_e.local_name().as_ref() == b"cols" => {
+                            break;
+                        }
+                        Ok(Event::Eof) => return Err(XlsxError::XmlEof("cols")),
+                        Err(e) => return Err(XlsxError::Xml(e)),
+                        _ => {}
+                    }
+                },
+                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"sheetData" => {
+                    loop {
+                        buf.clear();
+                        match xml.read_event_into(&mut buf) {
+                            Ok(Event::Start(ref row_e))
+                                if row_e.local_name().as_ref() == b"row" =>
+                            {
+                                let mut row_num = None;
+                                let mut height = 0.0;
+                                let mut custom_height = false;
+                                let mut hidden = false;
+                                let mut thick_top = false;
+                                let mut thick_bottom = false;
+
+                                for attr in row_e.attributes() {
+                                    let attr = attr.map_err(XlsxError::XmlAttr)?;
+                                    match attr.key.as_ref() {
+                                        b"r" => {
+                                            if let Ok(row_str) = xml.decoder().decode(&attr.value) {
+                                                if let Ok(r) = row_str.parse::<u32>() {
+                                                    row_num = Some(r.saturating_sub(1));
+                                                }
+                                            }
+                                        }
+                                        b"ht" => {
+                                            if let Ok(height_str) =
+                                                xml.decoder().decode(&attr.value)
+                                            {
+                                                if let Ok(h) = height_str.parse::<f64>() {
+                                                    height = h;
+                                                }
+                                            }
+                                        }
+                                        b"customHeight" => {
+                                            custom_height = &*attr.value != b"0";
+                                        }
+                                        b"hidden" => {
+                                            hidden = &*attr.value != b"0";
+                                        }
+                                        b"thickTop" => {
+                                            thick_top = &*attr.value != b"0";
+                                        }
+                                        b"thickBot" => {
+                                            thick_bottom = &*attr.value != b"0";
+                                        }
+                                        _ => {}
+                                    }
+                                }
+
+                                if let Some(row) = row_num {
+                                    if custom_height
+                                        || hidden
+                                        || thick_top
+                                        || thick_bottom
+                                        || height > 0.0
+                                    {
+                                        let row_height = RowHeight::new(row, height)
+                                            .with_custom_height(custom_height)
+                                            .with_hidden(hidden)
+                                            .with_thick_top(thick_top)
+                                            .with_thick_bottom(thick_bottom);
+                                        layout = layout.add_row_height(row_height);
+                                    }
+                                }
+
+                                xml.read_to_end_into(row_e.name(), &mut Vec::new())?;
+                            }
+                            Ok(Event::End(ref end_e))
+                                if end_e.local_name().as_ref() == b"sheetData" =>
+                            {
+                                break;
+                            }
+                            Ok(Event::Eof) => return Err(XlsxError::XmlEof("sheetData")),
+                            Err(e) => return Err(XlsxError::Xml(e)),
+                            _ => {}
+                        }
+                    }
+                    break;
+                }
+                Ok(Event::Eof) => break,
+                Err(e) => return Err(XlsxError::Xml(e)),
+                _ => {}
+            }
+        }
+
+        Ok(layout)
+    }
 }
 
 /// A hyperlink declared on an XLSX worksheet.
@@ -2513,7 +2984,43 @@ impl InnerTableMetadata {
 }
 
 impl<RS: Read + Seek> Xlsx<RS> {
-    /// Get a reader over all used cells in the given worksheet cell reader
+    /// Get the cells reader for a worksheet.
+    ///
+    /// This function returns a [`XlsxCellReader`] for the specified worksheet.
+    /// The reader can be used to iterate over the cells in the worksheet.
+    ///
+    /// # Parameters
+    ///
+    /// - `name`: The name of the worksheet to get the cells reader for.
+    ///
+    /// # Errors
+    ///
+    /// - [`XlsxError::WorksheetNotFound`].
+    ///
+    /// # Examples
+    ///
+    /// An example of getting the cells reader for a worksheet.
+    ///
+    /// ```
+    /// use calamine::{open_workbook, Error, Xlsx};
+    ///
+    /// fn main() -> Result<(), Error> {
+    ///     let path = "tests/merged_range.xlsx";
+    ///
+    ///     // Open the workbook.
+    ///     let mut workbook: Xlsx<_> = open_workbook(path)?;
+    ///
+    ///     // Get the cells reader for the first worksheet.
+    ///     let mut reader = workbook.worksheet_cells_reader("Sheet1")?;
+    ///
+    ///     // Iterate over the cells in the worksheet.
+    ///     while let Some(cell) = reader.next_cell()? {
+    ///         println!("{:?}", cell);
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
     pub fn worksheet_cells_reader<'a>(
         &'a mut self,
         name: &str,
@@ -2528,7 +3035,8 @@ impl<RS: Read + Seek> Xlsx<RS> {
         let is_1904 = self.is_1904;
         let strings = &self.strings;
         let formats = &self.formats;
-        XlsxCellReader::new(xml, strings, formats, is_1904)
+        let styles = &self.styles;
+        XlsxCellReader::new(xml, strings, formats, styles, is_1904)
     }
 }
 
@@ -2545,6 +3053,7 @@ impl<RS: Read + Seek> Reader<RS> for Xlsx<RS> {
             xl_path: "xl/".to_string(),
             strings: Vec::new(),
             formats: Vec::new(),
+            styles: Vec::new(),
             is_1904: false,
             sheets: Vec::new(),
             tables: None,
@@ -2617,6 +3126,14 @@ impl<RS: Read + Seek> Reader<RS> for Xlsx<RS> {
         Ok(Range::from_sparse(cells))
     }
 
+    fn worksheet_style(&mut self, name: &str) -> Result<StyleRange, XlsxError> {
+        Xlsx::worksheet_style(self, name)
+    }
+
+    fn worksheet_layout(&mut self, name: &str) -> Result<WorksheetLayout, XlsxError> {
+        Xlsx::worksheet_layout(self, name)
+    }
+
     fn worksheets(&mut self) -> Vec<(String, Range<Data>)> {
         let names = self
             .sheets
@@ -2708,6 +3225,7 @@ impl<RS: Read + Seek> ReaderRef<RS> for Xlsx<RS> {
                                 cells.first().expect("cells should not be empty").pos.1,
                             ),
                             val: DataRef::Empty,
+                            style: None,
                         },
                     );
                 }
@@ -2929,6 +3447,360 @@ where
     }
 }
 
+/// Result of parsing run properties - includes both the font and whether there's "rich" formatting
+struct RunPropertiesResult {
+    font: Font,
+    /// Whether the font has "rich" formatting (bold, italic, underline, strikethrough, color)
+    /// that would make this text run distinct from plain text
+    has_rich_formatting: bool,
+}
+
+/// Parse run properties (rPr) to extract font formatting for rich text
+fn parse_run_properties<RS>(
+    xml: &mut XlReader<'_, RS>,
+    closing: QName,
+) -> Result<Option<RunPropertiesResult>, XlsxError>
+where
+    RS: Read + Seek,
+{
+    let mut font = Font::new();
+    let mut has_any_props = false;
+    let mut has_rich_formatting = false;
+    let mut buf = Vec::with_capacity(256);
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(Event::Start(e) | Event::Empty(e)) => {
+                match e.local_name().as_ref() {
+                    b"b" => {
+                        // Bold - check for val attribute
+                        let mut is_bold = true;
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                let val = String::from_utf8_lossy(&attr.value);
+                                is_bold = val != "0" && val != "false";
+                            }
+                        }
+                        if is_bold {
+                            font = font.with_weight(FontWeight::Bold);
+                            has_any_props = true;
+                            has_rich_formatting = true;
+                        }
+                    }
+                    b"i" => {
+                        // Italic - check for val attribute
+                        let mut is_italic = true;
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                let val = String::from_utf8_lossy(&attr.value);
+                                is_italic = val != "0" && val != "false";
+                            }
+                        }
+                        if is_italic {
+                            font = font.with_style(FontStyle::Italic);
+                            has_any_props = true;
+                            has_rich_formatting = true;
+                        }
+                    }
+                    b"u" => {
+                        // Underline
+                        let mut underline = UnderlineStyle::Single;
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                let val = String::from_utf8_lossy(&attr.value);
+                                underline = match val.as_ref() {
+                                    "double" => UnderlineStyle::Double,
+                                    "singleAccounting" => UnderlineStyle::SingleAccounting,
+                                    "doubleAccounting" => UnderlineStyle::DoubleAccounting,
+                                    "none" => UnderlineStyle::None,
+                                    _ => UnderlineStyle::Single,
+                                };
+                            }
+                        }
+                        if underline != UnderlineStyle::None {
+                            font = font.with_underline(underline);
+                            has_any_props = true;
+                            has_rich_formatting = true;
+                        }
+                    }
+                    b"strike" => {
+                        // Strikethrough
+                        let mut is_strike = true;
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                let val = String::from_utf8_lossy(&attr.value);
+                                is_strike = val != "0" && val != "false";
+                            }
+                        }
+                        if is_strike {
+                            font = font.with_strikethrough(true);
+                            has_any_props = true;
+                            has_rich_formatting = true;
+                        }
+                    }
+                    b"sz" => {
+                        // Font size - captured but doesn't count as "rich" formatting
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                if let Ok(size) =
+                                    String::from_utf8_lossy(&attr.value).parse::<f64>()
+                                {
+                                    font = font.with_size(size);
+                                    has_any_props = true;
+                                }
+                            }
+                        }
+                    }
+                    b"color" => {
+                        // Font color - counts as rich formatting
+                        if let Some(color) = parse_run_color(&e)? {
+                            font = font.with_color(color);
+                            has_any_props = true;
+                            has_rich_formatting = true;
+                        }
+                    }
+                    b"rFont" => {
+                        // Font name - captured but doesn't count as "rich" formatting
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                font = font
+                                    .with_name(String::from_utf8_lossy(&attr.value).to_string());
+                                has_any_props = true;
+                            }
+                        }
+                    }
+                    b"family" => {
+                        // Font family - captured but doesn't count as "rich" formatting
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"val" {
+                                font = font
+                                    .with_family(String::from_utf8_lossy(&attr.value).to_string());
+                                has_any_props = true;
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            Ok(Event::End(e)) if e.name() == closing => break,
+            Ok(Event::Eof) => return Err(XlsxError::XmlEof("rPr")),
+            Err(e) => return Err(XlsxError::Xml(e)),
+            _ => {}
+        }
+    }
+
+    Ok(if has_any_props {
+        Some(RunPropertiesResult {
+            font,
+            has_rich_formatting,
+        })
+    } else {
+        None
+    })
+}
+
+/// Parse color from a run properties color element
+fn parse_run_color(
+    e: &quick_xml::events::BytesStart<'_>,
+) -> Result<Option<crate::Color>, XlsxError> {
+    use crate::Color;
+
+    for attr in e.attributes().flatten() {
+        match attr.key.as_ref() {
+            b"rgb" => {
+                let rgb_str: &[u8] = attr.value.as_ref();
+                if rgb_str.len() == 6 {
+                    let r = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[0..2]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid red color value"))?;
+                    let g = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[2..4]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid green color value"))?;
+                    let b = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[4..6]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid blue color value"))?;
+                    return Ok(Some(Color::rgb(r, g, b)));
+                } else if rgb_str.len() == 8 {
+                    let a = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[0..2]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid alpha color value"))?;
+                    let r = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[2..4]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid red color value"))?;
+                    let g = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[4..6]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid green color value"))?;
+                    let b = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[6..8]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid blue color value"))?;
+                    return Ok(Some(Color::new(a, r, g, b)));
+                }
+            }
+            b"theme" => {
+                // Theme colors - using a simplified palette
+                let theme_str = String::from_utf8_lossy(&attr.value);
+                if let Ok(theme) = theme_str.parse::<u8>() {
+                    let color = match theme {
+                        0 => Color::rgb(255, 255, 255), // Light 1
+                        1 => Color::rgb(0, 0, 0),       // Dark 1
+                        2 => Color::rgb(68, 84, 106),   // Light 2
+                        3 => Color::rgb(31, 73, 125),   // Dark 2
+                        4 => Color::rgb(79, 129, 189),  // Accent 1
+                        5 => Color::rgb(192, 80, 77),   // Accent 2
+                        6 => Color::rgb(155, 187, 89),  // Accent 3
+                        7 => Color::rgb(128, 100, 162), // Accent 4
+                        8 => Color::rgb(75, 172, 198),  // Accent 5
+                        9 => Color::rgb(247, 150, 70),  // Accent 6
+                        _ => Color::rgb(0, 0, 0),
+                    };
+                    return Ok(Some(color));
+                }
+            }
+            b"indexed" => {
+                // Indexed colors
+                let idx_str = String::from_utf8_lossy(&attr.value);
+                if let Ok(idx) = idx_str.parse::<u8>() {
+                    let color = match idx {
+                        1 => Color::rgb(0, 0, 0),
+                        2 => Color::rgb(255, 255, 255),
+                        3 => Color::rgb(255, 0, 0),
+                        4 => Color::rgb(0, 255, 0),
+                        5 => Color::rgb(0, 0, 255),
+                        6 => Color::rgb(255, 255, 0),
+                        7 => Color::rgb(255, 0, 255),
+                        8 => Color::rgb(0, 255, 255),
+                        _ => Color::rgb(0, 0, 0),
+                    };
+                    return Ok(Some(color));
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(None)
+}
+
+/// Read a string from shared strings, preserving rich text formatting if present.
+/// Returns Data::String for plain text or Data::RichText for formatted text.
+fn read_rich_string<RS>(
+    xml: &mut XlReader<'_, RS>,
+    closing: QName,
+) -> Result<Option<Data>, XlsxError>
+where
+    RS: Read + Seek,
+{
+    let mut buf = Vec::with_capacity(1024);
+    let mut val_buf = Vec::with_capacity(1024);
+    let mut runs: Vec<TextRun> = Vec::new();
+    let mut current_props: Option<RunPropertiesResult> = None;
+    let mut is_rich_text = false;
+    let mut is_phonetic_text = false;
+    let mut plain_text: Option<String> = None;
+    let mut has_any_rich_formatting = false;
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(Event::Start(e)) if e.local_name().as_ref() == b"r" => {
+                // Start of a rich text run
+                is_rich_text = true;
+                current_props = None;
+            }
+            Ok(Event::End(e)) if e.local_name().as_ref() == b"r" => {
+                // End of a rich text run
+                current_props = None;
+            }
+            Ok(Event::Start(e)) if e.local_name().as_ref() == b"rPr" => {
+                // Run properties (formatting)
+                current_props = parse_run_properties(xml, e.name())?;
+                if let Some(ref props) = current_props {
+                    if props.has_rich_formatting {
+                        has_any_rich_formatting = true;
+                    }
+                }
+            }
+            Ok(Event::Start(e)) if e.local_name().as_ref() == b"rPh" => {
+                is_phonetic_text = true;
+            }
+            Ok(Event::End(e)) if e.local_name().as_ref() == b"rPh" => {
+                is_phonetic_text = false;
+            }
+            Ok(Event::End(e)) if e.name() == closing => {
+                // End of string item.
+                if is_rich_text && !runs.is_empty() {
+                    // Only return RichText if there's actual rich formatting (bold, italic, etc.).
+                    if has_any_rich_formatting {
+                        // Prepend any plain text that appeared before the rich runs as
+                        // an unformatted run so it isn't dropped.
+                        if let Some(text) = plain_text.take() {
+                            runs.insert(0, TextRun { text, font: None });
+                        }
+                        return Ok(Some(Data::RichText(RichText::from_runs(runs))));
+                    } else {
+                        // All runs are plain text or only have non-rich style info,
+                        // concatenate them with any preceding plain text.
+                        let mut text = plain_text.take().unwrap_or_default();
+                        for run in &runs {
+                            text.push_str(&run.text);
+                        }
+                        return Ok(Some(Data::String(text)));
+                    }
+                } else if let Some(text) = plain_text {
+                    return Ok(Some(Data::String(text)));
+                } else if is_rich_text {
+                    // Rich text with no runs means empty string.
+                    return Ok(Some(Data::String(String::new())));
+                } else {
+                    // Empty element.
+                    return Ok(Some(Data::String(String::new())));
+                }
+            }
+            Ok(Event::Start(e)) if e.local_name().as_ref() == b"t" && !is_phonetic_text => {
+                // Text content
+                let preserve_space =
+                    matches!(e.raw_attr(b"xml:space")?, Some(v) if v == b"preserve");
+                val_buf.clear();
+                let mut value = String::new();
+                loop {
+                    match xml.read_event_into(&mut val_buf)? {
+                        Event::Text(t) => value.push_str(&unescape_xml(&t.xml10_content()?)),
+                        Event::GeneralRef(e) => unescape_entity_to_buffer(&e, &mut value)?,
+                        Event::End(end) if end.name() == e.name() => break,
+                        Event::Eof => return Err(XlsxError::XmlEof("t")),
+                        _ => (),
+                    }
+                }
+
+                if !preserve_space {
+                    // Trim ASCII whitespace (space/tab/CR/LF) unless
+                    // xml:space="preserve". Unicode spaces such as U+00A0 (NBSP)
+                    // are preserved.
+                    let trimmed = value.trim_matches([' ', '\t', '\r', '\n']);
+                    if trimmed.len() != value.len() {
+                        value = trimmed.to_string();
+                    }
+                }
+
+                if is_rich_text {
+                    // Add as a run with optional formatting.
+                    // Only include font if there's rich formatting (bold, italic, etc.).
+                    let font = current_props
+                        .take()
+                        .filter(|p| p.has_rich_formatting)
+                        .map(|p| p.font);
+                    runs.push(TextRun { text: value, font });
+                } else {
+                    // Plain text (not in a run).
+                    // Don't return early here: subsequent <r> rich text runs
+                    // may follow an initial plain <t>, so keep parsing.
+                    if let Some(ref mut pt) = plain_text {
+                        pt.push_str(&value);
+                    } else {
+                        plain_text = Some(value);
+                    }
+                }
+            }
+            Ok(Event::Eof) => return Err(XlsxError::XmlEof("")),
+            Err(e) => return Err(XlsxError::Xml(e)),
+            _ => (),
+        }
+    }
+}
+
 fn check_for_password_protected<RS: Read + Seek>(reader: &mut RS) -> Result<(), XlsxError> {
     let offset_end = reader.seek(std::io::SeekFrom::End(0))? as usize;
     reader.seek(std::io::SeekFrom::Start(0))?;
@@ -2988,7 +3860,6 @@ enum Reference {
 }
 
 impl Reference {
-    // Create a cell reference with validation.
     fn cell(row: u32, col: u32, absolute_row: bool, absolute_col: bool) -> Result<Self, XlsxError> {
         let reference = Reference::Cell {
             row,
@@ -3000,21 +3871,18 @@ impl Reference {
         Ok(reference)
     }
 
-    // Create a column reference with validation.
     fn column(col: u32, absolute: bool) -> Result<Self, XlsxError> {
         let reference = Reference::Column { col, absolute };
         reference.validate()?;
         Ok(reference)
     }
 
-    // Create a row reference with validation.
     fn row(row: u32, absolute: bool) -> Result<Self, XlsxError> {
         let reference = Reference::Row { row, absolute };
         reference.validate()?;
         Ok(reference)
     }
 
-    // Parse a reference (e.g., "A1", "$A1", "A$1", "$A$1", "E", "$E", "5", "$5").
     fn parse(name: &[u8]) -> Result<Self, XlsxError> {
         let mut iter = name.iter().peekable();
         let mut col: u32 = 0;
@@ -3060,7 +3928,6 @@ impl Reference {
         }
     }
 
-    // Apply offset to create a new reference with validation.
     fn offset(self, offset: (i64, i64)) -> Result<Self, XlsxError> {
         let result = match self {
             Reference::Cell {
@@ -3117,7 +3984,6 @@ impl Reference {
         Ok(result)
     }
 
-    // Validate that row/column values are in bounds.
     fn validate(&self) -> Result<(), XlsxError> {
         match self {
             Reference::Cell { row, col, .. } => {
@@ -3144,7 +4010,6 @@ impl Reference {
         }
     }
 
-    // Format a reference to bytes.
     fn format(&self, buf: &mut Vec<u8>) -> Result<(), XlsxError> {
         match self {
             Reference::Cell {
@@ -3180,7 +4045,31 @@ impl Reference {
     }
 }
 
-// Advance a reference by the offset (e.g., "A1", "E:F", "5:6", "A1:B5").
+/// Convert a (row, col) coordinate to an Excel cell name like "A1".
+// Kept for use by upcoming conditional formatting / data validation PRs.
+#[allow(dead_code)]
+fn coordinate_to_name(coord: (u32, u32)) -> Result<Vec<u8>, XlsxError> {
+    let mut buf = Vec::new();
+    column_number_to_name(coord.1, &mut buf)?;
+    buf.extend((coord.0 + 1).to_string().into_bytes());
+    Ok(buf)
+}
+
+/// Advance the cell name by the offset.
+// Kept for use by upcoming conditional formatting / data validation PRs.
+#[allow(dead_code)]
+pub fn offset_cell_name(name: &[u8], offset: (i64, i64)) -> Result<Vec<u8>, XlsxError> {
+    let cell = get_row_column(name)?;
+    let new_row = cell.0 as i64 + offset.0;
+    let new_col = cell.1 as i64 + offset.1;
+    if new_row < 0 || new_col < 0 {
+        return Err(XlsxError::Unexpected(
+            "Cell offset produces negative row or column",
+        ));
+    }
+    coordinate_to_name((new_row as u32, new_col as u32))
+}
+
 fn offset_range(range: &[u8], offset: (i64, i64), buf: &mut Vec<u8>) -> Result<(), XlsxError> {
     let colon_pos = range.iter().position(|&b| b == b':');
 
@@ -4563,6 +5452,7 @@ mod tests {
             sheets: vec![],
             tables: None,
             formats: vec![],
+            styles: Vec::new(),
             is_1904: false,
             metadata: Metadata::default(),
             #[cfg(feature = "picture")]
@@ -4574,8 +5464,32 @@ mod tests {
 
         assert!(xlsx.read_shared_strings().is_ok());
         assert_eq!(3, xlsx.strings.len());
-        assert_eq!("String 1", &xlsx.strings[0]);
-        assert_eq!("String 2", &xlsx.strings[1]);
-        assert_eq!("String 3", &xlsx.strings[2]);
+        assert_eq!(Data::String("String 1".to_string()), xlsx.strings[0]);
+        assert_eq!(Data::String("String 2".to_string()), xlsx.strings[1]);
+        assert_eq!(Data::String("String 3".to_string()), xlsx.strings[2]);
+    }
+
+    #[test]
+    fn test_offset_cell_name_basic() {
+        assert_eq!(offset_cell_name(b"A1", (1, 1)).unwrap(), b"B2".to_vec());
+        assert_eq!(offset_cell_name(b"C5", (0, 0)).unwrap(), b"C5".to_vec());
+        assert_eq!(offset_cell_name(b"B3", (2, 3)).unwrap(), b"E5".to_vec());
+    }
+
+    #[test]
+    fn test_offset_cell_name_negative_offset_error() {
+        let result = offset_cell_name(b"A1", (-1, 0));
+        assert!(result.is_err(), "Negative row offset from A1 should error");
+
+        let result = offset_cell_name(b"A1", (0, -1));
+        assert!(result.is_err(), "Negative col offset from A1 should error");
+    }
+
+    #[test]
+    fn test_coordinate_to_name() {
+        assert_eq!(coordinate_to_name((0, 0)).unwrap(), b"A1".to_vec());
+        assert_eq!(coordinate_to_name((0, 25)).unwrap(), b"Z1".to_vec());
+        assert_eq!(coordinate_to_name((0, 26)).unwrap(), b"AA1".to_vec());
+        assert_eq!(coordinate_to_name((99, 2)).unwrap(), b"C100".to_vec());
     }
 }
diff --git a/src/xlsx/style_parser.rs b/src/xlsx/style_parser.rs
new file mode 100644
index 00000000..2dc711f1
--- /dev/null
+++ b/src/xlsx/style_parser.rs
@@ -0,0 +1,871 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright 2016-2025, Johann Tuffe.
+
+use quick_xml::{
+    events::{attributes::Attribute, BytesStart, Event},
+    name::QName,
+    Reader,
+};
+use std::io::BufRead;
+
+use crate::style::*;
+use crate::utils::unescape_entity_to_buffer;
+use crate::XlsxError;
+
+/// Default Office 2007 theme colors, indexed by Excel's theme attribute value.
+///
+/// Excel swaps the first four entries relative to the clrScheme XML order:
+///   theme="0" -> lt1, theme="1" -> dk1, theme="2" -> lt2, theme="3" -> dk2
+pub fn default_theme_colors() -> Vec<Color> {
+    vec![
+        Color::rgb(255, 255, 255), // 0: lt1 (White)
+        Color::rgb(0, 0, 0),       // 1: dk1 (Black)
+        Color::rgb(238, 236, 225), // 2: lt2 (EEECE1)
+        Color::rgb(31, 73, 125),   // 3: dk2 (1F497D)
+        Color::rgb(79, 129, 189),  // 4: accent1
+        Color::rgb(192, 80, 77),   // 5: accent2
+        Color::rgb(155, 187, 89),  // 6: accent3
+        Color::rgb(128, 100, 162), // 7: accent4
+        Color::rgb(75, 172, 198),  // 8: accent5
+        Color::rgb(247, 150, 70),  // 9: accent6
+        Color::rgb(0, 0, 255),     // 10: hlink
+        Color::rgb(128, 0, 128),   // 11: folHlink
+    ]
+}
+
+/// Get theme color using the workbook's palette when available.
+fn get_theme_color(theme: u8, theme_colors: &[Color]) -> Color {
+    theme_colors
+        .get(theme as usize)
+        .copied()
+        .unwrap_or_else(|| Color::rgb(0, 0, 0))
+}
+
+/// Apply tint to a color per the OOXML spec (Section 18.8.19).
+///
+/// Negative tint darkens:  result = channel * (1 + tint)
+/// Positive tint lightens: result = channel + (255 - channel) * tint
+fn apply_tint(color: Color, tint: f64) -> Color {
+    let apply_channel = |c: u8| -> u8 {
+        let val = if tint < 0.0 {
+            c as f64 * (1.0 + tint)
+        } else {
+            c as f64 + (255.0 - c as f64) * tint
+        };
+        val.round().clamp(0.0, 255.0) as u8
+    };
+    Color::new(
+        color.alpha,
+        apply_channel(color.red),
+        apply_channel(color.green),
+        apply_channel(color.blue),
+    )
+}
+
+/// Resolve theme colors from `xl/theme/theme1.xml`.
+///
+/// Reads the clrScheme element which lists colors in order:
+///   dk1, lt1, dk2, lt2, accent1..accent6, hlink, folHlink
+///
+/// Excel swaps the first four when mapping to theme indices, so:
+///   theme="0" -> lt1, theme="1" -> dk1, theme="2" -> lt2, theme="3" -> dk2
+pub fn read_theme_colors<RS: BufRead>(xml: &mut Reader<RS>) -> Vec<Color> {
+    let mut xml_order: Vec<Color> = Vec::new();
+    let mut buf = Vec::new();
+    let mut in_clr_scheme = false;
+    let clr_elements: &[&[u8]] = &[
+        b"dk1",
+        b"lt1",
+        b"dk2",
+        b"lt2",
+        b"accent1",
+        b"accent2",
+        b"accent3",
+        b"accent4",
+        b"accent5",
+        b"accent6",
+        b"hlink",
+        b"folHlink",
+    ];
+    let mut current_element: Option<Vec<u8>> = None;
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(Event::Start(ref e)) => {
+                let local = e.local_name();
+                if local.as_ref() == b"clrScheme" {
+                    in_clr_scheme = true;
+                } else if in_clr_scheme {
+                    if clr_elements.iter().any(|&el| local.as_ref() == el) {
+                        current_element = Some(local.as_ref().to_vec());
+                    } else if current_element.is_some() {
+                        if let Some(color) = parse_theme_srgb_or_sys(e.attributes()) {
+                            xml_order.push(color);
+                            current_element = None;
+                        }
+                    }
+                }
+            }
+            Ok(Event::Empty(ref e)) if in_clr_scheme && current_element.is_some() => {
+                if let Some(color) = parse_theme_srgb_or_sys(e.attributes()) {
+                    xml_order.push(color);
+                    current_element = None;
+                }
+            }
+            Ok(Event::End(ref e)) => {
+                let local = e.local_name();
+                if local.as_ref() == b"clrScheme" {
+                    break;
+                }
+                if current_element
+                    .as_ref()
+                    .is_some_and(|el| el == local.as_ref())
+                {
+                    current_element = None;
+                }
+            }
+            Ok(Event::Eof) => break,
+            Err(_) => break,
+            _ => {}
+        }
+    }
+
+    if xml_order.len() >= 4 {
+        // Apply Excel's swap: indices 0/1 and 2/3
+        xml_order.swap(0, 1);
+        xml_order.swap(2, 3);
+        xml_order
+    } else {
+        default_theme_colors()
+    }
+}
+
+/// Parse an srgbClr or sysClr element's attributes into a Color.
+///
+/// For srgbClr: reads the `val` attribute (a 6-char hex string like "1F497D").
+/// For sysClr: prefers `lastClr` (resolved color) over `val` (system name like "window").
+fn parse_theme_srgb_or_sys(attributes: quick_xml::events::attributes::Attributes) -> Option<Color> {
+    let mut color: Option<Color> = None;
+
+    for attr in attributes.flatten() {
+        match attr.key.as_ref() {
+            b"lastClr" => {
+                if let Some(c) = parse_hex_attr(attr.value.as_ref()) {
+                    return Some(c);
+                }
+            }
+            b"val" if color.is_none() => {
+                color = parse_hex_attr(attr.value.as_ref());
+            }
+            _ => {}
+        }
+    }
+
+    color
+}
+
+fn parse_hex_attr(val: &[u8]) -> Option<Color> {
+    if val.len() != 6 {
+        return None;
+    }
+    let r = u8::from_str_radix(&String::from_utf8_lossy(&val[0..2]), 16).ok()?;
+    let g = u8::from_str_radix(&String::from_utf8_lossy(&val[2..4]), 16).ok()?;
+    let b = u8::from_str_radix(&String::from_utf8_lossy(&val[4..6]), 16).ok()?;
+    Some(Color::rgb(r, g, b))
+}
+
+/// Get indexed color from Excel's official color index palette.
+/// Based on: https://learn.microsoft.com/en-us/office/vba/api/excel.colorindex
+fn get_indexed_color(index: u8) -> Color {
+    match index {
+        1 => Color::rgb(0, 0, 0),        // Black
+        2 => Color::rgb(255, 255, 255),  // White
+        3 => Color::rgb(255, 0, 0),      // Red
+        4 => Color::rgb(0, 255, 0),      // Green
+        5 => Color::rgb(0, 0, 255),      // Blue
+        6 => Color::rgb(255, 255, 0),    // Yellow
+        7 => Color::rgb(255, 0, 255),    // Magenta
+        8 => Color::rgb(0, 255, 255),    // Cyan
+        9 => Color::rgb(128, 0, 0),      // Dark Red
+        10 => Color::rgb(0, 128, 0),     // Dark Green
+        11 => Color::rgb(0, 0, 128),     // Dark Blue
+        12 => Color::rgb(128, 128, 0),   // Dark Yellow
+        13 => Color::rgb(128, 0, 128),   // Dark Magenta
+        14 => Color::rgb(0, 128, 128),   // Dark Cyan
+        15 => Color::rgb(192, 192, 192), // Light Gray
+        16 => Color::rgb(128, 128, 128), // Gray
+        17 => Color::rgb(153, 153, 255), // Light Blue
+        18 => Color::rgb(153, 51, 102),  // Dark Pink
+        19 => Color::rgb(255, 255, 204), // Light Yellow
+        20 => Color::rgb(204, 255, 255), // Light Cyan
+        21 => Color::rgb(102, 0, 102),   // Dark Purple
+        22 => Color::rgb(255, 128, 128), // Light Red
+        23 => Color::rgb(0, 102, 204),   // Medium Blue
+        24 => Color::rgb(204, 204, 255), // Light Purple
+        25 => Color::rgb(0, 0, 128),     // Navy
+        26 => Color::rgb(255, 0, 255),   // Fuchsia
+        27 => Color::rgb(255, 255, 0),   // Yellow
+        28 => Color::rgb(0, 255, 255),   // Aqua
+        29 => Color::rgb(128, 0, 128),   // Purple
+        30 => Color::rgb(128, 0, 0),     // Maroon
+        31 => Color::rgb(0, 128, 128),   // Teal
+        32 => Color::rgb(0, 0, 255),     // Blue
+        33 => Color::rgb(0, 204, 255),   // Sky Blue
+        34 => Color::rgb(204, 255, 255), // Light Turquoise
+        35 => Color::rgb(204, 255, 204), // Light Green
+        36 => Color::rgb(255, 255, 153), // Light Yellow
+        37 => Color::rgb(153, 204, 255), // Pale Blue
+        38 => Color::rgb(255, 153, 204), // Pink
+        39 => Color::rgb(204, 153, 255), // Lavender
+        40 => Color::rgb(255, 204, 153), // Tan
+        41 => Color::rgb(51, 102, 255),  // Bright Blue
+        42 => Color::rgb(51, 204, 204),  // Aqua
+        43 => Color::rgb(153, 204, 0),   // Lime
+        44 => Color::rgb(255, 204, 0),   // Gold
+        45 => Color::rgb(255, 153, 0),   // Orange
+        46 => Color::rgb(255, 102, 0),   // Orange Red
+        47 => Color::rgb(102, 102, 153), // Blue Gray
+        48 => Color::rgb(150, 150, 150), // Gray 40%
+        49 => Color::rgb(0, 51, 102),    // Dark Teal
+        50 => Color::rgb(51, 153, 102),  // Sea Green
+        51 => Color::rgb(0, 51, 0),      // Dark Green
+        52 => Color::rgb(51, 51, 0),     // Olive
+        53 => Color::rgb(153, 51, 0),    // Brown
+        54 => Color::rgb(153, 51, 102),  // Plum
+        55 => Color::rgb(51, 51, 153),   // Indigo
+        56 => Color::rgb(51, 51, 51),    // Gray 80%
+        0 => Color::rgb(0, 0, 0),        // Auto (Black)
+        64 => Color::rgb(192, 192, 192), // System window background
+        65 => Color::rgb(0, 0, 0),       // System auto color
+        _ => Color::rgb(0, 0, 0),        // Black for unknown indices
+    }
+}
+
+/// Parse color from XML attributes, resolving theme/indexed references and
+/// applying the tint modifier when present.
+fn parse_color(
+    attributes: &[Attribute],
+    theme_colors: &[Color],
+) -> Result<Option<Color>, XlsxError> {
+    let mut color: Option<Color> = None;
+    let mut tint: Option<f64> = None;
+
+    for attr in attributes {
+        match attr.key.as_ref() {
+            b"rgb" => {
+                let rgb_str: &[u8] = attr.value.as_ref();
+                if rgb_str.len() == 6 {
+                    let r = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[0..2]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid red color value"))?;
+                    let g = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[2..4]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid green color value"))?;
+                    let b = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[4..6]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid blue color value"))?;
+                    color = Some(Color::rgb(r, g, b));
+                } else if rgb_str.len() == 8 {
+                    let a = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[0..2]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid alpha color value"))?;
+                    let r = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[2..4]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid red color value"))?;
+                    let g = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[4..6]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid green color value"))?;
+                    let b = u8::from_str_radix(&String::from_utf8_lossy(&rgb_str[6..8]), 16)
+                        .map_err(|_| XlsxError::Unexpected("Invalid blue color value"))?;
+                    color = Some(Color::new(a, r, g, b));
+                }
+            }
+            b"theme" => {
+                let theme_str = String::from_utf8_lossy(&attr.value);
+                if let Ok(theme_value) = theme_str.parse::<u8>() {
+                    color = Some(get_theme_color(theme_value, theme_colors));
+                }
+            }
+            b"indexed" => {
+                let indexed_str = String::from_utf8_lossy(&attr.value);
+                if let Ok(indexed_value) = indexed_str.parse::<u8>() {
+                    color = Some(get_indexed_color(indexed_value));
+                }
+            }
+            b"tint" => {
+                let tint_str = String::from_utf8_lossy(&attr.value);
+                tint = tint_str.parse::<f64>().ok();
+            }
+            _ => {}
+        }
+    }
+
+    Ok(color.map(|c| match tint {
+        Some(t) if t != 0.0 => apply_tint(c, t),
+        _ => c,
+    }))
+}
+
+/// Parse font weight from string.
+///
+/// Handles OOXML boolean values (`"1"`, `"true"`, `"0"`, `"false"`),
+/// named values (`"bold"`, `"normal"`), and numeric CSS-style weights.
+fn parse_font_weight(s: &str) -> FontWeight {
+    match s {
+        "bold" | "700" | "1" | "true" => FontWeight::Bold,
+        "normal" | "400" | "0" | "false" => FontWeight::Normal,
+        _ => {
+            if let Ok(weight) = s.parse::<u16>() {
+                if weight >= 600 {
+                    FontWeight::Bold
+                } else {
+                    FontWeight::Normal
+                }
+            } else {
+                FontWeight::Normal
+            }
+        }
+    }
+}
+
+/// Parse font style from string.
+///
+/// Handles OOXML boolean values (`"1"`, `"true"`) in addition to
+/// named values (`"italic"`, `"oblique"`).
+fn parse_font_style(s: &str) -> FontStyle {
+    match s {
+        "italic" | "oblique" | "1" | "true" => FontStyle::Italic,
+        _ => FontStyle::Normal,
+    }
+}
+
+fn parse_underline_style(s: &str) -> UnderlineStyle {
+    match s {
+        "single" => UnderlineStyle::Single,
+        "double" => UnderlineStyle::Double,
+        "singleAccounting" => UnderlineStyle::SingleAccounting,
+        "doubleAccounting" => UnderlineStyle::DoubleAccounting,
+        _ => UnderlineStyle::None,
+    }
+}
+
+fn parse_horizontal_alignment(s: &str) -> HorizontalAlignment {
+    match s {
+        "left" => HorizontalAlignment::Left,
+        "center" => HorizontalAlignment::Center,
+        "right" => HorizontalAlignment::Right,
+        "justify" => HorizontalAlignment::Justify,
+        "distributed" => HorizontalAlignment::Distributed,
+        "fill" => HorizontalAlignment::Fill,
+        _ => HorizontalAlignment::General,
+    }
+}
+
+fn parse_vertical_alignment(s: &str) -> VerticalAlignment {
+    match s {
+        "top" => VerticalAlignment::Top,
+        "center" => VerticalAlignment::Center,
+        "bottom" => VerticalAlignment::Bottom,
+        "justify" => VerticalAlignment::Justify,
+        "distributed" => VerticalAlignment::Distributed,
+        _ => VerticalAlignment::Bottom,
+    }
+}
+
+fn parse_fill_pattern(s: &str) -> FillPattern {
+    match s {
+        "solid" => FillPattern::Solid,
+        "darkGray" => FillPattern::DarkGray,
+        "mediumGray" => FillPattern::MediumGray,
+        "lightGray" => FillPattern::LightGray,
+        "gray125" => FillPattern::Gray125,
+        "gray0625" => FillPattern::Gray0625,
+        "darkHorizontal" => FillPattern::DarkHorizontal,
+        "darkVertical" => FillPattern::DarkVertical,
+        "darkDown" => FillPattern::DarkDown,
+        "darkUp" => FillPattern::DarkUp,
+        "darkGrid" => FillPattern::DarkGrid,
+        "darkTrellis" => FillPattern::DarkTrellis,
+        "lightHorizontal" => FillPattern::LightHorizontal,
+        "lightVertical" => FillPattern::LightVertical,
+        "lightDown" => FillPattern::LightDown,
+        "lightUp" => FillPattern::LightUp,
+        "lightGrid" => FillPattern::LightGrid,
+        "lightTrellis" => FillPattern::LightTrellis,
+        _ => FillPattern::None,
+    }
+}
+
+fn parse_border_style(s: &str) -> BorderStyle {
+    match s {
+        "thin" => BorderStyle::Thin,
+        "medium" => BorderStyle::Medium,
+        "thick" => BorderStyle::Thick,
+        "double" => BorderStyle::Double,
+        "hair" => BorderStyle::Hair,
+        "dashed" => BorderStyle::Dashed,
+        "dotted" => BorderStyle::Dotted,
+        "mediumDashed" => BorderStyle::MediumDashed,
+        "dashDot" => BorderStyle::DashDot,
+        "dashDotDot" => BorderStyle::DashDotDot,
+        "slantDashDot" => BorderStyle::SlantDashDot,
+        _ => BorderStyle::None,
+    }
+}
+
+/// Parse font element.
+pub fn parse_font<RS: BufRead>(
+    xml: &mut Reader<RS>,
+    _start_elem: &BytesStart,
+    theme_colors: &[Color],
+) -> Result<Font, XlsxError> {
+    let mut font = Font::new();
+    let mut buf = Vec::new();
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(ref event @ (Event::Start(ref e) | Event::Empty(ref e))) => {
+                let is_empty = matches!(event, Event::Empty(_));
+                match e.local_name().as_ref() {
+                    b"name" => {
+                        let mut name = None;
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"val" {
+                                name = Some(String::from_utf8_lossy(&attr.value).to_string());
+                                break;
+                            }
+                        }
+                        if !is_empty {
+                            if name.is_none() {
+                                name = read_string(xml, QName(b"name"))?;
+                            } else {
+                                xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                            }
+                        }
+                        if let Some(n) = name {
+                            font = font.with_name(n);
+                        }
+                    }
+                    b"sz" => {
+                        let mut size_str = None;
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"val" {
+                                size_str = Some(String::from_utf8_lossy(&attr.value).to_string());
+                                break;
+                            }
+                        }
+                        if !is_empty {
+                            if size_str.is_none() {
+                                size_str = read_string(xml, QName(b"sz"))?;
+                            } else {
+                                xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                            }
+                        }
+                        if let Some(s) = size_str {
+                            if let Ok(size) = s.parse::<f64>() {
+                                font = font.with_size(size);
+                            }
+                        }
+                    }
+                    b"b" => {
+                        let mut weight = FontWeight::Bold;
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"val" {
+                                let val_str = String::from_utf8_lossy(&attr.value);
+                                weight = parse_font_weight(&val_str);
+                                break;
+                            }
+                        }
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                        font = font.with_weight(weight);
+                    }
+                    b"i" => {
+                        let mut style = FontStyle::Italic;
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"val" {
+                                let val_str = String::from_utf8_lossy(&attr.value);
+                                style = parse_font_style(&val_str);
+                                break;
+                            }
+                        }
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                        font = font.with_style(style);
+                    }
+                    b"u" => {
+                        let mut underline_style = UnderlineStyle::Single;
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"val" {
+                                let val_str = String::from_utf8_lossy(&attr.value);
+                                underline_style = parse_underline_style(&val_str);
+                                break;
+                            }
+                        }
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                        font = font.with_underline(underline_style);
+                    }
+                    b"strike" => {
+                        let mut is_strike = true;
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"val" {
+                                let val_str = String::from_utf8_lossy(&attr.value);
+                                is_strike = &*val_str != "0" && &*val_str != "false";
+                                break;
+                            }
+                        }
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                        if is_strike {
+                            font = font.with_strikethrough(true);
+                        }
+                    }
+                    b"color" => {
+                        if let Some(color) = parse_color(
+                            &e.attributes().collect::<Result<Vec<_>, _>>()?,
+                            theme_colors,
+                        )? {
+                            font = font.with_color(color);
+                        }
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                    }
+                    b"family" => {
+                        if !is_empty {
+                            if let Some(family) = read_string(xml, QName(b"family"))? {
+                                font = font.with_family(family);
+                            }
+                        }
+                    }
+                    _ => {
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                    }
+                }
+            }
+            Ok(Event::End(ref e)) if e.local_name().as_ref() == b"font" => break,
+            Ok(Event::Eof) => return Err(XlsxError::XmlEof("font")),
+            Err(e) => return Err(XlsxError::Xml(e)),
+            _ => {}
+        }
+    }
+
+    Ok(font)
+}
+
+/// Parse fill element.
+pub fn parse_fill<RS: BufRead>(
+    xml: &mut Reader<RS>,
+    _start_elem: &BytesStart,
+    theme_colors: &[Color],
+) -> Result<Fill, XlsxError> {
+    let mut fill = Fill::new();
+    let mut buf = Vec::new();
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(Event::Start(ref e) | Event::Empty(ref e)) => match e.local_name().as_ref() {
+                b"patternFill" => {
+                    for attr in e.attributes() {
+                        let attr = attr?;
+                        if attr.key.as_ref() == b"patternType" {
+                            let pattern_str = String::from_utf8_lossy(&attr.value);
+                            fill = fill.with_pattern(parse_fill_pattern(&pattern_str));
+                        }
+                    }
+                }
+                b"fgColor" => {
+                    if let Some(color) = parse_color(
+                        &e.attributes().collect::<Result<Vec<_>, _>>()?,
+                        theme_colors,
+                    )? {
+                        fill = fill.with_foreground_color(color);
+                    }
+                }
+                b"bgColor" => {
+                    if let Some(color) = parse_color(
+                        &e.attributes().collect::<Result<Vec<_>, _>>()?,
+                        theme_colors,
+                    )? {
+                        fill = fill.with_background_color(color);
+                    }
+                }
+                _ => {}
+            },
+            Ok(Event::End(ref e)) if e.local_name().as_ref() == b"fill" => break,
+            Ok(Event::Eof) => return Err(XlsxError::XmlEof("fill")),
+            Err(e) => return Err(XlsxError::Xml(e)),
+            _ => {}
+        }
+    }
+
+    Ok(fill)
+}
+
+/// Parse border element.
+pub fn parse_border<RS: BufRead>(
+    xml: &mut Reader<RS>,
+    start_elem: &BytesStart,
+    theme_colors: &[Color],
+) -> Result<Borders, XlsxError> {
+    let mut borders = Borders::new();
+    let mut buf = Vec::new();
+
+    // Read diagonalDown/diagonalUp from the outer <border> element
+    let mut has_diagonal_down = false;
+    let mut has_diagonal_up = false;
+    for attr in start_elem.attributes() {
+        let attr = attr?;
+        match attr.key.as_ref() {
+            b"diagonalDown" => has_diagonal_down = &*attr.value != b"0",
+            b"diagonalUp" => has_diagonal_up = &*attr.value != b"0",
+            _ => {}
+        }
+    }
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(ref event @ (Event::Start(ref e) | Event::Empty(ref e))) => {
+                let is_empty = matches!(event, Event::Empty(_));
+                match e.local_name().as_ref() {
+                    b"left" | b"right" | b"top" | b"bottom" | b"diagonal" => {
+                        let mut style = BorderStyle::None;
+                        let mut color = None;
+
+                        for attr in e.attributes() {
+                            let attr = attr?;
+                            if attr.key.as_ref() == b"style" {
+                                let style_str = String::from_utf8_lossy(&attr.value);
+                                style = parse_border_style(&style_str);
+                            }
+                        }
+
+                        if !is_empty {
+                            let mut inner_buf = Vec::new();
+                            loop {
+                                inner_buf.clear();
+                                match xml.read_event_into(&mut inner_buf) {
+                                    Ok(Event::Start(ref inner_e) | Event::Empty(ref inner_e))
+                                        if inner_e.local_name().as_ref() == b"color" =>
+                                    {
+                                        if let Some(border_color) = parse_color(
+                                            &inner_e.attributes().collect::<Result<Vec<_>, _>>()?,
+                                            theme_colors,
+                                        )? {
+                                            color = Some(border_color);
+                                        }
+                                    }
+                                    Ok(Event::End(ref inner_e))
+                                        if inner_e.local_name().as_ref()
+                                            == e.local_name().as_ref() =>
+                                    {
+                                        break
+                                    }
+                                    Ok(Event::Eof) => return Err(XlsxError::XmlEof("border side")),
+                                    Err(e) => return Err(XlsxError::Xml(e)),
+                                    _ => {}
+                                }
+                            }
+                        }
+
+                        let border = if let Some(c) = color {
+                            Border::with_color(style, c)
+                        } else {
+                            Border::new(style)
+                        };
+
+                        match e.local_name().as_ref() {
+                            b"left" => borders.left = border,
+                            b"right" => borders.right = border,
+                            b"top" => borders.top = border,
+                            b"bottom" => borders.bottom = border,
+                            b"diagonal" => {
+                                if has_diagonal_down {
+                                    borders.diagonal_down = border.clone();
+                                }
+                                if has_diagonal_up {
+                                    borders.diagonal_up = border.clone();
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                    _ => {
+                        if !is_empty {
+                            xml.read_to_end_into(e.name(), &mut Vec::new())?;
+                        }
+                    }
+                }
+            }
+            Ok(Event::End(ref e)) if e.local_name().as_ref() == b"border" => break,
+            Ok(Event::Eof) => return Err(XlsxError::XmlEof("border")),
+            Err(e) => return Err(XlsxError::Xml(e)),
+            _ => {}
+        }
+    }
+
+    Ok(borders)
+}
+
+/// Parse alignment element.
+pub fn parse_alignment<RS: BufRead>(
+    _xml: &mut Reader<RS>,
+    start_elem: &BytesStart,
+) -> Result<Alignment, XlsxError> {
+    let mut alignment = Alignment::new();
+
+    for attr in start_elem.attributes() {
+        let attr = attr?;
+        match attr.key.as_ref() {
+            b"horizontal" => {
+                let horizontal_str = String::from_utf8_lossy(&attr.value);
+                alignment = alignment.with_horizontal(parse_horizontal_alignment(&horizontal_str));
+            }
+            b"vertical" => {
+                let vertical_str = String::from_utf8_lossy(&attr.value);
+                alignment = alignment.with_vertical(parse_vertical_alignment(&vertical_str));
+            }
+            b"wrapText" => {
+                let wrap_str = String::from_utf8_lossy(&attr.value);
+                if wrap_str == "1" || wrap_str == "true" {
+                    alignment = alignment.with_wrap_text(true);
+                }
+            }
+            b"textRotation" => {
+                if let Ok(rotation) = String::from_utf8_lossy(&attr.value).parse::<u16>() {
+                    let text_rotation = if rotation == 255 {
+                        TextRotation::Stacked
+                    } else {
+                        TextRotation::Degrees(rotation)
+                    };
+                    alignment = alignment.with_text_rotation(text_rotation);
+                }
+            }
+            b"indent" => {
+                if let Ok(indent) = String::from_utf8_lossy(&attr.value).parse::<u8>() {
+                    alignment = alignment.with_indent(indent);
+                }
+            }
+            b"shrinkToFit" => {
+                let shrink_str = String::from_utf8_lossy(&attr.value);
+                if shrink_str == "1" || shrink_str == "true" {
+                    alignment = alignment.with_shrink_to_fit(true);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(alignment)
+}
+
+/// Parse protection element.
+pub fn parse_protection<RS: BufRead>(
+    _xml: &mut Reader<RS>,
+    start_elem: &BytesStart,
+) -> Result<Protection, XlsxError> {
+    let mut locked = true; // Per OOXML spec, cells are locked by default
+    let mut hidden = false;
+
+    for attr in start_elem.attributes() {
+        let attr = attr?;
+        match attr.key.as_ref() {
+            b"locked" => {
+                let val = String::from_utf8_lossy(&attr.value);
+                locked = val != "0" && val != "false";
+            }
+            b"hidden" => {
+                let val = String::from_utf8_lossy(&attr.value);
+                hidden = val == "1" || val == "true";
+            }
+            _ => {}
+        }
+    }
+
+    Ok(Protection::new().with_locked(locked).with_hidden(hidden))
+}
+
+/// Read string content from XML element.
+fn read_string<RS: BufRead>(
+    xml: &mut Reader<RS>,
+    closing: QName,
+) -> Result<Option<String>, XlsxError> {
+    let mut buf = Vec::new();
+    let mut content = String::new();
+
+    loop {
+        buf.clear();
+        match xml.read_event_into(&mut buf) {
+            Ok(Event::Text(e)) => {
+                content.push_str(&e.xml10_content()?);
+            }
+            Ok(Event::GeneralRef(e)) => {
+                unescape_entity_to_buffer(&e, &mut content)?;
+            }
+            Ok(Event::End(ref e)) if e.local_name() == closing.into() => break,
+            Ok(Event::Eof) => return Err(XlsxError::XmlEof("string")),
+            Err(e) => return Err(XlsxError::Xml(e)),
+            _ => {}
+        }
+    }
+
+    if content.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(content))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_font_weight_boolean_values() {
+        assert_eq!(parse_font_weight("1"), FontWeight::Bold);
+        assert_eq!(parse_font_weight("true"), FontWeight::Bold);
+        assert_eq!(parse_font_weight("0"), FontWeight::Normal);
+        assert_eq!(parse_font_weight("false"), FontWeight::Normal);
+    }
+
+    #[test]
+    fn test_parse_font_weight_named_values() {
+        assert_eq!(parse_font_weight("bold"), FontWeight::Bold);
+        assert_eq!(parse_font_weight("normal"), FontWeight::Normal);
+    }
+
+    #[test]
+    fn test_parse_font_weight_numeric_values() {
+        assert_eq!(parse_font_weight("700"), FontWeight::Bold);
+        assert_eq!(parse_font_weight("400"), FontWeight::Normal);
+        assert_eq!(parse_font_weight("600"), FontWeight::Bold);
+        assert_eq!(parse_font_weight("599"), FontWeight::Normal);
+    }
+
+    #[test]
+    fn test_parse_font_style_boolean_values() {
+        assert_eq!(parse_font_style("1"), FontStyle::Italic);
+        assert_eq!(parse_font_style("true"), FontStyle::Italic);
+        assert_eq!(parse_font_style("0"), FontStyle::Normal);
+        assert_eq!(parse_font_style("false"), FontStyle::Normal);
+    }
+
+    #[test]
+    fn test_parse_font_style_named_values() {
+        assert_eq!(parse_font_style("italic"), FontStyle::Italic);
+        assert_eq!(parse_font_style("oblique"), FontStyle::Italic);
+        assert_eq!(parse_font_style("normal"), FontStyle::Normal);
+    }
+}
diff --git a/tests/EMSI_JobChange_UK.xlsx b/tests/EMSI_JobChange_UK.xlsx
new file mode 100644
index 00000000..e72265db
Binary files /dev/null and b/tests/EMSI_JobChange_UK.xlsx differ
diff --git a/tests/borders.xlsx b/tests/borders.xlsx
new file mode 100644
index 00000000..f3f18f47
Binary files /dev/null and b/tests/borders.xlsx differ
diff --git a/tests/problematic_formats.xlsx b/tests/problematic_formats.xlsx
new file mode 100644
index 00000000..a376a92d
Binary files /dev/null and b/tests/problematic_formats.xlsx differ
diff --git a/tests/styles.xlsx b/tests/styles.xlsx
new file mode 100644
index 00000000..4c0369a6
Binary files /dev/null and b/tests/styles.xlsx differ
diff --git a/tests/styles_1M.xlsx b/tests/styles_1M.xlsx
new file mode 100644
index 00000000..4cbce1a3
Binary files /dev/null and b/tests/styles_1M.xlsx differ
diff --git a/tests/test.rs b/tests/test.rs
index 1fd0fcb1..47027655 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -5,9 +5,10 @@
 use calamine::vba::Reference;
 use calamine::Data::{Bool, DateTime, DateTimeIso, DurationIso, Empty, Error, Float, Int, String};
 use calamine::{
-    open_workbook, open_workbook_auto, DataRef, DataType, Dimensions, ExcelDateTime,
-    ExcelDateTimeType, HeaderRow, Ods, Range, Reader, ReaderRef, Sheet, SheetType, SheetVisible,
-    Xls, Xlsb, Xlsx, XlsxFormulaMetadata,
+    open_workbook, open_workbook_auto, BorderStyle, Color, DataRef, DataType, Dimensions,
+    ExcelDateTime, ExcelDateTimeType, HeaderRow, HorizontalAlignment, Ods, Range, Reader,
+    ReaderRef, Sheet, SheetType, SheetVisible, UnderlineStyle, VerticalAlignment, Xls, Xlsb, Xlsx,
+    XlsxFormulaMetadata,
 };
 use calamine::{CellErrorType::*, Data};
 use rstest::rstest;
@@ -46,6 +47,38 @@ macro_rules! range_eq {
     };
 }
 
+/// Helper to compare text content regardless of whether it's String or RichText
+fn text_eq(data: &Data, expected: &str) -> bool {
+    match data {
+        Data::String(s) => s == expected,
+        Data::RichText(rt) => rt.plain_text() == expected,
+        _ => false,
+    }
+}
+
+/// Macro for comparing ranges where cells may be String or RichText
+macro_rules! range_text_eq {
+    ($range:expr, $right:expr) => {
+        assert_eq!(
+            $range.get_size(),
+            ($right.len(), $right[0].len()),
+            "Size mismatch"
+        );
+        for (i, (rl, rr)) in $range.rows().zip($right.iter()).enumerate() {
+            for (j, (cl, cr)) in rl.iter().zip(rr.iter()).enumerate() {
+                assert!(
+                    text_eq(cl, cr),
+                    "Text mismatch at position ({}, {}): got {:?}, expected {:?}",
+                    i,
+                    j,
+                    cl.as_string(),
+                    cr
+                );
+            }
+        }
+    };
+}
+
 #[test]
 fn issue_2() {
     let mut excel: Xlsx<_> = wb("issues.xlsx");
@@ -112,14 +145,11 @@ fn error_file() {
 fn issue_9() {
     let mut excel: Xlsx<_> = wb("issue9.xlsx");
     let range = excel.worksheet_range("Feuil1").unwrap();
-    range_eq!(
+    // Some cells in this file have rich text formatting (bold, underline)
+    // so we compare text content rather than exact Data type
+    range_text_eq!(
         range,
-        [
-            [String("test1".to_string())],
-            [String("test2 other".to_string())],
-            [String("test3 aaa".to_string())],
-            [String("test4".to_string())]
-        ]
+        [["test1"], ["test2 other"], ["test3 aaa"], ["test4"]]
     );
 }
 
@@ -3236,6 +3266,88 @@ fn biff5_defined_names_and_empty_sheets_612() {
     );
 }
 
+#[test]
+fn test_all_styles() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let values = xlsx.worksheet_range("Sheet 1").unwrap();
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+    let get_font = |row: usize, col: usize| styles.get((row, col)).unwrap().get_font().unwrap();
+
+    // assert that the text is bold
+    let a1 = get_font(0, 0);
+    assert!(a1.is_bold());
+
+    // assert top border
+    let a1_style = styles.get((0, 0)).unwrap();
+    assert_eq!(
+        a1_style.borders.as_ref().unwrap().top.style,
+        BorderStyle::Thin
+    );
+
+    // assert that the text is italic
+    let a2 = get_font(1, 0);
+    assert!(a2.is_italic());
+
+    // assert that the text is underlined
+    let a3 = get_font(2, 0);
+    assert!(a3.has_underline());
+
+    // assert that the text is strikethrough
+    let a4 = get_font(3, 0);
+    assert!(a4.has_strikethrough());
+
+    // assert that the color is red
+    let a5 = get_font(4, 0);
+    assert_eq!(a5.color, Some(Color::new(255, 255, 0, 0)));
+
+    // assert that the foreground color is yellow
+    let a6 = styles.get((5, 0)).unwrap().get_fill().unwrap();
+    assert_eq!(a6.foreground_color, Some(Color::new(255, 255, 255, 0)));
+
+    // assert that text is horizontally centered
+    let a7 = styles.get((6, 0)).unwrap().get_alignment().unwrap();
+    assert_eq!(a7.horizontal, HorizontalAlignment::Center);
+
+    // assert that text is vertically centered
+    let a8 = styles.get((7, 0)).unwrap().get_alignment().unwrap();
+    assert_eq!(a8.vertical, VerticalAlignment::Center);
+
+    // assert that text is wrapped
+    let a9 = styles.get((8, 0)).unwrap().get_alignment().unwrap();
+    assert!(a9.wrap_text);
+
+    // assert that 1000000 is formatted as 1,000,000
+    let a10 = styles.get((9, 0)).unwrap().get_number_format().unwrap();
+    assert_eq!(a10.format_code, "#,##0");
+
+    // assert that 100 is formatted as $100.00
+    let a11 = styles.get((10, 0)).unwrap().get_number_format().unwrap();
+    assert_eq!(a11.format_code, "$0.00");
+
+    // assert that 0.5 is formatted as 0.5%
+    // assert that the value is 0.5
+    let a12 = styles.get((11, 0)).unwrap().get_number_format().unwrap();
+    assert_eq!(a12.format_code, "0.0%");
+    assert_eq!(values.get((11, 0)).unwrap(), &Float(0.005));
+
+    // assert that 1000000 is formatted as 1.00E+06
+    let a13 = styles.get((12, 0)).unwrap().get_number_format().unwrap();
+    assert_eq!(a13.format_code, "0.00E+00");
+    assert_eq!(values.get((12, 0)).unwrap(), &Float(1000000.0));
+
+    // assert that 7/21/2025  1:09:31 PM is formatted as 2005-07-21 13:09:31
+    let a14 = styles.get((13, 0)).unwrap().get_number_format().unwrap();
+    assert_eq!(a14.format_code, "yyyy-mm-dd hh:mm:ss");
+    assert_eq!(
+        values.get((13, 0)).unwrap(),
+        &DateTime(ExcelDateTime::new(
+            45859.54827546296,
+            ExcelDateTimeType::DateTime,
+            false,
+        ))
+    );
+}
+
 #[test]
 fn biff5_formula_ptg_ref_643() {
     // covers a parsing error where biff8 formula token sizes were assumed
@@ -3278,6 +3390,486 @@ fn test_capitalized_book_stream() {
     let _wb: Xls<_> = wb("capitalized_wbook_stream.xls");
 }
 
+#[test]
+fn test_worksheet_style_iter() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    // Verify that we can iterate through styles without panicking
+    let mut style_count = 0;
+    let mut found_a1 = false;
+    for (row, col, style) in styles.cells() {
+        style_count += 1;
+        // Basic validation that we can access style properties
+        if row == 0 && col == 0 {
+            // A1 should be bold
+            assert!(style.get_font().unwrap().is_bold());
+            found_a1 = true;
+        }
+    }
+    assert!(style_count > 0, "Should have found at least one style");
+    assert!(found_a1, "Should have found A1");
+}
+
+#[test]
+fn test_worksheet_layout() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let layout = xlsx.worksheet_layout("Sheet 1").unwrap();
+
+    // Verify layout parsing produces some result (values depend on the test file)
+    // The important thing is no panic and the structure is populated
+    if let Some(width) = layout.default_column_width {
+        assert!(width > 0.0, "Default column width should be positive");
+    }
+    if let Some(height) = layout.default_row_height {
+        assert!(height > 0.0, "Default row height should be positive");
+    }
+}
+
+#[test]
+fn test_underline_parsing() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let worksheet = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    // Test that A3 has an underline (empty <u/> element)
+    let a3 = worksheet.get((2, 0)).unwrap().get_font().unwrap();
+    assert!(a3.has_underline());
+    assert_eq!(a3.underline, UnderlineStyle::Single);
+}
+
+#[test]
+fn test_color_parsing() {
+    use calamine::Color;
+
+    // Test that our color parsing works for both RGB and ARGB formats
+    let red_rgb = Color::rgb(255, 0, 0);
+    let red_argb = Color::new(255, 255, 0, 0);
+
+    assert_eq!(red_rgb, red_argb);
+
+    // Test that alpha=255 is the default for RGB
+    assert_eq!(red_rgb.alpha, 255);
+    assert_eq!(red_rgb.red, 255);
+    assert_eq!(red_rgb.green, 0);
+    assert_eq!(red_rgb.blue, 0);
+}
+
+#[test]
+fn test_border_colors() {
+    let mut xlsx: Xlsx<_> = wb("borders.xlsx");
+    let styles = xlsx.worksheet_style("Sheet1").unwrap();
+
+    let mut found_thin_with_color = false;
+    let mut found_dashed_with_color = false;
+
+    // Test the first few rows to find different border styles with colors
+    for row in 0..5 {
+        for col in 0..5 {
+            if let Some(style) = styles.get((row, col)) {
+                if let Some(borders) = &style.borders {
+                    // Check each border side for styles and colors
+                    for border in [&borders.left, &borders.right, &borders.top, &borders.bottom] {
+                        if let Some(color) = border.color {
+                            if border.style == BorderStyle::None {
+                                continue;
+                            }
+                            match border.style {
+                                BorderStyle::Thin => {
+                                    found_thin_with_color = true;
+                                }
+                                BorderStyle::Dashed => {
+                                    found_dashed_with_color = true;
+                                }
+                                _ => {}
+                            }
+
+                            // Verify the color is red as expected.
+                            assert_eq!(color.red, 255, "Expected red color component to be 255");
+                            assert_eq!(color.green, 0, "Expected green color component to be 0");
+                            assert_eq!(color.blue, 0, "Expected blue color component to be 0");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Verify we found both types of borders with colors
+    assert!(
+        found_thin_with_color,
+        "Expected to find at least one thin border with color"
+    );
+    assert!(
+        found_dashed_with_color,
+        "Expected to find at least one dashed border with color"
+    );
+}
+
+#[test]
+fn test_problematic_formats() {
+    let mut xlsx: Xlsx<_> = wb("problematic_formats.xlsx");
+    let range = xlsx.worksheet_range("Sheet1").unwrap();
+    let styles = xlsx.worksheet_style("Sheet1").unwrap();
+
+    // Check cell A1 (0,0) - should have white font
+    let a1_style = styles
+        .get((0, 0))
+        .expect("A1 should have style information");
+    let a1_font = a1_style
+        .get_font()
+        .expect("A1 should have font information");
+
+    // Font properties may or may not be explicitly set depending on the file;
+    // the important thing is that parsing succeeds without panic.
+    let _ = a1_font.name.as_ref();
+    let _ = a1_font.size;
+
+    // Check font color - should be white
+    if let Some(color) = a1_font.color {
+        assert!(
+            color.is_white(),
+            "A1 font color should be white, got RGB({}, {}, {})",
+            color.red,
+            color.green,
+            color.blue
+        );
+    }
+
+    // Check cell A2 (1,0) - verify it has style information
+    let a2_style = styles
+        .get((1, 0))
+        .expect("A2 should have style information");
+
+    // A2 should have number format information or use default
+    if let Some(number_format) = a2_style.get_number_format() {
+        assert!(
+            !number_format.format_code.is_empty(),
+            "Number format code should not be empty"
+        );
+    }
+
+    // Verify cell values exist
+    assert!(range.get((0, 0)).is_some(), "A1 should have a value");
+    assert!(range.get((1, 0)).is_some(), "A2 should have a value");
+}
+
+#[test]
+fn test_color_construction() {
+    use calamine::Color;
+
+    let rgb = Color::rgb(255, 0, 0);
+    assert_eq!(rgb.red, 255);
+    assert_eq!(rgb.green, 0);
+    assert_eq!(rgb.blue, 0);
+    assert_eq!(rgb.alpha, 255);
+
+    let argb = Color::new(128, 255, 0, 0);
+    assert_eq!(argb.alpha, 128);
+    assert_eq!(argb.red, 255);
+
+    assert!(Color::rgb(0, 0, 0).is_black());
+    assert!(Color::rgb(255, 255, 255).is_white());
+    assert!(!Color::rgb(1, 0, 0).is_black());
+}
+
+#[test]
+fn test_color_parsing_with_styles() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+
+    // Test that we can read styles and colors from the styles.xlsx file
+    let range = xlsx.worksheet_range("Sheet 1").unwrap();
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    let mut cells_with_styles = 0;
+    let mut cells_with_font_colors = 0;
+
+    // Iterate through cells and check for style information
+    for (row, col, _cell) in range.cells() {
+        if let Some(style) = styles.get((row, col)) {
+            cells_with_styles += 1;
+
+            if let Some(font) = style.get_font() {
+                if let Some(color) = font.color {
+                    cells_with_font_colors += 1;
+
+                    // color.{red,green,blue,alpha} are u8 so the 0..=255 range is
+                    // guaranteed by the type system; check known specific colors instead.
+                    if row == 4 && col == 0 {
+                        // A5 should have red font color (from test_all_styles)
+                        assert_eq!(color.red, 255, "A5 should have red font");
+                        assert_eq!(color.green, 0, "A5 should have red font");
+                        assert_eq!(color.blue, 0, "A5 should have red font");
+                    }
+                }
+            }
+        }
+    }
+
+    // Verify we found some styled cells
+    assert!(
+        cells_with_styles > 0,
+        "Should find at least some cells with styles"
+    );
+
+    // Verify color parsing is working (we should find at least one colored font)
+    assert!(
+        cells_with_font_colors > 0,
+        "Should find at least some cells with font colors"
+    );
+}
+
+#[test]
+fn test_style_range_rle() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    let unique_count = styles.unique_style_count();
+    let run_count = styles.run_count();
+
+    println!("RLE Stats for styles.xlsx:");
+    println!("  Unique styles: {}", unique_count);
+    println!("  Run count: {}", run_count);
+    println!("  Compression ratio: {:.1}x", styles.compression_ratio());
+
+    assert!(unique_count > 0, "Should have unique styles");
+
+    let mut cell_count = 0;
+    for (row, col, style) in styles.cells() {
+        cell_count += 1;
+        assert!(row < styles.height());
+        assert!(col < styles.width());
+        let _ = style.get_font();
+    }
+
+    println!("  Cell count: {}", cell_count);
+    assert!(cell_count > 0, "Should have cells with styles");
+
+    if let Some(style) = styles.get((0, 0)) {
+        let _ = style.get_font();
+    }
+}
+
+#[test]
+fn test_theme_color_with_tint() {
+    // EMSI_JobChange_UK.xlsx uses theme="2" tint="-0.0999..." for the header fill.
+    // The file's theme has lt2 = EEECE1 (238, 236, 225).
+    // With tint -0.1: each channel * 0.9 ≈ (214, 212, 203).
+    let mut xlsx: Xlsx<_> = wb("EMSI_JobChange_UK.xlsx");
+    let styles = xlsx.worksheet_style("1 digit").unwrap();
+
+    // Row 0 is the header row; check cell A1 (0, 0)
+    let header_style = styles.get((0, 0)).expect("Header cell should have style");
+    let fill = header_style.get_fill().expect("Header should have fill");
+    let color = fill.get_color().expect("Header fill should have a color");
+
+    // The color should be a tan/beige, NOT dark grey.
+    // Expected: approximately RGB(214, 212, 203) based on EEECE1 with tint -0.1
+    assert!(
+        color.red > 200 && color.green > 200 && color.blue > 190,
+        "Header fill should be tan/beige, got RGB({}, {}, {})",
+        color.red,
+        color.green,
+        color.blue
+    );
+
+    // Verify it's NOT the old incorrect dark blue-grey (68, 84, 106)
+    assert!(
+        color.red > 150,
+        "Header fill red should be > 150 (not dark grey), got {}",
+        color.red
+    );
+}
+
+#[test]
+fn test_theme_colors_read_from_file() {
+    // EMSI_JobChange_UK.xlsx has the Office 2007 theme:
+    //   dk1=000000, lt1=FFFFFF, dk2=1F497D, lt2=EEECE1
+    // After Excel's index swap: theme 0=lt1, 1=dk1, 2=lt2, 3=dk2
+    let mut xlsx: Xlsx<_> = wb("EMSI_JobChange_UK.xlsx");
+    let styles = xlsx.worksheet_style("1 digit").unwrap();
+
+    // The header row uses bold font with no explicit font color set,
+    // and the data rows use theme="1" (dk1=black) for font color.
+    // Verify a data cell (row 1) has correct style
+    let data_style = styles.get((1, 0)).expect("Data cell should have style");
+    assert!(
+        data_style.get_font().is_some(),
+        "Data cell should have font info"
+    );
+}
+
+#[test]
+fn test_sys_color_parsing_prefers_last_clr() {
+    // problematic_formats.xlsx has sysClr elements like:
+    //   <a:sysClr val="windowText" lastClr="000000"/>
+    //   <a:sysClr val="window" lastClr="FFFFFF"/>
+    // The parser should use lastClr (resolved) over val (system name).
+    let mut xlsx: Xlsx<_> = wb("problematic_formats.xlsx");
+    let styles = xlsx.worksheet_style("Sheet1").unwrap();
+
+    let a1_style = styles.get((0, 0)).expect("A1 should have style");
+    let font = a1_style.get_font().expect("A1 should have font");
+
+    // Font uses theme="0" which should resolve to lt1 = FFFFFF (white)
+    // via the sysClr lastClr attribute
+    if let Some(color) = font.color {
+        assert!(
+            color.is_white(),
+            "A1 font color should be white (from sysClr lastClr), got RGB({}, {}, {})",
+            color.red,
+            color.green,
+            color.blue
+        );
+    }
+}
+
+#[test]
+fn test_tint_darkening() {
+    // Verify that negative tint darkens a color.
+    // EMSI_JobChange_UK.xlsx border colors use theme="0" tint="-0.2499..."
+    // theme 0 = lt1 = FFFFFF (255,255,255)
+    // With tint -0.25: 255 * 0.75 = 191 per channel → approximately (191, 191, 191)
+    let mut xlsx: Xlsx<_> = wb("EMSI_JobChange_UK.xlsx");
+    let styles = xlsx.worksheet_style("1 digit").unwrap();
+
+    // Check a data cell that should have borders with tinted colors
+    if let Some(data_style) = styles.get((1, 0)) {
+        if let Some(borders) = data_style.get_borders() {
+            if borders.top.is_visible() {
+                if let Some(color) = borders.top.color {
+                    // Should be a light grey (around 191,191,191), not pure white or black
+                    assert!(
+                        color.red > 180 && color.red < 200,
+                        "Border color should be light grey from tinted white, got R={}",
+                        color.red
+                    );
+                }
+            }
+        }
+    }
+}
+
+// ============================================================================
+// Regression tests for quality fixes
+// ============================================================================
+
+#[test]
+fn test_font_parsing_empty_elements() {
+    // Regression: parse_font was ignoring Event::Empty elements like <b/>, <sz val="11"/>
+    // which are the most common form in real Excel files.
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    // A1 should have bold font - this was broken when Event::Empty was ignored
+    let a1_style = styles.get((0, 0)).expect("A1 should have a style");
+    let a1_font = a1_style.get_font().expect("A1 should have font info");
+    assert!(
+        a1_font.is_bold(),
+        "A1 should be bold (tests Event::Empty handling for <b/>)"
+    );
+}
+
+#[test]
+fn test_fill_parsing_empty_elements() {
+    // Regression: parse_fill was ignoring Event::Empty for <patternFill/>, <fgColor/>, etc.
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    let mut found_fill = false;
+    for (_row, _col, style) in styles.cells() {
+        if let Some(fill) = &style.fill {
+            if fill.is_visible() {
+                found_fill = true;
+                break;
+            }
+        }
+    }
+    assert!(
+        found_fill,
+        "Should find at least one visible fill (tests Event::Empty handling for fill elements)"
+    );
+}
+
+#[test]
+fn test_border_parsing_empty_elements() {
+    // Regression: parse_border was ignoring Event::Empty for self-closing border sides
+    // like <left style="thin"/> with no child <color> element.
+    let mut xlsx: Xlsx<_> = wb("borders.xlsx");
+    let styles = xlsx.worksheet_style("Sheet1").unwrap();
+
+    let mut found_border = false;
+    for (_row, _col, style) in styles.cells() {
+        if let Some(borders) = &style.borders {
+            if borders.left.is_visible()
+                || borders.right.is_visible()
+                || borders.top.is_visible()
+                || borders.bottom.is_visible()
+            {
+                found_border = true;
+                break;
+            }
+        }
+    }
+    assert!(
+        found_border,
+        "Should find at least one visible border (tests Event::Empty handling)"
+    );
+}
+
+#[test]
+fn test_worksheet_layout_column_spans() {
+    // Regression: worksheet_layout was ignoring the 'max' attribute on <col> elements,
+    // so a <col min="3" max="10" width="15"/> only recorded column 3.
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let layout = xlsx.worksheet_layout("Sheet 1").unwrap();
+
+    // Verify that column widths have been populated for column spans.
+    // BTreeMap is keyed by column index, so all entries are unique by definition.
+    if layout.column_widths.len() > 1 {
+        // Verify that column indices are populated (not all the same)
+        let min_col = *layout.column_widths.keys().next().unwrap();
+        let max_col = *layout.column_widths.keys().next_back().unwrap();
+        assert!(
+            max_col > min_col,
+            "Column widths should span multiple columns"
+        );
+    }
+}
+
+#[test]
+fn test_worksheet_layout_via_reader_trait() {
+    // Regression: the Reader trait impl for worksheet_layout was a full copy-paste
+    // instead of delegating. Verify both paths produce the same result.
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+
+    // Call via inherent impl
+    let layout1 = Xlsx::worksheet_layout(&mut xlsx, "Sheet 1").unwrap();
+
+    // Re-open to call via Reader trait
+    let mut xlsx2: Xlsx<_> = wb("styles.xlsx");
+    let layout2 = Reader::worksheet_layout(&mut xlsx2, "Sheet 1").unwrap();
+
+    assert_eq!(
+        layout1.default_column_width, layout2.default_column_width,
+        "Both paths should produce same default column width"
+    );
+    assert_eq!(
+        layout1.default_row_height, layout2.default_row_height,
+        "Both paths should produce same default row height"
+    );
+    assert_eq!(
+        layout1.column_widths.len(),
+        layout2.column_widths.len(),
+        "Both paths should produce same number of column widths"
+    );
+    assert_eq!(
+        layout1.row_heights.len(),
+        layout2.row_heights.len(),
+        "Both paths should produce same number of row heights"
+    );
+}
+
 #[test]
 fn test_xlsx_inline_str_with_value() {
     // extraneous v nodes should be ignored for inlineStr cells
@@ -3347,6 +3939,98 @@ fn test_xlsx_richtext_after_plain() {
     );
 }
 
+#[test]
+fn test_text_rotation_stacked() {
+    use calamine::TextRotation;
+
+    // Regression: textRotation=255 was being parsed as Degrees(255) instead of Stacked.
+    // This is a unit-level check on the type.
+    let stacked = TextRotation::Stacked;
+    let degrees = TextRotation::Degrees(90);
+    let none = TextRotation::None;
+
+    assert_ne!(stacked, degrees);
+    assert_ne!(stacked, none);
+    assert_ne!(degrees, none);
+}
+
+#[test]
+fn test_protection_defaults() {
+    use calamine::Protection;
+
+    // Regression: Protection::new() defaulted locked=false, but per OOXML spec
+    // cells are locked by default. The parser now correctly defaults to locked=true,
+    // so verify the Protection struct itself is consistent.
+    let protection = Protection::new();
+    // Protection::new() uses Default which is locked=false, hidden=false.
+    // The parser sets locked=true when the attribute is absent.
+    assert!(!protection.locked, "Protection::new() starts unlocked");
+    assert!(!protection.hidden, "Protection::new() starts not hidden");
+
+    let locked = protection.with_locked(true);
+    assert!(locked.locked);
+}
+
+#[test]
+fn test_style_parsing_with_protection() {
+    // Verify that protection parsing works on a real file
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    // Just verify we can access protection without panic
+    for (_row, _col, style) in styles.cells() {
+        if let Some(protection) = &style.protection {
+            let _ = protection.locked;
+            let _ = protection.hidden;
+        }
+    }
+}
+
+#[test]
+fn test_style_alignment_parsing() {
+    // Verify alignment parsing handles all properties correctly
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let styles = xlsx.worksheet_style("Sheet 1").unwrap();
+
+    let mut found_alignment = false;
+    for (_row, _col, style) in styles.cells() {
+        if let Some(alignment) = &style.alignment {
+            // Verify we can read all alignment properties
+            let _ = alignment.horizontal;
+            let _ = alignment.vertical;
+            let _ = alignment.text_rotation;
+            let _ = alignment.wrap_text;
+            let _ = alignment.indent;
+            let _ = alignment.shrink_to_fit;
+            found_alignment = true;
+        }
+    }
+    assert!(
+        found_alignment,
+        "Should find at least one cell with alignment"
+    );
+}
+
+#[test]
+fn test_worksheet_style_nonexistent_sheet() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let result = xlsx.worksheet_style("nonexistent_sheet_name");
+    assert!(
+        result.is_err(),
+        "Should return error for nonexistent sheet name"
+    );
+}
+
+#[test]
+fn test_worksheet_layout_nonexistent_sheet() {
+    let mut xlsx: Xlsx<_> = wb("styles.xlsx");
+    let result = xlsx.worksheet_layout("nonexistent_sheet_name");
+    assert!(
+        result.is_err(),
+        "Should return error for nonexistent sheet name"
+    );
+}
+
 #[test]
 fn test_xlsx_nonstandard_ns_prefix() {
     // Check that non-standard namespace alias for relationships is accepted.