1IO::Uncompress::AnyInflUasteer(3C)ontributed Perl DocumeInOt:a:tUinocnompress::AnyInflate(3)
2
3
4

NAME

6       IO::Uncompress::AnyInflate - Uncompress zlib-based (zip, gzip)
7       file/buffer
8

SYNOPSIS

10           use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
11
12           my $status = anyinflate $input => $output [,OPTS]
13               or die "anyinflate failed: $AnyInflateError\n";
14
15           my $z = IO::Uncompress::AnyInflate->new( $input [OPTS] )
16               or die "anyinflate failed: $AnyInflateError\n";
17
18           $status = $z->read($buffer)
19           $status = $z->read($buffer, $length)
20           $status = $z->read($buffer, $length, $offset)
21           $line = $z->getline()
22           $char = $z->getc()
23           $char = $z->ungetc()
24           $char = $z->opened()
25
26           $status = $z->inflateSync()
27
28           $data = $z->trailingData()
29           $status = $z->nextStream()
30           $data = $z->getHeaderInfo()
31           $z->tell()
32           $z->seek($position, $whence)
33           $z->binmode()
34           $z->fileno()
35           $z->eof()
36           $z->close()
37
38           $AnyInflateError ;
39
40           # IO::File mode
41
42           <$z>
43           read($z, $buffer);
44           read($z, $buffer, $length);
45           read($z, $buffer, $length, $offset);
46           tell($z)
47           seek($z, $position, $whence)
48           binmode($z)
49           fileno($z)
50           eof($z)
51           close($z)
52

DESCRIPTION

54       This module provides a Perl interface that allows the reading of
55       files/buffers that have been compressed in a number of formats that use
56       the zlib compression library.
57
58       The formats supported are
59
60       RFC 1950
61       RFC 1951 (optionally)
62       gzip (RFC 1952)
63       zip
64
65       The module will auto-detect which, if any, of the supported compression
66       formats is being used.
67

Functional Interface

69       A top-level function, "anyinflate", is provided to carry out "one-shot"
70       uncompression between buffers and/or files. For finer control over the
71       uncompression process, see the "OO Interface" section.
72
73           use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
74
75           anyinflate $input_filename_or_reference => $output_filename_or_reference [,OPTS]
76               or die "anyinflate failed: $AnyInflateError\n";
77
78       The functional interface needs Perl5.005 or better.
79
80   anyinflate $input_filename_or_reference => $output_filename_or_reference [,
81       OPTS]
82       "anyinflate" expects at least two parameters,
83       $input_filename_or_reference and $output_filename_or_reference and zero
84       or more optional parameters (see "Optional Parameters")
85
86       The $input_filename_or_reference parameter
87
88       The parameter, $input_filename_or_reference, is used to define the
89       source of the compressed data.
90
91       It can take one of the following forms:
92
93       A filename
94            If the $input_filename_or_reference parameter is a simple scalar,
95            it is assumed to be a filename. This file will be opened for
96            reading and the input data will be read from it.
97
98       A filehandle
99            If the $input_filename_or_reference parameter is a filehandle, the
100            input data will be read from it.  The string '-' can be used as an
101            alias for standard input.
102
103       A scalar reference
104            If $input_filename_or_reference is a scalar reference, the input
105            data will be read from $$input_filename_or_reference.
106
107       An array reference
108            If $input_filename_or_reference is an array reference, each
109            element in the array must be a filename.
110
111            The input data will be read from each file in turn.
112
113            The complete array will be walked to ensure that it only contains
114            valid filenames before any data is uncompressed.
115
116       An Input FileGlob string
117            If $input_filename_or_reference is a string that is delimited by
118            the characters "<" and ">" "anyinflate" will assume that it is an
119            input fileglob string. The input is the list of files that match
120            the fileglob.
121
122            See File::GlobMapper for more details.
123
124       If the $input_filename_or_reference parameter is any other type,
125       "undef" will be returned.
126
127       The $output_filename_or_reference parameter
128
129       The parameter $output_filename_or_reference is used to control the
130       destination of the uncompressed data. This parameter can take one of
131       these forms.
132
133       A filename
134            If the $output_filename_or_reference parameter is a simple scalar,
135            it is assumed to be a filename.  This file will be opened for
136            writing and the uncompressed data will be written to it.
137
138       A filehandle
139            If the $output_filename_or_reference parameter is a filehandle,
140            the uncompressed data will be written to it.  The string '-' can
141            be used as an alias for standard output.
142
143       A scalar reference
144            If $output_filename_or_reference is a scalar reference, the
145            uncompressed data will be stored in
146            $$output_filename_or_reference.
147
148       An Array Reference
149            If $output_filename_or_reference is an array reference, the
150            uncompressed data will be pushed onto the array.
151
152       An Output FileGlob
153            If $output_filename_or_reference is a string that is delimited by
154            the characters "<" and ">" "anyinflate" will assume that it is an
155            output fileglob string. The output is the list of files that match
156            the fileglob.
157
158            When $output_filename_or_reference is an fileglob string,
159            $input_filename_or_reference must also be a fileglob string.
160            Anything else is an error.
161
162            See File::GlobMapper for more details.
163
164       If the $output_filename_or_reference parameter is any other type,
165       "undef" will be returned.
166
167   Notes
168       When $input_filename_or_reference maps to multiple compressed
169       files/buffers and $output_filename_or_reference is a single
170       file/buffer, after uncompression $output_filename_or_reference will
171       contain a concatenation of all the uncompressed data from each of the
172       input files/buffers.
173
174   Optional Parameters
175       The optional parameters for the one-shot function "anyinflate" are (for
176       the most part) identical to those used with the OO interface defined in
177       the "Constructor Options" section. The exceptions are listed below
178
179       "AutoClose => 0|1"
180            This option applies to any input or output data streams to
181            "anyinflate" that are filehandles.
182
183            If "AutoClose" is specified, and the value is true, it will result
184            in all input and/or output filehandles being closed once
185            "anyinflate" has completed.
186
187            This parameter defaults to 0.
188
189       "BinModeOut => 0|1"
190            This option is now a no-op. All files will be written  in binmode.
191
192       "Append => 0|1"
193            The behaviour of this option is dependent on the type of output
194            data stream.
195
196            •    A Buffer
197
198                 If "Append" is enabled, all uncompressed data will be append
199                 to the end of the output buffer. Otherwise the output buffer
200                 will be cleared before any uncompressed data is written to
201                 it.
202
203            •    A Filename
204
205                 If "Append" is enabled, the file will be opened in append
206                 mode. Otherwise the contents of the file, if any, will be
207                 truncated before any uncompressed data is written to it.
208
209            •    A Filehandle
210
211                 If "Append" is enabled, the filehandle will be positioned to
212                 the end of the file via a call to "seek" before any
213                 uncompressed data is written to it.  Otherwise the file
214                 pointer will not be moved.
215
216            When "Append" is specified, and set to true, it will append all
217            uncompressed data to the output data stream.
218
219            So when the output is a filehandle it will carry out a seek to the
220            eof before writing any uncompressed data. If the output is a
221            filename, it will be opened for appending. If the output is a
222            buffer, all uncompressed data will be appended to the existing
223            buffer.
224
225            Conversely when "Append" is not specified, or it is present and is
226            set to false, it will operate as follows.
227
228            When the output is a filename, it will truncate the contents of
229            the file before writing any uncompressed data. If the output is a
230            filehandle its position will not be changed. If the output is a
231            buffer, it will be wiped before any uncompressed data is output.
232
233            Defaults to 0.
234
235       "MultiStream => 0|1"
236            If the input file/buffer contains multiple compressed data
237            streams, this option will uncompress the whole lot as a single
238            data stream.
239
240            Defaults to 0.
241
242       "TrailingData => $scalar"
243            Returns the data, if any, that is present immediately after the
244            compressed data stream once uncompression is complete.
245
246            This option can be used when there is useful information
247            immediately following the compressed data stream, and you don't
248            know the length of the compressed data stream.
249
250            If the input is a buffer, "trailingData" will return everything
251            from the end of the compressed data stream to the end of the
252            buffer.
253
254            If the input is a filehandle, "trailingData" will return the data
255            that is left in the filehandle input buffer once the end of the
256            compressed data stream has been reached. You can then use the
257            filehandle to read the rest of the input file.
258
259            Don't bother using "trailingData" if the input is a filename.
260
261            If you know the length of the compressed data stream before you
262            start uncompressing, you can avoid having to use "trailingData" by
263            setting the "InputLength" option.
264
265   Examples
266       To read the contents of the file "file1.txt.Compressed" and write the
267       uncompressed data to the file "file1.txt".
268
269           use strict ;
270           use warnings ;
271           use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
272
273           my $input = "file1.txt.Compressed";
274           my $output = "file1.txt";
275           anyinflate $input => $output
276               or die "anyinflate failed: $AnyInflateError\n";
277
278       To read from an existing Perl filehandle, $input, and write the
279       uncompressed data to a buffer, $buffer.
280
281           use strict ;
282           use warnings ;
283           use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
284           use IO::File ;
285
286           my $input = IO::File->new( "<file1.txt.Compressed" )
287               or die "Cannot open 'file1.txt.Compressed': $!\n" ;
288           my $buffer ;
289           anyinflate $input => \$buffer
290               or die "anyinflate failed: $AnyInflateError\n";
291
292       To uncompress all files in the directory "/my/home" that match
293       "*.txt.Compressed" and store the compressed data in the same directory
294
295           use strict ;
296           use warnings ;
297           use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
298
299           anyinflate '</my/home/*.txt.Compressed>' => '</my/home/#1.txt>'
300               or die "anyinflate failed: $AnyInflateError\n";
301
302       and if you want to compress each file one at a time, this will do the
303       trick
304
305           use strict ;
306           use warnings ;
307           use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
308
309           for my $input ( glob "/my/home/*.txt.Compressed" )
310           {
311               my $output = $input;
312               $output =~ s/.Compressed// ;
313               anyinflate $input => $output
314                   or die "Error compressing '$input': $AnyInflateError\n";
315           }
316

OO Interface

318   Constructor
319       The format of the constructor for IO::Uncompress::AnyInflate is shown
320       below
321
322           my $z = IO::Uncompress::AnyInflate->new( $input [OPTS] )
323               or die "IO::Uncompress::AnyInflate failed: $AnyInflateError\n";
324
325       Returns an "IO::Uncompress::AnyInflate" object on success and undef on
326       failure.  The variable $AnyInflateError will contain an error message
327       on failure.
328
329       If you are running Perl 5.005 or better the object, $z, returned from
330       IO::Uncompress::AnyInflate can be used exactly like an IO::File
331       filehandle.  This means that all normal input file operations can be
332       carried out with $z.  For example, to read a line from a compressed
333       file/buffer you can use either of these forms
334
335           $line = $z->getline();
336           $line = <$z>;
337
338       The mandatory parameter $input is used to determine the source of the
339       compressed data. This parameter can take one of three forms.
340
341       A filename
342            If the $input parameter is a scalar, it is assumed to be a
343            filename. This file will be opened for reading and the compressed
344            data will be read from it.
345
346       A filehandle
347            If the $input parameter is a filehandle, the compressed data will
348            be read from it.  The string '-' can be used as an alias for
349            standard input.
350
351       A scalar reference
352            If $input is a scalar reference, the compressed data will be read
353            from $$input.
354
355   Constructor Options
356       The option names defined below are case insensitive and can be
357       optionally prefixed by a '-'.  So all of the following are valid
358
359           -AutoClose
360           -autoclose
361           AUTOCLOSE
362           autoclose
363
364       OPTS is a combination of the following options:
365
366       "AutoClose => 0|1"
367            This option is only valid when the $input parameter is a
368            filehandle. If specified, and the value is true, it will result in
369            the file being closed once either the "close" method is called or
370            the IO::Uncompress::AnyInflate object is destroyed.
371
372            This parameter defaults to 0.
373
374       "MultiStream => 0|1"
375            Allows multiple concatenated compressed streams to be treated as a
376            single compressed stream. Decompression will stop once either the
377            end of the file/buffer is reached, an error is encountered
378            (premature eof, corrupt compressed data) or the end of a stream is
379            not immediately followed by the start of another stream.
380
381            This parameter defaults to 0.
382
383       "Prime => $string"
384            This option will uncompress the contents of $string before
385            processing the input file/buffer.
386
387            This option can be useful when the compressed data is embedded in
388            another file/data structure and it is not possible to work out
389            where the compressed data begins without having to read the first
390            few bytes. If this is the case, the uncompression can be primed
391            with these bytes using this option.
392
393       "Transparent => 0|1"
394            If this option is set and the input file/buffer is not compressed
395            data, the module will allow reading of it anyway.
396
397            In addition, if the input file/buffer does contain compressed data
398            and there is non-compressed data immediately following it, setting
399            this option will make this module treat the whole file/buffer as a
400            single data stream.
401
402            This option defaults to 1.
403
404       "BlockSize => $num"
405            When reading the compressed input data, IO::Uncompress::AnyInflate
406            will read it in blocks of $num bytes.
407
408            This option defaults to 4096.
409
410       "InputLength => $size"
411            When present this option will limit the number of compressed bytes
412            read from the input file/buffer to $size. This option can be used
413            in the situation where there is useful data directly after the
414            compressed data stream and you know beforehand the exact length of
415            the compressed data stream.
416
417            This option is mostly used when reading from a filehandle, in
418            which case the file pointer will be left pointing to the first
419            byte directly after the compressed data stream.
420
421            This option defaults to off.
422
423       "Append => 0|1"
424            This option controls what the "read" method does with uncompressed
425            data.
426
427            If set to 1, all uncompressed data will be appended to the output
428            parameter of the "read" method.
429
430            If set to 0, the contents of the output parameter of the "read"
431            method will be overwritten by the uncompressed data.
432
433            Defaults to 0.
434
435       "Strict => 0|1"
436            This option controls whether the extra checks defined below are
437            used when carrying out the decompression. When Strict is on, the
438            extra tests are carried out, when Strict is off they are not.
439
440            The default for this option is off.
441
442            If the input is an RFC 1950 data stream, the following will be
443            checked:
444
445            1.   The ADLER32 checksum field must be present.
446
447            2.   The value of the ADLER32 field read must match the adler32
448                 value of the uncompressed data actually contained in the
449                 file.
450
451            If the input is a gzip (RFC 1952) data stream, the following will
452            be checked:
453
454            1.   If the FHCRC bit is set in the gzip FLG header byte, the
455                 CRC16 bytes in the header must match the crc16 value of the
456                 gzip header actually read.
457
458            2.   If the gzip header contains a name field (FNAME) it consists
459                 solely of ISO 8859-1 characters.
460
461            3.   If the gzip header contains a comment field (FCOMMENT) it
462                 consists solely of ISO 8859-1 characters plus line-feed.
463
464            4.   If the gzip FEXTRA header field is present it must conform to
465                 the sub-field structure as defined in RFC 1952.
466
467            5.   The CRC32 and ISIZE trailer fields must be present.
468
469            6.   The value of the CRC32 field read must match the crc32 value
470                 of the uncompressed data actually contained in the gzip file.
471
472            7.   The value of the ISIZE fields read must match the length of
473                 the uncompressed data actually read from the file.
474
475       "RawInflate => 0|1"
476            When auto-detecting the compressed format, try to test for raw-
477            deflate (RFC 1951) content using the "IO::Uncompress::RawInflate"
478            module.
479
480            The reason this is not default behaviour is because RFC 1951
481            content can only be detected by attempting to uncompress it. This
482            process is error prone and can result is false positives.
483
484            Defaults to 0.
485
486       "ParseExtra => 0|1" If the gzip FEXTRA header field is present and this
487       option is set, it will force the module to check that it conforms to
488       the sub-field structure as defined in RFC 1952.
489            If the "Strict" is on it will automatically enable this option.
490
491            Defaults to 0.
492
493   Examples
494       TODO
495

Methods

497   read
498       Usage is
499
500           $status = $z->read($buffer)
501
502       Reads a block of compressed data (the size of the compressed block is
503       determined by the "Buffer" option in the constructor), uncompresses it
504       and writes any uncompressed data into $buffer. If the "Append"
505       parameter is set in the constructor, the uncompressed data will be
506       appended to the $buffer parameter. Otherwise $buffer will be
507       overwritten.
508
509       Returns the number of uncompressed bytes written to $buffer, zero if
510       eof or a negative number on error.
511
512   read
513       Usage is
514
515           $status = $z->read($buffer, $length)
516           $status = $z->read($buffer, $length, $offset)
517
518           $status = read($z, $buffer, $length)
519           $status = read($z, $buffer, $length, $offset)
520
521       Attempt to read $length bytes of uncompressed data into $buffer.
522
523       The main difference between this form of the "read" method and the
524       previous one, is that this one will attempt to return exactly $length
525       bytes. The only circumstances that this function will not is if end-of-
526       file or an IO error is encountered.
527
528       Returns the number of uncompressed bytes written to $buffer, zero if
529       eof or a negative number on error.
530
531   getline
532       Usage is
533
534           $line = $z->getline()
535           $line = <$z>
536
537       Reads a single line.
538
539       This method fully supports the use of the variable $/ (or
540       $INPUT_RECORD_SEPARATOR or $RS when "English" is in use) to determine
541       what constitutes an end of line. Paragraph mode, record mode and file
542       slurp mode are all supported.
543
544   getc
545       Usage is
546
547           $char = $z->getc()
548
549       Read a single character.
550
551   ungetc
552       Usage is
553
554           $char = $z->ungetc($string)
555
556   inflateSync
557       Usage is
558
559           $status = $z->inflateSync()
560
561       TODO
562
563   getHeaderInfo
564       Usage is
565
566           $hdr  = $z->getHeaderInfo();
567           @hdrs = $z->getHeaderInfo();
568
569       This method returns either a hash reference (in scalar context) or a
570       list or hash references (in array context) that contains information
571       about each of the header fields in the compressed data stream(s).
572
573   tell
574       Usage is
575
576           $z->tell()
577           tell $z
578
579       Returns the uncompressed file offset.
580
581   eof
582       Usage is
583
584           $z->eof();
585           eof($z);
586
587       Returns true if the end of the compressed input stream has been
588       reached.
589
590   seek
591           $z->seek($position, $whence);
592           seek($z, $position, $whence);
593
594       Provides a sub-set of the "seek" functionality, with the restriction
595       that it is only legal to seek forward in the input file/buffer.  It is
596       a fatal error to attempt to seek backward.
597
598       Note that the implementation of "seek" in this module does not provide
599       true random access to a compressed file/buffer. It  works by
600       uncompressing data from the current offset in the file/buffer until it
601       reaches the uncompressed offset specified in the parameters to "seek".
602       For very small files this may be acceptable behaviour. For large files
603       it may cause an unacceptable delay.
604
605       The $whence parameter takes one the usual values, namely SEEK_SET,
606       SEEK_CUR or SEEK_END.
607
608       Returns 1 on success, 0 on failure.
609
610   binmode
611       Usage is
612
613           $z->binmode
614           binmode $z ;
615
616       This is a noop provided for completeness.
617
618   opened
619           $z->opened()
620
621       Returns true if the object currently refers to a opened file/buffer.
622
623   autoflush
624           my $prev = $z->autoflush()
625           my $prev = $z->autoflush(EXPR)
626
627       If the $z object is associated with a file or a filehandle, this method
628       returns the current autoflush setting for the underlying filehandle. If
629       "EXPR" is present, and is non-zero, it will enable flushing after every
630       write/print operation.
631
632       If $z is associated with a buffer, this method has no effect and always
633       returns "undef".
634
635       Note that the special variable $| cannot be used to set or retrieve the
636       autoflush setting.
637
638   input_line_number
639           $z->input_line_number()
640           $z->input_line_number(EXPR)
641
642       Returns the current uncompressed line number. If "EXPR" is present it
643       has the effect of setting the line number. Note that setting the line
644       number does not change the current position within the file/buffer
645       being read.
646
647       The contents of $/ are used to determine what constitutes a line
648       terminator.
649
650   fileno
651           $z->fileno()
652           fileno($z)
653
654       If the $z object is associated with a file or a filehandle, "fileno"
655       will return the underlying file descriptor. Once the "close" method is
656       called "fileno" will return "undef".
657
658       If the $z object is associated with a buffer, this method will return
659       "undef".
660
661   close
662           $z->close() ;
663           close $z ;
664
665       Closes the output file/buffer.
666
667       For most versions of Perl this method will be automatically invoked if
668       the IO::Uncompress::AnyInflate object is destroyed (either explicitly
669       or by the variable with the reference to the object going out of
670       scope). The exceptions are Perl versions 5.005 through 5.00504 and
671       5.8.0. In these cases, the "close" method will be called automatically,
672       but not until global destruction of all live objects when the program
673       is terminating.
674
675       Therefore, if you want your scripts to be able to run on all versions
676       of Perl, you should call "close" explicitly and not rely on automatic
677       closing.
678
679       Returns true on success, otherwise 0.
680
681       If the "AutoClose" option has been enabled when the
682       IO::Uncompress::AnyInflate object was created, and the object is
683       associated with a file, the underlying file will also be closed.
684
685   nextStream
686       Usage is
687
688           my $status = $z->nextStream();
689
690       Skips to the next compressed data stream in the input file/buffer. If a
691       new compressed data stream is found, the eof marker will be cleared and
692       $.  will be reset to 0.
693
694       Returns 1 if a new stream was found, 0 if none was found, and -1 if an
695       error was encountered.
696
697   trailingData
698       Usage is
699
700           my $data = $z->trailingData();
701
702       Returns the data, if any, that is present immediately after the
703       compressed data stream once uncompression is complete. It only makes
704       sense to call this method once the end of the compressed data stream
705       has been encountered.
706
707       This option can be used when there is useful information immediately
708       following the compressed data stream, and you don't know the length of
709       the compressed data stream.
710
711       If the input is a buffer, "trailingData" will return everything from
712       the end of the compressed data stream to the end of the buffer.
713
714       If the input is a filehandle, "trailingData" will return the data that
715       is left in the filehandle input buffer once the end of the compressed
716       data stream has been reached. You can then use the filehandle to read
717       the rest of the input file.
718
719       Don't bother using "trailingData" if the input is a filename.
720
721       If you know the length of the compressed data stream before you start
722       uncompressing, you can avoid having to use "trailingData" by setting
723       the "InputLength" option in the constructor.
724

Importing

726       No symbolic constants are required by IO::Uncompress::AnyInflate at
727       present.
728
729       :all Imports "anyinflate" and $AnyInflateError.  Same as doing this
730
731                use IO::Uncompress::AnyInflate qw(anyinflate $AnyInflateError) ;
732

EXAMPLES

734   Working with Net::FTP
735       See IO::Compress::FAQ
736

SUPPORT

738       General feedback/questions/bug reports should be sent to
739       <https://github.com/pmqs/IO-Compress/issues> (preferred) or
740       <https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Compress>.
741

SEE ALSO

743       Compress::Zlib, IO::Compress::Gzip, IO::Uncompress::Gunzip,
744       IO::Compress::Deflate, IO::Uncompress::Inflate,
745       IO::Compress::RawDeflate, IO::Uncompress::RawInflate,
746       IO::Compress::Bzip2, IO::Uncompress::Bunzip2, IO::Compress::Lzma,
747       IO::Uncompress::UnLzma, IO::Compress::Xz, IO::Uncompress::UnXz,
748       IO::Compress::Lzip, IO::Uncompress::UnLzip, IO::Compress::Lzop,
749       IO::Uncompress::UnLzop, IO::Compress::Lzf, IO::Uncompress::UnLzf,
750       IO::Compress::Zstd, IO::Uncompress::UnZstd,
751       IO::Uncompress::AnyUncompress
752
753       IO::Compress::FAQ
754
755       File::GlobMapper, Archive::Zip, Archive::Tar, IO::Zlib
756
757       For RFC 1950, 1951 and 1952 see
758       <http://www.faqs.org/rfcs/rfc1950.html>,
759       <http://www.faqs.org/rfcs/rfc1951.html> and
760       <http://www.faqs.org/rfcs/rfc1952.html>
761
762       The zlib compression library was written by Jean-loup Gailly
763       "gzip@prep.ai.mit.edu" and Mark Adler "madler@alumni.caltech.edu".
764
765       The primary site for the zlib compression library is
766       <http://www.zlib.org>.
767
768       The primary site for gzip is <http://www.gzip.org>.
769

AUTHOR

771       This module was written by Paul Marquess, "pmqs@cpan.org".
772

MODIFICATION HISTORY

774       See the Changes file.
775
777       Copyright (c) 2005-2021 Paul Marquess. All rights reserved.
778
779       This program is free software; you can redistribute it and/or modify it
780       under the same terms as Perl itself.
781
782
783
784perl v5.32.1                      2021-03-01     IO::Uncompress::AnyInflate(3)
Impressum