omnizip 0.4.7-aarch64-linux

data/lib/omnizip/algorithms/zstandard/encoder.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      # Pure Ruby Zstandard encoder (RFC 8878).
+      #
+      # Emits a single-segment frame. Each 128 KiB chunk becomes one
+      # block, choosing whichever is smallest: RLE, a Compressed_Block
+      # (LZ77 match finding + Huffman literals + FSE-coded sequences),
+      # or a Raw_Block fallback for incompressible data. The match
+      # finder works over absolute positions, so blocks can reference
+      # earlier blocks; repeat-offset state is carried between blocks
+      # exactly as the decoder tracks it.
+      class Encoder
+        include Constants
+
+        attr_reader :output_stream, :options
+
+        # Initialize encoder
+        #
+        # @param output_stream [IO] output for compressed data
+        # @param options [Hash]
+        # @option options [Integer] :level compression level (1-22)
+        # @option options [Boolean] :checksum write the frame checksum
+        def initialize(output_stream, options = {})
+          @output_stream = output_stream
+          @options = options
+          @level = options[:level] || DEFAULT_LEVEL
+          @checksum = options.fetch(:checksum, false)
+        end
+
+        # Encode a data stream
+        #
+        # @param data [String]
+        def encode_stream(data)
+          data = data.dup.force_encoding(Encoding::BINARY)
+          write_frame(data)
+        end
+
+        # Encode a data stream primed with a dictionary prefix (port
+        # of the Rust encode_frame_with_dict): the dictionary content
+        # is prepended as virtual history, the match finder is seeded
+        # with its positions, and only the plaintext is emitted.
+        # Frame_Content_Size and the checksum cover the plaintext
+        # only; the frame header carries the dictionary's ID and
+        # requires the dict-aware decoder.
+        #
+        # @param data [String]
+        # @param dict [Dictionary]
+        def encode_stream_with_dict(data, dict)
+          data = data.dup.force_encoding(Encoding::BINARY)
+          virtual = dict.content + data
+          prefix_len = dict.content.bytesize
+
+          write_u32le(MAGIC_NUMBER)
+          write_frame_header(data, dict.id)
+          write_blocks(virtual, prefix_len)
+          write_u32le(XXHash64.frame_checksum(data)) if @checksum
+        end
+
+        private
+
+        def write_frame(data, dict = nil)
+          write_u32le(MAGIC_NUMBER)
+          write_frame_header(data, dict && dict.id)
+          write_blocks(data)
+          write_u32le(XXHash64.frame_checksum(data)) if @checksum
+        end
+
+        # Single-segment frame header: no window descriptor;
+        # optional Dictionary_ID, then Frame_Content_Size in 1, 2, 4
+        # or 8 bytes.
+        def write_frame_header(data, dict_id = nil)
+          did_flag, did_bytes = dict_id_encoding(dict_id)
+
+          size = data.bytesize
+          if size < 256
+            @output_stream.putc(0x20 | did_flag) # single segment, FCS 1 byte
+            write_dict_id_bytes(did_bytes)
+            @output_stream.putc(size)
+          elsif size <= 65_791
+            @output_stream.putc(0x60 | did_flag) # single segment, FCS 2 bytes
+            write_dict_id_bytes(did_bytes)
+            write_u16le(size - 256)
+          elsif size <= 0xFFFFFFFF
+            @output_stream.putc(0xA0 | did_flag) # single segment, FCS 4 bytes
+            write_dict_id_bytes(did_bytes)
+            write_u32le(size)
+          else
+            @output_stream.putc(0xE0 | did_flag) # single segment, FCS 8 bytes
+            write_dict_id_bytes(did_bytes)
+            write_u64le(size)
+          end
+        end
+
+        def dict_id_encoding(dict_id)
+          return [0, "".b] if dict_id.nil? || dict_id.zero?
+          return [1, [dict_id].pack("C")] if dict_id <= 0xFF
+          return [2, [dict_id].pack("v")] if dict_id <= 0xFFFF
+
+          [3, [dict_id].pack("V")]
+        end
+
+        def write_dict_id_bytes(bytes)
+          @output_stream.write(bytes)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize
+        def write_blocks(data, start = 0)
+          return write_empty_last_block if data.bytesize <= start
+
+          params = MatchFinder.params_for_level(@level, data.bytesize)
+          ms = MatchFinder::MatchState.new(params[:hash_log])
+          ms.enable_chain(params[:chain]) if params[:chain].positive?
+          ms.seed_prefix(data, start) if start.positive?
+
+          # LDM (long-distance matching) at high levels on multi-block
+          # inputs: a sparse table over the whole frame finds matches
+          # beyond the 128 KiB block window. Chains are disabled —
+          # the chain table is block-sized and LDM provides the
+          # long-distance coverage instead (Rust reference behavior).
+          ldm = nil
+          max_distance = BLOCK_MAX_SIZE
+          if @level >= LDM_MIN_LEVEL && data.bytesize > BLOCK_MAX_SIZE
+            window_log = data.bytesize.bit_length.clamp(10, 31)
+            ldm = LdmHashTable.new(data.bytesize, window_log)
+            (0...data.bytesize).each { |pos| ldm.insert(data, pos) }
+            ms.disable_chain
+            max_distance = data.bytesize
+          end
+
+          # Wire repeat-offset state carried across blocks; matches the
+          # decoder's executor state. Raw and RLE blocks leave it
+          # untouched.
+          reps = [1, 4, 8]
+
+          offset = start
+          while offset < data.bytesize
+            block_end = [offset + BLOCK_MAX_SIZE, data.bytesize].min
+            is_last = block_end == data.bytesize
+            chunk = data.byteslice(offset, block_end - offset)
+
+            # Adaptive splitting (port of the Rust reference): a
+            # heterogeneous chunk — first and second halves' byte
+            # distributions diverge — is split into 16 KiB sub-blocks
+            # so each Huffman/FSE table fits its region; homogeneous
+            # chunks keep the single block and its minimal header
+            # overhead.
+            step = if chunk.bytesize >= 32 * 1024 &&
+                halves_diverge(chunk)
+                     16 * 1024
+                   else
+                     chunk.bytesize
+                   end
+
+            sub = offset
+            while sub < block_end
+              sub_end = [sub + step, block_end].min
+              sub_last = is_last && sub_end == block_end
+              sub_chunk = data.byteslice(sub, sub_end - sub)
+
+              if sub_chunk.bytesize >= 4 && rle_chunk?(sub_chunk)
+                write_block_header(sub_last ? 1 : 0, BLOCK_TYPE_RLE,
+                                   sub_chunk.bytesize)
+                @output_stream.putc(sub_chunk.getbyte(0))
+              else
+                seq_store = MatchFinder::SeqStore.new(reps.dup)
+                MatchFinder.compress_range(data, sub, sub_end, seq_store,
+                                           ms, params[:min_match],
+                                           params[:lazy], ldm, max_distance)
+                content, new_reps = try_compressed(seq_store, reps)
+                if content.nil?
+                  write_block_header(sub_last ? 1 : 0, BLOCK_TYPE_RAW,
+                                     sub_chunk.bytesize)
+                  @output_stream.write(sub_chunk)
+                else
+                  write_block_header(sub_last ? 1 : 0,
+                                     BLOCK_TYPE_COMPRESSED,
+                                     content.bytesize)
+                  @output_stream.write(content)
+                  reps = new_reps
+                end
+              end
+
+              sub = sub_end
+            end
+
+            offset = block_end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def write_empty_last_block
+          write_block_header(1, BLOCK_TYPE_RAW, 0)
+        end
+
+        # Whether the byte distributions of a chunk's halves diverge
+        # (total-variation sum above 0.5 = "different content
+        # regimes", per the Rust reference).
+        def halves_diverge(chunk)
+          mid = chunk.bytesize / 2
+          ha = Array.new(256, 0)
+          hb = Array.new(256, 0)
+          chunk.byteslice(0, mid).each_byte { |b| ha[b] += 1 }
+          chunk.byteslice(mid, chunk.bytesize - mid).each_byte { |b| hb[b] += 1 }
+          la = mid.to_f
+          lb = (chunk.bytesize - mid).to_f
+          tvd = 0.0
+          256.times { |i| tvd += ((ha[i] / la) - (hb[i] / lb)).abs }
+          tvd > 0.5
+        end
+
+        # Build a Compressed_Block content: literals section plus the
+        # sequences section. Returns [content, wire_reps], or [nil,
+        # nil] when the result is not smaller than the raw chunk.
+        #
+        # The chunk's decompressed size is the literal bytes plus every
+        # sequence's match length.
+        #
+        # @param initial_reps [Array<Integer>] wire rep state the
+        #   decoder holds before this block
+        def try_compressed(seq_store, initial_reps)
+          literals_section = LiteralsEncoder.encode(seq_store.literals)
+          sequences_section, wire_reps =
+            SequencesEncoder.encode_section(seq_store, initial_reps)
+          content = literals_section + sequences_section
+          chunk_size = seq_store.literals.bytesize +
+            seq_store.sequences.sum(&:match_length)
+          return [nil, nil] if content.bytesize >= chunk_size
+
+          [content, wire_reps]
+        rescue Omnizip::CompressionError
+          [nil, nil]
+        end
+
+        def rle_chunk?(chunk)
+          first = chunk.getbyte(0)
+          idx = 1
+          while idx < chunk.bytesize
+            return false if chunk.getbyte(idx) != first
+
+            idx += 1
+          end
+          true
+        end
+
+        def write_block_header(last, type, size)
+          header = (last & 1) | (type << 1) | (size << 3)
+          @output_stream.putc(header & 0xFF)
+          @output_stream.putc((header >> 8) & 0xFF)
+          @output_stream.putc((header >> 16) & 0xFF)
+        end
+
+        def write_u16le(value)
+          @output_stream.putc(value & 0xFF)
+          @output_stream.putc((value >> 8) & 0xFF)
+        end
+
+        def write_u32le(value)
+          @output_stream.putc(value & 0xFF)
+          @output_stream.putc((value >> 8) & 0xFF)
+          @output_stream.putc((value >> 16) & 0xFF)
+          @output_stream.putc((value >> 24) & 0xFF)
+        end
+
+        def write_u64le(value)
+          8.times { |i| @output_stream.putc((value >> (8 * i)) & 0xFF) }
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard/frame/block.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      module Frame
+        # Zstandard block header parser (RFC 8878 Section 3.1.1.2)
+        #
+        # Block_Header structure (3 bytes, little-endian):
+        # - Last_Block: bit 0
+        # - Block_Type: bits 1-2
+        # - Block_Size: bits 3-23
+        class Block
+          include Constants
+
+          # @return [Boolean] True if this is the last block
+          attr_reader :last_block
+
+          # @return [Integer] Block type (0=Raw, 1=RLE, 2=Compressed, 3=Reserved)
+          attr_reader :block_type
+
+          # @return [Integer] Block size in bytes
+          attr_reader :block_size
+
+          # @return [Integer] Block header bytes
+          attr_reader :raw_header
+
+          # Parse block header from input
+          #
+          # @param input [IO] Input stream positioned at block header
+          # @return [Block] Parsed block header
+          def self.parse(input)
+            bytes = input.read(3)
+            # Read 3 bytes as little-endian 24-bit value
+            raw = bytes.nil? ? 0 : (bytes.getbyte(0) | (bytes.getbyte(1) << 8) | (bytes.getbyte(2) << 16))
+            last_block = raw.allbits?(0x01)
+            block_type = (raw >> 1) & 0x03
+            block_size = (raw >> 3) & 0x1FFFFF
+
+            new(last_block, block_type, block_size, raw)
+          end
+
+          # Parse block header from a byte string.
+          #
+          # @param data [String]
+          # @param pos [Integer] offset of the 3-byte header
+          # @return [Array(Block, Integer)] block and position after the
+          #   header
+          def self.parse_from(data, pos)
+            raw = data.getbyte(pos) |
+              (data.getbyte(pos + 1) << 8) |
+              (data.getbyte(pos + 2) << 16)
+            last_block = raw.allbits?(0x01)
+            block_type = (raw >> 1) & 0x03
+            block_size = (raw >> 3) & 0x1FFFFF
+
+            [new(last_block, block_type, block_size, raw), pos + 3]
+          end
+
+          # Initialize with parsed values
+          #
+          # @param last_block [Boolean]
+          # @param block_type [Integer]
+          # @param block_size [Integer]
+          # @param raw_header [Integer]
+          def initialize(last_block, block_type, block_size, raw_header)
+            @last_block = last_block
+            @block_type = block_type
+            @block_size = block_size
+            @raw_header = raw_header
+          end
+
+          # Check if this is a raw (uncompressed) block
+          #
+          # @return [Boolean]
+          def raw?
+            @block_type == BLOCK_TYPE_RAW
+          end
+
+          # Check if this is an RLE block
+          #
+          # @return [Boolean]
+          def rle?
+            @block_type == BLOCK_TYPE_RLE
+          end
+
+          # Check if this is a compressed block
+          #
+          # @return [Boolean]
+          def compressed?
+            @block_type == BLOCK_TYPE_COMPRESSED
+          end
+
+          # Check if block type is reserved
+          #
+          # @return [Boolean]
+          def reserved?
+            @block_type == BLOCK_TYPE_RESERVED
+          end
+
+          # Validate block type
+          #
+          # @return [Boolean] True if block type is valid
+          def valid?
+            !reserved?
+          end
+
+          # Get block type name
+          #
+          # @return [Symbol]
+          def type_name
+            case @block_type
+            when BLOCK_TYPE_RAW then :raw
+            when BLOCK_TYPE_RLE then :rle
+            when BLOCK_TYPE_COMPRESSED then :compressed
+            when BLOCK_TYPE_RESERVED then :reserved
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard/frame/header.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      module Frame
+        # Zstandard frame header parser (RFC 8878 Section 3.1.1.1)
+        #
+        # Frame_Header structure:
+        # - Frame_Header_Descriptor: 1 byte
+        # - Window_Descriptor: 0-1 byte (optional)
+        # - Dictionary_ID: 0-4 bytes (optional)
+        # - Frame_Content_Size: 0-8 bytes (optional)
+        class Header
+          include Constants
+
+          # @return [Integer] Frame content size flag (bits 6-7)
+          attr_reader :content_size_flag
+
+          # @return [Boolean] Single segment flag (bit 5)
+          attr_reader :single_segment
+
+          # @return [Integer] Content checksum flag (bit 2)
+          attr_reader :checksum_flag
+
+          # @return [Integer] Dictionary ID flag (bits 0-1)
+          attr_reader :dictionary_id_flag
+
+          # @return [Integer, nil] Window log value
+          attr_reader :window_log
+
+          # @return [Integer, nil] Dictionary ID
+          attr_reader :dictionary_id
+
+          # @return [Integer, nil] Frame content size
+          attr_reader :content_size
+
+          # @return [Integer] Total header size in bytes
+          attr_reader :header_size
+
+          # Parse frame header from input
+          #
+          # @param input [IO] Input stream positioned at frame header
+          # @return [Header] Parsed header
+          def self.parse(input)
+            parse_from(input.read, 0).first
+          end
+
+          # Parse frame header from a byte string.
+          #
+          # @param data [String]
+          # @param pos [Integer] offset of the descriptor byte
+          # @return [Array(Header, Integer)] header and position after
+          #   the header
+          def self.parse_from(data, pos)
+            descriptor = data.getbyte(pos)
+
+            header = new(descriptor)
+            offset = pos + 1
+
+            if header.window_descriptor?
+              header.parse_window_descriptor_byte(data.getbyte(offset))
+              offset += 1
+            end
+
+            if header.dictionary_id?
+              size = header.dictionary_id_size
+              bytes = data.byteslice(offset, size)
+              offset += size
+              header.assign_dictionary_id(bytes)
+            end
+
+            if header.content_size?
+              size = header.content_size_size
+              bytes = data.byteslice(offset, size)
+              offset += size
+              header.assign_content_size(bytes)
+            end
+
+            [header, offset]
+          end
+
+          # Initialize with descriptor byte
+          #
+          # @param descriptor [Integer] Frame header descriptor byte
+          def initialize(descriptor)
+            @descriptor = descriptor
+
+            # Extract flags from descriptor byte
+            @content_size_flag = (descriptor >> 6) & 0x03
+            @single_segment = (descriptor >> 5).allbits?(0x01)
+            @checksum_flag = (descriptor >> 2) & 0x01
+            @dictionary_id_flag = descriptor & 0x03
+
+            @window_log = nil
+            @window_mantissa = 0
+            @dictionary_id = nil
+            @content_size = nil
+            @header_size = 1
+          end
+
+          # Check if window descriptor is present
+          #
+          # @return [Boolean]
+          def window_descriptor?
+            !@single_segment
+          end
+
+          # Check if dictionary ID is present
+          #
+          # @return [Boolean]
+          def dictionary_id?
+            @dictionary_id_flag != 0
+          end
+
+          # Check if content size is present
+          #
+          # @return [Boolean]
+          def content_size?
+            @content_size_flag != 0 || @single_segment
+          end
+
+          # Check if content checksum is present
+          #
+          # @return [Boolean]
+          def content_checksum?
+            @checksum_flag == 1
+          end
+
+          # Get the size of dictionary ID field
+          #
+          # @return [Integer]
+          def dictionary_id_size
+            case @dictionary_id_flag
+            when 0 then 0
+            when 1 then 1
+            when 2 then 2
+            when 3 then 4
+            end
+          end
+
+          # Get the size of content size field
+          #
+          # @return [Integer]
+          def content_size_size
+            if @single_segment
+              # For single segment, FCS size depends on content_size_flag
+              case @content_size_flag
+              when 0 then 1
+              when 1 then 2
+              when 2 then 4
+              when 3 then 8
+              end
+            else
+              case @content_size_flag
+              when 0 then 0
+              when 1 then 2
+              when 2 then 4
+              when 3 then 8
+              end
+            end
+          end
+
+          # Get window size
+          #
+          # windowAdd = (windowBase / 8) * Mantissa (RFC 8878
+          # §3.1.1.1.2); the mantissa occupies descriptor bits 0-2 and
+          # the exponent bits 3-7.
+          #
+          # @return [Integer, nil] Window size or nil if not applicable
+          def window_size
+            return nil unless @window_log
+
+            window_base = 1 << @window_log
+            window_base + ((window_base / 8) * @window_mantissa)
+          end
+
+          # Parse window descriptor byte
+          def parse_window_descriptor_byte(byte)
+            @window_mantissa = byte & 0x07
+            @window_log = 10 + ((byte >> 3) & 0x1F)
+            @header_size += 1
+          end
+
+          # Assign the dictionary ID from its wire bytes.
+          def assign_dictionary_id(bytes)
+            @dictionary_id = case bytes.bytesize
+                             when 1 then bytes.ord
+                             when 2 then bytes.unpack1("v")
+                             when 4 then bytes.unpack1("V")
+                             end
+
+            @header_size += bytes.bytesize
+          end
+
+          # Assign the content size from its wire bytes.
+          def assign_content_size(bytes)
+            @content_size = case bytes.bytesize
+                            when 1 then bytes.ord
+                            when 2 then bytes.unpack1("v") + 256
+                            when 4 then bytes.unpack1("V")
+                            when 8
+                              low, high = bytes.unpack("VV")
+                              low + (high << 32)
+                            end
+
+            @header_size += bytes.bytesize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard/frame.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      # Frame module namespace
+      module Frame
+        autoload :Header, "omnizip/algorithms/zstandard/frame/header"
+        autoload :Block, "omnizip/algorithms/zstandard/frame/block"
+      end
+    end
+  end
+end