xlsxrb 0.1.14 → 0.1.16

data/lib/xlsxrb/ooxml/writer/drawing_xml.rb

@@ -159,8 +159,6 @@ module Xlsxrb
                                              else
                                                ""
                                              end
-                                 head_part = build_line_end_xml("headEnd", shape[:head_end])
-                                 tail_part = build_line_end_xml("tailEnd", shape[:tail_end])
                                  join_part = case shape[:line_join]
                                              when "round" then "<a:round/>"
                                              when "bevel" then "<a:bevel/>"
@@ -168,7 +166,9 @@ module Xlsxrb
                                                shape[:line_miter_limit] ? "<a:miter lim=\"#{shape[:line_miter_limit].to_i}\"/>" : "<a:miter/>"
                                              else ""
                                              end
-                                 %(<a:ln#{ln_attrs}>#{fill_part}#{dash_part}#{head_part}#{tail_part}#{join_part}</a:ln>)
+                                 head_part = build_line_end_xml("headEnd", shape[:head_end])
+                                 tail_part = build_line_end_xml("tailEnd", shape[:tail_end])
+                                 %(<a:ln#{ln_attrs}>#{fill_part}#{dash_part}#{join_part}#{head_part}#{tail_part}</a:ln>)
                                else
                                  ""
                                end
@@ -425,14 +425,6 @@ module Xlsxrb
           attrs << %( err="1") if font[:err]
           attrs << %( bmk="#{xml_escape(font[:bmk])}") if font[:bmk]
           children = +""
-          children << %(<a:solidFill>#{color_xml(font[:color])}</a:solidFill>) if font[:color]
-          children << %(<a:highlight>#{color_xml(font[:highlight])}</a:highlight>) if font[:highlight]
-          children << %(<a:latin typeface="#{xml_escape(font[:name])}"/>) if font[:name]
-          children << %(<a:ea typeface="#{xml_escape(font[:ea_font])}"/>) if font[:ea_font]
-          children << %(<a:cs typeface="#{xml_escape(font[:cs_font])}"/>) if font[:cs_font]
-          children << %(<a:sym typeface="#{xml_escape(font[:sym_font])}"/>) if font[:sym_font]
-          children << "<a:uFillTx/>" if font[:u_fill_tx]
-          children << "<a:uLnTx/>" if font[:u_ln_tx]
           if font[:line_color] || font[:line_width] || font[:line_dash] || font[:line_cap] || font[:line_join]
             ln_attrs = +(font[:line_width] ? %( w="#{font[:line_width].to_i}") : "")
             ln_attrs << %( cap="#{xml_escape(font[:line_cap])}") if font[:line_cap]
@@ -447,6 +439,7 @@ module Xlsxrb
                       end
             children << "<a:ln#{ln_attrs}>#{ln_fill}#{ln_dash}#{ln_join}</a:ln>"
           end
+          children << %(<a:solidFill>#{color_xml(font[:color])}</a:solidFill>) if font[:color]
           if font[:outer_shadow] || font[:inner_shadow] || font[:glow] || font[:soft_edge] || font[:reflection] || font[:blur]
             eff = +""
             if font[:outer_shadow]
@@ -504,6 +497,13 @@ module Xlsxrb
             end
             children << "<a:effectLst>#{eff}</a:effectLst>"
           end
+          children << %(<a:highlight>#{color_xml(font[:highlight])}</a:highlight>) if font[:highlight]
+          children << "<a:uLnTx/>" if font[:u_ln_tx]
+          children << "<a:uFillTx/>" if font[:u_fill_tx]
+          children << %(<a:latin typeface="#{xml_escape(font[:name])}"/>) if font[:name]
+          children << %(<a:ea typeface="#{xml_escape(font[:ea_font])}"/>) if font[:ea_font]
+          children << %(<a:cs typeface="#{xml_escape(font[:cs_font])}"/>) if font[:cs_font]
+          children << %(<a:sym typeface="#{xml_escape(font[:sym_font])}"/>) if font[:sym_font]
           if children.empty?
             "<#{tag}#{attrs}/>"
           else
@@ -513,7 +513,11 @@ module Xlsxrb
 
         # : (untyped tag, untyped col, untyped row, ?col_off: ::Integer, ?row_off: ::Integer) -> ::String
         def anchor_xml(tag, col, row, col_off: 0, row_off: 0)
-          "<xdr:#{tag}><xdr:col>#{col}</xdr:col><xdr:colOff>#{col_off}</xdr:colOff><xdr:row>#{row}</xdr:row><xdr:rowOff>#{row_off}</xdr:rowOff></xdr:#{tag}>"
+          c = col.to_s.empty? ? 0 : col.to_i
+          r = row.to_s.empty? ? 0 : row.to_i
+          co = col_off.to_s.empty? ? 0 : col_off.to_i
+          ro = row_off.to_s.empty? ? 0 : row_off.to_i
+          "<xdr:#{tag}><xdr:col>#{c}</xdr:col><xdr:colOff>#{co}</xdr:colOff><xdr:row>#{r}</xdr:row><xdr:rowOff>#{ro}</xdr:rowOff></xdr:#{tag}>"
         end
 
         # : (untyped obj) -> ::String

data/lib/xlsxrb/ooxml/writer/features_xml.rb

@@ -715,7 +715,7 @@ module Xlsxrb
                        "<vt:i4>#{prop[:value]}</vt:i4>"
                      when :float, :r8
                        "<vt:r8>#{prop[:value]}</vt:r8>"
-                     when :bool
+                     when :bool, :boolean
                        "<vt:bool>#{prop[:value] ? "true" : "false"}</vt:bool>"
                      when :date, :filetime
                        "<vt:filetime>#{prop[:value]}</vt:filetime>"

data/lib/xlsxrb/ooxml/writer/styles_xml.rb

@@ -125,7 +125,10 @@ module Xlsxrb
             parts << "<colors>"
             unless @indexed_colors.empty?
               parts << "<indexedColors>"
-              @indexed_colors.each { |c| parts << %(<rgbColor rgb="#{c}"/>) }
+              @indexed_colors.each do |c|
+                rgb_str = format_rgb_hex(c) || c
+                parts << %(<rgbColor rgb="#{rgb_str}"/>)
+              end
               parts << "</indexedColors>"
             end
             unless @mru_colors.empty?
@@ -163,18 +166,63 @@ module Xlsxrb
           "<protection #{attrs.join(" ")}/>"
         end
 
-        # : (untyped source, ?tag: ::String) -> (::String | ::String | ::String | ::String | "")
+        # : (untyped rgb) -> ::String?
+        def format_rgb_hex(rgb)
+          return nil unless rgb
+
+          str = rgb.to_s.sub(/^#/, "").strip
+          return nil if str.empty?
+
+          case str
+          when /\A[0-9a-fA-F]{8}\z/
+            str.upcase
+          when /\A[0-9a-fA-F]{6}\z/
+            "FF#{str.upcase}"
+          when /\A[0-9a-fA-F]{3}\z/
+            r, g, b = str.chars
+            "FF#{r}#{r}#{g}#{g}#{b}#{b}".upcase
+          else
+            resolved = StyleBuilder.resolve_color(rgb)
+            case resolved
+            when /\A[0-9a-fA-F]{8}\z/
+              resolved.upcase
+            when /\A[0-9a-fA-F]{6}\z/
+              "FF#{resolved.upcase}"
+            end
+          end
+        end
+
+        # : (untyped source, ?tag: ::String) -> ::String
         def emit_color_xml(source, tag: "color")
-          if source[:auto]
-            %(<#{tag} auto="1"/>)
-          elsif source[:color] || source[:rgb]
-            %(<#{tag} rgb="#{source[:color] || source[:rgb]}"/>)
-          elsif source[:theme]
-            attrs = [%(theme="#{source[:theme]}")]
-            attrs << %(tint="#{source[:tint]}") if source[:tint]
-            %(<#{tag} #{attrs.join(" ")}/>)
-          elsif source[:indexed]
-            %(<#{tag} indexed="#{source[:indexed]}"/>)
+          return "" unless source
+
+          spec = if source.is_a?(Hash) && source[:color]
+                   source[:color]
+                 else
+                   source
+                 end
+
+          return "" unless spec
+
+          if spec.is_a?(Hash)
+            if spec[:auto]
+              %(<#{tag} auto="1"/>)
+            elsif spec[:rgb] || (spec[:color] && !spec[:color].is_a?(Hash))
+              raw_rgb = spec[:rgb] || spec[:color]
+              formatted_rgb = format_rgb_hex(raw_rgb)
+              formatted_rgb ? %(<#{tag} rgb="#{formatted_rgb}"/>) : ""
+            elsif spec[:theme]
+              attrs = [%(theme="#{spec[:theme]}")]
+              attrs << %(tint="#{spec[:tint]}") if spec[:tint]
+              %(<#{tag} #{attrs.join(" ")}/>)
+            elsif spec[:indexed]
+              %(<#{tag} indexed="#{spec[:indexed]}"/>)
+            else
+              ""
+            end
+          elsif spec.is_a?(String) || spec.is_a?(Symbol)
+            formatted_rgb = format_rgb_hex(spec)
+            formatted_rgb ? %(<#{tag} rgb="#{formatted_rgb}"/>) : ""
           else
             ""
           end
@@ -226,10 +274,11 @@ module Xlsxrb
           parts.join
         end
 
-        # : (untyped tag, untyped fill, untyped prefix) -> (::String | ::String | ::String | ::String | "")
+        # : (untyped tag, untyped fill, untyped prefix) -> ::String
         def emit_fill_color_xml(tag, fill, prefix)
-          if fill[:"#{prefix}_color"]
-            %(<#{tag} rgb="#{fill[:"#{prefix}_color"]}"/>)
+          val = fill[:"#{prefix}_color"]
+          if val
+            emit_color_xml(val, tag: tag)
           elsif fill[:"#{prefix}_color_theme"]
             attrs = [%(theme="#{fill[:"#{prefix}_color_theme"]}")]
             attrs << %(tint="#{fill[:"#{prefix}_color_tint"]}") if fill[:"#{prefix}_color_tint"]

data/lib/xlsxrb/ooxml/writer.rb

@@ -2691,35 +2691,38 @@ module Xlsxrb
 
         # Emit <dataValidations> if defined.
         unless sheet_dv.empty?
-          dv_container_attrs = %( count="#{sheet_dv.size}")
-          dv_container_attrs << ' disablePrompts="1"' if dv_options[:disable_prompts]
-          dv_container_attrs << %( xWindow="#{dv_options[:x_window]}") if dv_options[:x_window]
-          dv_container_attrs << %( yWindow="#{dv_options[:y_window]}") if dv_options[:y_window]
-          parts << "<dataValidations#{dv_container_attrs}>"
-          sheet_dv.each do |dv|
-            dv_attrs = %(sqref="#{dv[:sqref]}")
-            dv_attrs << %( type="#{dv[:type]}") if dv[:type]
-            dv_attrs << %( operator="#{dv[:operator]}") if dv[:operator]
-            dv_attrs << %( errorStyle="#{dv[:error_style]}") if dv[:error_style]
-            dv_attrs << ' allowBlank="1"' if dv[:allow_blank]
-            dv_attrs << ' showInputMessage="1"' if dv[:show_input_message]
-            dv_attrs << ' showErrorMessage="1"' if dv[:show_error_message]
-            dv_attrs << %( errorTitle="#{xml_escape(dv[:error_title])}") if dv[:error_title]
-            dv_attrs << %( error="#{xml_escape(dv[:error])}") if dv[:error]
-            dv_attrs << %( promptTitle="#{xml_escape(dv[:prompt_title])}") if dv[:prompt_title]
-            dv_attrs << %( prompt="#{xml_escape(dv[:prompt])}") if dv[:prompt]
-            dv_attrs << ' showDropDown="1"' if dv[:show_drop_down]
-            dv_attrs << %( imeMode="#{dv[:ime_mode]}") if dv[:ime_mode]
-            if dv[:formula1] || dv[:formula2]
-              parts << "<dataValidation #{dv_attrs}>"
-              parts << "<formula1>#{xml_escape(dv[:formula1])}</formula1>" if dv[:formula1]
-              parts << "<formula2>#{xml_escape(dv[:formula2])}</formula2>" if dv[:formula2]
-              parts << "</dataValidation>"
-            else
-              parts << "<dataValidation #{dv_attrs}/>"
+          valid_dv = sheet_dv.reject { |dv| dv[:sqref].nil? || dv[:sqref].to_s.empty? }
+          unless valid_dv.empty?
+            dv_container_attrs = %( count="#{valid_dv.size}")
+            dv_container_attrs << ' disablePrompts="1"' if dv_options[:disable_prompts]
+            dv_container_attrs << %( xWindow="#{dv_options[:x_window]}") if dv_options[:x_window]
+            dv_container_attrs << %( yWindow="#{dv_options[:y_window]}") if dv_options[:y_window]
+            parts << "<dataValidations#{dv_container_attrs}>"
+            valid_dv.each do |dv|
+              dv_attrs = %(sqref="#{dv[:sqref]}")
+              dv_attrs << %( type="#{dv[:type]}") if dv[:type]
+              dv_attrs << %( operator="#{dv[:operator]}") if dv[:operator]
+              dv_attrs << %( errorStyle="#{dv[:error_style]}") if dv[:error_style]
+              dv_attrs << ' allowBlank="1"' if dv[:allow_blank]
+              dv_attrs << ' showInputMessage="1"' if dv[:show_input_message]
+              dv_attrs << ' showErrorMessage="1"' if dv[:show_error_message]
+              dv_attrs << %( errorTitle="#{xml_escape(dv[:error_title])}") if dv[:error_title]
+              dv_attrs << %( error="#{xml_escape(dv[:error])}") if dv[:error]
+              dv_attrs << %( promptTitle="#{xml_escape(dv[:prompt_title])}") if dv[:prompt_title]
+              dv_attrs << %( prompt="#{xml_escape(dv[:prompt])}") if dv[:prompt]
+              dv_attrs << ' showDropDown="1"' if dv[:show_drop_down]
+              dv_attrs << %( imeMode="#{dv[:ime_mode]}") if dv[:ime_mode]
+              if dv[:formula1] || dv[:formula2]
+                parts << "<dataValidation #{dv_attrs}>"
+                parts << "<formula1>#{xml_escape(dv[:formula1])}</formula1>" if dv[:formula1]
+                parts << "<formula2>#{xml_escape(dv[:formula2])}</formula2>" if dv[:formula2]
+                parts << "</dataValidation>"
+              else
+                parts << "<dataValidation #{dv_attrs}/>"
+              end
             end
+            parts << "</dataValidations>"
           end
-          parts << "</dataValidations>"
         end
 
         # Emit <printOptions> if defined.
@@ -2754,7 +2757,7 @@ module Xlsxrb
           ps_attrs << 'blackAndWhite="1"' if sheet_ps[:black_and_white]
           ps_attrs << 'draft="1"' if sheet_ps[:draft]
           ps_attrs << %(cellComments="#{sheet_ps[:cell_comments]}") if sheet_ps[:cell_comments]
-          ps_attrs << %(firstPageNumber="#{sheet_ps[:first_page_number]}") if sheet_ps[:first_page_number]
+          ps_attrs << %(firstPageNumber="#{sheet_ps[:first_page_number]}") if sheet_ps[:first_page_number] && sheet_ps[:first_page_number].to_i >= 0
           ps_attrs << 'useFirstPageNumber="1"' if sheet_ps[:use_first_page_number]
           ps_attrs << %(horizontalDpi="#{sheet_ps[:horizontal_dpi]}") if sheet_ps[:horizontal_dpi]
           ps_attrs << %(verticalDpi="#{sheet_ps[:vertical_dpi]}") if sheet_ps[:vertical_dpi]

data/lib/xlsxrb/ooxml/xml_builder.rb

@@ -118,14 +118,34 @@ module Xlsxrb
         str.match?(ESCAPE_RE) ? str.gsub(ESCAPE_RE, ESCAPE_MAP) : str
       end
 
-      # Unescapes predefined XML entities in a string in a single pass.
+      NUM_ENTITY_RE = /&#(?:(\d+)|x([0-9a-fA-F]+));/
+      XSTRING_RE = /_x([0-9A-Fa-f]{4})_/
+      private_constant :NUM_ENTITY_RE, :XSTRING_RE
+
+      # Unescapes predefined and numeric/hex XML entities, as well as
+      # ISO/IEC 29500-1 ST_Xstring (_xHHHH_) control character sequences.
       #
       # @param value [Object]
       # @return [String]
       #: (untyped value) -> String
       def self.unescape(value)
         str = value.to_s
-        str.include?("&") ? str.gsub(UNESCAPE_RE, UNESCAPE_MAP) : str
+        return str unless str.include?("&") || str.include?("_x")
+
+        res = str.gsub(UNESCAPE_RE, UNESCAPE_MAP)
+        res = res.gsub(NUM_ENTITY_RE) do |match|
+          dec = Regexp.last_match(1)
+          codepoint = dec ? Integer(dec) : Integer(Regexp.last_match(2), 16)
+          codepoint.chr(Encoding::UTF_8)
+        rescue RangeError
+          match
+        end
+        res.gsub(XSTRING_RE) do |match|
+          codepoint = Integer(Regexp.last_match(1), 16)
+          codepoint.chr(Encoding::UTF_8)
+        rescue RangeError
+          match
+        end
       end
 
       private

data/lib/xlsxrb/ooxml/xml_parser.rb

@@ -5,6 +5,51 @@
 require "rexml/parsers/sax2parser"
 require "rexml/sax2listener"
 
+# Ensure REXML constants and security limits are accessible across Ractors
+begin
+  if defined?(Ractor)
+    Ractor.make_shareable(REXML::Parsers::BaseParser::DEFAULT_ENTITIES) if defined?(REXML::Parsers::BaseParser::DEFAULT_ENTITIES) && !Ractor.shareable?(REXML::Parsers::BaseParser::DEFAULT_ENTITIES)
+    if defined?(REXML::Source) && REXML::Source.const_defined?(:Private)
+      priv = REXML::Source.const_get(:Private)
+      if priv.const_defined?(:PRE_DEFINED_TERM_PATTERNS)
+        terms = priv.const_get(:PRE_DEFINED_TERM_PATTERNS)
+        Ractor.make_shareable(terms) unless Ractor.shareable?(terms)
+      end
+    end
+    if defined?(REXML::Security)
+      prev_verbose = $VERBOSE
+      $VERBOSE = nil
+      begin
+        REXML::Security.instance_eval do
+          @entity_expansion_limit = 10_000
+          @entity_expansion_text_limit = 10_240
+
+          def self.entity_expansion_limit
+            @entity_expansion_limit || 10_000
+          end
+
+          def self.entity_expansion_limit=(val)
+            @entity_expansion_limit = val
+          end
+
+          def self.entity_expansion_text_limit
+            @entity_expansion_text_limit || 10_240
+          end
+
+          def self.entity_expansion_text_limit=(val)
+            @entity_expansion_text_limit = val
+          end
+        end
+        Ractor.make_shareable(REXML::Security)
+      ensure
+        $VERBOSE = prev_verbose
+      end
+    end
+  end
+rescue StandardError
+  # Best-effort Ractor isolation preparation for standard library REXML
+end
+
 module Xlsxrb
   module Ooxml
     # Thin wrapper around REXML SAX2 parser for streaming XML processing.

data/lib/xlsxrb/ooxml/zip_reader.rb

@@ -11,7 +11,7 @@ module Xlsxrb
     # Reads ZIP archives using only stdlib (zlib).
     # Supports streaming entry decompression with bounded memory consumption.
     class ZipReader
-      LOCAL_HEADER_SIG = "PK\x03\x04".b
+      LOCAL_HEADER_SIG = "PK\x03\x04".b.freeze
       MAX_UNCOMPRESSED_SIZE = 500 * 1024 * 1024 # 500MB per file limit
       attr_accessor :max_uncompressed_size
 
@@ -37,14 +37,15 @@ module Xlsxrb
 
         attr_reader :data_offset, :compressed_size, :compression_method
 
-        #: (untyped io, Integer data_offset, Integer compressed_size, Integer compression_method, ?max_uncompressed_size: Integer?) -> void
-        def initialize(io, data_offset, compressed_size, compression_method, max_uncompressed_size: nil)
+        #: (untyped io, Integer data_offset, Integer compressed_size, Integer compression_method, ?max_uncompressed_size: Integer?, ?encoding: Encoding?) -> void
+        def initialize(io, data_offset, compressed_size, compression_method, max_uncompressed_size: nil, encoding: nil)
           @io = io
           @data_offset = data_offset
           @compressed_size = compressed_size
           @compression_method = compression_method
           @max_uncompressed_size = max_uncompressed_size || ZipReader::MAX_UNCOMPRESSED_SIZE
-          @buffer = +""
+          @encoding = encoding
+          @buffer = +"".b
           @bytes_read_compressed = 0
           @total_uncompressed = 0
           @eof = false
@@ -60,15 +61,16 @@ module Xlsxrb
           check_bom_encoding!
 
           if length.nil?
-            result = @buffer.dup
-            @buffer.clear
+            result = @buffer.b
+            @buffer = +"".b
             while (chunk = fetch_chunk(DEFAULT_CHUNK_SIZE))
               result << chunk
             end
+            result.force_encoding(@encoding) if @encoding
             return result
           end
 
-          return "" if length.zero?
+          return "".force_encoding(@encoding || Encoding::BINARY) if length.zero?
 
           while @buffer.bytesize < length && !@eof
             chunk = fetch_chunk([length - @buffer.bytesize, DEFAULT_CHUNK_SIZE].max)
@@ -79,7 +81,9 @@ module Xlsxrb
 
           return nil if @buffer.empty? && @eof
 
-          @buffer.slice!(0, length)
+          sliced = @buffer.slice!(0, length)
+          sliced.force_encoding(@encoding) if @encoding && sliced
+          sliced
         end
 
         #: (?Integer chunk_size) ?{ (String) -> void } -> (void | Enumerator[String, void])
@@ -142,7 +146,7 @@ module Xlsxrb
 
             @bytes_read_compressed += raw.bytesize
             @total_uncompressed += raw.bytesize
-            raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{@max_uncompressed_size} bytes" if @total_uncompressed > @max_uncompressed_size
+            raise ZipBombError, "ZIP bomb detected: Uncompressed size exceeds #{@max_uncompressed_size} bytes" if @total_uncompressed > @max_uncompressed_size
 
             raw
           elsif @compression_method == 8
@@ -176,7 +180,7 @@ module Xlsxrb
             @eof = true if @inflater&.finished?
 
             @total_uncompressed += inflated.bytesize
-            raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{@max_uncompressed_size} bytes" if @total_uncompressed > @max_uncompressed_size
+            raise ZipBombError, "ZIP bomb detected: Uncompressed size exceeds #{@max_uncompressed_size} bytes" if @total_uncompressed > @max_uncompressed_size
 
             inflated.empty? && @eof ? nil : inflated
           else
@@ -194,25 +198,25 @@ module Xlsxrb
 
           raw_b = peek.b
           if raw_b.start_with?("\xFF\xFE".b)
-            rest = +""
+            rest = +"".b
             while (chunk = fetch_chunk(DEFAULT_CHUNK_SIZE))
               rest << chunk
             end
             full = (peek + rest).force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8).delete_prefix("\uFEFF")
-            @buffer = full
+            @buffer = full.b
             @eof = true
           elsif raw_b.start_with?("\xFE\xFF".b)
-            rest = +""
+            rest = +"".b
             while (chunk = fetch_chunk(DEFAULT_CHUNK_SIZE))
               rest << chunk
             end
             full = (peek + rest).force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8).delete_prefix("\uFEFF")
-            @buffer = full
+            @buffer = full.b
             @eof = true
           elsif raw_b.start_with?("\xEF\xBB\xBF".b)
-            @buffer << peek.b.delete_prefix("\xEF\xBB\xBF".b).force_encoding(Encoding::UTF_8)
+            @buffer << peek.b.delete_prefix("\xEF\xBB\xBF".b)
           else
-            @buffer << peek
+            @buffer << peek.b
           end
         end
       end
@@ -291,20 +295,35 @@ module Xlsxrb
       end
 
       # Opens an EntryStreamIO for an entry by name.
-      #: (String entry_name) -> EntryStreamIO
-      def open_entry_io(entry_name)
+      #: (String entry_name, ?encoding: (Encoding | String | false | nil)) -> EntryStreamIO
+      def open_entry_io(entry_name, encoding: nil)
         entry = lookup_entry(entry_name)
-        raise ArgumentError, "Entry not found in archive: #{entry_name}" unless entry
+        raise ZipError, "Entry not found in archive: #{entry_name}" unless entry
 
-        EntryStreamIO.new(io, entry.data_offset, entry.compressed_size, entry.method, max_uncompressed_size: @max_uncompressed_size)
+        resolved_encoding = if encoding == false
+                              nil
+                            elsif encoding
+                              encoding.is_a?(String) ? Encoding.find(encoding) : encoding
+                            elsif entry_name.end_with?(".xml", ".rels") || entry.name.end_with?(".xml", ".rels")
+                              Encoding::UTF_8
+                            end
+
+        EntryStreamIO.new(
+          io,
+          entry.data_offset,
+          entry.compressed_size,
+          entry.method,
+          max_uncompressed_size: @max_uncompressed_size,
+          encoding: resolved_encoding
+        )
       end
 
       # Yields inflated binary chunks directly from the compressed stream.
-      #: (String entry_name, ?chunk_size: Integer) ?{ (String) -> void } -> (void | Enumerator[String, void])
-      def each_entry_chunk(entry_name, chunk_size: 65_536, &block)
-        return enum_for(:each_entry_chunk, entry_name, chunk_size: chunk_size) unless block
+      #: (String entry_name, ?chunk_size: Integer, ?encoding: (Encoding | String | false | nil)) ?{ (String) -> void } -> (void | Enumerator[String, void])
+      def each_entry_chunk(entry_name, chunk_size: 65_536, encoding: nil, &block)
+        return enum_for(:each_entry_chunk, entry_name, chunk_size: chunk_size, encoding: encoding) unless block
 
-        stream = open_entry_io(entry_name)
+        stream = open_entry_io(entry_name, encoding: encoding)
         begin
           stream.each_chunk(chunk_size, &block)
         ensure
@@ -334,7 +353,7 @@ module Xlsxrb
       #: (String entry_name, ZipWriter writer, ?target_path: String?) -> void
       def copy_to_writer(entry_name, writer, target_path: nil)
         entry = lookup_entry(entry_name)
-        raise ArgumentError, "Entry not found in archive: #{entry_name}" unless entry
+        raise ZipError, "Entry not found in archive: #{entry_name}" unless entry
 
         if entry.compressed_size.zero? && entry.uncompressed_size.positive?
           data = read_entry(entry_name)
@@ -391,13 +410,13 @@ module Xlsxrb
 
       def parse_catalog
         first_sig = io.read(4)
-        raise ArgumentError, "Invalid magic number: Expected a valid ZIP/XLSX file format (PK\\x03\\x04)" unless first_sig == LOCAL_HEADER_SIG
+        raise ZipError, "Invalid magic number: Expected a valid ZIP/XLSX file format (PK\\x03\\x04)" unless first_sig == LOCAL_HEADER_SIG
 
         # Try Central Directory first
         cd_catalog = parse_catalog_from_central_directory(io)
         return cd_catalog if cd_catalog && !cd_catalog.empty?
 
-        io.seek(-4, IO::SEEK_CUR) if io.respond_to?(:seek)
+        io.seek(0, IO::SEEK_SET) if io.respond_to?(:seek)
         parse_catalog_from_local_headers(io)
       end
 
@@ -437,7 +456,10 @@ module Xlsxrb
 
           _v_made, _v_need, _gp, method, _time, _date, crc, csize, usize, nlen, elen, clen, _dnum, _iattr, _eattr, offset = cd_header.unpack("vvvvvvVVVvvvvvVV")
           entry_name = io.read(nlen).force_encoding("UTF-8")
-          io.read(elen + clen)
+          extra_data = elen.positive? ? io.read(elen) : nil
+          io.read(clen) if clen.positive?
+
+          usize, csize, offset = parse_zip64_extra(extra_data, usize, csize, offset) if extra_data && (usize == 0xFFFF_FFFF || csize == 0xFFFF_FFFF || offset == 0xFFFF_FFFF)
 
           norm_name = normalize_entry_name(entry_name)
           next if norm_name.end_with?("/")
@@ -496,7 +518,8 @@ module Xlsxrb
           extra_len       = header[24, 2].unpack1("v")
 
           entry_name = io.read(name_len).force_encoding("UTF-8")
-          io.read(extra_len)
+          extra_data = extra_len.positive? ? io.read(extra_len) : nil
+          uncompressed_size, compressed_size, = parse_zip64_extra(extra_data, uncompressed_size, compressed_size, 0) if extra_data && (uncompressed_size == 0xFFFF_FFFF || compressed_size == 0xFFFF_FFFF)
           data_offset = io.pos
 
           norm_name = normalize_entry_name(entry_name)
@@ -550,7 +573,7 @@ module Xlsxrb
 
               inflated = inflater.inflate(chunk)
               limit = @max_uncompressed_size || MAX_UNCOMPRESSED_SIZE
-              raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{limit} bytes" if result.bytesize + inflated.bytesize > limit
+              raise ZipBombError, "ZIP bomb detected: Uncompressed size exceeds #{limit} bytes" if result.bytesize + inflated.bytesize > limit
 
               result << inflated
             end
@@ -602,13 +625,13 @@ module Xlsxrb
           while offset < raw_len
             chunk = raw.byteslice(offset, chunk_size)
             inflated = inflater.inflate(chunk)
-            raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{limit} bytes" if result.bytesize + inflated.bytesize > limit
+            raise ZipBombError, "ZIP bomb detected: Uncompressed size exceeds #{limit} bytes" if result.bytesize + inflated.bytesize > limit
 
             result << inflated
             offset += chunk_size
           end
           inflated = inflater.finish
-          raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{limit} bytes" if result.bytesize + inflated.bytesize > limit
+          raise ZipBombError, "ZIP bomb detected: Uncompressed size exceeds #{limit} bytes" if result.bytesize + inflated.bytesize > limit
 
           result << inflated
         ensure
@@ -645,6 +668,34 @@ module Xlsxrb
           data.force_encoding(Encoding::UTF_8)
         end
       end
+
+      #: (String extra_data, Integer usize, Integer csize, Integer offset) -> [Integer, Integer, Integer]
+      def parse_zip64_extra(extra_data, usize, csize, offset)
+        pos = 0
+        len = extra_data.bytesize
+        while pos + 4 <= len
+          header_id, data_size = extra_data.byteslice(pos, 4).unpack("vv")
+          pos += 4
+          if header_id == 0x0001
+            field_data = extra_data.byteslice(pos, data_size)
+            if field_data
+              fpos = 0
+              if usize == 0xFFFF_FFFF && fpos + 8 <= field_data.bytesize
+                usize = field_data.byteslice(fpos, 8).unpack1("Q<")
+                fpos += 8
+              end
+              if csize == 0xFFFF_FFFF && fpos + 8 <= field_data.bytesize
+                csize = field_data.byteslice(fpos, 8).unpack1("Q<")
+                fpos += 8
+              end
+              offset = field_data.byteslice(fpos, 8).unpack1("Q<") if offset == 0xFFFF_FFFF && fpos + 8 <= field_data.bytesize
+            end
+            break
+          end
+          pos += data_size
+        end
+        [usize, csize, offset]
+      end
     end
   end
 end

data/lib/xlsxrb/stream_row.rb

@@ -33,13 +33,14 @@ module Xlsxrb
     # @param collapsed [Boolean] Whether the row is collapsed.
     # @param outline_level [Integer, nil] Grouping/outline level.
     # @param style_index [Integer, nil] Style index.
+    # @param styles [Elements::Styles, Hash, nil] Optional parsed styles.
     # @param date1904 [Boolean] Whether the 1904 date system is active.
     # @param pad_empty_cells [Boolean] Whether missing cells in this row are padded.
-    #: (index: Integer, xml_bytes: String, from: Integer, to: Integer, shared_strings: Array[String], ?prefix: String, ?height: Float | Integer | nil, ?hidden: bool, ?custom_height: bool, ?collapsed: bool, ?outline_level: Integer | nil, ?style_index: Integer | nil, ?styles: Hash[untyped, untyped]?, ?date1904: bool, ?pad_empty_cells: bool) -> void
+    #: (index: Integer, xml_bytes: String, from: Integer, to: Integer, shared_strings: Array[String], ?prefix: String, ?height: Float | Integer | nil, ?hidden: bool, ?custom_height: bool, ?collapsed: bool, ?outline_level: Integer | nil, ?style_index: Integer | nil, ?styles: (Elements::Styles | Hash[untyped, untyped])?, ?date1904: bool, ?pad_empty_cells: bool) -> void
     def initialize(index:, xml_bytes:, from:, to:, shared_strings:, prefix: "", height: nil, hidden: false,
                    custom_height: false, collapsed: false, outline_level: nil, style_index: nil, styles: nil, date1904: false, pad_empty_cells: false)
       @index = index
-      @xml = xml_bytes
+      @xml = xml_bytes.encoding == Encoding::BINARY ? xml_bytes : xml_bytes.b
       @from = from
       @to = to
       @shared_strings = shared_strings
@@ -60,7 +61,7 @@ module Xlsxrb
     def self.fast_create(index, xml_bytes, from, to, shared_strings, prefix = "", height = nil, hidden = false, custom_height = false, outline_level = nil, style_index = nil, styles = nil, date1904 = false, collapsed = false, pad_empty_cells = false)
       inst = allocate
       inst.instance_variable_set(:@index, index)
-      inst.instance_variable_set(:@xml, xml_bytes)
+      inst.instance_variable_set(:@xml, xml_bytes.encoding == Encoding::BINARY ? xml_bytes : xml_bytes.b)
       inst.instance_variable_set(:@from, from)
       inst.instance_variable_set(:@to, to)
       inst.instance_variable_set(:@shared_strings, shared_strings)