xlsxrb 0.1.12 → 0.1.14

data/lib/xlsxrb/ooxml/worksheet_parser.rb

@@ -3,6 +3,7 @@
 # rbs_inline: enabled
 
 require_relative "xml_parser"
+require_relative "xml_builder"
 
 module Xlsxrb
   module Ooxml
@@ -12,45 +13,71 @@ module Xlsxrb
     class WorksheetParser
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
+      TAG_DELIM_BYTES = [32, 62, 9, 10, 13, 47].freeze
+      ROW_ATTR_START_BYTES = [104, 99, 111, 115].freeze
 
       # Parses all rows from a worksheet XML string.
       # Returns an Array of raw row hashes:
       #   { index:, cells: [{ ref:, type:, style_index:, value:, formula: }], attrs:, unmapped: }
-      def self.parse(xml_string, shared_strings: [])
+      def self.parse(xml_string, shared_strings: [], styles: nil)
         return [] if xml_string.nil? || xml_string.empty?
 
         rows = []
-        each_row(xml_string, shared_strings: shared_strings) { |row| rows << row }
+        each_row(xml_string, shared_strings: shared_strings, styles: styles) { |row| rows << row }
         rows
       end
 
       # Streaming parse: yields one raw row hash at a time.
-      def self.each_row(xml_string, shared_strings: [], part_name: "xl/worksheets/sheet1.xml", &block)
-        return enum_for(:each_row, xml_string, shared_strings: shared_strings, part_name: part_name) unless block
-        return if xml_string.nil? || xml_string.empty?
+      def self.each_row(xml_source, shared_strings: [], part_name: "xl/worksheets/sheet1.xml", styles: nil, date1904: false, trim_empty_rows: false, pad_empty_rows: false, pad_empty_cells: false, &block)
+        return enum_for(:each_row, xml_source, shared_strings: shared_strings, part_name: part_name, styles: styles, date1904: date1904, trim_empty_rows: trim_empty_rows, pad_empty_rows: pad_empty_rows, pad_empty_cells: pad_empty_cells) unless block
+        return if xml_source.nil? || (xml_source.respond_to?(:empty?) && xml_source.empty?)
+
+        row_consumer = if trim_empty_rows
+                         pending_empty = []
+                         lambda do |row|
+                           if row.empty?
+                             pending_empty << row
+                           else
+                             pending_empty.each(&block)
+                             pending_empty.clear
+                             block.call(row)
+                           end
+                         end
+                       else
+                         block
+                       end
+
+        if pad_empty_rows
+          current_expected_idx = 0
+          inner_consumer = row_consumer
+          row_consumer = lambda do |row|
+            while current_expected_idx < row.index
+              empty_row = StreamRow.fast_create(
+                current_expected_idx, "".b, 0, 0, shared_strings, "", nil, false, false, nil, nil, styles, date1904, false, pad_empty_cells
+              )
+              inner_consumer.call(empty_row)
+              current_expected_idx += 1
+            end
+            inner_consumer.call(row)
+            current_expected_idx = row.index + 1
+          end
+        end
 
-        fast_scan_rows_direct(xml_string, shared_strings, part_name, &block)
+        if xml_source.is_a?(String)
+          fast_scan_rows_direct(xml_source, shared_strings, part_name, styles, date1904, pad_empty_cells, &row_consumer)
+        else
+          scan_rows_stream(xml_source, shared_strings, part_name, styles, date1904, pad_empty_cells, &row_consumer)
+        end
       end
 
       # Parses column definitions (<cols>) from a worksheet.
-      def self.parse_columns(xml_string, part_name: "xl/worksheets/sheet1.xml")
+      def self.parse_columns(xml_string, _part_name = "xl/worksheets/sheet1.xml")
         return [] if xml_string.nil? || xml_string.empty?
+        return [] unless xml_string.include?("<cols")
 
-        columns = []
-        each_event(xml_string, part_name: part_name) do |event|
-          next unless event.type == :column
-
-          min, max, width, hidden, custom_width, outline_level = event.args
-          columns << {
-            min: min,
-            max: max,
-            width: width,
-            hidden: hidden,
-            custom_width: custom_width,
-            outline_level: outline_level
-          }
-        end
-        columns
+        listener = ColumnsListener.new
+        XmlParser.parse(xml_string, listener)
+        listener.columns
       end
 
       # Yields Event objects for columns, rows, cells, and hyperlinks.
@@ -75,19 +102,37 @@ module Xlsxrb
         fast_scan_events(xml_string, shared_strings, part_name, &block)
 
         # 3. Parse and yield hyperlink events
-        return unless xml_string.include?("hyperlink")
+        parse_hyperlinks(xml_string).each do |hl|
+          block.call(Event.new(
+                       type: :hyperlink,
+                       args: [hl[:ref], hl[:rid], hl[:display], hl[:tooltip], hl[:location]],
+                       source: { part: part_name, cell: hl[:ref] }
+                     ))
+        end
+      end
+
+      # Parses all hyperlink elements from worksheet XML.
+      #
+      # @param xml_string [String, nil]
+      # @return [Array<Hash[Symbol, untyped]>]
+      # @api public
+      #: (String?) -> Array[Hash[Symbol, untyped]]
+      def self.parse_hyperlinks(xml_string)
+        return [] if xml_string.nil? || xml_string.empty?
+        return [] unless xml_string.include?("hyperlink")
 
         xml = xml_string.b
         hpos_term = xml.index("hyperlinks")
-        return unless hpos_term
+        return [] unless hpos_term
 
         hpos = xml.rindex("<", hpos_term)
-        return unless hpos
+        return [] unless hpos
 
         h_end_term = xml.index("/hyperlinks", hpos)
         h_end = h_end_term ? xml.index(">", h_end_term) : xml.size
         h_end ||= xml.size
 
+        links = []
         pos = hpos
         while pos < h_end
           hl_start_term = xml.index("hyperlink", pos)
@@ -101,20 +146,22 @@ module Xlsxrb
 
           hl_tag = xml.byteslice(hl_start, hl_tag_end - hl_start)
           ref = tag_attr(hl_tag, ' ref="')
-          rid = tag_attr(hl_tag, ' r:id="') || tag_attr(hl_tag, ' id="')
+          rid = tag_attr(hl_tag, ' r:id="') || tag_attr(hl_tag, ' id="') || hl_tag[/(?:[a-zA-Z0-9_]+:)?id="([^"]+)"/, 1]
           display = tag_attr(hl_tag, ' display="')
           tooltip = tag_attr(hl_tag, ' tooltip="')
           location = tag_attr(hl_tag, ' location="')
 
           if ref
-            block.call(Event.new(
-                         type: :hyperlink,
-                         args: [ref, rid, display, tooltip, location],
-                         source: { part: part_name, cell: ref }
-                       ))
+            entry = { ref: ref }
+            entry[:rid] = rid if rid
+            entry[:display] = display if display
+            entry[:tooltip] = tooltip if tooltip
+            entry[:location] = location if location
+            links << entry
           end
           pos = hl_tag_end + 1
         end
+        links
       end
 
       # ---- Fast string-scanning event parser (byte-level) ----
@@ -152,13 +199,14 @@ module Xlsxrb
         row_end_len = row_end_tag.bytesize
 
         pos = sd_open_end + 1
+        last_row_index = -1
 
         while pos < sd_end
           row_start = xml.index(row_start_pattern, pos)
           break unless row_start && row_start < sd_end
 
           nb = xml.getbyte(row_start + row_start_len)
-          unless [32, 62, 9, 10, 13, 47].include?(nb)
+          unless TAG_DELIM_BYTES.include?(nb)
             pos = row_start + row_start_len
             next
           end
@@ -173,9 +221,9 @@ module Xlsxrb
 
           # Row index and attrs from tag substring (bounded search)
           row_tag = xml.byteslice(row_start, tag_end - row_start)
-          row_index = 0
           r_val = tag_attr(row_tag, ' r="')
-          row_index = r_val.to_i - 1 if r_val
+          row_index = r_val ? r_val.to_i - 1 : last_row_index + 1
+          last_row_index = row_index
 
           attrs = extract_row_attrs(row_tag)
 
@@ -212,22 +260,33 @@ module Xlsxrb
           attrs[:height] = ht_val.to_f
         end
 
-        if row_tag.include?('hidden="1"')
+        if row_tag.include?('hidden="1"') || row_tag.include?('hidden="true"')
           attrs = {} if attrs.equal?(EMPTY_HASH)
           attrs[:hidden] = true
         end
 
-        if row_tag.include?('customHeight="1"')
+        if row_tag.include?('customHeight="1"') || row_tag.include?('customHeight="true"')
           attrs = {} if attrs.equal?(EMPTY_HASH)
           attrs[:custom_height] = true
         end
 
+        if row_tag.include?('collapsed="1"') || row_tag.include?('collapsed="true"')
+          attrs = {} if attrs.equal?(EMPTY_HASH)
+          attrs[:collapsed] = true
+        end
+
         ol_val = tag_attr(row_tag, ' outlineLevel="')
         if ol_val
           attrs = {} if attrs.equal?(EMPTY_HASH)
           attrs[:outline_level] = ol_val.to_i
         end
 
+        s_val = tag_attr(row_tag, ' s="')
+        if s_val
+          attrs = {} if attrs.equal?(EMPTY_HASH)
+          attrs[:style_index] = s_val.to_i
+        end
+
         attrs
       end
 
@@ -273,7 +332,7 @@ module Xlsxrb
           break unless c_start && c_start < to
 
           nb = xml.getbyte(c_start + c_start_len)
-          unless [32, 62, 9, 10, 13, 47].include?(nb)
+          unless TAG_DELIM_BYTES.include?(nb)
             pos = c_start + c_start_len
             next
           end
@@ -396,8 +455,7 @@ module Xlsxrb
           break unless t_end && t_end <= to
 
           text_segment = xml.byteslice(t_tag_end + 1, t_close - t_tag_end - 1).force_encoding("UTF-8")
-          text_segment = decode_xml_entities(text_segment) if text_segment.include?("&")
-          result << text_segment
+          result << normalize_text(text_segment)
 
           pos = t_end + 1
         end
@@ -413,8 +471,7 @@ module Xlsxrb
         when "b"
           raw == "1"
         when "e", "str", "inlineStr"
-          val = raw.force_encoding("UTF-8")
-          val.include?("&") ? decode_xml_entities(val) : val
+          normalize_text(raw.force_encoding("UTF-8"))
         else
           return nil if raw.empty?
 
@@ -428,16 +485,19 @@ module Xlsxrb
 
       private_class_method :resolve_fast_value
 
-      XML_ENTITIES = { "&amp;" => "&", "&lt;" => "<", "&gt;" => ">", "&quot;" => '"', "&apos;" => "'" }.freeze
-
       # SECURITY NOTE: Decodes only standard predefined XML entities in a single pass.
       # This completely prevents "Billion Laughs" attacks (exponential entity expansion)
       # because it avoids recursive expansion and ignores custom entities entirely.
+      #: (String str) -> String
       def self.decode_xml_entities(str)
-        str.gsub(/&(?:amp|lt|gt|quot|apos);/, XML_ENTITIES)
+        XmlBuilder.unescape(str)
       end
 
-      private_class_method :decode_xml_entities
+      #: (String str) -> String
+      def self.normalize_text(str)
+        s = decode_xml_entities(str)
+        s.include?("\r") ? s.gsub("\r\n", "\n").tr("\r", "\n") : s
+      end
 
       # Parses <cols> section for column definitions.
       class ColumnsListener
@@ -463,7 +523,8 @@ module Xlsxrb
               width: attrs["width"]&.to_f,
               hidden: attrs["hidden"] == "1",
               custom_width: attrs["customWidth"] == "1",
-              outline_level: attrs["outlineLevel"]&.to_i
+              outline_level: attrs["outlineLevel"]&.to_i,
+              style_index: attrs["style"]&.to_i
             }
             @columns << col
           end
@@ -476,7 +537,9 @@ module Xlsxrb
         def characters(_text); end
       end
 
-      def self.fast_scan_rows_direct(xml_src, shared_strings, _part_name, &block)
+      # rubocop:disable Style/OptionalBooleanParameter
+      def self.fast_scan_rows_direct(xml_src, shared_strings, _part_name, styles = nil, date1904 = false, pad_empty_cells = false, &block)
+        # rubocop:enable Style/OptionalBooleanParameter
         xml = xml_src.b # force ASCII-8BIT for O(1) byte indexing
 
         sd_term = xml.index("sheetData")
@@ -501,13 +564,14 @@ module Xlsxrb
         row_end_len = row_end_tag.bytesize
 
         pos = sd_open_end + 1
+        last_row_index = -1
 
         while pos < sd_end
           row_start = xml.index(row_start_pattern, pos)
           break unless row_start && row_start < sd_end
 
           nb = xml.getbyte(row_start + row_start_len)
-          unless [32, 62, 9, 10, 13, 47].include?(nb)
+          unless TAG_DELIM_BYTES.include?(nb)
             pos = row_start + row_start_len
             next
           end
@@ -520,23 +584,23 @@ module Xlsxrb
             next
           end
 
-          row_index = 0
+          row_index = nil
           has_custom_attrs = false
           ri = row_start + row_start_len
           while ri < tag_end
             rb = xml.getbyte(ri)
             if rb == 114 && xml.getbyte(ri + 1) == 61 && xml.getbyte(ri + 2) == 34 # r="
               ri += 3
+              parsed_r = 0
               while ri < tag_end
                 cb = xml.getbyte(ri)
                 break unless cb.between?(48, 57)
 
-                row_index = (row_index * 10) + (cb - 48)
+                parsed_r = (parsed_r * 10) + (cb - 48)
                 ri += 1
-
               end
-              row_index -= 1
-            elsif [104, 99, 111].include?(rb) # 'h', 'c', 'o' for ht, customHeight, hidden, outlineLevel
+              row_index = parsed_r - 1
+            elsif ROW_ATTR_START_BYTES.include?(rb) # 'h', 'c', 'o', 's' for ht, customHeight, hidden, outlineLevel, s
               has_custom_attrs = true
               ri += 1
             else
@@ -544,6 +608,9 @@ module Xlsxrb
             end
           end
 
+          row_index ||= last_row_index + 1
+          last_row_index = row_index
+
           attrs = if has_custom_attrs
                     row_tag = xml.byteslice(row_start, tag_end - row_start)
                     extract_row_attrs(row_tag)
@@ -564,7 +631,12 @@ module Xlsxrb
             attrs[:height],
             attrs[:hidden] || false,
             attrs[:custom_height] || false,
-            attrs[:outline_level]
+            attrs[:outline_level],
+            attrs[:style_index],
+            styles,
+            date1904,
+            attrs[:collapsed] || false,
+            pad_empty_cells
           )
           block.call(row_obj)
 
@@ -574,6 +646,191 @@ module Xlsxrb
 
       private_class_method :fast_scan_rows_direct
 
+      # rubocop:disable Style/OptionalBooleanParameter
+      def self.scan_rows_stream(source, shared_strings, _part_name, styles = nil, date1904 = false, pad_empty_cells = false, &block)
+        # rubocop:enable Style/OptionalBooleanParameter
+        buffer = +""
+        buffer.force_encoding(Encoding::BINARY)
+        in_sheet_data = false
+        prefix = ""
+        row_start_pattern = "<row"
+        row_start_len = 4
+        row_end_tag = "</row>"
+        row_end_len = 6
+        sd_end_tag = "</sheetData>"
+        last_row_index = -1
+
+        push_chunk = lambda do |chunk|
+          return if in_sheet_data == :closed
+          return if chunk.nil? || chunk.empty?
+
+          buffer << chunk.b
+
+          unless in_sheet_data
+            sd_term = buffer.index("sheetData")
+            if sd_term.nil?
+              buffer.slice!(0...(buffer.bytesize - 32)) if buffer.bytesize > 64
+              return
+            end
+
+            sd_start = buffer.rindex("<", sd_term)
+            if sd_start.nil?
+              buffer.slice!(0...sd_term)
+              return
+            end
+
+            sd_open_end = buffer.index(">", sd_term)
+            return if sd_open_end.nil?
+
+            if buffer.getbyte(sd_open_end - 1) == 47
+              in_sheet_data = :closed
+              buffer.clear
+              return
+            end
+
+            prefix = buffer.byteslice(sd_start + 1, sd_term - (sd_start + 1))
+            row_start_pattern = "<#{prefix}row"
+            row_start_len = row_start_pattern.bytesize
+            row_end_tag = "</#{prefix}row>"
+            row_end_len = row_end_tag.bytesize
+            sd_end_tag = "</#{prefix}sheetData>"
+
+            buffer.slice!(0..sd_open_end)
+            in_sheet_data = true
+          end
+
+          pos = 0
+          last_consumed_pos = 0
+          sd_end_pos = buffer.index(sd_end_tag)
+
+          loop do
+            row_start = buffer.index(row_start_pattern, pos)
+
+            if sd_end_pos && (row_start.nil? || sd_end_pos < row_start)
+              in_sheet_data = :closed
+              buffer.clear
+              return
+            end
+
+            break if row_start.nil?
+
+            next_pos = row_start + row_start_len
+            break if next_pos >= buffer.bytesize
+
+            nb = buffer.getbyte(next_pos)
+            unless TAG_DELIM_BYTES.include?(nb)
+              pos = next_pos
+              next
+            end
+
+            tag_end = buffer.index(">", next_pos)
+            break if tag_end.nil?
+
+            if buffer.getbyte(tag_end - 1) == 47
+              pos = tag_end + 1
+              last_consumed_pos = pos
+              next
+            end
+
+            row_end = buffer.index(row_end_tag, tag_end + 1)
+            if row_end.nil?
+              raise ArgumentError, "Malformed XML: row size exceeds maximum buffer limit" if buffer.bytesize > 50 * 1024 * 1024
+
+              break
+            end
+
+            row_index = nil
+            has_custom_attrs = false
+            ri = row_start + row_start_len
+            while ri < tag_end
+              rb = buffer.getbyte(ri)
+              if rb == 114 && buffer.getbyte(ri + 1) == 61 && buffer.getbyte(ri + 2) == 34 # r="
+                ri += 3
+                parsed_r = 0
+                while ri < tag_end
+                  cb = buffer.getbyte(ri)
+                  break unless cb.between?(48, 57)
+
+                  parsed_r = (parsed_r * 10) + (cb - 48)
+                  ri += 1
+                end
+                row_index = parsed_r - 1
+              elsif ROW_ATTR_START_BYTES.include?(rb)
+                has_custom_attrs = true
+                ri += 1
+              else
+                ri += 1
+              end
+            end
+
+            row_index ||= last_row_index + 1
+            last_row_index = row_index
+
+            attrs = if has_custom_attrs
+                      row_tag = buffer.byteslice(row_start, tag_end - row_start)
+                      extract_row_attrs(row_tag)
+                    else
+                      EMPTY_HASH
+                    end
+
+            cells_xml = buffer.byteslice(tag_end + 1, row_end - (tag_end + 1))
+            row_obj = StreamRow.fast_create(
+              row_index,
+              cells_xml,
+              0,
+              cells_xml.bytesize,
+              shared_strings,
+              prefix,
+              attrs[:height],
+              attrs[:hidden] || false,
+              attrs[:custom_height] || false,
+              attrs[:outline_level],
+              attrs[:style_index],
+              styles,
+              date1904,
+              attrs[:collapsed] || false,
+              pad_empty_cells
+            )
+            block.call(row_obj)
+
+            pos = row_end + row_end_len
+            last_consumed_pos = pos
+          end
+
+          buffer.slice!(0...last_consumed_pos) if last_consumed_pos.positive?
+        end
+
+        catch(:done) do
+          if source.respond_to?(:each_chunk)
+            source.each_chunk(65_536) do |chunk|
+              push_chunk.call(chunk)
+              throw :done if in_sheet_data == :closed
+            end
+          elsif source.respond_to?(:read)
+            while (chunk = source.read(65_536))
+              break if chunk.empty?
+
+              push_chunk.call(chunk)
+              break if in_sheet_data == :closed
+            end
+          elsif source.respond_to?(:call)
+            source.call do |chunk|
+              push_chunk.call(chunk)
+              throw :done if in_sheet_data == :closed
+            end
+          elsif source.respond_to?(:each)
+            source.each do |chunk|
+              push_chunk.call(chunk)
+              break if in_sheet_data == :closed
+            end
+          else
+            raise ArgumentError, "Unsupported stream source: #{source.class}"
+          end
+        end
+      end
+
+      private_class_method :scan_rows_stream
+
       COL_LETTERS = (0...16_384).map do |index|
         result = +""
         i = index
@@ -589,8 +846,8 @@ module Xlsxrb
         [COL_LETTERS[idx], idx]
       end.freeze
 
-      CELL_FAST_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\s+r="([A-Za-z0-9]+)"(?:[^>]*?s="(\d+)")?(?:[^>]*?t="([a-zA-Z]+)")?[^>]*>(?:<(?:[a-zA-Z0-9_]+:)?f[^>]*>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>)?</(?:[a-zA-Z0-9_]+:)?c>|<(?:[a-zA-Z0-9_]+:)?c\s+r="([A-Za-z0-9]+)"(?:[^>]*?s="(\d+)")?[^>]*/>}
-      CELL_GENERIC_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\b([^>]*?)(?:>(?:<(?:[a-zA-Z0-9_]+:)?f[^>]*>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>)?</(?:[a-zA-Z0-9_]+:)?c>|/>)}m
+      CELL_FAST_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\s+r="([A-Za-z0-9]+)"(?:[^>]*?s="(\d+)")?(?:[^>]*?t="([a-zA-Z]+)")?[^>]*>\s*(?:<(?:[a-zA-Z0-9_]+:)?f\b[^>]*?(?:/>|>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)\s*)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>\s*)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>\s*)?.*?</(?:[a-zA-Z0-9_]+:)?c>|<(?:[a-zA-Z0-9_]+:)?c\s+r="([A-Za-z0-9]+)"(?:[^>]*?s="(\d+)")?[^>]*/>}m
+      CELL_GENERIC_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\b([^>]*?)(?:>\s*(?:<(?:[a-zA-Z0-9_]+:)?f\b[^>]*?(?:/>|>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)\s*)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>\s*)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>\s*)?.*?</(?:[a-zA-Z0-9_]+:)?c>|/>)}m
       ATTR_R = /r="([A-Za-z0-9]+)"/
       ATTR_T = /t="([a-zA-Z]+)"/
       ATTR_S = /s="(\d+)"/
@@ -601,7 +858,9 @@ module Xlsxrb
         cells
       end
 
-      def self.fast_scan_cells_direct(xml, from, to, shared_strings, row_source, _prefix = "", &block)
+      # rubocop:disable Style/OptionalBooleanParameter
+      def self.fast_scan_cells_direct(xml, from, to, shared_strings, row_source, _prefix = "", styles = nil, date1904 = false, &block)
+        # rubocop:enable Style/OptionalBooleanParameter
         chunk = xml.byteslice(from, to - from)
         row_idx = row_source.is_a?(Hash) ? row_source[:row] : row_source
         col_idx = 0
@@ -626,6 +885,8 @@ module Xlsxrb
                     col_idx
                   end
           col_idx = c_idx + 1
+          v = v.strip if v
+          f = f.strip if f
 
           val = if t == "s"
                   shared_strings[v.to_i] || ""
@@ -635,7 +896,7 @@ module Xlsxrb
                   if is
                     extract_inline_text(is, 0, is.bytesize)
                   elsif v
-                    v.include?("&") ? decode_xml_entities(v) : v
+                    normalize_text(v)
                   else
                     ""
                   end
@@ -643,8 +904,16 @@ module Xlsxrb
                   v.include?(".") ? v.to_f : v.to_i
                 end
 
-          formula_expr = f&.include?("&") ? decode_xml_entities(f) : f
-          cell = Elements::Cell.fast_create(row_idx, c_idx, val, style_idx, formula_expr)
+          raw_val = if is
+                      extract_inline_text(is, 0, is.bytesize)
+                    elsif v
+                      normalize_text(v)
+                    end
+
+          formula_expr = f ? normalize_text(f) : nil
+          formula_expr = nil if formula_expr && formula_expr.empty?
+          fmt_code = NumberFormatter.format_code_for(style_idx, styles) if styles && style_idx
+          cell = Elements::Cell.fast_create(row_idx, c_idx, val, style_idx, formula_expr, raw_val, fmt_code, date1904)
           block.call(cell)
         end
 
@@ -670,6 +939,8 @@ module Xlsxrb
                     col_idx
                   end
           col_idx = c_idx + 1
+          v = v.strip if v
+          f = f.strip if f
 
           val = if t == "s"
                   shared_strings[v.to_i] || ""
@@ -679,7 +950,7 @@ module Xlsxrb
                   if is
                     extract_inline_text(is, 0, is.bytesize)
                   elsif v
-                    v.include?("&") ? decode_xml_entities(v) : v
+                    normalize_text(v)
                   else
                     ""
                   end
@@ -687,13 +958,145 @@ module Xlsxrb
                   v.include?(".") ? v.to_f : v.to_i
                 end
 
+          raw_val = if is
+                      extract_inline_text(is, 0, is.bytesize)
+                    elsif v
+                      normalize_text(v)
+                    end
+
           style_idx = s&.to_i
-          formula_expr = f&.include?("&") ? decode_xml_entities(f) : f
-          cell = Elements::Cell.fast_create(row_idx, c_idx, val, style_idx, formula_expr)
+          formula_expr = f ? normalize_text(f) : nil
+          formula_expr = nil if formula_expr && formula_expr.empty?
+          fmt_code = NumberFormatter.format_code_for(style_idx, styles) if styles && style_idx
+          cell = Elements::Cell.fast_create(row_idx, c_idx, val, style_idx, formula_expr, raw_val, fmt_code, date1904)
           block.call(cell)
         end
       end
 
+      # rubocop:disable Style/OptionalBooleanParameter
+      #: (String xml, Integer from, Integer to, Array[String] shared_strings, ?untyped styles, ?bool date1904, ?type_cast: bool) -> Array[untyped]
+      def self.fast_scan_row_values(xml, from, to, shared_strings, styles = nil, date1904 = false, type_cast: false)
+        # rubocop:enable Style/OptionalBooleanParameter
+        chunk = xml.byteslice(from, to - from)
+        return [] if chunk.nil? || chunk.empty?
+
+        col_idx = 0
+        matched_any = false
+        row_values = []
+
+        chunk.scan(CELL_FAST_RE) do |r, s, t, _f, v, is, self_r, self_s|
+          matched_any = true
+          ref = r || self_r
+          s_val = s || self_s
+          c_idx = if ref
+                    expected_letter = COL_LETTERS[col_idx]
+                    if expected_letter && ref.start_with?(expected_letter)
+                      col_idx
+                    else
+                      c_len = 0
+                      c_len += 1 while (b = ref.getbyte(c_len)) && (b.between?(65, 90) || b.between?(97, 122))
+                      col_letters = ref.byteslice(0, c_len).upcase
+                      COL_MAP[col_letters] || col_idx
+                    end
+                  else
+                    col_idx
+                  end
+          col_idx = c_idx + 1
+          v = v.strip if v
+
+          val = if t == "s"
+                  shared_strings[v.to_i] || ""
+                elsif t == "b"
+                  v == "1"
+                elsif %w[inlineStr str e].include?(t)
+                  if is
+                    extract_inline_text(is, 0, is.bytesize)
+                  elsif v
+                    normalize_text(v)
+                  else
+                    ""
+                  end
+                elsif v
+                  v.include?(".") ? v.to_f : v.to_i
+                end
+
+          if type_cast && val.is_a?(Numeric) && s_val && styles
+            fmt_type = NumberFormatter.format_type_for(s_val.to_i, styles)
+            begin
+              case fmt_type
+              when :date
+                val = Utils.serial_to_date(val, date1904: date1904)
+              when :datetime, :time
+                val = Utils.serial_to_datetime(val, date1904: date1904)
+              end
+            rescue StandardError
+              # Keep numeric value on conversion failure
+            end
+          end
+
+          row_values[c_idx] = val
+        end
+
+        return row_values if matched_any || (!chunk.include?("<c") && !chunk.include?(":c"))
+
+        # Fallback for non-standard attribute ordering
+        chunk.scan(CELL_GENERIC_RE) do |attrs, _f, v, is|
+          r = attrs[ATTR_R, 1]
+          t = attrs[ATTR_T, 1]
+          s = attrs[ATTR_S, 1]
+
+          c_idx = if r
+                    expected_letter = COL_LETTERS[col_idx]
+                    if expected_letter && r.start_with?(expected_letter)
+                      col_idx
+                    else
+                      c_len = 0
+                      c_len += 1 while (b = r.getbyte(c_len)) && (b.between?(65, 90) || b.between?(97, 122))
+                      col_letters = r.byteslice(0, c_len).upcase
+                      COL_MAP[col_letters] || col_idx
+                    end
+                  else
+                    col_idx
+                  end
+          col_idx = c_idx + 1
+          v = v.strip if v
+
+          val = if t == "s"
+                  shared_strings[v.to_i] || ""
+                elsif t == "b"
+                  v == "1"
+                elsif %w[inlineStr str e].include?(t)
+                  if is
+                    extract_inline_text(is, 0, is.bytesize)
+                  elsif v
+                    normalize_text(v)
+                  else
+                    ""
+                  end
+                elsif v
+                  v.include?(".") ? v.to_f : v.to_i
+                end
+
+          if type_cast && val.is_a?(Numeric) && s && styles
+            fmt_type = NumberFormatter.format_type_for(s.to_i, styles)
+            begin
+              case fmt_type
+              when :date
+                val = Utils.serial_to_date(val, date1904: date1904)
+              when :datetime, :time
+                val = Utils.serial_to_datetime(val, date1904: date1904)
+              end
+            rescue StandardError
+              # Keep numeric value on conversion failure
+            end
+          end
+
+          row_values[c_idx] = val
+        end
+
+        row_values
+      end
+
       private_class_method :fast_parse_cells_direct
     end
   end