xlsxrb 0.1.13 → 0.1.14

data/lib/xlsxrb/ooxml/worksheet_parser.rb

@@ -13,49 +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_source, shared_strings: [], part_name: "xl/worksheets/sheet1.xml", &block)
-        return enum_for(:each_row, xml_source, shared_strings: shared_strings, part_name: part_name) unless block
+      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
+
         if xml_source.is_a?(String)
-          fast_scan_rows_direct(xml_source, shared_strings, part_name, &block)
+          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, &block)
+          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.
@@ -80,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)
@@ -106,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) ----
@@ -157,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
@@ -178,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)
 
@@ -217,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
 
@@ -278,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
@@ -401,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
@@ -418,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?
 
@@ -441,6 +493,12 @@ module Xlsxrb
         XmlBuilder.unescape(str)
       end
 
+      #: (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
         include REXML::SAX2Listener
@@ -465,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
@@ -478,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")
@@ -503,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
@@ -522,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
@@ -546,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)
@@ -566,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)
 
@@ -576,7 +646,9 @@ module Xlsxrb
 
       private_class_method :fast_scan_rows_direct
 
-      def self.scan_rows_stream(source, shared_strings, _part_name, &block)
+      # 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
@@ -586,6 +658,7 @@ module Xlsxrb
         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
@@ -628,9 +701,9 @@ module Xlsxrb
 
           pos = 0
           last_consumed_pos = 0
+          sd_end_pos = buffer.index(sd_end_tag)
 
           loop do
-            sd_end_pos = buffer.index(sd_end_tag, pos)
             row_start = buffer.index(row_start_pattern, pos)
 
             if sd_end_pos && (row_start.nil? || sd_end_pos < row_start)
@@ -645,7 +718,7 @@ module Xlsxrb
             break if next_pos >= buffer.bytesize
 
             nb = buffer.getbyte(next_pos)
-            unless [32, 62, 9, 10, 13, 47].include?(nb)
+            unless TAG_DELIM_BYTES.include?(nb)
               pos = next_pos
               next
             end
@@ -666,22 +739,23 @@ module Xlsxrb
               break
             end
 
-            row_index = 0
+            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)
 
-                  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)
+                row_index = parsed_r - 1
+              elsif ROW_ATTR_START_BYTES.include?(rb)
                 has_custom_attrs = true
                 ri += 1
               else
@@ -689,6 +763,9 @@ module Xlsxrb
               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)
@@ -707,7 +784,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)
 
@@ -718,20 +800,32 @@ module Xlsxrb
           buffer.slice!(0...last_consumed_pos) if last_consumed_pos.positive?
         end
 
-        if source.respond_to?(:each_chunk)
-          source.each_chunk(65_536, &push_chunk)
-        elsif source.respond_to?(:read)
-          while (chunk = source.read(65_536))
-            break if chunk.empty?
+        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)
+              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
-        elsif source.respond_to?(:call)
-          source.call(&push_chunk)
-        elsif source.respond_to?(:each)
-          source.each(&push_chunk)
-        else
-          raise ArgumentError, "Unsupported stream source: #{source.class}"
         end
       end
 
@@ -752,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+)"/
@@ -764,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
@@ -789,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] || ""
@@ -798,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
@@ -806,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
 
@@ -833,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] || ""
@@ -842,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
@@ -850,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