xlsxrb 0.1.9 → 0.1.11

data/lib/xlsxrb/ooxml/worksheet_parser.rb

@@ -129,30 +129,41 @@ module Xlsxrb
       def self.fast_scan_events(xml_src, shared_strings, part_name, &block)
         xml = xml_src.b # force ASCII-8BIT for O(1) byte indexing
 
-        sd_start = xml.index("<sheetData")
+        sd_term = xml.index("sheetData")
+        return unless sd_term
+
+        sd_start = xml.rindex("<", sd_term)
         return unless sd_start
 
+        prefix = xml.byteslice(sd_start + 1, sd_term - (sd_start + 1))
+
         sd_open_end = xml.index(">", sd_start)
         return unless sd_open_end
 
         return if xml.getbyte(sd_open_end - 1) == 47 # self-closing <sheetData/>
 
-        sd_end = xml.index("</sheetData>", sd_open_end)
+        sd_end_tag = "</#{prefix}sheetData>"
+        sd_end = xml.index(sd_end_tag, sd_open_end)
         return unless sd_end
 
+        row_start_pattern = "<#{prefix}row"
+        row_start_len = row_start_pattern.bytesize
+        row_end_tag = "</#{prefix}row>"
+        row_end_len = row_end_tag.bytesize
+
         pos = sd_open_end + 1
 
         while pos < sd_end
-          row_start = xml.index("<row", pos)
+          row_start = xml.index(row_start_pattern, pos)
           break unless row_start && row_start < sd_end
 
-          nb = xml.getbyte(row_start + 4)
+          nb = xml.getbyte(row_start + row_start_len)
           unless [32, 62, 9, 10, 13, 47].include?(nb)
-            pos = row_start + 4
+            pos = row_start + row_start_len
             next
           end
 
-          tag_end = xml.index(">", row_start + 4)
+          tag_end = xml.index(">", row_start + row_start_len)
           break unless tag_end
 
           if xml.getbyte(tag_end - 1) == 47
@@ -168,7 +179,7 @@ module Xlsxrb
 
           attrs = extract_row_attrs(row_tag)
 
-          row_end = xml.index("</row>", tag_end + 1)
+          row_end = xml.index(row_end_tag, tag_end + 1)
           break unless row_end
 
           row_source = { part: part_name, row: row_index }
@@ -178,7 +189,7 @@ module Xlsxrb
                        source: row_source
                      ))
 
-          fast_scan_cells_events(xml, tag_end + 1, row_end, shared_strings, row_source, &block)
+          fast_scan_cells_events(xml, tag_end + 1, row_end, shared_strings, row_source, prefix, &block)
 
           block.call(Event.new(
                        type: :row_end,
@@ -186,7 +197,7 @@ module Xlsxrb
                        source: row_source
                      ))
 
-          pos = row_end + 6
+          pos = row_end + row_end_len
         end
       end
 
@@ -236,20 +247,38 @@ module Xlsxrb
 
       private_class_method :tag_attr
 
-      def self.fast_scan_cells_events(xml, from, to, shared_strings, row_source, &block)
+      def self.fast_scan_cells_events(xml, from, to, shared_strings, row_source, prefix = "", &block)
         pos = from
+        c_start_pattern = "<#{prefix}c"
+        c_start_len = c_start_pattern.bytesize
+        c_end_tag = "</#{prefix}c>"
+        c_end_len = c_end_tag.bytesize
+
+        v_tag_start_str = "<#{prefix}v>"
+        v_tag_start_len = v_tag_start_str.bytesize
+        v_tag_end_str = "</#{prefix}v>"
+        v_tag_end_len = v_tag_end_str.bytesize
+
+        is_tag_start_str = "<#{prefix}is>"
+        is_tag_start_len = is_tag_start_str.bytesize
+        is_tag_end_str = "</#{prefix}is>"
+        is_tag_end_len = is_tag_end_str.bytesize
+
+        f_tag_start_str = "<#{prefix}f"
+        f_tag_end_str = "</#{prefix}f>"
+        f_tag_end_len = f_tag_end_str.bytesize
 
         while pos < to
-          c_start = xml.index("<c", pos)
+          c_start = xml.index(c_start_pattern, pos)
           break unless c_start && c_start < to
 
-          nb = xml.getbyte(c_start + 2)
+          nb = xml.getbyte(c_start + c_start_len)
           unless [32, 62, 9, 10, 13, 47].include?(nb)
-            pos = c_start + 2
+            pos = c_start + c_start_len
             next
           end
 
-          c_tag_end = xml.index(">", c_start + 2)
+          c_tag_end = xml.index(">", c_start + c_start_len)
           break unless c_tag_end
 
           # Extract tag substring for bounded attribute search
@@ -272,7 +301,7 @@ module Xlsxrb
             next
           end
 
-          c_end = xml.index("</c>", c_tag_end + 1)
+          c_end = xml.index(c_end_tag, c_tag_end + 1)
           break unless c_end
 
           # Parse cell content sequentially (bounded to c_end - avoid unbounded scans)
@@ -284,35 +313,27 @@ module Xlsxrb
             tag_pos = xml.index("<", cpos)
             break unless tag_pos && tag_pos < c_end
 
-            tag_char = xml.getbyte(tag_pos + 1)
-            case tag_char
-            when 118 # 'v'
-              if xml.getbyte(tag_pos + 2) == 62 # <v>
-                v_val_start = tag_pos + 3
-                v_end = xml.index("</v>", v_val_start)
-                if v_end
-                  raw_value = xml.byteslice(v_val_start, v_end - v_val_start)
-                  value = resolve_fast_value(raw_value, type, shared_strings)
-                  cpos = v_end + 4
-                else
-                  cpos = tag_pos + 3
-                end
-              elsif xml.getbyte(tag_pos + 2) == 47 && xml.getbyte(tag_pos + 3) == 62 # <v/>
-                cpos = tag_pos + 4
+            if xml.byteslice(tag_pos, v_tag_start_len) == v_tag_start_str
+              v_val_start = tag_pos + v_tag_start_len
+              v_end = xml.index(v_tag_end_str, v_val_start)
+              if v_end
+                raw_value = xml.byteslice(v_val_start, v_end - v_val_start)
+                value = resolve_fast_value(raw_value, type, shared_strings)
+                cpos = v_end + v_tag_end_len
               else
-                cpos = tag_pos + 2
+                cpos = tag_pos + v_tag_start_len
               end
-            when 102 # 'f'
-              f_tag_end = xml.index(">", tag_pos + 2)
+            elsif xml.byteslice(tag_pos, f_tag_start_str.bytesize) == f_tag_start_str
+              f_tag_end = xml.index(">", tag_pos + f_tag_start_str.bytesize)
               if f_tag_end && f_tag_end < c_end
                 if xml.getbyte(f_tag_end - 1) == 47 # self-closing <f ... />
                   cpos = f_tag_end + 1
                 else
-                  f_end = xml.index("</f>", f_tag_end + 1)
+                  f_end = xml.index(f_tag_end_str, f_tag_end + 1)
                   if f_end && f_end <= c_end
                     formula = xml.byteslice(f_tag_end + 1, f_end - f_tag_end - 1).force_encoding("UTF-8")
                     formula = decode_xml_entities(formula) if formula.include?("&")
-                    cpos = f_end + 4
+                    cpos = f_end + f_tag_end_len
                   else
                     cpos = f_tag_end + 1
                   end
@@ -320,17 +341,13 @@ module Xlsxrb
               else
                 cpos = tag_pos + 2
               end
-            when 105 # 'i' - <is>
-              if xml.byteslice(tag_pos, 4) == "<is>"
-                is_end = xml.index("</is>", tag_pos + 4)
-                if is_end && is_end <= c_end
-                  inline_str = extract_inline_text(xml, tag_pos + 4, is_end)
-                  cpos = is_end + 5
-                else
-                  cpos = tag_pos + 4
-                end
+            elsif xml.byteslice(tag_pos, is_tag_start_len) == is_tag_start_str
+              is_end = xml.index(is_tag_end_str, tag_pos + is_tag_start_len)
+              if is_end && is_end <= c_end
+                inline_str = extract_inline_text(xml, tag_pos + is_tag_start_len, is_end)
+                cpos = is_end + is_tag_end_len
               else
-                cpos = tag_pos + 2
+                cpos = tag_pos + is_tag_start_len
               end
             else
               # Skip unknown tag
@@ -348,7 +365,7 @@ module Xlsxrb
                        source: cell_source
                      ))
 
-          pos = c_end + 4
+          pos = c_end + c_end_len
         end
       end
 
@@ -358,21 +375,32 @@ module Xlsxrb
         result = +""
         pos = from
         while pos < to
-          t_start = xml.index("<t", pos)
+          t_start = xml.index("<", pos)
           break unless t_start && t_start < to
 
-          t_tag_end = xml.index(">", t_start)
-          break unless t_tag_end
-          next (pos = t_start + 2) if xml.getbyte(t_tag_end - 1) == 47
+          t_term = xml.index("t", t_start)
+          break unless t_term && t_term < to
+
+          t_tag_end = xml.index(">", t_term)
+          break unless t_tag_end && t_tag_end < to
 
-          t_end = xml.index("</t>", t_tag_end + 1)
+          if xml.getbyte(t_tag_end - 1) == 47 # <t ... />
+            pos = t_tag_end + 1
+            next
+          end
+
+          t_close = xml.index("</", t_tag_end + 1)
+          break unless t_close && t_close <= to
+
+          t_end = xml.index(">", t_close + 2)
           break unless t_end && t_end <= to
 
-          result << xml.byteslice(t_tag_end + 1, t_end - t_tag_end - 1)
-          pos = t_end + 4
+          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
+
+          pos = t_end + 1
         end
-        result.force_encoding("UTF-8")
-        result = decode_xml_entities(result) if result.include?("&")
         result
       end
 
@@ -448,32 +476,43 @@ module Xlsxrb
         def characters(_text); end
       end
 
-      def self.fast_scan_rows_direct(xml_src, shared_strings, part_name, &block)
+      def self.fast_scan_rows_direct(xml_src, shared_strings, _part_name, &block)
         xml = xml_src.b # force ASCII-8BIT for O(1) byte indexing
 
-        sd_start = xml.index("<sheetData")
+        sd_term = xml.index("sheetData")
+        return unless sd_term
+
+        sd_start = xml.rindex("<", sd_term)
         return unless sd_start
 
+        prefix = xml.byteslice(sd_start + 1, sd_term - (sd_start + 1))
+
         sd_open_end = xml.index(">", sd_start)
         return unless sd_open_end
         return if xml.getbyte(sd_open_end - 1) == 47 # self-closing <sheetData/>
 
-        sd_end = xml.index("</sheetData>", sd_open_end)
+        sd_end_tag = "</#{prefix}sheetData>"
+        sd_end = xml.index(sd_end_tag, sd_open_end)
         return unless sd_end
 
+        row_start_pattern = "<#{prefix}row"
+        row_start_len = row_start_pattern.bytesize
+        row_end_tag = "</#{prefix}row>"
+        row_end_len = row_end_tag.bytesize
+
         pos = sd_open_end + 1
 
         while pos < sd_end
-          row_start = xml.index("<row", pos)
+          row_start = xml.index(row_start_pattern, pos)
           break unless row_start && row_start < sd_end
 
-          nb = xml.getbyte(row_start + 4)
+          nb = xml.getbyte(row_start + row_start_len)
           unless [32, 62, 9, 10, 13, 47].include?(nb)
-            pos = row_start + 4
+            pos = row_start + row_start_len
             next
           end
 
-          tag_end = xml.index(">", row_start + 4)
+          tag_end = xml.index(">", row_start + row_start_len)
           break unless tag_end
 
           if xml.getbyte(tag_end - 1) == 47
@@ -483,7 +522,7 @@ module Xlsxrb
 
           row_index = 0
           has_custom_attrs = false
-          ri = row_start + 4
+          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="
@@ -512,233 +551,146 @@ module Xlsxrb
                     EMPTY_HASH
                   end
 
-          row_end = xml.index("</row>", tag_end + 1)
+          row_end = xml.index(row_end_tag, tag_end + 1)
           break unless row_end
 
-          { part: part_name, row: row_index }
-          row_obj = StreamRow.new(
-            index: row_index,
-            xml_bytes: xml,
-            from: tag_end + 1,
-            to: row_end,
-            shared_strings: shared_strings,
-            height: attrs[:height],
-            hidden: attrs[:hidden] || false,
-            custom_height: attrs[:custom_height] || false,
-            outline_level: attrs[:outline_level]
+          row_obj = StreamRow.fast_create(
+            row_index,
+            xml,
+            tag_end + 1,
+            row_end,
+            shared_strings,
+            prefix,
+            attrs[:height],
+            attrs[:hidden] || false,
+            attrs[:custom_height] || false,
+            attrs[:outline_level]
           )
           block.call(row_obj)
 
-          pos = row_end + 6
+          pos = row_end + row_end_len
         end
       end
 
       private_class_method :fast_scan_rows_direct
 
-      def self.fast_parse_cells_direct(xml, from, to, shared_strings, row_source)
-        cells = []
-        fast_scan_cells_direct(xml, from, to, shared_strings, row_source) { |c| cells << c }
-        cells
-      end
-
-      def self.fast_scan_cells_direct(xml, from, to, shared_strings, row_source, &block)
-        pos = from
-        cell_count = 0
-
-        while pos < to
-          c_start = xml.index("<c", pos)
-          break unless c_start && c_start < to
+      COL_LETTERS = (0...16_384).map do |index|
+        result = +""
+        i = index
+        loop do
+          result.prepend(("A".ord + (i % 26)).chr)
+          i = (i / 26) - 1
+          break if i.negative?
+        end
+        result.freeze
+      end.freeze
 
-          nb = xml.getbyte(c_start + 2)
-          unless [32, 62, 9, 10, 13, 47].include?(nb)
-            pos = c_start + 2
-            next
-          end
+      COL_MAP = (0...16_384).to_h do |idx|
+        [COL_LETTERS[idx], idx]
+      end.freeze
 
-          c_tag_end = xml.index(">", c_start + 2)
-          break unless c_tag_end
+      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
+      ATTR_R = /r="([A-Za-z0-9]+)"/
+      ATTR_T = /t="([a-zA-Z]+)"/
+      ATTR_S = /s="(\d+)"/
 
-          # Zero-allocation attribute scan directly within the tag
-          type = nil
-          style_index = nil
-          col_idx = nil
-          row_idx = nil
-
-          ai = c_start + 2
-          while ai < c_tag_end
-            b = xml.getbyte(ai)
-            if [32, 9, 10, 13].include?(b)
-              ai += 1
-              next
-            end
+      def self.fast_parse_cells_direct(xml, from, to, shared_strings, row_source, prefix = "")
+        cells = []
+        fast_scan_cells_direct(xml, from, to, shared_strings, row_source, prefix) { |c| cells << c }
+        cells
+      end
 
-            if b == 114 && xml.getbyte(ai + 1) == 61 && xml.getbyte(ai + 2) == 34 # r="
-              ai += 3
-              col_idx = 0
-              while ai < c_tag_end
-                cb = xml.getbyte(ai)
-                if cb.between?(65, 90)
-                  col_idx = (col_idx * 26) + (cb - 64)
-                  ai += 1
-                elsif cb.between?(97, 122)
-                  col_idx = (col_idx * 26) + (cb - 96)
-                  ai += 1
-                else
-                  break
+      def self.fast_scan_cells_direct(xml, from, to, shared_strings, row_source, _prefix = "", &block)
+        chunk = xml.byteslice(from, to - from)
+        row_idx = row_source.is_a?(Hash) ? row_source[:row] : row_source
+        col_idx = 0
+        matched_any = false
+
+        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
+          style_idx = s_val&.to_i
+          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
+
+          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
+                    v.include?("&") ? decode_xml_entities(v) : v
+                  else
+                    ""
+                  end
+                elsif v
+                  v.include?(".") ? v.to_f : v.to_i
                 end
-              end
-              col_idx -= 1
-              row_idx = 0
-              while ai < c_tag_end
-                cb = xml.getbyte(ai)
-                break unless cb.between?(48, 57)
-
-                row_idx = (row_idx * 10) + (cb - 48)
-                ai += 1
-              end
-              row_idx -= 1
-              ai += 1 if xml.getbyte(ai) == 34
-            elsif b == 116 && xml.getbyte(ai + 1) == 61 && xml.getbyte(ai + 2) == 34 # t="
-              ai += 3
-              type_b = xml.getbyte(ai)
-              if type_b == 115 && xml.getbyte(ai + 1) == 34 # "s"
-                type = "s"
-                ai += 2
-              elsif type_b == 98 && xml.getbyte(ai + 1) == 34 # "b"
-                type = "b"
-                ai += 2
-              elsif type_b == 101 && xml.getbyte(ai + 1) == 34 # "e"
-                type = "e"
-                ai += 2
-              else
-                t_end = xml.index('"', ai)
-                type = xml.byteslice(ai, t_end - ai) if t_end
-                ai = t_end ? t_end + 1 : c_tag_end
-              end
-            elsif b == 115 && xml.getbyte(ai + 1) == 61 && xml.getbyte(ai + 2) == 34 # s="
-              ai += 3
-              style_index = 0
-              while ai < c_tag_end
-                cb = xml.getbyte(ai)
-                break unless cb.between?(48, 57)
 
-                style_index = (style_index * 10) + (cb - 48)
-                ai += 1
-              end
-              ai += 1 if xml.getbyte(ai) == 34
-            else
-              ai += 1
-            end
-          end
-
-          # Self-closing <c ... />
-          if xml.getbyte(c_tag_end - 1) == 47
-            cell_obj = Elements::Cell.new(
-              row_index: row_idx || row_source[:row],
-              column_index: col_idx || cell_count,
-              value: nil,
-              style_index: style_index,
-              errors: Elements::EMPTY_ERRORS
-            )
-            cell_count += 1
-            block.call(cell_obj)
-            pos = c_tag_end + 1
-            next
-          end
-
-          c_end = xml.index("</c>", c_tag_end + 1)
-          break unless c_end
-
-          # Parse cell content sequentially (bounded to c_end - avoid unbounded scans)
-          value = nil
-          formula = nil
-          inline_str = nil
-          cpos = c_tag_end + 1
-          while cpos < c_end
-            tag_pos = xml.index("<", cpos)
-            break unless tag_pos && tag_pos < c_end
+          formula_expr = f&.include?("&") ? decode_xml_entities(f) : f
+          cell = Elements::Cell.fast_create(row_idx, c_idx, val, style_idx, formula_expr)
+          block.call(cell)
+        end
 
-            tag_char = xml.getbyte(tag_pos + 1)
-            case tag_char
-            when 118 # 'v'
-              if xml.getbyte(tag_pos + 2) == 62 # <v>
-                v_val_start = tag_pos + 3
-                v_end = xml.index("</v>", v_val_start)
-                if v_end
-                  if type == "s"
-                    # Zero-allocation integer parse for SST index
-                    s_idx = 0
-                    v_i = v_val_start
-                    while v_i < v_end
-                      s_idx = (s_idx * 10) + (xml.getbyte(v_i) - 48)
-                      v_i += 1
+        return 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
-                    value = shared_strings[s_idx] || ""
-                  elsif type == "b"
-                    value = xml.getbyte(v_val_start) == 49 # '1'
                   else
-                    raw_value = xml.byteslice(v_val_start, v_end - v_val_start)
-                    value = resolve_fast_value(raw_value, type, shared_strings)
+                    col_idx
                   end
-                  cpos = v_end + 4
-                else
-                  cpos = tag_pos + 3
-                end
-              elsif xml.getbyte(tag_pos + 2) == 47 && xml.getbyte(tag_pos + 3) == 62 # <v/>
-                cpos = tag_pos + 4
-              else
-                cpos = tag_pos + 2
-              end
-            when 102 # 'f'
-              f_tag_end = xml.index(">", tag_pos + 2)
-              if f_tag_end && f_tag_end < c_end
-                if xml.getbyte(f_tag_end - 1) == 47 # self-closing <f ... />
-                  cpos = f_tag_end + 1
-                else
-                  f_end = xml.index("</f>", f_tag_end + 1)
-                  if f_end && f_end <= c_end
-                    formula = xml.byteslice(f_tag_end + 1, f_end - f_tag_end - 1).force_encoding("UTF-8")
-                    formula = decode_xml_entities(formula) if formula.include?("&")
-                    cpos = f_end + 4
+          col_idx = c_idx + 1
+
+          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
+                    v.include?("&") ? decode_xml_entities(v) : v
                   else
-                    cpos = f_tag_end + 1
+                    ""
                   end
+                elsif v
+                  v.include?(".") ? v.to_f : v.to_i
                 end
-              else
-                cpos = tag_pos + 2
-              end
-            when 105 # 'i' - <is>
-              if xml.byteslice(tag_pos, 4) == "<is>"
-                is_end = xml.index("</is>", tag_pos + 4)
-                if is_end && is_end <= c_end
-                  inline_str = extract_inline_text(xml, tag_pos + 4, is_end)
-                  cpos = is_end + 5
-                else
-                  cpos = tag_pos + 4
-                end
-              else
-                cpos = tag_pos + 2
-              end
-            else
-              # Skip unknown tag
-              close = xml.index(">", tag_pos + 1)
-              cpos = close ? close + 1 : c_end
-            end
-          end
-
-          val_to_use = inline_str || value
-          cell_obj = Elements::Cell.new(
-            row_index: row_idx || row_source[:row],
-            column_index: col_idx || cell_count,
-            value: val_to_use,
-            formula: formula,
-            style_index: style_index,
-            errors: Elements::EMPTY_ERRORS
-          )
-          cell_count += 1
-          block.call(cell_obj)
 
-          pos = c_end + 4
+          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)
+          block.call(cell)
         end
       end