0001
  0   ˆl–Ým_J	å0–5@=q\êbÑ¿À„q¡2×_‹uÐb&=LV[(ÀÃ ?÷     package IO::Compress::Zip ;

use strict ;
use warnings;
use bytes;

use IO::Compress::Base::Common  2.101 qw(:Status );
use IO::Compress::RawDeflate 2.101 ();
use IO::Compress::Adapter::Deflate 2.101 ;
use IO::Compress::Adapter::Identity 2.101 ;
use IO::Compress::Zlib::Extra 2.101 ;
use IO::Compress::Zip::Constants 2.101 ;

use File::Spec();
use Config;

use Compress::Raw::Zlib  2.101 ();

BEGIN
{
    eval { require IO::Compress::Adapter::Bzip2 ;
           IO::Compress::Adapter::Bzip2->import( 2.101 );
           require IO::Compress::Bzip2 ;
           IO::Compress::Bzip2->import( 2.101 );
         } ;

    eval { require IO::Compress::Adapter::Lzma ;
           IO::Compress::Adapter::Lzma->import( 2.101 );
           require IO::Compress::Lzma ;
           IO::Compress::Lzma->import( 2.101 );
         } ;

    eval { require IO::Compress::Adapter::Xz ;
           IO::Compress::Adapter::Xz->import( 2.101 );
           require IO::Compress::Xz ;
           IO::Compress::Xz->import( 2.101 );
         } ;
    eval { require IO::Compress::Adapter::Zstd ;
           IO::Compress::Adapter::Zstd->import( 2.101 );
           require IO::Compress::Zstd ;
           IO::Compress::Zstd->import( 2.101 );
         } ;
}


require Exporter ;

our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, %DEFLATE_CONSTANTS, $ZipError);

$VERSION = '2.102';
$ZipError = '';

@ISA = qw(IO::Compress::RawDeflate Exporter);
@EXPORT_OK = qw( $ZipError zip ) ;
%EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;

push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;

$EXPORT_TAGS{zip_method} = [qw( ZIP_CM_STORE ZIP_CM_DEFLATE ZIP_CM_BZIP2 ZIP_CM_LZMA ZIP_CM_XZ ZIP_CM_ZSTD)];
push @{ $EXPORT_TAGS{all} }, @{ $EXPORT_TAGS{zip_method} };

Exporter::export_ok_tags('all');

sub new
{
    my $class = shift ;

    my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$ZipError);
    $obj->_create(undef, @_);

}

sub zip
{
    my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$ZipError);
    return $obj->_def(@_);
}

sub isMethodAvailable
{
    my $method = shift;

    # Store & Deflate are always available
    return 1
        if $method == ZIP_CM_STORE || $method == ZIP_CM_DEFLATE ;

    return 1
        if $method == ZIP_CM_BZIP2 and
           defined $IO::Compress::Adapter::Bzip2::VERSION;

    return 1
        if $method == ZIP_CM_LZMA and
           defined $IO::Compress::Adapter::Lzma::VERSION;

    return 1
        if $method == ZIP_CM_XZ and
           defined $IO::Compress::Adapter::Xz::VERSION;

    return 1
        if $method == ZIP_CM_ZSTD and
           defined $IO::Compress::Adapter::ZSTD::VERSION;

    return 0;
}

sub beforePayload
{
    my $self = shift ;

    if (*$self->{ZipData}{Sparse} ) {
        my $inc = 1024 * 100 ;
        my $NULLS = ("\x00" x $inc) ;
        my $sparse = *$self->{ZipData}{Sparse} ;
        *$self->{CompSize}->add( $sparse );
        *$self->{UnCompSize}->add( $sparse );

        *$self->{FH}->seek($sparse, IO::Handle::SEEK_CUR);

        *$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32($NULLS, *$self->{ZipData}{CRC32})
            for 1 .. int $sparse / $inc;
        *$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(substr($NULLS, 0,  $sparse % $inc),
                                         *$self->{ZipData}{CRC32})
            if $sparse % $inc;
    }
}

sub mkComp
{
    my $self = shift ;
    my $got = shift ;

    my ($obj, $errstr, $errno) ;

    if (*$self->{ZipData}{Method} == ZIP_CM_STORE) {
        ($obj, $errstr, $errno) = IO::Compress::Adapter::Identity::mkCompObject(
                                                 $got->getValue('level'),
                                                 $got->getValue('strategy')
                                                 );
        *$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef);
    }
    elsif (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
        ($obj, $errstr, $errno) = IO::Compress::Adapter::Deflate::mkCompObject(