use markdown_parser::FormattedTextFragment;use string_offset::CharOffset; /// Maps between linear CharOffset positions and table cell coordinates.////// The table content is represented as:/// ```text/// Header1\tHeader2\tHeader3\n/// Cell1\tCell2\tCell3\n/// Cell4\tCell5\tCell6\n/// ```////// This structure enables:/// - Finding which cell contains a given CharOffset/// - Getting the CharOffset range for a specific cell/// - Determining if an offset is on a separator (tab or newline)#[derive(Debug, Clone)]pub struct TableOffsetMap {    cell_ranges: Vec<CellRange>,    row_ranges: Vec<RowRange>,    cell_index_by_row_col: Vec<Vec<usize>>,    total_length: CharOffset,    num_rows: usize,    num_cols: usize,} #[derive(Debug, Clone, Copy)]struct RowRange {    start: CharOffset,    end: CharOffset,} /// A range representing a single cell's position in the linear character stream.#[derive(Debug, Clone, Copy)]pub struct CellRange {    pub start: CharOffset,    pub end: CharOffset,    pub row: usize,    pub col: usize,} /// The location of a character offset within a table cell.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct CellAtOffset {    pub row: usize,    pub col: usize,    pub offset_in_cell: CharOffset,} /// The character offset range (start, end) of a cell in the linear content stream.#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct CellOffsetRange {    pub start: CharOffset,    pub end: CharOffset,} /// Result of looking up a CharOffset in the table.#[derive(Debug, Clone, Copy)]pub enum TablePosition {    /// Offset is within a cell's text content    InCell {        row: usize,        col: usize,        offset_in_cell: CharOffset,    },    /// Offset is on a tab separator between cells    OnTab { row: usize, after_col: usize },    /// Offset is on a newline at the end of a row    OnNewline { row: usize },} #[derive(Debug, Clone)]pub struct TableCellOffsetMap {    fragment_ranges: Vec<TableCellFragmentRange>,    rendered_length: CharOffset,    source_length: CharOffset,} #[derive(Debug, Clone, Copy)]struct TableCellFragmentRange {    rendered_start: CharOffset,    rendered_end: CharOffset,    source_end: CharOffset,    visible_source_start: CharOffset,    visible_source_end: CharOffset,}impl TableOffsetMap {    /// Build a new TableOffsetMap from cell text lengths.    ///    /// `cell_lengths` is a 2D array where cell_lengths[row][col] is the character    /// count of that cell's text content.    pub fn new(cell_lengths: Vec<Vec<usize>>) -> Self {        let num_rows = cell_lengths.len();        let num_cols = cell_lengths.first().map(|r| r.len()).unwrap_or(0);         let mut cell_ranges = Vec::new();        let mut row_ranges = Vec::with_capacity(num_rows);        let mut cell_index_by_row_col = Vec::with_capacity(num_rows);        let mut current_offset = CharOffset::zero();         for (row_idx, row) in cell_lengths.iter().enumerate() {            let row_start = current_offset;            let mut row_cell_indices = Vec::with_capacity(row.len());             for (col_idx, &cell_len) in row.iter().enumerate() {                let start = current_offset;                let end = start + cell_len;                let cell_idx = cell_ranges.len();                 cell_ranges.push(CellRange {                    start,                    end,                    row: row_idx,                    col: col_idx,                });                row_cell_indices.push(cell_idx);                current_offset = end;                 if col_idx < row.len() - 1 {                    current_offset += 1;                }            }             current_offset += 1;            row_ranges.push(RowRange {                start: row_start,                end: current_offset,            });            cell_index_by_row_col.push(row_cell_indices);        }         Self {            cell_ranges,            row_ranges,            cell_index_by_row_col,            total_length: current_offset,            num_rows,            num_cols,        }    }     /// Get the total content length including all cells, tabs, and newlines.    pub fn total_length(&self) -> CharOffset {        self.total_length    }     /// Find what's at the given offset.    pub fn position_at_offset(&self, offset: CharOffset) -> Option<TablePosition> {        if offset >= self.total_length {            return None;        }         let row_idx = self            .row_ranges            .partition_point(|row_range| row_range.end <= offset);        let row_range = self.row_ranges.get(row_idx)?;        if offset < row_range.start {            return None;        }         let row_cells = self.cell_index_by_row_col.get(row_idx)?;        let mut previous_cell: Option<CellRange> = None;        for &cell_idx in row_cells {            let cell = *self.cell_ranges.get(cell_idx)?;             if offset < cell.start {                return previous_cell.map(|cell| self.separator_position(cell));            }             if offset < cell.end {                return Some(TablePosition::InCell {                    row: cell.row,                    col: cell.col,                    offset_in_cell: offset - cell.start,                });            }             if offset == cell.end {                return Some(self.separator_position(cell));            }             previous_cell = Some(cell);        }         Some(TablePosition::OnNewline { row: row_idx })    }     /// Find which cell contains the given offset.    /// If the offset is on a separator, returns the cell before the separator.    pub fn cell_at_offset(&self, offset: CharOffset) -> Option<CellAtOffset> {        match self.position_at_offset(offset)? {            TablePosition::InCell {                row,                col,                offset_in_cell,            } => Some(CellAtOffset {                row,                col,                offset_in_cell,            }),            TablePosition::OnTab { row, after_col } => {                let cell = self.cell_range(row, after_col)?;                Some(CellAtOffset {                    row,                    col: after_col,                    offset_in_cell: cell.end - cell.start,                })            }            TablePosition::OnNewline { row } => {                let last_col = self                    .cell_index_by_row_col                    .get(row)                    .map(|cells| cells.len())                    .unwrap_or(0)                    .saturating_sub(1);                let cell = self.cell_range(row, last_col)?;                Some(CellAtOffset {                    row,                    col: last_col,                    offset_in_cell: cell.end - cell.start,                })            }        }    }     /// Get the character offset range for a specific cell by (row, col).    pub fn cell_range(&self, row: usize, col: usize) -> Option<CellOffsetRange> {        let cell_idx = *self.cell_index_by_row_col.get(row)?.get(col)?;        let cell = self.cell_ranges.get(cell_idx)?;        Some(CellOffsetRange {            start: cell.start,            end: cell.end,        })    }     /// Check if an offset is on a tab or newline separator.    pub fn is_separator(&self, offset: CharOffset) -> bool {        matches!(            self.position_at_offset(offset),            Some(TablePosition::OnTab { .. } | TablePosition::OnNewline { .. })        )    }     /// Get all cells that intersect with the given offset range.    /// Returns cells in row-major order.    pub fn cells_in_range(&self, start: CharOffset, end: CharOffset) -> Vec<CellRange> {        self.cell_ranges            .iter()            .filter(|cell| cell.end > start && cell.start < end)            .copied()            .collect()    }     /// Get the number of rows in the table.    pub fn num_rows(&self) -> usize {        self.num_rows    }     /// Get the number of columns in the table.    pub fn num_cols(&self) -> usize {        self.num_cols    }     fn separator_position(&self, cell: CellRange) -> TablePosition {        let row_len = self            .cell_index_by_row_col            .get(cell.row)            .map(|cells| cells.len())            .unwrap_or(0);        if cell.col + 1 < row_len {            TablePosition::OnTab {                row: cell.row,                after_col: cell.col,            }        } else {            TablePosition::OnNewline { row: cell.row }        }    }} // TODO: When we add editable tables or other complex table operations, consider moving// cell/row boundaries into the `SumTree` with new `BufferText` marker types so that// per-cell offsets can be derived by seeking to boundaries instead of re-parsing the// whole table on every edit. The current embedded-text-plus-cached-parse model is// sufficient for read-only tables; see PR #24326 discussion for context.impl TableCellOffsetMap {    /// Build a cell offset map from the raw cell `source` text and the parsed `inline`    /// fragments produced by the Markdown parser.    ///    /// This walks `source` character-by-character alongside the rendered text of each fragment,    /// which makes it robust to:    /// - backslash escapes (e.g. `\*foo` consumes two source chars for one rendered char),    /// - changes to Markdown marker syntax (we don't hardcode `**`, `*`, `<u>`, etc. here), and    /// - nested styles where adjacent fragments share outer markers (e.g. `**a *b* c**`), since we    ///   attribute each marker to the fragment whose rendered text follows it.    pub fn from_inline_and_source(source: &str, inline: &[FormattedTextFragment]) -> Self {        let source_chars: Vec<char> = source.chars().collect();        let total_source_chars = source_chars.len();        let mut fragment_ranges: Vec<TableCellFragmentRange> = Vec::new();        let mut rendered_offset = CharOffset::zero();        let mut source_idx: usize = 0;         for fragment in inline {            let rendered_chars: Vec<char> = fragment.text.chars().collect();            if rendered_chars.is_empty() {                continue;            }             let first_rendered = rendered_chars[0];            while source_idx < total_source_chars {                let sc = source_chars[source_idx];                if sc == '\\'                    && source_idx + 1 < total_source_chars                    && source_chars[source_idx + 1] == first_rendered                {                    source_idx += 1;                    break;                }                if sc == first_rendered {                    break;                }                source_idx += 1;            }             let visible_source_start = CharOffset::from(source_idx);             for &rendered_char in &rendered_chars {                if source_idx >= total_source_chars {                    break;                }                let sc = source_chars[source_idx];                if sc == '\\'                    && source_idx + 1 < total_source_chars                    && source_chars[source_idx + 1] == rendered_char                {                    source_idx += 2;                } else {                    source_idx += 1;                }            }             let visible_source_end = CharOffset::from(source_idx);            let rendered_start = rendered_offset;            let rendered_end = rendered_start + CharOffset::from(rendered_chars.len());             fragment_ranges.push(TableCellFragmentRange {                rendered_start,                rendered_end,                source_end: visible_source_end,                visible_source_start,                visible_source_end,            });             rendered_offset = rendered_end;        }         let total_source_offset = CharOffset::from(total_source_chars);        let fragment_count = fragment_ranges.len();        for i in 0..fragment_count {            let next_start = if i + 1 < fragment_count {                fragment_ranges[i + 1].visible_source_start            } else {                total_source_offset            };            fragment_ranges[i].source_end = next_start;        }         Self {            fragment_ranges,            rendered_length: rendered_offset,            source_length: total_source_offset,        }    }     pub fn rendered_length(&self) -> CharOffset {        self.rendered_length    }     pub fn source_length(&self) -> CharOffset {        self.source_length    }     pub fn rendered_to_source(&self, rendered_offset: CharOffset) -> CharOffset {        if rendered_offset >= self.rendered_length {            return self                .fragment_ranges                .last()                .map(|fragment| fragment.visible_source_end)                .unwrap_or(self.source_length);        }         for fragment in &self.fragment_ranges {            if rendered_offset < fragment.rendered_end {                return fragment.visible_source_start + (rendered_offset - fragment.rendered_start);            }        }         self.source_length    }     pub fn source_to_rendered(&self, source_offset: CharOffset) -> CharOffset {        if source_offset >= self.source_length {            return self.rendered_length;        }         for fragment in &self.fragment_ranges {            if source_offset < fragment.source_end {                if source_offset <= fragment.visible_source_start {                    return fragment.rendered_start;                }                if source_offset >= fragment.visible_source_end {                    return fragment.rendered_end;                }                return fragment.rendered_start + (source_offset - fragment.visible_source_start);            }        }         self.rendered_length    }} #[cfg(test)]#[path = "table_offset_map_tests.rs"]mod tests;